ABSTRACT Background Quantum Computing (QC) represents a disruptive paradigm in computing, with significant implications across various domains such as medicine, logistics, chemistry, and defense. However, quantum software development—the discipline that enables the exploitation of QC's potential—faces considerable challenges due to the inherent complexity of quantum mechanics. Objective This work aims to facilitate the systematic development of quantum software by introducing a method aligned with classical software engineering principles, particularly the analysis and synthesis phases, through the automated generation and optimization of quantum circuit components. Methods The proposed approach focuses on the automated generation of quantum circuit components whose behavior can be formally described using truth tables. To this end, (i) a set of algorithms for the automatic generation of components is introduced, (ii) an optimization algorithm is developed to improve the efficiency of the generated components, and (iii) an automated support system is provided, allowing users to specify truth tables through multiple modeling strategies. Results The resulting system enables a structured and automated process for building reusable quantum circuit components, reducing manual effort and supporting higher abstraction levels in quantum programming. The design of the system adheres to foundational principles of Software Engineering, including agnosticism and automatic code generation. Conclusions This proposal contributes to quantum software development by providing a practical, engineering‐driven methodology for generating and optimizing quantum circuit components, thereby improving the efficiency, scalability, and accessibility of quantum programming practices.

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 (QSE) as a distinct field within the broader software engineering landscape. In this work, a group of active researchers analyze in depth the current state of QSE research. From this analysis, the key areas of QSE 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 QSE.

Quantum computing is no longer a promise of the future but a rapidly evolving reality. Advances in quantum hardware are making it possible to make tangible a computational reality that until now was only theoretical. The proof of this is that development languages and platforms are appearing that bring physical principles closer to developers, making it feasible to begin to propose, in different areas of society, solutions to problems that until now were unsolvable. However, security vulnerabilities are also emerging that could hinder the progress of quantum computing, as well as its transition and development in industry. For this reason, this article proposes a review of some of the first artefacts that are emerging in the field of quantum computing. From this analysis, we begin to identify possible security issues that could become potential vulnerabilities in the quantum software of tomorrow. Likewise, and following the experience in classical software development, the testing technique is analysed as a possible candidate for improving security in quantum software development. Following the principles of Quantum Software Engineering, we are aware of the lack of tools, techniques and knowledge necessary to guarantee the development of quantum software in the immediate future. Therefore, this article aims to offer some first clues on what would be a roadmap to guarantee secure quantum software development.

Abstract Quantum computing is expected to exponentially outperform classic computing on a broad set of problems, including encryption, machine learning, and simulations. It has an impact yet to explore on all software lifecycle's processes and techniques. Testing quantum software raises a significant number of challenges due to the unique properties of quantum physics—such as superposition and entanglementand the stochastic behavior of quantum systems. It is, therefore, an open research issue. In this work, we offer a systematic mapping study of quantum software testing engineering, presenting a comprehensive view of the current state of the art. The main identified trends in testing techniques are (1) the statistic approaches based on repeated measurements and (2) the use of Hoare‐like logics to reason about software correctness. Another relevant line of research is reversible circuit testing, which is partially applicable to quantum software unitary testing. Finally, we have observed a flourishing of secondary studies and frameworks supporting testing processes from 2018 onwards.

Abstract One of the main challenges of software testing research is the automated addition of oracles to the generated test cases: Whereas the automated generation of operation sequences (which is one of the essential components of test cases) is in practice a solved problem, the automated addition of the oracle (another indispensable element) is still an important problem and an open research question. This article proposes an approach to get executable test suites composed by complete test cases (i.e., they include the oracle). The core of the method is based on annotated regular expressions. The test generation process, which is supported by a tool, follows three steps: (1) creation of annotated regular expressions, where each regular expression describes a set of sequences of operations to be executed against the system under test; (2) expansion of the regular expressions to get sequences of operations, which still do not have parameter values; and (3) generation of the executable test cases with oracle. In this third step, each test case is generated with the suitable oracle, depending on the conditions specified in the regular expression.

Global Software Development (GSD) is currently a strong industry trend. This means that if computer science engineers are to be trained to deal with this model, it is very important to include the topic in software engineering courses, attempting to ensure that students learn about GSD and become familiar with its advantages and challenges. However, software engineering courses do not always consider including it in their curricula. It must also be recognized that it is difficult to find a suitable method to teach/develop the different skills needed for GSD. There is often a lot of content and not a great deal of time available to teach it. In this article, we propose the use of a serious game called GSD-Aware, with which students can “suffer” some of the typical challenges of GSD by interacting with avatars and by using several means of communication to solve a number of problems posed. The article focuses on the description of the game and on the empirical study conducted to analyze whether GSD-Aware helps students to be conscious of GSD challenges. It was discovered that after 50 minutes playing the game, the students were aware of the greater influence that the following factors can have: lack of coordination, lack of trust, cultural differences, lack of face-to-face and informal communication, time difference, and lack of team spirit. In their final analysis, students agreed that the serious game scenarios helped them to understand what GSD is and to grasp the importance of some GSD challenges.

Abstract Background Codes of ethics (CoE) are widely adopted in several professional areas, including that of Software Engineering. However, contemporary CoE do not pay sufficient attention to one of the most important trends to have appeared in the last years environmental issues. Aim The aim of this study is to establish a Green CoE for software engineering and Professional Practices (GreCo). Our intention is to cover a wide range of aspects related to sustainability, such as economic, environmental, social, and technical features. We are additionally interested in encouraging software engineers to adopt these aspects. Methods The Green CoE presented is the result of the interaction of several experts in the area. A first version of GreCo, whose starting point was a discussion at the GInSEng workshop, was created by identifying key principles and adapting them to the Green area. Next, various important CoE were reviewed so as to gather the existing references to sustainability or to detect new ones. These elements would then possibly be incorporated into the new code or stimulate the creation of new sustainable principles. Results The final result is the GreCo code, which has been produced by modifying existing principles or by the introduction of new ones.

Software maintenance is recognized as an important knowledge area within the most common international curricula in software engineering. Despite this fact, and its importance in the industry, software maintenance and supporting techniques such as reengineering are hardly ever taught in practical lessons. This paper presents a reengineering teaching experience conducted during two last years in lab sessions by using reverse engineering and code generation tools. The experience was carried out by merging traditional methods (such as teaching lessons) with a practical exercise in laboratory. The teaching-learning process was qualitative- and quantitatively assessed by comparing results between an initial and final evaluation, as well as between the experiences conducted during two last years with different syllabus of courses. In fact, the effect of the experience in both syllabi proved to be effective. The reported results show that students do not know reengineering as a software maintenance technique although their satisfaction with the experience was high or very high (62%) or medium (30%). The key learned lessons are that students recognized the usage of reengineering tools as very convenient for their performance as future practitioners and the need to devote additional time in classroom to learn such tools.

ABSTRACT Databases are considered to be a valuable asset for organizations because they contain all those organizations’ persistent pieces of data. Both databases and the information systems that use them undergo erosion as a consequence of uncontrolled maintenance over time. However, when information systems evolve to become modernized versions of them, existing databases must not be discarded because they contain much valuable business knowledge that is not present anywhere else. Some of the software industry's current demands, such as time‐to‐market developments and the provision of software as services entail additional challenges in the reuse of legacy systems during software modernization. This paper addresses this problem and proposes a reengineering process that follows model‐driven development principles to recover Web services from legacy databases. The Web services that are mined manage access to legacy databases without discarding them. Legacy databases can thus be used by modernized information systems in service‐oriented environments. The adoption of this process is facilitated by the implementation of a support tool, which is used to conduct an industrial case study involving a real‐life legacy database. The study demonstrates that the proposal reduces development efforts and improves the return of investment by extending the lifespan of legacy databases. Copyright © 2012 John Wiley & Sons, Ltd.

SUMMARY Business processes have become one of the key assets of organization, since these processes allow them to discover and control what occurs in their environments, with information systems automating most of an organization's processes. Unfortunately, and as a result of uncontrolled maintenance, information systems age over time until it is necessary to replace them with new and modernized systems. However, while systems are aging, meaningful business knowledge that is not present in any of the organization's other assets gradually becomes embedded in them. The preservation of this knowledge through the recovery of the underlying business processes is, therefore, a critical problem. This paper provides, as a solution to the aforementioned problem, a model‐driven procedure for recovering business processes from legacy information systems. The procedure proposes a set of models at different abstraction levels, along with the model transformations between them. The paper also provides a supporting tool, which facilitates its adoption. Moreover, a real‐life case study concerning an e‐government system applies the proposed recovery procedure to validate its effectiveness and efficiency. The case study was carried out by following a formal protocol to improve its rigor and replicability. Copyright © 2011 John Wiley & Sons, Ltd.

Business process mining is a powerful tool to retrieve the valuable business knowledge embedded in existing information systems. The effectiveness of this kind of proposal is usually evaluated using recall and precision, which respectively measure the completeness and exactness of the retrieved business processes. Since the effectiveness assessment of business process mining is a difficult and error-prone activity, the main hypothesis of this work studies the possibility of obtaining thresholds to determine when recall and precision values are appropriate. The business process mining technique under study is MARBLE, a model-driven framework to retrieve business processes from existing information systems. The Bender method was applied to obtain the thresholds of the recall and precision measures. The experimental data used as input were obtained from a set of 44 business processes retrieved with MARBLE through a family of case studies carried out over the last two years. The study provides thresholds for recall and precision measures, which facilitates the interpretation of their values by means of five linguistic labels that range from low to very high. As a result, recall must be high (with at least a medium precision above 0.56), and precision must also be high (with at least a low recall of 0.70) to ensure that business processes were recovered (by using MARBLE) with an effectiveness value above 0.65. The thresholds allowed us to ascertain with more confidence whether MARBLE can effectively mine business processes from existing information systems. In addition, the provided results can be used as reference values to compare MARBLE with other similar business process mining techniques.

Modernization of legacy information systems is usually triggered by the need of introducing new business requirements or due to the technology obsolescence. During modernization software projects, there exists a lot of business knowledge that was embedded in source code owing to progressive maintenance, which is not present anywhere else. In order to preserve embedded business knowledge this paper presents MARBLE, a tool to recover business processes from legacy information systems. MARBLE provides an extensible framework, thus it is developed as an Eclipse™ plugin to ensure its future extension. So far, MARBLE supports Java-based system and focuses mainly on legacy source code. To facilitate its adoption in the industry, MARBLE has been applied in some real-life modernization projects, which demonstrated that MARBLE is suitable to retrieve business processes and facilitated its continuous improvement to reach an appropriate maturity level.

Information security is a crucial aspect for enterprises that has to be considered as a strong requirement from the early stages of the development process and Data Warehouses (DWs) manage highly important information used to make strategic decisions which has to be protected from unauthorized users. In order to develop secure DWs we have proposed a Model Driven Architecture (MDA) composed of several secure metamodels at different abstraction levels and transformations between them. Lately, a specialization of this architecture considering a multidimensional approach towards On-Line Analytical Processing (OLAP) tools has been defined, but the support to automatically transform complex security rules has not been dealt with so far. This paper analyzes this lack and defines improvements in our metamodels and a set of transformations between models in order to fulfill our MDA approach.

Data Warehouses (DWs) manage crucial information for enterprises which must be protected from unauthorized accesses. The question of which security issues are present in all stages of the DW design is therefore of great importance when considering these security constraints in design decisions. We have used the Model Driven Architecture (MDA) approach to propose an MDA architecture with which to develop secure DWs, which defines secure models at different abstraction levels along with their automatic transformation between models. Our approach considers a multidimensional path towards On-Line Analytical Processing (OLAP) tools, but did not, until now, support the transformation of complex security rules from conceptual models. After carrying out a modification of our conceptual metamodel to support a better representation of security rules and to define several sets of transformation rules, this paper shows how to transform these security rules through an example.

This paper describes a model-based method for the automatic generation of test cases in software product lines. The approach is completely based on well-known standards, such as UML 2.0, the UML Testing Profile and the QVT Language. To reach the goal, it is essential to maintain the traceability between different abstraction levels, as well as between domain and product engineering levels. The method is achieved using the Orthogonal Variability Model as an UML Profile.

Abstract Although powerful, mutation is a computationally very expensive testing technique. In fact, its three main stages (mutant generation, mutant execution and result analysis) require many resources to be successfully accomplished. Thus, researchers have made important efforts to reduce its costs. This paper represents an additional effort in this sense. It describes the results of two experiments in which, by means of combining the original set of mutants and therefore obtaining a new set of mutants—each one with two faults—the number of mutants used is reduced to half. Results lead to believe that mutant combination does not decrease the quality of the test suite, whereas it supposes important savings in mutant execution and result analysis. Copyright © 2008 John Wiley & Sons, Ltd.

Abstract This article presents the technical and functional descriptions of a tool specifically designed for database re‐engineering. As is well known, re‐engineering is the process of (1) applying reverse engineering to a software product to obtain higher‐level specifications and (2) using these specifications as the starting point for the development of a new version of the system. Thus, the complete process can be seen as a sequence of transformation functions that operate on the different sets involved in the whole process. The starting point of the re‐engineering process is the physical schema of the database which is translated into a vendor‐independent metamodel (the logical schema) and then translated into a class diagram representing a possible conceptual schema of the database. This diagram is then taken as the starting point for the code generation process, which produces an executable application for four possible different platforms. Copyright © 2007 John Wiley & Sons, Ltd.

This paper presents a tool specifically designed for database reengineering. As is well known, reengineering is the process of (1) applying reverse engineering to a software product to get higher-level specifications, and (2) using these specifications as the starting point for the development of a new version of the system. Thus, the complete process can be seen as a sequence of transformation functions that operate on the different sets of artifacts involved in the whole process. The starting point of the reengineering process is the physical schema of the database, which is translated into a vendor-independent metamodel; then, this is translated into a class diagram representing the possible conceptual schema used during the development of the database. This diagram is then taken as the starting point for the code generation process, which produces an executable application for four possible different platforms.