The Quantum Software Challenge
What software engineers should know about quantum computing.
“People who are serious about software should make their own hardware” — Alan Kay
I’ve been working on quantum computing for the past eight years, with teams across hardware, software, and foundations at Yale, ETH Zurich, Oxford and now at Rigetti Computing. During this time, quantum technology has advanced incredibly. Hardware (though still on small chips) has now reached performance thresholds that enable us to scale up their size, and near-term applications in quantum simulation and optimization have been developed.
So in some sense I feel like I’ve been waiting a long time to write this post, to try and condense just a glimpse of what has been going on and speak directly to software engineers.
And now is the time, because while quantum computing is certainly revolutionary at the hardware level, what the revolution unlocks is an entirely new world of software and applications:
Software engineers have a chance to build the device drivers, firmware, C, gcc, and unix of the quantum computing stack.
Computing technology has always advanced along with our understanding of physics. Mechanical computers as simple as the abacus developed into today’s electronics. The underlying laws of these electronics have been perfectly understood since Maxwell in the 1860’s.
Quantum electronics and computers are the next step in this journey and have two categories of major impact:
- They reorient the relationship between physics and computer science: physics does not just place restrictions on what computers we can design, it also grants new power and inspiration.
- We’ll have developed technology that simulates nature at its most fundamental level, allowing us to access deep problems in quantum chemistry, materials discovery, and more.
If you’re serious about software, then you’ll want to pay attention to this radical hardware.
There’s compelling academic literature in theoretical computer science — check out a summary at the quantum algorithms zoo — that’s paired with an exponential scaling of individual qubit performance. These qubits (quantum bits) are the basic building block of a quantum computer, like transistors are for regular computers. Their key metric is coherence time, which indicates how long a qubit will retain its quantum-like behavior. The coherence time of superconducting qubits has increased by 10 million times since 2000. Regular CPUs, which follow the well-known Moore’s law, have increased transistor density by only 100 times over this period.
The physicists and hardware engineers that I work with at Rigetti Computing — and many other talented scientists across the globe — are working on cutting-edge technology to design and build the first generation of true universal quantum processors.
For certain problems, these chips will be more powerful than any supercomputer within the next few years.
It’s time we talk about software.
What I aim to do here is just briefly go through the stack from the bottom up, and hint at some of the most interesting challenges that software engineers will need to take on. These are the challenges that we’re hiring for.
Building a useful quantum computer requires many different kinds of software engineers — ones with backgrounds in programming language and compiler design, experience with hardware description languages — but mostly we need smart software engineers who are comfortable with invention and ready for a highly creative role.
Where to go from here.
All of this is just scratching the surface. These problems are real. They are here today, and of the relatively few people who have been trying to solve them, fewer still are software engineers.
We need more software engineers looking at these challenges. Difficulties are just things to overcome, after all.
Building this stack is a chance to impact an entire technology (and entire new industry) at the embryonic stage. There do not yet exist large quantum code bases.
Right now, we have a chance to learn as much as possible from the history of classical software development and to devise architectures that will be used for decades, like C. They will need to be elegant and creative solutions and will need to leverage the very best of applied and theoretical computer science.