This document introduces ADPS (Asynchronous Distributed Publish Subscribe), a PubSub-based communication model tailored for a hierarchical architecture distributed on Edge, Fog, and Cloud layers. The primary challenge addressed by this model is establishing runtime connections between subscribers and data providers, enabling communication across various segments. ADPS is implemented within a Smart Cities healthcare application, monitoring vital statistics via IoT devices. Furthermore, this work will cover the specifications of message formats, topic definitions, message delivery reliability and latency effects, broker configurations, control data exchange among nodes, and the dynamic behaviour of topology due to user movement and structural changes with node additions at the Edge and Fog levels. Test results from the model’s most demanding scenarios showed latency variations of approximately 200ms, 300ms, and 400ms with quality of service levels 0, 1, and 2 from the initial Fog node to the Cloud.
Product Line Architecture (PLA) design can be modeled as an optimization problem to be solved with search-based algorithms. PLA design optimization has successfully been done using the Non-Dominated Sorting Genetic Algorithm II (NSGA-II) in scenarios involving up to three objectives, which involve software metrics for properties such as feature modularization, PLA extensibility, and cohesion. As many of these properties may be desired in a PLA at the same time, more than three objectives might need to be optimized simultaneously. The Non-Dominated Sorting Genetic Algorithm III (NSGA-III) was designed to solve problems impacted by more than three objectives, named many-objective problems, so it might suit this need. However, NSGA-III has not yet been applied in the context of PLA design. In this sense, this study aims to compare the performance of NSGA-II and NSGA-III for PLA design to uncover which algorithm best fits this problem. To accomplish this goal, we implemented a specialized version of NSGA-III and then ran experiments using both algorithms to optimize eight PLAs with three, four, and five objectives. We evaluate the algorithms’ performance via quality indicators commonly used in search-based software engineering. The empirical results point out that: (i) NSGA-III had a slightly better performance than NSGA-II when optimizing four or five objectives in the context of our study; (ii) NSGA-II was the best or the algorithms tied when the PLA given as input is easier to optimize due to reduced solution space.
The software development process has been studied since the beginning of technological evolution. Development practices have evolved, requiring processes capable of supporting intensive work, paving the way for agile methodologies. With the growing need for continuous integration (CI) and continuous deployment/delivery (CD), new data architectures have emerged, allowing for scalable, maintainable, and reusable environments, collectively known as DevOps (Development + Operations). In this context, the DevDocOps approach integrates continuous documentation into the software development lifecycle. However, little has been published regarding the benefits of this approach. To address this, an empirical study was conducted, applying findings from the literature to a real development environment by integrating continuous documentation into the data engineering development lifecycle. Based on feedback from developers and technical lead, the results highlight the importance of technical documentation in an agile development environment and demonstrate how automating this process can improve the quality and efficiency of software deliveries.
Healthcare services and IoT, as highlighted by Hu et al. [9], generate enormous volumes of time series data. Using caching in serverless functions can significantly reduce latency and improve performance when storing frequently accessed data in memory. Although several approaches offer improvements, such as the use of in-memory caching, data prediction, and distributed systems, none of them fully addresses the need for a robust and efficient system for time series in healthcare, leaving a gap in necessary data availability and optimization. The TriCache model proposes a three-tier caching system to optimize storage and access to time series data in healthcare serverless functions, using a combination of memory in the serverless function, in-memory cache, and disk storage, in addition to predictive intelligence. The main contribution of the model is the significant reduction in latency and the improvement in the hit rate by efficiently predicting and allocating data across different cache layers. Experiments demonstrated a notable reduction in response time, with a 110 millisecond decrease in the 99th percentile. Additionally, the model performed significantly, achieving a 93% hit rate, compared to the 78% observed in the traditional model.
Software reuse has been recognized as a key strategy for improving productivity, reducing development costs, and enhancing software quality. However, successfully implementing software reuse practices largely depends on the developer experience (DX). This study investigates the factors, barriers, and strategies influencing DX in software reuse. Through a Rapid Review (RR), we analyzed 328 studies, selecting 10 for detailed data extraction based on defined filters and the backward snowballing technique. Our findings identify 15 factors affecting DX in software reuse, categorized into technical, organizational, and human/social factors. We also uncover 7 barriers that impede developers from improving DX and identify 13 strategies to enhance it. The results highlight the critical role of comprehensive documentation, a clear understanding of software functionality, and robust reuse-compatible infrastructure as key technical factors. Organizational support, effective resource allocation, and fostering a communication, collaboration, and self-efficacy culture are essential for successful software reuse. This study’s insights have significant implications for researchers and practitioners, offering practical guidance to develop more effective reuse practices and improve DX.
As the global population of older adults continues to increase, there is a growing need for innovative technology solutions to improve their well-being and care. One prominent example is the Ambient-Assisted Living (AAL) domain, which involves the connection of many subsystems and heterogeneous devices to offer intelligent services in the user’s living ambient. One of the main challenges in developing AAL systems is the lack of interoperability, which can occur at different levels (from integration between different systems to the semantic level of the data). Although there are several solutions and approaches to this problem, there is no organized body knowledge about interoperability for AAL systems impacting decision making on which approach to use in developing this type of system. This paper proposes a Non-Functional Requirements (NFR) catalog dedicated to interoperability in AAL systems. This catalog establishes relationships among technologic strategies, architectural patterns, platform types, communication protocols, and data semantic and syntactic aspects. We extracted data about interoperability in AAL systems from the academic literature. We identified 25 studies focused on AAL systems prioritizing interoperability as a critical requirement by conducting a systematic mapping followed by a forward snowballing process. We then employed Grounded Theory (GT) to extract information regarding the interoperability characteristics specific to AAL from these documents, finding 41 softgoals and 29 operationalizations. Finally, we validate our findings with two specialists.
Search-based design of Product Line Architecture (PLA) focuses on enhancing the design and functionality of software product lines through variability management, reuse, and optimization. A particular challenge in this area is the selection of objective functions, which significantly influence the success of the search process. Moreover, many objectives make the analysis and choice of a solution to be used harder. The literature has assigned this task to the PLA designer, i.e., the Decision-Maker (DM), who does not always know all the functions and their impact on the optimization outcomes. On the other hand, recent research shows that Large Language Models (LLMs), particularly the Generative Pre-trained Transformer series (GPT), have obtained promising results to help in various Software Engineering (SE) tasks. Considering this fact, this work explores the integration of such LLMs, notably ChatGPT, into the search-based PLA design. By leveraging LLMs’ capacity to understand/generate human-like text, we investigate their potential to assist DMs and propose an approach for suggesting objective functions, thereby simplifying and improving decision-making in PLA design optimization. Through empirical tests and qualitative feedback from domain experts, this research highlights the application of LLMs in search-based SE. The results demonstrate that integrating ChatGPT into PLA design can significantly enhance decision-making efficiency and solution quality, with a 40% reduction in time required for selecting objective functions and a 25% improvement in solution quality from the DM’s point of view. This study maps out the challenges and opportunities that lie ahead in fully harnessing their potential for PLA search-based design.
Recent discussions have delved extensively into Smart Homes, focusing on constructing and integrating services into an architecture capable of supporting the daily routine of the homes of several users and providing a stable operation. When artificial intelligence is added to a development architecture with devices that interface between man and machine, creating a system that operates in conjunction with users becomes a real challenge. How the system may or may not behave in the day-to-day lives of users becomes the genuine concern of developers. This brings challenges to be overcome and decisions to be made. Implementation decisions, division and creation of modules, communications between applications, user actions, communication interfaces, server response times, and other issues arise amidst all the complexity of developing for the real world. Observing the current scenario, we present our proposal for a distributed Smart Home architecture integrated with a third-party SAAS-based cloud service with an extensive catalog of smart devices used in a smart home environment. Our architecture obtains data about devices from users’ homes registered in a third-party cloud, and uses Artificial Intelligence to train a model using the user’s routine based on the behavior and use of devices in the house. The system provides recommendations sent directly to the smartphone or smartwatch to help with user comfort or to reduce energy consumption. This work presents the system architecture, technologies, and communications between services. Ultimately, we list the lessons learned in architectural design, solution coding, module integration, communication with smartphones and smartwatches, and working with intelligent physical devices in the user’s environment.
Open-source repositories play a vital role in modern software development, facilitating collaboration and code sharing among developers worldwide. In this study, we investigate the usage of labels in GitHub repositories to understand their impact on the issue resolution process and project management.We employ data mining techniques to gather a dataset comprising 10,673,459 issues from 13,280 repositories hosted on GitHub’s featured topics list. Our study design involves four phases: repository selection, mining repository issues, pre-processing issues’ components, and data processing to address research questions (RQs). The first RQ focuses on the frequency and usage of standard and custom labels in repositories. The second and third RQs delve into the average time for labeling issues and defining the triage phase from labeling practices. We found that 73.14% of repositories employ issue labeling, with most labeling activity concentrated before the 100th day since issue opening. This rapid labeling process is often followed by a structured label change pattern, potentially corresponding to specific issue phases like triage, implementation, or change validation. Analyzing time intervals between label changes, we observed that most issues undergo triage within 1 to 100 days, with labels prioritized based on their frequency in the resolution process. Our analysis sheds light on labels’ significance in organizing and classifying issues through a systematic triage process within open-source repositories. Labels serve as social and technical elements, contributing to enhanced organization, identification, implementation, and validation of code changes. These findings provide valuable insights into the effective management and maintenance of open-source projects, aiding developers and project managers in optimizing issue resolution processes. The results and scripts from our study are available in the supplementary material repository for further exploration and reference by the software engineering community.
Fake News are a contemporary phenomenon with potential devastating effects. For inquiry and auditability purposes, it is essential that the news, once classified as false, can be persisted in an immutable means so that interested parties can query it. Although Blockchain clearly satisfies the main requirements for Fake News Management Software Systems, the prescriptive architectural solutions for that domain that cohabit Blockchain with other technologies in a single proposal still need to be made available. This paper's main contribution is presenting a prescriptive architectural solution for blockchain-based fake news management software systems. The Hoffmeister process for software architecture design is systematically followed to culminate in a software solution for that domain. The implementation of two candidate architectures and a brief simulation-based evaluation show the feasibility of the solution to satisfy the functional and quality requirements.
Designing systems to serve a large number of people, who have similar demands, but also have varied needs and generate a huge volume of data, requires a software architecture that allows constant evolution, is easy to maintain, and has the ability to scale smartly. The SPL technique with microservices architecture seems promising to meet these requirements, but this integration is not trivial. Thus, we conduct a SLR that identified 3 architectures that proposed the combination of these techniques. However, the architectures found were complex and reduced time-to-market, as they proposed the implementation of all resources through microservices. Thus, in order to reduce the complexity of development and, consequently, reduce the time to market, this work presents a proposal for the design of a hybrid SPL architecture, through the combination of large backend APIs and microservices. In addition, this research paper presents a case study that consisted of defining the architecture of a medical clinics SPL as a Multi-tenant Software as a Service. Finally, we compare the complexity of the architecture generated using our approach, with a microservice architecture constructed using other approach found in literature.
Variability management is crucial for companies that need to offer multiple product variants quickly. However, the increasing complexity of software-intensive systems has made variability management increasingly challenging. This challenge is compounded by the need for such systems to run continuously and adapt to changes in the environment and user needs at runtime. To address this challenge, Dynamic Software Product Line (DSPL) Engineering has emerged as a strategy for managing variability in complex and dynamic environments. The key challenge in DSPL engineering is to manage product configurations at runtime by detecting changes in the context and adapting accordingly. In this paper, we propose an adaptation mechanism for DSPL feature models that supports dynamic variability and is based on the MAPE-K model. The mechanism transforms feature model constraints into rules that enable the activation of each feature and annotates contexts in the corresponding features to be activated when changes occur. We have implemented the mechanism in the DyMMer 2.0 modeling tool and evaluated its performance using various DSPL feature models. Additionally, we performed a preliminary evaluation with a proof-of-concept study with an expert to assess its practical usage. Our results demonstrate the effectiveness and practicality of the proposed mechanism in managing variability in complex and dynamic environments.
Developers use code comments for various reasons, such as explaining the produced code, documenting specifications, communicating with other developers, and highlighting future tasks. Software projects with minimal documentation often have a significant number of comments. In this regard, code comment analysis techniques can be used as tools to examine more complex aspects of software projects, such as technical debt generated by merge conflicts. Technical debt resulting from the resolution of merge conflicts occurs when the resulting code contains comments indicating tasks to be performed in the future. No studies directly linking merge conflicts and technical debt were found in the literature. The objective of this work is to identify and analyze code comments generated during the resolution of merge conflicts from this perspective. This process can lead to improvements in software quality and assist in managing technical debt. To achieve this, an exploratory analysis was conducted on 100 software projects, specifically focusing on task annotations originating from the merge conflict resolution. The results revealed that 60.61% of the analyzed projects have at least one code comment indicating the creation or maintenance of technical debt.
The Product Line Architecture (PLA) is one of the most important artifacts of a Software Product Line (SPL). PLA design can be formulated as an interactive optimization problem with many conflicting factors. Incorporating Decision Makers’ (DM) preferences during the search process may help the algorithms find more adequate solutions for their profiles. Interactive approaches allow the DM to evaluate solutions, guiding the optimization according to their preferences. However, this brings up human fatigue problems caused by the excessive amount of interactions and solutions to evaluate. A common strategy to prevent this problem is limiting the number of interactions and solutions evaluated by the DM. Machine Learning (ML) models were also used to learn how to evaluate solutions according to the DM profile and replace them after some interactions. Feature selection performs an essential task as non-relevant and/or redundant features used to train the ML model can reduce the accuracy and comprehensibility of the hypotheses induced by ML algorithms. This work aims to select features of an ML model used to prevent human fatigue in an interactive search-based PLA design approach. We applied four selectors and through results we were able to reduce 30% of features, obtaining an accuracy of 99%.
Software systems must evolve to avoid its degradation. The refactoring technique associated with the application of design patterns help software consistent evolution. A refactoring opportunity consists of a source code that can be altered by refactoring to improve its quality. In this sense, this study presents a mechanic to search refactoring opportunities to Encapsulate Classes with Factory refactoring pattern. Some clues and refactoring steps which aid to solve the indicated problems are described. We conducted a case study with a set of open-source projects to evaluate the opportunities identified by the mechanic.
Background: #ifdefs allow developers to define source code related to features that should or should not be compiled. A feature dependency occurs in a configurable system when source code snippets of different features share code elements, such as variables. Variables that produce feature dependency are called dependent variables. The dependency between two features may include just one dependent variable or more than one. It is reasonable to suspect that a high number of dependent variables and their use make the analysis of variability scenarios more complex. In fact, previous studies show that #ifdefs may affect comprehensibility, especially when their use implies feature dependency. Aims: In this sense, the main goal of our experiment is to evaluate if the comprehensibility of configurable system source code varies according to the number of dependent variables. Testing this hypothesis is important so that we can recommend practitioners and researchers the extent to which writing #ifdef code with dependencies is harmful. Method: We executed a controlled experiment with 12 participants who analyzed programs trying to specify their output. We quantified comprehensibility using metrics based on time and attempts to answer tasks correctly, participants’ visual effort, and participants’ heart rate. Results: Our results indicate that the higher the number of dependent variables the more difficult it was to understand programs with feature dependency. Conclusions: In practice, our results indicate that comprehensibility is more negatively affected in programs with higher number of dependent variables and when these variables are defined at a point far from the points where they are used.
Continuous Integration (CI) is a widely adopted practice in modern software engineering that involves integrating developers’ local changes with the project baseline daily. Despite its popularity, recent studies have revealed that integrating changes can be time-consuming, requiring significant effort to correct errors that arise. This can lead to development activities being paused, including the addition of new features and fixing bugs, while developers focus on analyzing and correcting build failures. In this study, we investigate the factors that influence the time taken to correct build failures in CI. Specifically, we analyze the impact of developer activity, project characteristics, and build complexity on build failure correction time. To conduct our analysis, we collected data from 18 industrial projects of a software company, calculating 13 metrics for each project based on the literature on build failures analysis. We used association rules, a data mining technique, to examine the relationship between the defined factors and build failure correction time. Our findings reveal significant correlations between the factors studied and the duration of build failure correction time. Specifically, we found that more experienced developers require less time to correct build failures, while build failures that originate in the early stages of the project are resolved more quickly. Additionally, we observed that build failures with more lines and modified files tend to have longer correction times. Overall, this study sheds light on the factors that impact build failure correction time in CI. By identifying these factors, our findings can help software development teams optimize their CI processes and minimize the impact of build failures on development activities.
This paper proposes a automated transformation method based on the MDA that performs the transformation from the business process diagram (BPMN) to UML classes diagram. This transformation is accomplished through the relationship between the elements of the business process diagram and the class diagram, which generates the transformation rules which are implemented in the Atlas Transformation Language (ATL). This method is intended to standardize the transformation process and decrease the loss of information between the models during the transformation process. Applying the method in three proofs of concept demonstrated that performing a transformation of BPMN to a class diagram is possible.
Most current mobile applications work with a back-end server over the Internet. But in many occasions network connectivity is not available and a proper offline treatment must be provided. This question can be solved in many ways, such as storing requests for later attempts, caching data and full client-server synchronization, among others. There are solutions both in the industry and academia, however two challenges remain: to solve the problem in a way that covers many software layers, including interface and usability issues; and to support different kinds of treatment to the absence of connection. This paper presents a mobile library built to help developers provide offline functionality on their apps, while trying to solving these two challenges. To do that, the library, called OfflineManager, offers different ways to treat each call to the back-end, both in the case of missing Internet connection and unavailable server. It also offers feedback messages, and a point of interaction via pop-up messages. To evaluate the library, four evaluation methods were used, including experts, developers, users and well-known heuristics. The collected evidence indicates that the library achieves its goal to overcome the two presented challenges, and also uncovers some problems and points for improvement.
