Legacy systems still play a critical role in the operation of many software organizations. However, these systems have high maintenance costs due to their reliance on deprecated technologies. Also, they are often too complex to be rewritten from scratch. Such systems could benefit from being migrated to an event-driven architecture (EDA), as it enables the creation of software systems with loosely coupled components which improves their maintainability and scalability. However, migrating legacy systems is not straightforward, and may have significant costs. Furthermore, there is limited empirical knowledge on how practitioners approach legacy-to-EDA migration in industrial settings. To bridge this gap, we conducted a survey with software practitioners to investigate the state of practice of legacy-to-EDA migration. The purpose of the survey is to gain insights on the methodologies adopted for implementing EDAs, and the specifics of the legacy-to-EDA migration process in industrial settings. The survey consists of two parts: (1) an online questionnaire featuring 26 questions, and (2) an interview session with some of the participants. The questionnaire was answered by 31 participants, two of whom volunteered for the interview. The key findings of the survey include: (1) the main motivation behind legacy-to-EDA migrations is to decouple parts of the system, (2) the technologies preferred by professionals when implementing EDAs are Java and Apache Kafka, and (3) software professionals mainly rely on business processes and human expertise to guide the migration. Our study highlights the limited adoption of automation tools in the legacy-to-EDA migration process. It also emphasizes the need for practitioners to develop tools that facilitate the migration and to adopt best practices to handle data consistency.

The migration of legacy software systems to aservice-oriented architecture(SOA) is one of the main strategies for modernising such systems. The success of modernising a legacy system to a SOA highly depends on the used service identification approach where the goal is to identify reusable functionalities that could become services. In this paper, we perform a comparative analysis of service identification approaches proposed by academia and industry. We show that there is a gap between academia and industry in the used approaches to identify services from legacy systems. We extract from the comparative analysis several recommendations about the inputs, processes, and outputs that a service identification approach should have. Based on these recommendations, we proposeServiceMiner, a bottom-up service identification approach, which relies on source-code analysis, because other sources of information may be unavailable or out of sync with the actual code.ServiceMinerrelies on a categorisation of service types and code-level patterns characterising types of services. We evaluateServiceMineron four case studies. We also compare our results to those of three state-of-the-art approaches. We show thatServiceMineridentifies architecturally-significant services with, on average, 78% precision, 76% recall, and 77% F-measure.

The Internet of Things (IoT) is increasingly prevalent, with systems developed across various domains. Choosing the right IoT architectural style is challenging due to the diversity of devices, dynamic environments, and real-time data needs. This choice significantly impacts system quality, requiring a careful balance of quality requirements and tradeoffs. Previous studies have not adequately identified the most suitable architectural styles for specific IoT quality needs. This study presents a systematic literature review of 103 primary studies (PSs) on IoT system quality requirements and architectural styles, assessing how each architectural style satisfies specific requirements. We followed the preferred reporting items for systematic review and meta-analysis (PRISMA) protocol to report our findings and answer three research questions (RQs). We selected PSs by applying inclusion and exclusion criteria to relevant papers published until the end of 2023. We analyzed data from PSs to understand IoT system quality requirements and architectural styles, assessing their alignment. The research revealed ten essential quality requirements for IoT systems and identified ten distinct architectural styles. Notably, each architectural style varies in its capacity to fulfill specific quality requirements, particularly regarding security, scalability, and performance. SOA, client-server, and REST architectural styles best fulfill many quality requirements. However, various architectural styles, such as Layered, Microservices, and Peer-to-Peer, show limited support for privacy requirements. Our findings can guide IoT systems practitioners in selecting an architectural style that aligns with their desired quality standards. Additionally, we recommend new research opportunities to deepen understanding of key architectural styles based on specific quality requirements.

Cross-platform mobile app development frame-works allow developers to use a single codebase to develop apps targeting different platforms. As these frame-works provide distinct features and may impact the apps' quality, their selection must be done with care. Although many works evaluated mobile frame-works, there is no synthesis on these studies. In this paper, we present a Systematic Literature Review (SLR) on approaches that evaluated cross- platform frame-works. Our SLR covers 75 papers and provides insights on 1) the most studied frame-works, 2) the criteria used for evaluation, 3) the evaluation methods used and 4) the results of these evaluations. The SLR shows that prior works generally used a prototype app to evaluate the frame-works but none explored the impact of the frame-works on the app's code quality. Thus, we carried out a preliminary empirical study on 3,566 mobile apps to evaluate the impact of mobile frame-works on the number of bugs and code smells in apps. The results of the study on native Android and React Native indicate that the latter has fewer code smells than native Android apps. Native Android apps generally had worse quality considering the number of bugs and code smells.

Machine Learning (ML) has revolutionized the field of computer software development, enabling data-based predictions and decision-making across several domains. Following modern software development practices, developers use third-party libraries—e.g., Scikit Learn, TensorFlow, and PyTorch—to integrate ML-based functionalities into their applications. Due to the complexity inherent in ML techniques, the models available in the APIs of these tools often require an extensive list of arguments to be set up. Library maintainers overcome this issue by defining default values for most of these arguments so developers can use ML models in their client applications effortlessly. By relying on these default arguments, the clients inadvertently depend on the value defined in these parameters to keep running as expected. We interpret this problem as a semantical breaking change variant, which we named Default Argument Breaking Change (DABC). In this work, we leverage 77 DABCs in Scikit Learn—a well-known ML library—and investigate how 194K client applications are vulnerable to them. Our results show that 72 DABCs (93%) are responsible for exposing 67,747 clients (35%). We also detected that most DABCs (61, 79%) involve APIs used in ML model training and model evaluation stages. Finally, we discuss the importance of managing DABCs in third-party ML libraries and provide insights for developers to mitigate the potential impact of these changes in their applications.

Typical object-oriented (OO) systems implement several functional features that are interwoven into class hierarchies. In the absence of aspect-oriented techniques to develop and compose these features, developers resort to object-oriented design and programming idioms to separate features as well as possible. Given a legacy OO system, discovering existing functional features helps understand the design of the system and extract these features to ease their maintenance and reuse. We want to discover candidate functional features in OO systems. We first define functional features and then discuss the footprints that such features are likely to leave in an OO system. We identify three such footprints: (1) multiple inheritance, (2) delegation, and (3) ad-hoc. We develop a set of algorithms for identifying such footprints in OO code and implemented them for the Java language using Eclipse JDT. In this article, we present the algorithms, and the results of applying the corresponding tools on five open-source systems: FreeMind, JavaWebMail, JHotDraw, JReversePro, and Lucene. Our experimental results show that: (1) the different algorithms can identify interesting and useful candidate functional features in OO systems, (2) they can identify opportunities for refactoring, and (3) they are complementary and could help developers.

Safety-critical systems are highly heterogeneous, combining different characteristics. Effectively designing such systems requires a complex modelling approach that deals with diverse components (e.g., mechanical, electronic, software)—each having its own underlying domain theories and vocabularies—as well as with various aspects of the same component (e.g., function, structure, behaviour). Furthermore, the regulated nature of such systems prescribes the objectives for their design verification and validation. This paper proposeschecsdm, a systematic approach, based on Model-Driven Engineering (MDE), for assisting engineering teams in ensuring consistency of heterogeneous design of safety-critical systems. The approach is developed as a genericmethodologyand atool framework, that can be applied to various design scenarios involving different modelling languages and different design guidelines. The methodology comprises an iterative three-phased process. The first phase,elicitation, aims at specifying requirements of the heterogeneous design scenario. Using the proposed tool framework, the second phase,codification, consists in building a particular tool set that supports the heterogeneous design scenario and helps engineers in flagging consistency errors for review and eventual correction. The third phase,operation, applies the tool set to actual system designs. Empirical evaluation of the work is presented through two executions of thechecsdmapproach for the specific cases of a design scenario involving a mix of UML, Simulink and Stateflow, and a design scenario involving a mix of AADL, Simulink and Stateflow. Theoperationphase of the first case was performed over three avionics systems and the identified inconsistencies in the design models of these systems were compared to the results of a fully manual verification carried out by professional engineers. The evaluation also includes an assessment workshop with industrial practitioners to examine their perceptions about the approach. The empirical validation indicates the feasibility and “cost-effectiveness” of the approach. Inconsistencies were identified in the three avionics systems with a greater recall rate over the manual verification. The assessment workshop shows the practitioners found the approach easy to understand and gave an overall likelihood of adoption within the context of their work.

Safety-critical software are highly heterogeneous, possessing very different characteristics. These characteristics are described using diverse modelling mechanisms (e.g., MathWorks Simulink and Stateflow, UML). The different resulting models may facilitate understanding and communication, but hinder verification and certification. This is in part due to the fact that design models have to be kept consistent, specially in cases where overlaps exist. Moreover, where overlapping exists, mappings between overlapping elements are required. In particular, the regulated nature of these systems, along with the size and complexity of their design models requires well-defined guidelines for ensuring model consistency. This paper presents a model-driven approach for verifying consistency between UML, Simulink and Stateflow design models, and for recording mappings between overlapping elements in them. The approach is intended to be part of the design standards and process of avionics companies to help them comply with DO-178C. An avionics industrial case study is used to motivate the work and demonstrate the proposed approach.

J2EE applications tend to be multi-tier and multi-language applications. They rely on the J2EE platform and containers that offer infrastructure and architectural services to ensure distributed, secure, safe, and scalable executions. These mechanisms hide many program dependencies, which helps development but hinders maintenance, evolution, and re-engineering of J2EE applications. In this paper, we study (i) the J2EE specifications to extract a declarative specification of the dependencies that are inherent in the services offered and that are not visible in the user code that uses them. Then, we introduce (ii) a codification of the dependencies into rules, and (iii) a tool that supports the specification of those dependencies and their detection in J2EE applications. We validate our approach and tool on a sample of 10 J2EE applications. We also compare our tool against JRipples, a state-of-the-art tool for change-impact analysis tasks. Results show that our tool adds, on average, 15% more call dependencies, which would have been missed otherwise. On change impact analysis tasks, our tool outperforms JRipples in all 10 applications, especially for the early iterations of change propagation exploration.

Abstract Declarative rules are frequently used in model refactoring in order to detect refactoring opportunities and to apply the appropriate ones. However, a large number of rules is required to obtain a complete specification of refactoring opportunities. Companies usually have accumulated examples of refactorings from past maintenance experiences. Based on these observations, we consider the model refactoring problem as a multi objective problem by suggesting refactoring sequences that aim to maximize both structural and textual similarity between a given model (the model to be refactored) and a set of poorly designed models in the base of examples (models that have undergone some refactorings) and minimize the structural similarity between a given model and a set of well‐designed models in the base of examples (models that do not need any refactoring). To this end, we use the Non‐dominated Sorting Genetic Algorithm (NSGA‐II) to find a set of representative Pareto optimal solutions that present the best trade‐off between structural and textual similarities of models. The validation results, based on 8 real world models taken from open‐source projects, confirm the effectiveness of our approach, yielding refactoring recommendations with an average correctness of over 80%. In addition, our approach outperforms 5 of the state‐of‐the‐art refactoring approaches.

Program dependency artifacts such as call graphs help support a number of software engineering tasks such as software mining, program understanding, debugging, feature location, software maintenance and evolution. Java Enterprise Edition (JEE) applications represent a significant part of the recent legacy applications, and we are interested in modernizing them. This modernization involves, among other things, analyzing dependencies between their various components/tiers. JEE applications tend to be multilanguage, rely on JEE container services, and make extensive use of late binding techniques-all of which makes finding such dependencies difficult. In this paper, we describe some of these difficulties and how we addressed them to build a dependency call graph. We developed our tool called DeJEE (Dependencies in JEE) as an Eclipse plug-in. We applied DeJEE on two open-source JEE applications: Java PetStore and JSP Blog. The results show that DeJEE is able to identify different types of JEE dependencies.

Web developers face some unique challenges when trying to understand, modify and document the structure of their web applications. The heterogeneity and complexity of the underlying technologies and languages heighten comprehension problems. In particular, JavaScript, as an essential part of the Web ecosystem, is a language that offers a flexibility that can make its code hard to grasp, when it comes to comprehension and documentation tasks. In this paper, we present the first iteration of WAVI (WebAppViewer), a reverse engineering tool that uses static analysis and a filter-based mechanism to retrieve and document the structure of a Web application. WAVI is able to extract elements coming from essential web languages and frameworks such as HTML, JavaScript, CSS and Node.js. The tool makes use of some simple, effective heuristics to accurately retrieve dependency links for files and methods. WAVI also offers the visualisation of the extracted information as force-directed graphs and customized class diagrams. The effectiveness of WAVI is evaluated with experiments that demonstrate that (i) it can resolve JavaScript calls better than a recent technique, and (ii) its visualisation modules are intuitive and scalable.

Software designers have to deal with a large number of distinct software design artifacts (SDAs), including requirements, patterns, and tactics.This paper proposes a technique that systematizes the classification of SDAs, and a classification scheme (CS) which organizes the SDAs into a matrix, in a manner derived from the Zachman Framework for enterprise architecture.An instantiation of this CS is a traceability matrix called a software-structure map (SSM) that records the SDAs and their relationships.The approach is illustrated through the analysis of the Template Method (TM) design pattern as an example of a SDA.

Recovering the architecture of existing software systems remains a challenge and an active research field in software engineering. In this paper, we propose an approach to recover the layered architecture of object oriented software systems. To do so, our approach first recovers clusters corresponding to the various responsibilities of the system; the challenge in this context is to find the appropriate level of granularity of these responsibilities. Then the recovered clusters are assigned to layers using an optimization algorithm that exploits the principles of the layering architectural style. The approach was validated on five Java open source systems.

ABSTRACT One of the important challenges in model‐driven engineering is how to improve the quality of the models' design in order to help designers understand them. Refactoring represents an efficient technique to improve the quality of a design while preserving its behavior. Most of existing work on model refactoring relies on declarative rules to detect refactoring opportunities and to apply the appropriate refactorings. However, a complete specification of refactoring opportunities requires a huge number of rules. In this paper, we consider the refactoring mechanism as a combinatorial optimization problem where the goal is to find good refactoring suggestions starting from a small set of refactoring examples applied to similar contexts. Our approach, named model refactoring by example, takes as input an initial model to refactor, a set of structural metrics calculated on both initial model and models in the base of examples, and a base of refactoring examples extracted from different software systems and generates as output a sequence of refactorings. A solution is defined as a combination of refactoring operations that should maximize as much as possible the structural similarity based on metrics between the initial model and the models in the base of examples. A heuristic method is used to explore the space of possible refactoring solutions. To this end, we used and adapted a genetic algorithm as a global heuristic search. The validation results on different systems of real‐world models taken from open‐source projects confirm the effectiveness of our approach. Copyright © 2014 John Wiley & Sons, Ltd.

SUMMARY Design patterns codify proven solutions to recurring design problems. Their proper use within a development context requires that: (i) we understand them; (ii) we ascertain their applicability or relevance to the design problem at hand; and (iii) we apply them faithfully to the problem at hand. We argue that an explicit representation of the design problem solved by a design pattern is key to supporting the three tasks in an integrated fashion. We propose a model‐driven representation of design patterns consisting of triples < MP,MS,T > whereMPis a model of the problem solved by the pattern,MSis a model of the solution proposed by the pattern, andTis a model transformation of an instance of the problem into an instance of the solution. Given an object‐oriented design model, we look for model fragments that matchMP(call them instances ofMP), and when one is found, we apply the transformationTyielding an instance ofMS. Easier said than done. Experimentation with an Eclipse Modeling Framework‐based implementation of our approach applied to a number of open‐source software application's raised fundamental questions about: (i) the nature of design patterns in general, and the ones that lend themselves to our approach, and (ii) our understanding and codification of seemingly simple design patterns. In this paper, we present the principles behind our approach, report on the results of applying the approach to the Gang of Four (GoF) design patterns, and discuss the representability of design problems solved by these patterns. Copyright © 2011 John Wiley & Sons, Ltd.

Design patterns encode proven solutions to recurring design problems. To use a design pattern properly, we need to 1) understand the design problem the pattern resolves, 2) recognize an instance of this problem in the model at hand, and 3) to transform the model to produce the proposed solution. We argue that an explicit representation of the design problem solved by a pattern is key to supporting each one of these tasks. We propose to represent a design pattern using a triple (MP, MS, T) where MP is a model of the design problem solved by the pattern, MS is a model of the solution proposed by it, and T is a rule-based representation of the transformations embodied in the application of the pattern. In this paper, we describe the principles underlying our approach and the current implementation using the Eclipse Modeling FrameworkTMand JRulesTM.