Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
169 tokens/sec
GPT-4o
7 tokens/sec
Gemini 2.5 Pro Pro
45 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
38 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

Quantum Software Engineering: Roadmap and Challenges Ahead (2404.06825v2)

Published 10 Apr 2024 in cs.SE

Abstract: As quantum computers advance, the complexity of the software they can execute increases as well. To ensure this software is efficient, maintainable, reusable, and cost-effective -key qualities of any industry-grade software-mature software engineering practices must be applied throughout its design, development, and operation. However, the significant differences between classical and quantum software make it challenging to directly apply classical software engineering methods to quantum systems. This challenge has led to the emergence of Quantum Software Engineering as a distinct field within the broader software engineering landscape. In this work, a group of active researchers analyse in depth the current state of quantum software engineering research. From this analysis, the key areas of quantum software engineering are identified and explored in order to determine the most relevant open challenges that should be addressed in the next years. These challenges help identify necessary breakthroughs and future research directions for advancing Quantum Software Engineering.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (142)
  1. 2016. IBM Makes Quantum Computing Available on IBM Cloud to Accelerate Innovation. https://uk.newsroom.ibm.com/2016-May-04-IBM-Makes-Quantum-Computing-Available-on-IBM-Cloud-to-Accelerate-Innovation
  2. Scaffold: Quantum programming language. Technical Report. Department of Computer Science, Princeton University.
  3. Metamorphic Testing of Oracle Quantum Programs. In Proceedings of the 3rd International Workshop on Quantum Software Engineering (Pittsburgh, Pennsylvania) (Q-SE ’22). Association for Computing Machinery, New York, NY, USA, 16–23. https://doi.org/10.1145/3528230.3529189
  4. A systematic decision-making framework for tackling quantum software engineering challenges. Automated Software Engineering 30, 2 (2023), 22. https://doi.org/10.1007/s10515-023-00389-7
  5. Genetic model-based success probability prediction of quantum software development projects. Information and Software Technology 165 (2024), 107352. https://doi.org/10.1016/j.infsof.2023.107352
  6. Architecture Decisions in Quantum Software Systems: An Empirical Study on Stack Exchange and GitHub. arXiv:2312.05421 [cs.SE]
  7. Assessing the effectiveness of input and output coverage criteria for testing quantum programs. In 2021 14th IEEE Conference on Software Testing, Verification and Validation (ICST). IEEE, 13–23. https://doi.org/10.1109/ICST49551.2021.00014
  8. Shaukat Ali and Tao Yue. 2020. Modeling Quantum programs: challenges, initial results, and research directions. In Proceedings of the 1st ACM SIGSOFT International Workshop on Architectures and Paradigms for Engineering Quantum Software (Virtual, USA) (APEQS 2020). Association for Computing Machinery, New York, NY, USA, 14–21. https://doi.org/10.1145/3412451.3428499
  9. Shaukat Ali and Tao Yue. 2023a. On the Need of Quantum-Oriented Paradigm. In Proceedings of the 2nd International Workshop on Quantum Programming for Software Engineering (QP4SE 2023). Association for Computing Machinery, New York, NY, USA, 17–20. https://doi.org/10.1145/3617570.3617868
  10. Shaukat Ali and Tao Yue. 2023b. Quantum Software Testing: A Brief Introduction. In 2023 IEEE/ACM 45th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). 332–333. https://doi.org/10.1109/ICSE-Companion58688.2023.00093
  11. When software engineering meets quantum computing. Commun. ACM 65, 4 (2022), 84–88.
  12. Engineering the development of quantum programs: Application to the Boolean satisfiability problem. Advances in Engineering Software 173 (2022), 103216. https://doi.org/10.1016/j.advengsoft.2022.103216
  13. Quokka: a service ecosystem for workflow-based execution of variational quantum algorithms. In International Conference on Service-Oriented Computing. Springer, 369–373.
  14. Jon Bentley. 1985. Programming pearls: confessions of a coder. Commun. ACM 28, 7 (1985), 671–679.
  15. Distributing Quantum Computations, by Shots. In International Conference on Service-Oriented Computing. Springer, 363–377.
  16. Nearly optimal measurement scheduling for partial tomography of quantum states. Physical Review X 10, 3 (2020), 031064.
  17. „Patterns for Quantum Software Development “. In Proceedings of the 15th International Conference on Pervasive Patterns and Applications (PATTERNS 2023). 30–39.
  18. Architecting the Future of Software Engineering: A National Agenda for Software Engineering Research and Development. Report. Software Engineering Institute, Carnegie Mellon University. https://resources.sei.cmu.edu/library/asset-view.cfm?assetid=741193
  19. Variational quantum algorithms. Nature Reviews Physics 3, 9 (2021), 625–644.
  20. The Smelly Eight: An Empirical Study on the Prevalence of Code Smells in Quantum Computing. In 45th IEEE/ACM International Conference on Software Engineering, ICSE. IEEE, 358–370. https://doi.org/10.1109/ICSE48619.2023.00041
  21. Programming languages and compiler design for realistic quantum hardware. Nature 549, 7671 (2017), 180–187.
  22. John Clark and Susan Stepney. 2002. Proposed ”Grand Challenge for Computing Research” Quantum Software Engineering. https://www.cs.york.ac.uk/quantum/sig/021108/qsegc.pdf
  23. Towards a Set of Metrics for Quantum Circuits Understandability. In Quality of Information and Communications Technology - 14th International Conference, QUATIC 2021, Algarve, Portugal, September 8-11, 2021, Proceedings (Communications in Computer and Information Science, Vol. 1439), Ana C. R. Paiva, Ana Rosa Cavalli, Paula Ventura Martins, and Ricardo Pérez-Castillo (Eds.). Springer, 239–249. https://doi.org/10.1007/978-3-030-85347-1_18
  24. A new quantum ripple-carry addition circuit. arXiv:quant-ph/0410184 [quant-ph]
  25. Evandro Chagas Ribeiro Da Rosa and Rafael De Santiago. 2021. Ket Quantum Programming. J. Emerg. Technol. Comput. Syst. 18, 1, Article 12 (oct 2021), 25 pages. https://doi.org/10.1145/3474224
  26. Quantum software testing: State of the art. J. Softw. Evol. Process. 35, 4 (2023). https://doi.org/10.1002/SMR.2419
  27. Automatic generation of test circuits for the verification of Quantum deterministic algorithms. In Proceedings of the 1st International Workshop on Quantum Programming for Software Engineering, QP4SE 2022, Singapore, Singapore, 18 November 2022, Fabiano Pecorelli, Vita Santa Barletta, and Manuel A. Serrano (Eds.). ACM, 1–6. https://doi.org/10.1145/3549036.3562055
  28. QDLC – The Quantum Development Life Cycle. arXiv:2010.08053 [cs.ET]
  29. Richard P Feynman. 2018. Simulating physics with computers. In Feynman and computation. CRC Press, 133–153.
  30. Mutation Testing of Quantum Programs: A Case Study With Qiskit. IEEE Transactions on Quantum Engineering 3 (2022), 1–17. https://doi.org/10.1109/TQE.2022.3195061
  31. Mutation Testing of Quantum Programs Written in QISKit. In Proceedings of the ACM/IEEE 44th International Conference on Software Engineering: Companion Proceedings (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 358–359. https://doi.org/10.1145/3510454.3528649
  32. QMutPy: A Mutation Testing Tool for Quantum Algorithms and Applications in Qiskit. In Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (Virtual, South Korea) (ISSTA 2022). Association for Computing Machinery, New York, NY, USA, 797–800. https://doi.org/10.1145/3533767.3543296
  33. Semi-automated capacity analysis of limitation-aware microservices architectures. In International Conference on the Economics of Grids, Clouds, Systems, and Services. Springer, 75–88.
  34. Quingo: A Programming Framework for Heterogeneous Quantum-Classical Computing with NISQ Features. ACM Transactions on Quantum Computing 2, 4, Article 19 (dec 2021), 37 pages. https://doi.org/10.1145/3483528
  35. The role of limitations and SLAs in the API industry. In Proceedings of the 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). 1006–1014.
  36. Quantum software as a service through a quantum API gateway. IEEE Internet Computing 26, 1 (2021), 34–41.
  37. The Prime state and its quantum relatives. Quantum 4 (Dec. 2020), 371. https://doi.org/10.22331/q-2020-12-11-371
  38. Alan Geller. 2020. Introducing quantum intermediate representation (QIR). Q# Blog. Sept (2020).
  39. Model-Driven Optimization for Quantum Program Synthesis with MOMoT. In 2023 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C). IEEE, 614–621.
  40. Towards model-driven quantum software engineering. In 2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE). IEEE, 13–15.
  41. A Model-Driven Framework for Composition-Based Quantum Circuit Design. (2024).
  42. Quantum DevOps: Towards Reliable and Applicable NISQ Quantum Computing. 2020 IEEE Globecom Workshops (GC Wkshps (2020), 1–6. https://api.semanticscholar.org/CorpusID:232150074
  43. Optimizing quantum optimization algorithms via faster quantum gradient computation. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms. Society for Industrial and Applied Mathematics, 1425–1444. https://doi.org/10.1137/1.9781611975482.87
  44. Jonathan Grattage. 2011. An overview of QML with a concrete implementation in Haskell. Electronic Notes in Theoretical Computer Science 270, 1 (2011), 165–174.
  45. Quipper: a scalable quantum programming language. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13, Hans-Juergen Boehm and Cormac Flanagan (Eds.). ACM, 333–342. https://doi.org/10.1145/2491956.2462177
  46. Lov K. Grover. 1998. Quantum Computers Can Search Rapidly by Using Almost Any Transformation. Physical Review Letters 80, 19 (may 1998), 4329–4332. https://doi.org/10.1103/physrevlett.80.4329
  47. On Repairing Quantum Programs Using ChatGPT. In 2024 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE). ACM.
  48. Quantum Software Engineering Challenges from Developers’ Perspective: Mapping Research Challenges to the Proposed Workflow Model. 2023 IEEE International Conference on Quantum Computing and Engineering (QCE) 02 (2023), 173–176.
  49. Property-Based Testing of Quantum Programs in Q#. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops (Seoul, Republic of Korea) (ICSEW’20). Association for Computing Machinery, New York, NY, USA, 430–435. https://doi.org/10.1145/3387940.3391459
  50. Yipeng Huang and Margaret Martonosi. 2019. Statistical Assertions for Validating Patterns and Finding Bugs in Quantum Programs. In Proceedings of the 46th International Symposium on Computer Architecture (Phoenix, Arizona) (ISCA ’19). Association for Computing Machinery, New York, NY, USA, 541–553. https://doi.org/10.1145/3307650.3322213
  51. Quantum circuits for floating-point arithmetic. arXiv:1807.02023 [quant-ph]
  52. KDM to UML Model transformation for quantum software modernization. In International Conference on the Quality of Information and Communications Technology. Springer, 211–224.
  53. Tiancheng Jin and Jianjun Zhao. 2023. ScaffML: A Quantum Behavioral Interface Specification Language for Scaffold. In 2023 IEEE International Conference on Quantum Software (QSW). IEEE, 128–137.
  54. Jose Jose Campos and Andre Souto. 2021. QBugs: A Collection of Reproducible Bugs in Quantum Algorithms and a Supporting Infrastructure to Enable Controlled Quantum Software Testing and Debugging Experiments. In Second International Workshop on Quantum Software Engineering (Q-SE 2021). 28–32.
  55. Software architecture for quantum computing systems — A systematic review. Journal of Systems and Software 201 (2023), 111682. https://doi.org/10.1016/j.jss.2023.111682
  56. Agile Practices for Quantum Software Development: Practitioners Perspectives. ArXiv arXiv:.09825 (2022). https://doi.org/10.48550/arXiv.2210.09825
  57. Automatic Diagnosis of Quantum Software Bug Fix Motifs. In The 35th International Conference on Software Engineering and Knowledge Engineering, SEKE. 97–102. https://doi.org/10.18293/SEKE2023-196
  58. Frank Leymann. 2019. Towards a Pattern Language for Quantum Algorithms. In Quantum Technology and Optimization Problems (Lecture Notes in Computer Science (LNCS), Vol. 11413). Springer International Publishing, Cham, 218–230. https://doi.org/10.1007/978-3-030-14082-3_19
  59. Frank Leymann and Johanna Barzen. 2020. The bitter truth about gate-based quantum algorithms in the NISQ era. Quantum Science and Technology 5, 4 (sep 2020), 044007. https://doi.org/10.1088/2058-9565/abae7d
  60. Projection-Based Runtime Assertions for Testing and Debugging Quantum Programs. Proc. ACM Program. Lang. 4, OOPSLA, Article 150 (Nov. 2020), 29 pages. https://doi.org/10.1145/3428218
  61. Yangjia Li and Mingsheng Ying. 2014. Debugging quantum processes using monitoring measurements. Physical Review A 89, 4 (2014), 042338.
  62. Quantum Circuits for Dynamic Runtime Assertions in Quantum Computation. In Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems. 1017–1030.
  63. Peixun Long and Jianjun Zhao. 2024a. Equivalence, identity, and unitarity checking in black-box testing of quantum programs. Journal of Systems and Software (2024), 112000.
  64. Peixun Long and Jianjun Zhao. 2024b. Testing multi-subroutine quantum programs: From unit testing to integration testing. ACM Transactions on Software Engineering and Methodology (2024).
  65. Linear Structure of Training Samples in Quantum Neural Network Applications. In Service-Oriented Computing – ICSOC 2023 Workshops, Flavia Monti, Pierluigi Plebani, Naouel Moha, Hye-young Paik, Johanna Barzen, Gowri Ramachandran, Devis Bianchini, Damian A. Tamburri, and Massimo Mecella (Eds.). Springer Nature Singapore, Singapore, 150–161.
  66. Philip Maymin. 1997. Extending the Lambda Calculus to Express Randomized and Quantumized Algorithms. arXiv:quant-ph/9612052 [quant-ph]
  67. Constraint Programming. Springer Berlin Heidelberg. https://books.google.es/books?id=B0aqCAAAQBAJ
  68. Muskit: A Mutation Analysis Tool for Quantum Software Testing. In Proceedings of the 36th IEEE/ACM International Conference on Automated Software Engineering (Melbourne, Australia) (ASE ’21). IEEE Press, 1266–1270. https://doi.org/10.1109/ASE51524.2021.9678563
  69. Sara Ayman Metwalli and Rodney Van Meter. 2024. Testing and Debugging Quantum Circuits. IEEE Transactions on Quantum Engineering (2024).
  70. Andriy Miranskyy and Lei Zhang. 2019. On Testing Quantum Programs. In Proceedings of the 41st International Conference on Software Engineering: New Ideas and Emerging Results (Montreal, Quebec, Canada) (ICSE-NIER ’19). IEEE Press, 57–60. https://doi.org/10.1109/ICSE-NIER.2019.00023
  71. Is Your Quantum Program Bug-Free?. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering: New Ideas and Emerging Results (Seoul, South Korea) (ICSE-NIER ’20). Association for Computing Machinery, New York, NY, USA, 29–32. https://doi.org/10.1145/3377816.3381731
  72. On Testing and Debugging Quantum Software. (2021). arXiv:2103.09172
  73. Prospects for Quantum Software Engineering in the Next Decade — Supplementary material. https://doi.org/10.5281/zenodo.10877492
  74. MDE4QAI: Towards Model-Driven Engineering for Quantum Artificial Intelligence. CoRR abs/2107.06708 (2021). arXiv:2107.06708 https://arxiv.org/abs/2107.06708
  75. Mitigating Noise in Quantum Software Testing Using Machine Learning. arXiv:2306.16992 [cs.SE]
  76. Q-PAC: Automated Detection of Quantum Bug-Fix Patterns. arXiv:2311.17705
  77. Technical debts and faults in open-source quantum software systems: An empirical study. Journal of Systems and Software 193 (2022), 111458. https://doi.org/10.1016/J.JSS.2022.111458
  78. Scott Pakin. 2016. A quantum macro assembler. In 2016 IEEE High Performance Extreme Computing Conference (HPEC). 1–8. https://doi.org/10.1109/HPEC.2016.7761637
  79. Matteo Paltenghi and Michael Pradel. 2022. Bugs in Quantum computing platforms: an empirical study. Proceedings of the ACM on Programming Languages 6, OOPSLA1 (2022), 1–27. https://doi.org/10.1145/3527330
  80. Matteo Paltenghi and Michael Pradel. 2023a. LintQ: A Static Analysis Framework for Qiskit Quantum Programs. arXiv preprint arXiv:2310.00718 (2023).
  81. Matteo Paltenghi and Michael Pradel. 2023b. MorphQ: Metamorphic Testing of the Qiskit Quantum Computing Platform. In Proceedings of the 45th International Conference on Software Engineering (Melbourne, Victoria, Australia) (ICSE ’23). IEEE Press, 2413–2424. https://doi.org/10.1109/ICSE48619.2023.00202
  82. Service-oriented computing: State of the art and research challenges. Computer 40, 11 (2007), 38–45.
  83. SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation. Proc. ACM Program. Lang. 8, POPL, Article 81 (jan 2024), 31 pages. https://doi.org/10.1145/3632923
  84. QRev: migrating quantum code towards hybrid information systems. Software Quality Journal 30, 2 (2022), 551–580.
  85. Carlos A. Pérez-Delgado and Hector G. Perez-Gonzalez. 2020. Towards a Quantum Software Modeling Language. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops (Seoul, Republic of Korea) (ICSEW’20). Association for Computing Machinery, New York, NY, USA, 442–444. https://doi.org/10.1145/3387940.3392183
  86. Toward a Quantum Software Engineering. IT Professional 23, 1 (2021), 62–66. https://doi.org/10.1109/MITP.2020.3019522
  87. John Preskill. 2018. Quantum computing in the NISQ era and beyond. Quantum 2 (2018), 79.
  88. A Preliminary Study of the Usage of Design Patterns in Quantum Software. In 2024 IEEE/ACM 4nd International Workshop on Quantum Software Engineering (Q-SE). In Press.
  89. Generation of Classical-Quantum Code from UML models. 02 (2023), 165–168. https://doi.org/10.1109/QCE57702.2023.10202
  90. Modelling Quantum Circuits with UML. In 2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE). 7–12. https://doi.org/10.1109/Q-SE52541.2021.00009
  91. Guidelines to use the incremental commitment spiral model for developing quantum-classical systems. Quantum Information and Computation 24, 1&2 (2024), 71–88. https://www.rintonpress.com/xxqic24/qic-24-12/0071-0088.pdf
  92. Software modernization to embrace quantum technology. Advances in Engineering Software 151 (2021), 102933. https://doi.org/10.1016/j.advengsoft.2020.102933
  93. Learning qubo Models for Quantum Annealing: A Constraint-Based Approach. In Computational Science – ICCS 2023, Jiří Mikyška, Clélia de Mulatier, Maciej Paszynski, Valeria V. Krzhizhanovskaya, Jack J. Dongarra, and Peter M.A. Sloot (Eds.). Springer Nature Switzerland, Cham, 153–167.
  94. Trials and tribulations of developing hybrid quantum-classical microservices systems. arXiv preprint arXiv:2105.04421 (2021).
  95. Using Open API for the Development of Hybrid Classical-Quantum Services. In International Conference on Service-Oriented Computing. Springer, 364–368.
  96. Enabling continuous deployment techniques for quantum services. Software: Practice and Experience n/a, n/a ([n. d.]). https://doi.org/10.1002/spe.3326 arXiv:https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.3326
  97. Johannes Sametinger. 1997. Software engineering with reusable components. Springer.
  98. Operating with Quantum Integers: An Efficient ‘Multiples of’ Oracle. In Service-Oriented Computing, Marco Aiello, Johanna Barzen, Schahram Dustdar, and Frank Leymann (Eds.). Springer Nature Switzerland, Cham, 105–124.
  99. Automatic Generation of an Efficient Less-Than Oracle for Quantum Amplitude Amplification. In 2023 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE). 26–33. https://doi.org/10.1109/Q-SE59154.2023.00011
  100. Automatic Generation of Efficient Oracles: The Less-Than Case. In SSRN. https://doi.org/10.2139/ssrn.4594664
  101. Some Initial Guidelines for Building Reusable Quantum Oracles. In Services and Quantum Software - 21st International Conference on Service-Oriented Computing.
  102. Non-Functional Requirements for Quantum Programs.. In Q-SET@ QCE. 89–73.
  103. Naoto Sato and Ryota Katsube. 2023. Locating Buggy Segments in Quantum Program Debugging. arXiv preprint arXiv:2309.04266 (2023).
  104. Douglas C Schmidt et al. 2006. Model-driven engineering. Computer-IEEE Computer Society- 39, 2 (2006), 25.
  105. Efficient Floating Point Arithmetic for Quantum Computers. arXiv:2112.10537 [quant-ph]
  106. Quantum Software Components and Platforms: Overview and Quality Assessment. 55, 8, Article 164 (dec 2022), 31 pages. https://doi.org/10.1145/3548679
  107. Making Quantum Computing Open: Lessons from Open Source Projects. In ICSE ’20: 42nd International Conference on Software Engineering, Workshops. ACM, 451–455. https://doi.org/10.1145/3387940.3391471
  108. A Practical Quantum Instruction Set Architecture. arXiv:1608.03355 [quant-ph]
  109. Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Physical review letters 108, 7 (2012), 070502.
  110. Journeys in non-classical computation. Grand Challenges in Computing Research (2004), 29–32.
  111. Full-Stack Quantum Software in Practice: Ecosystem, Stakeholders and Challenges. (sep 2023), 177–180. https://doi.org/10.1109/QCE57702.2023.10205
  112. Q#: Enabling Scalable Quantum Computing and Development with a High-level DSL. In Proceedings of the Real World Domain Specific Languages Workshop 2018 (Vienna, Austria) (RWDSL2018). Association for Computing Machinery, New York, NY, USA, Article 7, 10 pages. https://doi.org/10.1145/3183895.3183901
  113. Which Quantum Circuit Mutants Shall Be Used? An Empirical Evaluation of Quantum Circuit Mutations. arXiv preprint arXiv:2311.16913 (2023).
  114. Quantum types: going beyond qubits and quantum gates. arXiv:2401.15073 [quant-ph]
  115. QuanFuzz: Fuzz Testing of Quantum Program. CoRR abs/1810.10310 (2018). arXiv:1810.10310 http://arxiv.org/abs/1810.10310
  116. QDiff: Differential Testing of Quantum Software Stacks. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). 692–704. https://doi.org/10.1109/ASE51524.2021.9678792
  117. Guess What Quantum Computing Can Do for Test Case Optimization. arXiv:2312.15547 [cs.SE]
  118. Application of Combinatorial Testing to Quantum Programs. In 2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS). 179–188. https://doi.org/10.1109/QRS54544.2021.00029
  119. Generating Failing Test Suites for Quantum Programs With Search. In Search-Based Software Engineering, Una-May O’Reilly and Xavier Devroey (Eds.). Springer International Publishing, Cham, 9–25. https://doi.org/10.1007/978-3-030-88106-1_2
  120. Quito: A Coverage-Guided Test Generator for Quantum Programs. In Proceedings of the 36th IEEE/ACM International Conference on Automated Software Engineering (Melbourne, Australia) (ASE ’21). IEEE Press, 1237–1241. https://doi.org/10.1109/ASE51524.2021.9678798
  121. QuSBT: Search-Based Testing of Quantum Programs. In Proceedings of the ACM/IEEE 44th International Conference on Software Engineering: Companion Proceedings (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 173–177. https://doi.org/10.1145/3510454.3516839
  122. QuCAT: A Combinatorial Testing Tool for Quantum Software. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE Computer Society, Los Alamitos, CA, USA, 2066–2069. https://doi.org/10.1109/ASE56229.2023.00062
  123. Test Case Minimization with Quantum Annealers. arXiv:2308.05505 [cs.SE]
  124. Mutation-Based Test Generation for Quantum Programs with Multi-Objective Search. In Proceedings of the Genetic and Evolutionary Computation Conference (Boston, Massachusetts) (GECCO ’22). Association for Computing Machinery, New York, NY, USA, 1345–1353. https://doi.org/10.1145/3512290.3528869
  125. Provenance-Preserving Analysis and Rewrite of Quantum Workflows for Hybrid Quantum Algorithms. SN Computer Science 4, 3 (2023), 233.
  126. Quantum Software Development Lifecycle. Springer International Publishing, Cham, 61–83. https://doi.org/10.1007/978-3-031-05324-5_4
  127. Hybrid quantum applications need two orchestrations in superposition: a software architecture perspective. In 2021 IEEE International Conference on Web Services (ICWS). IEEE, 1–13.
  128. Integrating quantum computing into workflow modeling and execution. In 2020 IEEE/ACM 13th International Conference on Utility and Cloud Computing (UCC). IEEE, 279–291.
  129. Patterns for hybrid quantum algorithms. In Symposium and Summer School on Service-Oriented Computing. Springer, 34–51.
  130. Nathan Wiebe and Vadym Kliuchnikov. 2013. Floating point representations in quantum circuit synthesis. New Journal of Physics 15, 9 (Sept. 2013), 093041. https://doi.org/10.1088/1367-2630/15/9/093041
  131. TOSCA4QC: two modeling styles for TOSCA to automate the deployment and orchestration of quantum applications. In 2020 IEEE 24th International Enterprise Distributed Object Computing Conference (EDOC). IEEE, 125–134.
  132. QuraTest: Integrating Quantum Specific Features in Quantum Program Testing. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). 1149–1161. https://doi.org/10.1109/ASE56229.2023.00196
  133. Towards Quantum Software Requirements Engineering. In 2023 IEEE International Conference on Quantum Computing and Engineering (QCE), Vol. 02. 161–164. https://doi.org/10.1109/QCE57702.2023.10201
  134. Challenges and Opportunities in Quantum Software Architecture. Springer Nature Switzerland, Cham, 1–23. https://doi.org/10.1007/978-3-031-36847-9_1
  135. Identifying Flakiness in Quantum Programs. In ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM. IEEE, 1–7. https://doi.org/10.1109/ESEM56168.2023.10304850
  136. Jianjun Zhao. 2020. Quantum Software Engineering: Landscapes and Horizons. Arxiv. (jul 2020). https://doi.org/10.48550/arXiv.2007.07047 arXiv:2007.07047
  137. Jianjun Zhao. 2021. Some size and structure metrics for quantum software. In 2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE). IEEE, 22–27.
  138. Bugs4Q: A benchmark of existing bugs to enable controlled testing and debugging studies for quantum programs. J. Syst. Softw. 205, C (nov 2023), 13 pages. https://doi.org/10.1016/j.jss.2023.111805
  139. Qchecker: Detecting bugs in quantum programs via static analysis. In 2023 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE). IEEE, 50–57.
  140. An Empirical Study of Bugs in Quantum Machine Learning Frameworks. In 2023 IEEE International Conference on Quantum Software (QSW). 68–75. https://doi.org/10.1109/QSW59989.2023.00018
  141. Unraveling quantum computing system architectures: An extensive survey of cutting-edge paradigms. Information and Software Technology 167 (2024), 107380. https://doi.org/10.1016/j.infsof.2023.107380
  142. Huiyang Zhou and Gregory T. Byrd. 2019. Quantum Circuits for Dynamic Runtime Assertions in Quantum Computation. IEEE Computer Architecture Letters 18, 2 (2019), 111–114. https://doi.org/10.1109/LCA.2019.2935049
Citations (8)
View on Semantic Scholar

Summary

We haven't generated a summary for this paper yet.

Ai Sparkles Streamline Icon: https://streamlinehq.com Summarize Now
X Twitter Logo Streamline Icon: https://streamlinehq.com

Tweets