As we know, the history of Computer Science is characterized by a succession of different paradigms. Let us remember that in the 1930s, on the one hand, Gödel, Turing, Church, etc. laid the foundations for Computer Science; and, on the other hand, in the 40’s the first computers were built (Zuse’s Z1, ENIAC, IBM’s Mark I, etc.). The first ones based on vacuum tubes, in the late 1940´s transistor-based computers appeared and in the late 1950s integrated circuits, then the first microprocessors 1971, and personal computers in the 80’s.

These computers brought machine and assembly languages; and later, in the 1960’s the first high level programming languages (FORTRAN, COBOL, etc.). So, the need for structured programming techniques (Dijkstra) arose, and design and structured analysis techniques in the 70’s, and complete methodologies in the 80’s.

The same pattern followed the object-oriented technology, OO languages were diffused in the 80s (C++, Objective-C, Eiffel). In 1990 the techniques for OO design and analysis began to be proposed (UML, Unified Process, RUP, etc.) and other languages as Java emerged; and in the 2000’s agile methodologies for OO development have been adopted.

In the last decade, a set of technologies around DevOps was spread: Infrastructure as Code (e.g. Puppet), Continuous Integration and Deployment (e.g. Jenkins), Test automation (e.g. Cucumber, Jmeter), Containers (e.g. Docker), Orchestration (e.g. Kubernetes) Deployment (e.g. Opctopus, Elastic). And a third wave in software development began.

All these changes required significant investments in knowledge and platforms acquisition; and sometimes led to economic losses due to betting on technologies or languages that ended up disappearing due to lack of maturity or market pressures. On the other hand, companies that waited too long to incorporate these advances were unable to take advantage of the competitive advantage offered, which even led in some cases to their disappearance

History is repeating itself with quantum computation. In the early eighties, Richard Feynman raised the question of building a quantum computer to simulate our “quantum world”, and Paul Benioff in 1980 and Yuri Manin laid the theoretical foundations of quantum computing. In 1985 David Deutsch proposed the “Universal Quantum Computer”. Thus, the “second quantum revolution” began.   In the 1990´s some quantum algorithms were proposed: Deutsch and Jozsa, Shor, Grover, etc. In 1995, Juan Ignacio Cirac and Zoller proposed the construction of a quantum computer using trapped ions. And since then, many different techniques have been researched to build the cubits at a physical level: neutral-atom, superconducting, quantum dots, semiconductor based, NV center, topological, photon and nuclear magnetic resonance qubits.

With the new quantum computers (whether simulators, quantum annealers or gate-based quantum computers), new quantum programming languages (qGCL, Q Language, QML, Quipper, OpenQASM, Qiskit, Q#, Silq, QIR,  etc.) are also appearing, which propose different ways of creating quantum applications.

The problem that arises, and more in these moments of rapid evolution and lack of standardization in quantum programming, is the fear of betting on a platform that does not continue in the future. All this leads companies to slow the adoption of quantum applications, which is dangerous because the use of quantum technologies can lead to a relatively important period of learning and experimentation. In addition to not being able to take advantage of all the benefits offered by this new paradigm in a timely manner.

But we are already in the fourth era of software development, and so we must prepare ourselves to take full advantage of it. The “Talavera Manifesto” urges to take care of producing quantum software by applying knowledge and lessons learned from the software engineering field. This implies to apply or adapt the existing software engineering processes, methods, techniques, practices, and principles for the development of quantum software (or it may imply creating new ones).

This has been one of the main challenges we faced when creating QPath, as a Quantum Software Development & Application Lifecycle Platform. QPath proposes an environment that makes programmers independent of the specific details of each platform and language, following the principle of “write once, run everywhere”. In this way, QPath supports the execution of quantum process units transparently from the environment in which they are executed. Therefore, it masks the complexities of the different environments by supporting the necessary transformations and automating the whole process through efficient tools.

This allows to accelerate the construction and deployment of quantum applications, abstracting their technical complexities, since programmers can focus on the domain of the problem or business model, needing only the functional knowledge required for the solution.

We believe that in this way QPath can significantly contribute to the adoption of quantum technologies and specifically enable companies to develop and deploy applications based on these technologies, safeguarding their investments.