Abstract Software model optimization is a process that automatically generates design alternatives aimed at improving quantifiable non-functional properties of software systems, such as performance and reliability. Multi-objective evolutionary algorithms effectively help designers identify trade-offs among the desired non-functional properties. To reduce the use of computational resources, this work examines the impact of implementing a search budget to limit the search for design alternatives. In particular, we analyze how time budgets affect the quality of Pareto fronts by utilizing quality indicators and exploring the structural features of the generated design alternatives. This study identifies distinct behavioral differences among evolutionary algorithms when a search budget is implemented. It further reveals that design alternatives generated under a budget are structurally different from those produced without one. Additionally, we offer recommendations for designers on selecting algorithms in relation to time constraints, thereby facilitating the effective application of automated refactoring to improve non-functional properties.

Software architecture optimization aims to enhance non-functional attributes like performance and reliability while meeting functional requirements. Multi-objective optimization employs metaheuristic search techniques, such as genetic algorithms, to explore feasible architectural changes and propose alternatives to designers. However, this resource-intensive process may not always align with practical constraints. This study investigates the impact of designer interactions on multi-objective software architecture optimization. Designers can intervene at intermediate points in the fully automated optimization process, making choices that guide exploration towards more desirable solutions. Through several controlled experiments as well as an initial user study (14 subjects), we compare this interactive approach with a fully automated optimization process, which serves as a baseline. The findings demonstrate that designer interactions lead to a more focused solution space, resulting in improved architectural quality. By directing the search toward regions of interest, the interaction uncovers architectures that remain unexplored in the fully automated process. In the user study, participants found that our interactive approach provides a better trade-off between sufficient exploration of the solution space and the required computation time.

Gender bias is a common and often neglected issue in legal documents. It arises from perceptions or prejudices about the characteristics of a group, or the roles individuals should play in society. This bias can significantly impact the reasoning or outcomes of legal processes, such as judicial rulings. To ensure equal treatment for all individuals, it is crucial to effectively reduce this bias. The first step to reduce bias is to define approaches that can identify manifestations of gender bias. However, these manifestations are not usually easily detectable in text (e.g., through keywords) as they often require detailed contextual analysis, typically done manually by experts. This paper addresses this issue by leveraging natural language processing and machine learning techniques to automate parts of the analysis. Specifically, it proposes a processing pipeline based on text embeddings, binary classification, and the use of large language models (LLMs) to explain classification results. An initial evaluation on a set of judicial rulings shows promising results in terms of precision and recall, along with qualitative insights into the potential of these techniques in the legal domain.

The problem of migrating monolithic applications to microservices has become popular both in industry and academia, particularly when using automated tools to assist developers in the decomposition. While a variety of tools and techniques have been proposed, deciding which is the most appropriate decomposition for a given monolith is challenging because the selected technique can return alternative decompositions depending on how the parameters of that technique are configured. This issue has not received enough attention in the literature, and therefore, developers have to resort to their intuition or use the default parameters reported by the authors of the technique. To investigate this problem further, in this work we perform a study of the parameters and variability of the MicroMiner approach, assessing its parameter sensitivity when dealing with two monolithic applications from the literature. Based on a systematic, data-driven analysis of the landscape of possible decompositions, our results show that, depending on the monolithic application provided as input, certain parameters of MicroMiner have more or less importance on the characteristics of the generated decompositions. These findings provide initial guidelines for developers to configure MicroMiner, as well as other approaches, in order to obtain microservice decompositions with relatively low variability.

Group recommenders aim to provide recommendations that satisfy the collective preferences of multiple users, a challenging task due to the diverse individual tastes and conflicting interests to be balanced. This is often accomplished by using aggregation techniques that select items on which the group can agree. Traditional aggregators struggle with these complexities, as items are chosen independently, leading to sub-optimal recommendations lacking diversity, novelty, or fairness. In this paper, we propose an aggregation technique that leverages Monte Carlo Tree Search (MCTS) to enhance group recommendations. MCTS is used to explore and evaluate candidate recommendation sequences to optimize overall group satisfaction. We also investigate the integration of MCTS with LLMs aiming at better understanding interactions between user preferences and recommendation sequences to inform the search. Experimental evaluations, although preliminary, showed that our proposal outperforms existing aggregation techniques in terms of relevance and beyond-accuracy aspects of recommendations. The LLM integration achieved positive results for recommendations’ relevance. Overall, this work highlights the potential of heuristic search techniques to tackle the complexities of group recommendations.

When developing Java Script (JS) applications, the assessment and selection of JS packages have become challenging for developers due to the growing number of technology options available. Given a technology need, a common developers' strat-egy is to query Web repositories via search engines (e.g., NPM, Google) and shortlist candidate JS packages. However, these engines might return a long list of results. Furthermore, these results should be ranked according to the developer's criteria. To address these problems, we developed a recommender system called AIDT that assists developers in the package selection task. AIDT relies on meta-search and machine learning techniques to infer the relevant packages for a query. An initial evaluation of AIDT showed good search effectiveness. Recently, the emergence of ChatGPT has opened new opportunities for this kind of assistants, as reported by some experiments. Anyway, human developers should judge whether the recommendations (e.g., JS packages) of these tools are fit to purpose. In this paper, we report on a user study in which we used both AIDT and ChatGPT on a sample of JS-related queries, compared their results, and also validated them against developers' criteria and expectations for the task. Our initial findings show that ChatGPT is not yet on par with AIDT or even human efforts for the task at hand, but the model is flexible to be improved and furthermore, it can provide good arguments for its package choices.

When developing JavaScript (JS) applications, the assessment of JS packages has become a difficult and time-consuming task for developers, due to the growing number of technology options available. Given a technology need, a common developers’ strategy is to browse software repositories via search engines (e.g., NPM, Google) and identify candidate JS packages. However, these engines might return a long list of results, which often causes information overloading issues in the developer. Furthermore, the results should be ranked according to the developer’s criteria, but weighting the available criteria to choose a JS package is not straightforward. To address these problems, we propose a two-phase recommender system for assisting developers in retrieving and ranking JS packages in a semi-automated fashion. The first phase uses a meta-search technique for collecting JS packages that meet the developer’s needs. Based on criteria used by other projects on the Web, the second phase applies a machine learning technique to infer a ranking of relevant packages for the output of the first phase. We performed an initial evaluation of our approach with the NPM package repository and obtained satisfactory results in terms of both the accuracy of the retrieved packages and the quality of the ranking for the developers.

Context: Software projects are common inputs in Empirical Software Engineering (ESE) studies, although they are often selected with ad-hoc strategies that reduce the generalizability of the results. An alternative is the usage of available datasets of software projects, which should be current and follow explicit rules for ensuring their validity over time. Goal: In this context, it is important to assess the general state of software datasets in terms of purpose, last update, project characterization, source code metrics, and tools to extract source-code-related artifacts. Method: We conducted a systematic mapping study retrieving software datasets used in ESE studies published from January 2013 to December 2021. Results: We selected 74 datasets created mainly for software defects, software estimation, and software maintainability studies. The majority of these datasets (64%) explicitly stated the characteristics to select the projects, and the most common programming languages were Java and C. Conclusions: Our study identified scarce efforts to keep datasets updated over time and also provides recommendations to support their construction and consumption for ESE studies.

The COVID-19 pandemic has affected all aspects of society, bringing health hazards and posing challenges to public order, governments, and mental health. This study examines the stages of crisis response and recovery as a sociological problem by operationalising a well-known model of crisis stages in terms of a psycho-linguistic analysis. Based on an extensive collection of Twitter data spanning from March to August 2020 in Argentina, we present a thematic study on the differences in language used in social media posts and look at indicators that reveal the distinctive stages of a crisis and the country response thereof. The analysis was combined with a study of the temporal prevalence of mental health related conversations and emotions. This approach can provide insights for public health policy design to monitor and eventually intervene during the different stages of a crisis, thus improving the adverse mental health effects on the population.

Software systems naturally evolve, and this evolution often brings design problems that cause system degradation. Architectural smells are typical symptoms of such problems, and several of these smells are related to undesired dependencies among modules. The early detection of these smells is important for developers, because they can plan ahead for maintenance or refactoring efforts, thus preventing system degradation. Existing tools for identifying architectural smells can detect the smells once they exist in the source code. This means that their undesired dependencies are already created. In this work, we explore a forward-looking approach that is able to infer groups of likely module dependencies that can anticipate architectural smells in a future system version. Our approach considers the current module structure as a network, along with information from previous versions, and applies link prediction techniques (from the field of social network analysis). In particular, we focus on dependency-related smells, such as Cyclic Dependency and Hub-like Dependency, which fit well with the link prediction model. An initial evaluation with two open-source projects shows that, under certain considerations, the predictions of our approach are satisfactory. Furthermore, the approach can be extended to other types of dependency-based smells or metrics.

Summary The manifestation of code anomalies in software systems often indicates symptoms of architecture degradation. Several approaches have been proposed to detect such anomalies in the source code. However, most of them fail to assist developers in prioritizing anomalies harmful to the software architecture of a system. This article presents an investigation on how developers, when supported by architecture blueprints, are able to prioritize architecturally relevant code anomalies. First, we performed a controlled experiment where participants explored both blueprints and source code to reveal architecturally relevant code anomalies. Although the use of blueprints has the potential to improve code anomaly prioritization, the participants often made several mistakes. We found these mistakes might occur because developers miss relationships between implementation and blueprint elements when they prioritize anomalies in an ad hoc manner. Furthermore, the time spent on the prioritization process was considerably high. Aiming to improve the accuracy and effectiveness of the process, we provided means to automate the prioritization process. In particular, we explored 3 prioritization criteria, which establish different ways of relating the blueprint elements with code anomalies. These criteria were implemented in the JSpIRIT tool. The approach was evaluated in the context of 2 applications with satisfactory precision results.

Code smells are a popular mechanism for identifying structural design problems in software systems. Several tools have emerged to support the detection of code smells and propose some refactorings. However, existing tools do not guarantee that a smell will be automatically fixed by means of refactorings. This article presents Bandago, an automated approach to fix a specific type of code smell called Brain Method . A Brain Method centralizes the intelligence of a class and manifests itself as a long and complex method that is difficult to understand and maintain by developers. For each Brain Method , Bandago recommends several refactoring solutions to remove the smell using a search strategy based on simulated annealing. Our approach has been evaluated with several open-source Java applications, and the results show that Bandago can automatically fix more than 60% of Brain Methods . Furthermore, we conducted a survey with 35 industrial developers that showed evidence about the usefulness of the refactorings proposed by Bandago. Also, we compared the performance of the Bandago against that of a third-party refactoring tool.

Developing high-quality requirements specifications often demands a thoughtful analysis and an adequate level of expertise from analysts. Although requirements modeling techniques provide mechanisms for abstraction and clarity, fostering the reuse of shared functionality (e.g., via UML relationships for use cases), they are seldom employed in practice. A particular quality problem of textual requirements, such as use cases, is that of having duplicate pieces of functionality scattered across the specifications. Duplicate functionality can sometimes improve readability for end users, but hinders development-related tasks such as effort estimation, feature prioritization and maintenance, among others. Unfortunately, inspecting textual requirements by hand in order to deal with redundant functionality can be an arduous, time-consuming and error-prone activity for analysts. In this context, we introduce a novel approach called ReqAligner that aids analysts to spot signs of duplication in use cases in an automated fashion. To do so, ReqAligner combines several text processing techniques, such as a use-case-aware classifier and a customized algorithm for sequence alignment. Essentially, the classifier converts the use cases into an abstract representation that consists of sequences of semantic actions, and then these sequences are compared pairwise in order to identify action matches, which become possible duplications. We have applied our technique to five real-world specifications, achieving promising results and identifying many sources of duplication in the use cases.

Abstract Finding software faults is a problematic activity in many systems. Existing approaches usually work close to the system implementation and require developers to perform different code analyses. Although these approaches are effective, the amount of information to be managed by developers is often overwhelming. This problem calls for complementary approaches able to work at higher levels of abstraction than code, helping developers to keep intellectual control over the system when analyzing faults. In this context, we present an expert‐system approach, called FLABot, which assists developers in fault‐localization tasks by reasoning about faults using software architecture models. We have evaluated a prototype of FLABot in two medium‐size case studies, involving novice and non‐novice developers. We compared time consumed, code browsed and faults found by these developers, with and without the support of FLABot, observing interesting effort reductions when applying FLABot. The results and lessons learned have shown that our approach is practical and reduces the efforts for finding individual faults.

Abstract Some of the challenges faced by most software projects are tight budget constraints and schedules, which often make managers and developers prioritize the delivery of a functional product over other engineering activities, such as software documentation. In particular, having little or low‐quality documentation of the software architecture of a system can have negative consequences for the project, as the architecture is the main container of the key design decisions to fulfill the stakeholders' goals. To further complicate this situation, generating and maintaining architectural documentation is a non‐trivial and time‐consuming activity. In this context, we present a tool approach that aims at (i) assisting the documentation writer in their tasks and (ii) ensuring a cost‐effective documentation process by means of optimization techniques. Our tool, called SADHelper, follows the principle of producing reader‐oriented documentation, in order to focus the available, and often limited, resources on generating just enough documentation that satisfies the stakeholders' concerns. The approach was evaluated in two experiments with users of software architecture documents, with encouraging results. These results show evidence that our tool can be useful to reduce the documentation costs and even improve the documentation quality, as perceived by their stakeholders. Copyright © 2015 John Wiley & Sons, Ltd.

Abstract: Software architectures are very important to capture early design decisions and reason about quality attributes of a system. Unfortunately, there are mismatches between the quality attributes prescribed by the architecture and those realized by its object‐oriented implementation. The mismatches decrease the ability to reason architecturally about the system. Developing an object‐oriented materialization that conforms to the original architecture depends on both the application of the right patterns and the developer's expertise. Since the space of allowed materializations can be really large, tool support for assisting the developer in the exploration of alternative materializations is of great help. In previous research, we developed a prototype for generating quality‐preserving implementations of software architectures, using pre‐compiled knowledge about architectural styles and frameworks. In this paper, we present a more flexible approach, called SAME, which focuses on the architectural connectors as the pillars for the materialization process. The SAME design assistant applies a case‐based reasoning (CBR) metaphor to deal with connector‐related materialization experiences and quality attributes. The CBR engine is able to recall and adapt past experiences to solve new materialization problems; thus SAME can take advantage of developers' knowledge. Preliminary experiments have shown that this approach can improve the exploration of object‐oriented solutions that are still faithful to the architectural prescriptions.

Architecture evolution, a key aspect of software evolution, is typically done in an ad hoc manner, guided only by the competence of the architect performing it. This process lacks the rigor of an engineering discipline. In this paper, we argue that architecture evolution must be engineered - based on rational decisions that are supported by formal models and objective analyses. We believe that evolutions of a restricted form - close-ended evolution, where the starting and ending design points are known a priori - are amenable to being engineered. We discuss some of the key challenges in engineering close-ended evolution. We present a conceptual framework in which an architecture evolutionary trajectory is modeled as a sequence of steps, each captured by an operator. The goal of our framework is to support exploration and objective evaluation of different evolutionary trajectories. We conclude with open research questions in developing this framework.

Given the difficulties of conventional object technologies to deal with quality-attribute concerns, software architectures appear as an interesting approach to manage them better. A problem to make this approach feasible is the gap between architectural and object models. Succeeding in bridging these two worlds implies that those design decisions about quality attributes made at the architectural level should be reflected at the object level. Nonetheless, a given architecture usually admits multiple, different materializations. Furthermore, any materialization requires considerable design background and experience from the developer. In this paper, we describe a tool approach, called ArchMatE, to assist developers in the exploration of object-oriented solutions for grounding specific architectural models. An important aspect of the approach is that the materializations are accomplished by means of quality-oriented strategies, so that those concerns prescribed by the original architecture are mostly preserved.

No abstract available.

Summary form only given. Proposes an approach for enhancing aspect-oriented software development considering aspects as first-class design entities. The proposal puts together lines of research coming from different fields, namely: aspect-oriented frameworks, aspect models extending UML models, knowledge-driven framework documentation and agent-based planning. The concept of smart-weaving promotes essentially an early incorporation of aspects in the development cycle, so that designers are able to specify their designs by means of aspect models, reuse parts of these models, and also provide different strategies to map generic aspect structures to specific implementations. With this purpose, we have built an experimental environment called Smartweaver aiming to support this process. The kind of assistance provided by the tool relies on the Smartbooks method, a method extending traditional techniques for framework documentation. Smartbooks includes a special planning agent that is able to derive the sequence of activities that should be executed to implement a given functionality from a target framework.

Abstract In this article, we present an approach to architecture‐driven design of object‐oriented frameworks based on the notion of object‐oriented materialization of architectural styles. This approach leads us to the development of the proto‐framework concept, which is a new denomination for an object‐oriented framework that provides the essential basis to build other frameworks that adopt an underlying architectural design derived from non‐object‐oriented styles. In this context, we describe the approach to framework design, the design of a particular proto‐framework called Bubble, and a real example of its application to the design of an enterprise framework. Copyright © 2002 John Wiley & Sons, Ltd.

Enforcing framework adaptability is one of the key points in the process of building an object-oriented application framework. When it comes to simulation, some adaptation mechanisms to configure components on-the-fly are usually required in order to produce quality software artifacts and alleviate development effort. The paper reports on an experience using a simulation multi-agent framework, initially conceived to be used in fluid flow problems. The framework architecture demonstrated during its evolution a great potential regarding to flexibility and modularity, tackling a wide range of other problems ranging from a network protocol simulation to a soccer simulation.