Wesley Klewerton Guez Assunção

North Carolina State University | NCSU · Department of Computer Science

Consistency checking is widely used to detect inconsistencies in engineering artifacts. In collaborative modeling environments, however, maintaining model consistency is challenging due to the frequent changes introduced by multiple engineers, leading to possibly numerous inconsistencies. These inconsistencies need to be identified and shared among...

Refactoring is a non-trivial maintenance activity. Developers spend time and effort refactoring code to remove structural problems, i.e., code smells. Recent studies indicated that developers often apply composite refactoring (composite, for short), i.e., two or more interrelated refactorings. However, prior studies revealed that only 10% of compos...

Refactoring is a non-trivial maintenance activity. Developers spend time and effort refactoring code to remove structural problems, i.e., code smells. Recent studies indicated that developers often apply composite refactoring (composite, for short), i.e., two or more interrelated refactorings. However, previous studies revealed that only 10% of com...

Bug localization is the task of recommending source code locations (typically files) that contain the cause of a bug and hence need to be changed to fix the bug. Along these lines, information retrieval-based bug localization (IRBL) approaches have been adopted, which identify the most bug-prone files from the source code space. In current practice...

The adoption of microservice architecture has seen a considerable upswing in recent years, mainly driven by the need to modernize legacy systems and address their limitations. Legacy systems, typically designed as monolithic applications, often struggle with maintenance, scalability, and deployment inefficiencies. This study investigates the motiva...

Metamodels like many other software artifacts, are expected to evolve and exist in different versions. Consequently, the instances of these metamodels (models), become invalid and need fixing. The usual strategy for this is adapting models based on changes made to the metamodels, i.e., co-evolution. However, co-evolution usually adopts an all-or-no...

Microservices emerged as a popular architectural style over the last decade. Although microservices are designed to be self-contained, they must communicate to realize business capabilities, creating dependencies among their data and functionalities. Developers then resort to asynchronous, event-based communication to fulfill such dependencies whil...

Software modernization is an inherent activity of software engineering, as inevitably systems become old and technology advances. The term "software modernization" emerged as a research topic in the early 2000's, with a differentiation of the traditional software evolution. Studies on this topic became popular due to new programming paradigms, tech...

Non-Functional Requirements (NFRs) should be defined in the early stages of the software development process, driving developers to make important design decisions. Neglecting NFRs may lead developers to create systems that are difficult to maintain and do not meet users expectations. Despite their importance, the discussion of NFRs is often ad-hoc...

Collaborative Model-driven Software Engineering (CoMDSE) involves multiple engineers working together on modifying domain-specific models. This collaborative effort, however, can lead to conflicts during merges due to differing perspectives and goals among engineers. Solutions primarily focus on resolving conflicts during merges, but these approach...

Model-Based Engineering (MBE) has streamlined software development by focusing on abstraction and automation. The adoption of MBE in Maintenance and Evolution (MBM&E), however, is still limited due to poor tool support and a lack of perceived benefits. We argue that Generative Artificial Intelligence (GenAI) can be used as a means to address the li...

Testing Highly Configurable Systems (HCSs) is a challenging task, especially in an evolution scenario where features are added, changed, or removed, which hampers test case selection and prioritization. Existing work is usually based on the variability model, which is not always available or updated. Yet, the few existing approaches rely on links b...

Modern software development relies on cloud-based collaborative platforms (e.g., GitHub and GitLab), characterized by remote, distributed, and asynchronous collaboration. In these platforms, developers often employ a pull-based development approach, proposing changes via pull requests and engaging in communication via message exchanges. Since commu...

Collaborative model-driven development is a de facto practice to create software-intensive systems in several domains (e.g., aerospace, automotive, and robotics). However, when multiple engineers work concurrently, keeping all model artifacts synchronized and consistent is difficult. This is even harder when the engineering process relies on a myri...

Metamodels, as any other software artifact, are expected to evolve. Consequently, the instances of those metamodels - aka the models- must evolve according to the changes made to the metamodels.This is commonly known as co-evolution and is a prominent research topic in Model Driven Engineering. However, co-evolutionmostly adopts an all-or-nothing s...

The modernization of monolithic legacy systems with microservices has been a trend in recent years. As part of this modernization, identifying microservice candidates starting from legacy code is challenging, as maintainers may consider many criteria simultaneously. Multi-objective search-based approaches represent a promising state-of-the-art solu...

Background: Code development is done collaboratively in platforms such as GitHub and GitLab, following a pull-based development model. In this model, developers actively communicate and share their knowledge through conversations. Pull request conversations are affected by social aspects such as communication dynamics among developers, discussion c...

Repairing design models is a laborious task that requires a considerable amount of time and effort from developers. Repair recommendation (RR) approaches focus on reducing the effort and improving the quality of the repairs performed. Such approaches have been evaluated in terms of scalability, correctness, and minimalism. These evaluations, howeve...

Modern programming languages, such as Java, use exception-handling mechanisms to guarantee the robustness of software systems. Although important, the quality of exception code is usually poor and neglected by developers. Indiscriminate robustness changes (e.g., the addition of empty catch blocks) can indicate design decisions that negatively impac...

Bug localization is the task of recommending source code locations (typically files) that probably contain the cause of a bug and hence need to be changed to fix the bug. Along these lines, information retrieval-based bug localization (IRBL) approaches have been adopted, which identify the most bug-prone files from the source code space. In current...

A large number of bug reports are created during the evolution of a software system. Locating the source code files that need to be changed in order to fix these bugs is a challenging task. Information retrieval-based bug localization techniques do so by correlating bug reports with historical information about the source code (e.g., previously res...

Maintaining the consistency of engineering artifacts is a challenge faced by several engineering companies. This is more evident when the engineering artifacts are created using different tools and have different formats. This is the context of a company that builds agricultural machines, where components are developed using a decentralized iterati...

With the increasing prevalence of AI, a key question is how to adequately prepare the next generation of software engineers to build AIintensive systems. This article presents our teaching experience for the “Engineering of AI-intensive Systems” course to postgraduate students. This course is tailored for computer science students, bridging the dis...

Context: code refactoring is a code transformation that aims to improve software quality. A composite refactoring (or, simply, composite) is defined by two or more interrelated refactorings, which is often applied by developers. Each composite needs to be somehow represented and has its own characteristics (e.g., code scope) as well as its effects...

Effectively using software languages, be it programming or domain-specific languages, requires effective editing support. Modern IDEs, modeling tools, and code editors typically provide sophisticated support to create, comprehend, or modify instances—programs or models—of particular languages. Unfortunately, building such editing support is challen...

Code smells are symptoms of poor design that hamper software evolution and maintenance. Hence, code smells should be detected as early as possible to avoid software quality degradation. However, the notion of whether a design and/or implementation choice is smelly is subjective, varying for different projects and developers. In practice, developers...

Design degradation problems occur as a result of sub-optimal decisions that negatively impact internal software quality. These problems can affect isolated elements (e.g., a class) or multiple code elements (e.g., components). When neglected, design degradation increases maintenance costs. In this scenario, refactoring is paramount to keep internal...

In large code bases, locating the elements that implement concrete features of a system is challenging. This information is paramount for maintenance and evolution tasks, although not always explicitly available. In this work, motivated by the needs of locating features as a first step for feature-based Software Product Line adoption, we propose a...

Software reuse is a way to reduce costs and improve the quality of products. In practice, software reuse is commonly done by opportunistic strategies. In these strategies, the artifacts are simply copied/cloned and modified/adapted to fulfill existing needs. Opportunistic reuse leads to a set of system variants developed independently, generating t...

Variability makes it possible to easily change and adapt software systems for specific contexts in a preplanned manner. It has been considered in several research topics, including self-adaptive systems, large-scale enterprise systems, and system-of-systems, and was mainly consolidated by the Software Product Line (SPL) engineering. SPL manages a c...

The Product Line Architecture (PLA) is a crucial artifact for the development of Software Product Lines. However, PLA is a complex artifact to be designed due to its large size and the multiple conflicting properties that need to be considered to ensure its quality, requiring a great effort for the architect. PLA designing has been formulated as an...

Families of software products are usually created using opportunistic reuse (clone-and-own) in which products are cloned and adapted to meet new requirements, user preferences, or non-functional properties. Opportunistic reuse brings short-term benefits, e.g., reduced time-to-market, whereas creating long-term drawbacks, e.g., the need of changing...

Software companies commonly develop and maintain variants of systems, with different feature combinations for different customers. Thus, they must cope with variability in space. Software companies further must cope with variability in time, when updating system variants by revising existing software features. Inevitably, variants evolve orthogonal...

Highly-Configurable Software (HCSs) testing is usually costly, as a significant number of variants need to be tested. This becomes more problematic when Continuous Integration (CI) practices are adopted. CI leads the software to be integrated and tested multiple times a day, subject to time constraints (budgets). To address CI challenges, a learnin...

Among the approaches to develop Software Product Lines (SPL), the extractive approach is adopted when the company has a set of similar systems that are analyzed to extract, categorize, and group their features throughout the SPL reengineering process. However, SPL reengineering scenarios differ due to different variables, such as the experience of...

Software Product Lines (SPLs) are rarely developed from scratch. Commonly, they emerge from one product when there is a need to create tailored variants, or from existing variants created in an ad-hoc way once their separated maintenance and evolution become challenging. Despite the vast literature about re-engineering systems into SPLs and related...

Repairing software models may be a laborious task, as the number of alternatives that must be considered by engineers can be large. This is more evident in collaborative environments, where the stream of changes applied to models by different engineers is constant and unanticipated. These changes can cause multiple inconsistencies that must be fixe...

There are many repair alternatives for resolving model inconsistencies, each involving one or more model changes. Enumerating them all could overwhelm the developer because the number of possible repairs can grow exponentially. To address this problem, this paper focuses on the immediate cause of an inconsistency. By focusing on the cause, we can g...

The expensive maintenance of legacy systems leads companies to migrate such systems to modern architectures. Microservice architectural style has become a trend to modernize monolithic legacy systems. A microservice architecture consists of small, autonomous, and highly-independent services communicating by using lightweight network protocols. To s...

Developers constantly perform code changes throughout the lifetime of a project. These changes may induce the introduction of design problems (design decay) over time, which may be reduced or accelerated by interacting with different factors (e.g., refactorings) that underlie each change. However, existing studies lack evidence about how these fact...

Software product line (SPL) scoping aids companies to define the boundaries of their resources such as products, domains, and assets, the target of reuse tasks scoping technical and organizational aspects. As scoping guides the management of the resources in SPL development, it becomes one of the core activities in this process. We can find in the...

Software product line (SPL) scoping aids companies to define the boundaries of their resources such as products, domains, and assets, the target of reuse tasks scoping technical and organizational aspects. As scoping guides the management of the resources in SPL development, it becomes one of the core activities in this process. We can find in the...