ABSTRACT Software development has a relevant human side, and this could, for example, imply that developers' feelings have an impact on certain aspects of software development such as quality, productivity, or performance. This paper explores the effects of toxic emotions on code quality and presents the SentiQ tool, which gathers and analyzes sentiments from commit messages (obtained from GitHub) and code quality measures (obtained from SonarQube). The SentiQ tool we proposed performs a sentiment analysis (based on natural language processing techniques) and relates the results to the code quality measures. The datasets extracted are then used as the basis on which to conduct a preliminary case study, which demonstrates that there is a relationship between toxic comments and code quality that may affect the quality of the whole software project. This has resulted in the drafting of a predictive model to validate the correlation of the impact of toxic comments on code quality. The main implication of this work is that these results could, in the future, make it possible to estimate code quality as a function of developers' toxic comments.

Abstract Quantum computing is gaining an increasing interest since it can solve certain problems exponentially faster than classical computing. Thus, many organizations are researching and launching investments for integrating quantum software into their existing systems. Software modernization (as based on Model-Driven Engineering) has been proposed to migrate from/to the so-called hybrid software systems, which integrate classical and quantum software. In that process, both, reverse engineering and restructuring phases, have already been investigated. However, forward engineering phase for generating hybrid source code from high-level design models has not yet been addressed. Thus, this research proposes a quantum code generation technique from extended UML design models. It consists of a set of Model-to-Text transformations (defined through Epsilon Generation Language) to generate both Python and Qiskit code, which, respectively, integrate classical and quantum code. The transformation has been validated through a multi-case study with 7 hybrid software systems modeled in UML, which demonstrated that the transformation is effective and efficient. The implication of this work is that the software modernization process for hybrid software systems can be completed by tackling forward engineering phase, and that Model-Driven Engineering can therefore globally facilitate industry adoption of quantum software.

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.

Enterprise architecture has become an important driver to facilitate digital transformation in companies, since it allows to manage IT and business in a holistic and integrated manner by establishing connections among technology concerns and strategical/motivational ones. Enterprise architecture modelling is critical to accurately represent business and their IT assets in combination. This modelling is important when companies start to manage their enterprise architecture, but also when it is remodelled so that the enterprise architecture is realigned in a changing world. Enterprise architecture is commonly modelled by few experts in a manual way, which is error-prone and time-consuming and makes continuous realignment difficult. In contrast, other enterprise architecture modelling proposal automatically analyses some artefacts like source code, databases, services, etc. Previous automated modelling proposals focus on the analysis of individual artefacts with isolated transformations toward ArchiMate or other enterprise architecture notations and/or frameworks. We propose the usage of Knowledge Discovery Metamodel (KDM) to represent all the intermediate information retrieved from information systems' artefacts, which is then transformed into ArchiMate models. Thus, the core contribution of this paper is the model transformation between KDM and ArchiMate metamodels. The main implication of this proposal is that ArchiMate models are automatically generated from a common knowledge repository. Thereby, the relationships between different-nature artefacts can be exploited to get more complete and accurate enterprise architecture representations.

Abstract Quantum computing is now a reality, and its incomparable computational power has led companies to show a great interest in being able to work with quantum software in order to support part of their current and future business operations. However, the quantum computing paradigm differs significantly from its classical counterparts, which has brought about the need to revolutionise how the future software is designed, built, and operated in order to work with quantum computers. Since companies cannot discard all their current (and probably mission-critical) information systems, they must adapt their classical information systems to new specific quantum applications, thus evolving towards hybrid information systems. Unfortunately, there are no specific methods with which to deal with this challenge. We believe that reengineering, and more specifically, software modernisation using model-driven engineering principles, could be useful as regard migrating classical systems and existing quantum programs towards hybrid information systems. This paper, therefore, presents QRev, a reverse engineering tool that analyses quantum programs developed in Q# in order to identify its components and interrelationships, and then generates abstract models that can be used in software modernisation processes. The platform-independent models are generated according to the Knowledge Discovery Metamodel (KDM) standard. QRev is validated in a case study involving five quantum programs in order to demonstrate its effectiveness and scalability. The main implication of the study is that QRev can be used in order to attain KDM models, which can subsequently be employed to restructure or add new quantum functionality at a higher abstraction level, i.e. independently of the specific quantum technology.

Abstract In the context of digital transformation, companies are increasingly forced to develop, manage and continually align IT and business. Companies have found in Enterprise Architecture (EA) a valuable tool to represent and manage IT and business in a holistic way by establishing connections among technology concerns and business/strategical/motivational ones. EA modelling is one of the most critical tasks in this context to represent accurate models that make the difference in the decision‐making and governance processes of the company. In most of the cases, EA models are manually defined by experts which is usually error‐prone and time‐consuming. Thus, the constant business and IT realignment through manual modelling becomes complex and expensive. This research presents ArchiRev, an extensible reverse engineering method that automate the extraction of EA models (using ArchiMate language) by analysing different information systems artefacts. This proposal has been validated through an industrial case study in the context of a C#‐based system of an Italian ship refurbishment company. The study has demonstrated the effectiveness (based in the opinion of some business experts) and efficiency of the method. The main implication is that EA modelling can be accelerated, whereas subjectivity and errors introduced by experts might be reduced.

Scrum dramatically shortens the feedback loop between customer and developers as well as between requirement list and functional implementations. Scrum poses to turn small teams into self-managers of their own work. Despite the increasing importance of Scrum in the software development Industry, Academia is not providing a suitable response to meet the demand of professionals. This is because, in many cases, reference curricula do not consider Scrum with a great relevance in knowledge areas nor in time scheduled for it. Even so, Academia should be able to educate and provide software engineers with enough Scrum knowledge and skills. To collaborate to this aim, we present our efforts for improving the teaching/learning experience when dealing with time limitations: we have verified that when using a comparison strategy (regarding traditional software development methodologies like Unified Process, (UP)), students improve their learning process. To validate our results, students were assessed through a twofold assessment: (i) based on Scrum certification exams plus, and with (ii) a questionnaire based on the previously mentioned comparison (Scrum vs UP). The main conclusion raised from this investigation is that students' learning experience is really more satisfactory when Scrum concepts are introduced after a comparison with UP ones.

Companies possess a history and large array of legacy information systems that consume a great part of their IT budget in operations and maintenance. These systems are mission-critical, and they cannot be fully discarded since they retain business rules and provide information that is not available anywhere else. Unfortunately, decades-old legacy systems cannot easily withstand modification. Mainframes specifically conglomerate most of these legacy systems. Although there are some white-box solutions for migrating mainframe systems, such solutions lack systematicity and do not provide mechanisms for verifying business rules preservation. Hence, this paper presents a black-box solution (ignoring the internal structure of COBOL programs) which uses a screen scraping technique for migrating mainframe systems toward JavaFX and relational databases. Together with this solution, this paper provides an automatic verification technique to check if the recreated system reflects all the embedded business logic. This proposal has been designed and developed in the context of an industrial project, in which the solution has already migrated 43,000,000 mainframe screens from four systems. The main implication for researchers and practitioners is that screen scraping has proved to be feasible for migrating mainframe systems in large-scale projects within a manageable time-frame while preserving business.

Abstract Code cloning can seriously affect software quality. Code clones are various fragments of syntactically or semantically equivalent code. Some authors argue that code clones have a negative impact on maintainability and understandability, since clones propagate defects and make it mandatory to pay attention to several copies. However, other authors believe clones are not necessarily bad, since self‐admitted clones favor system stability and allow developers to move projects forward. Although some root causes and effects of cloning have been widely studied, there is not much relevant work analyzing how certain projects context factors impact on code cloning. This work presents an empirical validation of six open source projects by considering certain factors from Git repositories measured throughout a total of 70 releases for the 6 systems. The factors analyzed were the number of commits and committers per release, the average size of the commits and the size of the system in each release. The main conclusion obtained from the study is that, while the number of commits and committers and the system size do not significantly affect cloning, larger commits lead to a higher cloning ratio. These insights contribute to predicting and preventing code cloning, thus enabling a software quality improvement.

Concept location is a key activity during software modernization since it allows maintainers to exactly determine what pieces of source code support a specific concept. When concepts supported by an information system are getting outdated or misaligned, concept location becomes a time-consuming and error-prone task. Moreover, information systems embed significant business knowledge over time that is neither present nor documented anywhere else. For this reason, this paper proposes an approach to locate concepts in execution traces, which contain the actual and current information derived from the execution of the existing code. This approach, based on text segmentation tools, first retrieves and depicts relevant information from the execution traces, and then, it provides a mapping between such information and particular pieces of source code. The main idea of the approach is to take the file of the trace as text where the content of each function (i.e., method) appearing in the trace is a sentence composing the text and then applying the C99 algorithm to segment the text to a thematically coherent segments. The C99 is the state of the art algorithm proposed in text mining community to segment natural text. Each produced segment is composed by a set of functions or methods and bears a concept. Also, under this idea all techniques, proposed by text mining community, for text segmentation will be accessible to the software evolution community. We evaluated our approach on different execution scenarios of JHotDraw and ArgoUML.

While often being the not very well liked stepchild of IT departments, legacy information systems are valuable assets for companies. After many years of development and maintenance, these systems often contain valuable business logic and implement business processes that are nowadays unknown even to the owner of the system. However, maintenance and further development is often costly and requires an increased effort compared to modern applications. Hence, developing sound strategies for gradually modernizing these applications and lowering the associated costs is of paramount importance. For carrying out such strategies, it is useful to understand why and how certain aspects of these systems are implemented. At itestra, we have collected architectural patterns in legacy information systems and use these to understand legacy information systems better and avoid mistakes in the analysis of behavior of such legacy systems. We present these patterns here in order to facilitate the decision-making process in modernization projects and increase their success probability.

Reverse engineering of business process enables business process to be discovered and retrieved from existing information systems, which embed many business rules that are not available anywhere else. These techniques are especially useful when business process models are unavailable, outdated, or misaligned because of uncontrolled maintenance. Reverse engineering techniques obtain well-designed business processes, but these are often retrieved with harmful quality faults as a consequence of the abstraction. Clustering techniques are then applied to reduce these quality faults and improve the understandability and modifiability of business process models. Regrettably, the most challenging concern is how to determine the similarity between two business activities to be clustered. Formal ontologies help to represent the essential concepts and constraints of a universe of discourse and determine the similarity in accordance with the given ontology. This paper shows how to compute and use the ontology-based similarity within a clustering algorithm whose aim is to improve the quality of business process models previously obtained from legacy information systems by reverse engineering. The principal contribution of this paper is the usage of an ontology-based similarity function and its application to 43 business process models retrieved from four real-life information systems. Copyright © 2014 John Wiley & Sons, Ltd.

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.

Concept location is a key activity during software modernization since it allows maintainers to exactly determine what pieces of source code support a specific concept. Real-world business processes and information systems providing operational IT support for respective processes can be misaligned as a consequence of uncontrolled maintenance over time. When concepts supported by an information system are getting outdated or misaligned, concept location becomes a time-consuming and error-prone task. Moreover, enterprise information systems (which implement business processes) embed significant business knowledge over time that is neither present nor documented anywhere else. To support the evolution of existing information systems, the embedded knowledge must first be retrieved and depicted in up-to-date business process models and then be mapped to the source code. This paper addresses this issue through a concept location approach that considers business activities as the key concept to be located and discovers different partial business process views for each piece of source code. Thus, the concept location problem becomes the problem of extracting such views. This approach follows model-driven development principles and an automatic model transformation is implemented to facilitate its adoption. Moreover, a case study involving two real-life information system demonstrates its feasibility.

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.

The volatile IT industry often tempts companies to replace legacy information systems with new ones. However, these systems cannot always be completely discarded because they gradually store a significant amount of valuable business knowledge as a result of progressive maintenance over time. MARBLE semi-automatically rebuilds the hidden business processes embedded in legacy information systems. MARBLE supports a business process archeology method which allows business experts to attain a rapid and meaningful understanding of the organization's business processes. MARBLE-framed techniques are based on static and dynamic analysis by considering different legacy software artifacts (e.g., source code, event logs, etc.). Through the validation of MARBLE with several industrial systems, the proposal proved to be less time-consuming and more exhaustive (since it considers the embedded business knowledge) than a manual process redesigned by experts from scratch. The main implications are that MARBLE provides maintainers with a mechanism with which to modernize legacy information systems in line with the actual business processes of an organization.

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.