No. 145 
No. 144 
No. 143 
No. 142 
No. 141 
No. 140 
No. 139 by Enrique Moguel, Jaime Alvarado-Valiente, and Javier Romero-Alvarez (Universidad de Extremadura)
If we wait until quantum hardware becomes mature before thinking seriously about Quantum Software Engineering (QSE), we risk repeating the same mistakes. The software crisis showed what happens when hardware evolves faster than software engineering. This article revisits the classic software crisis, in which we emphasize that learning from the past is essential for developing the methodologies and abstractions needed to prevent a future quantum software crisis.
Over the past century, quantum mechanics has transformed our understanding of the physical world and has driven revolutionary advances in disciplines ranging from chemistry and telecommunications to microelectronics and computing. Today, these same principles are giving rise to quantum computers, devices that exploit phenomena such as superposition and entanglement to process information in ways that are fundamentally different from classical computers. Their unique capabilities promise not only to solve certain problems dramatically faster, but also to tackle computational challenges that are currently beyond the reach of even the most powerful supercomputers [1].
However, revolutionary hardware alone is never enough. Without equally mature software engineering practices, powerful computers become difficult to program, expensive to maintain, and ultimately inaccessible to most developers.
Learning from the Past to Build the Future
During the first decades of classical computing, computers were expensive, enormous, and highly unreliable. Early systems based on vacuum tubes suffered frequent failures, while software was written using machine-specific instructions and tightly coupled to the hardware. As a result, programs were rarely portable and often had to be rewritten for each new machine. Ironically, as hardware advanced, software development became increasingly complex rather than easier.
Edsger Dijkstra famously summarized the situation: "The major cause of the software crisis is that the machines have become several orders of magnitude more powerful!" [2].
The problem was not simply that programs became larger. Developers lacked the necessary capabilities to handle increasing complexity. The response eventually became known as Software Engineering. In this context, instead of viewing programming as an individual craft, software development evolved into a disciplined engineering process supported by modular programming, object-oriented design, software architectures, and testing methodologies, among others.
Following the Same Path in Quantum Computing
Figure 1 compares the historical evolution of consumer computers, supercomputers and quantum computers. The current state of quantum computing closely resembles the early stages of classical computing. Both paradigms have faced remarkably similar challenges: (1) the first generations of classical computers were expensive, scarce, and unreliable; today's quantum computers are equally costly, limited in availability, and highly susceptible to noise. (2) Classical software was tightly coupled to specific hardware platforms, making applications difficult to port; similarly, quantum software remains strongly dependent on vendor-specific hardware, SDKs, and execution models. (3) Programming early classical computers required highly specialized expertise and considerable effort; likewise, developing quantum circuits and hybrid quantum-classical applications still demands scarce expertise and significant development time. (4) Finally, access to early mainframes was constrained by limited computing resources and shared infrastructures; similarly, quantum developers continue to face restricted access to QPUs and long execution queues.
Classical computing eventually overcame these limitations through advances in Software Engineering. Given the rapid progress of quantum hardware in recent years, quantum computing is expected to follow a similar evolution, where QSE will play a key role in enabling mature, portable, and widely accessible quantum systems [L1].
Beyond Classical Thinking
History shows that abstractions transformed classical computing. High-level programming languages replaced assembly language. Functions, objects, modules, components, and services enabled programmers to reason about increasingly complex systems without having to constantly consider processor instructions. Figure 1 also illustrates this historical progression, showing how advances in hardware have consistently been accompanied by corresponding advances in software engineering methodologies. Quantum computing must follow a similar path and needs similar abstractions to become a mature software platform rather than a collection of isolated experiments.
Developers require programming constructs that naturally express quantum algorithms while hiding unnecessary hardware details, since they currently typically manipulate quantum circuits directly, rather than reasoning at higher conceptual levels. They also need software architectures, reusable components, debugging techniques, testing methodologies and design patterns. Equally important, they need quantum equivalents of the fundamental building blocks that support iterative software development.
Looking at this trend, classical software engineering methodologies might seem directly applicable to quantum computing. However, they are based on the Von Neumann model [L2], where programs manipulate data to produce deterministic results. Quantum computing instead evolves through probability amplitudes, with measurement collapsing the state into a single outcome, making familiar concepts such as variable inspection or loop evaluation impossible or fundamentally different.
This is where one of the greatest challenges facing QSE arises [3]. The goal is not simply to provide new libraries, but to raise the level of abstraction so that developers can design applications without reasoning directly in terms of qubits. This requires introducing quantum-specific software constructs, such as reusable quantum data types, composable oracles, high-level programming primitives, and design patterns for hybrid quantum-classical applications, that encapsulate complex circuit implementations while preserving quantum behavior.
Conclusion
The history of classical computing offers a clear warning. Software crises do not arise because hardware is weak, they arise because hardware advances faster than our ability to engineer software. Today, quantum computing risks following the same trajectory.
The next generation of software engineers needs new abstractions and software engineering fundamentals that incorporate the unique characteristics of quantum computing, enabling them to “think in quantum”, while preserving the best lessons learned over more than sixty years of classical software engineering. If we wait for quantum hardware to mature and become standardized before tackling these software challenges, it will already be too late to avoid a new crisis in quantum software.
Work funded by grant PDC2025-165096-C31 and PID2024-155693NB-C41 funded by MICIU/AEI/10.13039/5010001103 by the “ERDF/EU”.
Links:
[L1] https://www.ibm.com/quantum/hardware
[L2] https://keepcoding.io/blog/que-es-el-modelo-de-von-neumann
References:
[1] M. J. Klein, “Max planck and the beginnings of the quantum theory”, Archive for History of Exact Sciences, vol. 1, no 5, pp. 459-479, 1961.
[2] E. W. Dijkstra, “The humble programmer”, Communications of the ACM, vol. 15, no. 10, pp. 859-866, 1972.
[3] J. M. Murillo, J. Garcia-Alonso, et al., “Quantum software engineering: Roadmap and challenges ahead”, ACM Transactions on Software Engineering and Methodology, vol. 34, no. 5, pp. 1-48, 2025.
Please contact:
Jaime Alvarado-Valiente, Universidad de Extremadura, Cáceres, Spain
E-mail:
Javier Romero-Alvarez
Universidad de Extremadura, Cáceres, Spain