Search

This paper presents a novel European Master programme on Software Engineering (SE), being put forward by four leading institutions from Sweden, UK, Netherlands and Italy. The Global SE European Master (GSEEM) programme aims to provide students with an excellence in SE based on sound theoretical foundations and practical experience, as well as preparing them to participate in the global development of complex and large software systems. GSEEM has been designed with two aspects of note: 1) the three specialization profiles in which the consortium excels: Software Architecting, Real-time Embedded Systems Engineering, and Web Systems and Services Engineering; 2) an innovative concept of 'shared modules', delivered all together by multiple institutions. Four types of shared modules are foreseen: 'parallel' twin modules, which run remotely between universities, 'shifted' modules, which teach SE concepts incrementally with shifts in study locations and timeline, 'complementary' modules in which complementary SE concepts are taught in parallel through shared projects, and 'common' modules, which share the presentations and the project. The profiles realize 'integrated knowledge' by complementing partial knowledge available at partner institutions. The paper presents some of the important issues faced during the design of the program and explains how GSEEM achieves the objectives of educating global software engineers. The lessons learned from the GSEEM design are of a technical, pedagogical and organisational or administrative nature. [ABSTRACT FROM AUTHOR]

In this article we report some practical experiences of integrating education for sustainable development into established university teaching modules. The 2021 guidance on Education for Sustainable Development from the UK's standards bodies QAA and Advance HE is an important and urgent motivation for introducing sustainability into university courses. We take as our context a first-year introductory module in Chemical Products and Process in the School of Chemistry and Chemical Engineering and a second-year module in Software Engineering and Systems Development in the School of Electronics, Electrical Engineering and Computer Science, both at Queen's University Belfast. We outline some of the challenges of adding new themes to existing courses. We comment on ways of presenting themes of sustainable development alongside existing module content, and we indicate the type of work students produced. We identify approaches that resulted in good outcomes, and outline changes we have made with a view to improved future outcomes. [ABSTRACT FROM AUTHOR]

Despite the increase in the efficiency of energy consumption in information and communication technology, software execution and its constraints are responsible for how energy is consumed in hardware hosts. Consequently, researchers have promoted the development of sustainable software with new development methods and tools to lessen its hardware demands. However, the approaches developed so far lack cohesiveness along the stages of the software development life cycle (SDLC) and exist outside of a holistic method for green software development (GSD). In addition, there is a severe lack of approaches that target the analysis and design stages of the SDLC, leaving software architects and designers unsupported. In this article, we introduce our behavior-based consumption profile (BBCP) external Domain-Specific Language (DSL), aimed at assisting software architects and designers in modeling the behavior of software. The models generated with our external DSL contain multiple sets of properties that characterize features of the software's behavior. In contrast to other modeling languages, our BBCP emphasizes how time and probability are involved in software execution and its evolution over time, helping its users to gather an expectation of software usage and hardware consumption from the initial stages of software development. To illustrate the feasibility and benefits of our proposal, we conclude with an analysis of the model of a software service created using the BBCP, which is simulated using Insight Maker to obtain an estimation of hardware consumption and later translated to energy consumption. [ABSTRACT FROM AUTHOR]

Cloud computing is characterized as a shared computing and communication infrastructure. It encourages the efficient and effective developmental processes that are carried out in various organizations. Cloud computing offers both possibilities and solutions of problems for outsourcing and management of software developmental operations across distinct geography. Cloud computing is adopted by organizations and application developers for developing quality software. The cloud has the significant impact on utilizing the artificial complexity required in developing and designing quality software. Software developmental organization prefers cloud computing for outsourcing tasks because of its available and scalable nature. Cloud computing is the ideal choice utilized for development modern software as they have provided a completely new way of developing real‐time cost‐effective, efficient, and quality software. Tenants (providers, developers, and consumers) are provided with platforms, software services, and infrastructure based on pay per use phenomenon. Cloud‐based software services are becoming increasingly popular, as observed by their widespread use. Cloud computing approach has drawn the interest of researchers and business because of its ability to provide a flexible and resourceful platform for development and deployment. To determine a cohesive understanding of the analyzed problems and solutions to improve the quality of software, the existing literature resources on cloud‐based software development should be analyzed and synthesized systematically. Keyword strings were formulated for analyzing relevant research articles from journals, book chapters, and conference papers. The research articles published in (2011–2021) various scientific databases were extracted and analyzed for retrieval of relevant research articles. A total of 97 research publications are examined in this SLR and are evaluated to be appropriate studies in explaining and discussing the proposed topic. The major emphasis of the presented systematic literature review (SLR) is to identify the participating entities of cloud‐based software development, challenges associated with adopting cloud for software developmental processes, and its significance to software industries and developers. This SLR will assist organizations, designers, and developers to develop and deploy user‐friendly, efficient, effective, and real time software applications. [ABSTRACT FROM AUTHOR]

Self-adaptive systems are capable of reconfiguring themselves while in use to reduce the risks forced by environments for which they may not have been specifically designed. Runtime validation techniques are required because complex self-adaptive systems must consistently offer acceptable behavior for important services. The runtime testing can offer further confidence that a self-adaptive system will continue to act as intended even when operating in unknowable circumstances. This article introduces an evolutionary framework that supports adaptive testing for self-adaptive systems. The objective is to ensure that the adaptive systems continue to operate following its requirements and that both test plans and test cases continuously stay relevant to shifting operational conditions. The proposed approach using the Strength Pareto Evolutionary Algorithm 2 (SPEA2) algorithm facilitates both the execution and adaptation of runtime testing operations. [ABSTRACT FROM AUTHOR]

Various approaches toward the development of sustainable software systems have been proposed by the requirements engineering community over the last decade. We conducted a systematic mapping study, analyzed 55 publications, and identified 29 approaches that have been published since the year 2000. We analyzed how the approaches evolved over time and how the publications and authors are influenced by each other. Furthermore, the approaches are analyzed in terms of their supported requirements engineering activities, along with the evidence provided in the publications. Additionally, we also analyzed which sustainability definitions have been used, if an iterative application of the approaches is discussed, and if the approaches also provide a tool-support for practitioners. We noticed an increase of publications on requirements engineering approaches toward sustainability in the last years, whereas a majority discuss sustainability based on the same multi-dimensional concept. Although different case studies have been already conducted, we noticed a lack of an industrial application. Our main findings concern the need of an evaluation on how the proposed requirements engineering approaches can also be applied in agile software development processes. Additionally, we also promote the development of supporting software tools to support practitioners in adapting the proposed approaches. [ABSTRACT FROM AUTHOR]

The metaphor of "technical debt" is used in software engineering to describe technical solutions that may be pragmatic in the near‐term but may have a negative long‐term impact. Similar decisions and similar dynamics are present in the field of systems engineering. This work investigates the current body of knowledge to identify if, and how, the technical debt metaphor is used within the systems engineering field and which systems engineering lifecycle stages are most susceptible to technical debt. A systematic literature review was conducted on 354 papers in February 2022, of which 18 were deemed relevant for inclusion in the study. The results of the systematic literature review show that the technical debt metaphor is not prevalent within systems engineering research and that existing research is limited to specific fields and theoretical discussions. This paper concludes with recommendations for future work to establish a research agenda on the identification and management of technical debt within systems engineering. [ABSTRACT FROM AUTHOR]

Systems Modeling Language (SysML) has been applied in the past years to a variety of software and systems engineering projects, by hundreds of researchers, engineers, and other systems and software professionals. Thus, it is expected that all this experience has been described in research articles. Therefore, we propose a survey describing what practitioners and researchers think about this modeling language, the actual use of SysML, and how SysML is used in the software and system engineering life cycle. This article describes a survey on SysML, answering questions such as the most used diagrams for each phase of the development of a system, the most common domains, and other data about the participants. The survey was answered by 343 participants from 38 countries, mostly systems engineers, software and systems architects, and researchers. Industry and academia can use our results (i) for assisting researchers and engineers to select appropriate diagrams for each software and systems development phase, (ii) for a better understanding of which industry domains SysML is most commonly applied, (iii) as a reference for identifying which types of systems are modeled with SysML, (iv) for knowing which software tools are most used, and (v) which other modeling languages are most commonly integrated with SysML for software and systems development. [ABSTRACT FROM AUTHOR]

Model merging conflicts occur when different stakeholders aim to integrate their contradicting changes that are applied concurrently to update software models. We conduct an extensive systematic mapping study on conflict management techniques and relevant collaboration attributes to the versioning and merging models from 2001 to the middle of 2021. This study follows the standard guidelines within the software engineering domain. We analyzed a total of 105 articles extracted from an initial pool of more than 1800 articles to infer a taxonomy for conflict management techniques. We use this taxonomy to classify existing approaches to understand characteristics, shortcomings, and challenges on conflict management techniques in merging models. It also provides a solid foundation for future work in this area. We show that syntactic conflicts are the most studied type and that the top three popular conflict detection techniques are constraint violation, change overlapping, and pattern matching. We observe the lack of a comprehensive state-of-the-art comparison between academic or industrial tools, as well as the need for real-world case studies. Finally, we show that recent trends have focused on online collaboration, where teams of stakeholders work on large-scale models. [ABSTRACT FROM AUTHOR]

Sustainability has become a critical issue for the software industry as the environmental impact of software development and use increases. To address this issue, organizations need a framework for developing and accessing sustainable software practices. In this study, we reviewed the existing literature, models, and practices in this domain as well as carried out surveys and interviews to understand the reality, practices, and challenges on the ground. We identified a set of research questions to discover why sustainability is important, what actions can be taken to improve it, and how and when they can be implemented. This study highlighted the limitations of existing models and the need to address the research gaps. Existing research is limited by a narrow focus on specific domains such as the environment and energy or a specific phase of software development. We aim to address these through the proposed comprehensive software sustainability capability framework (SSCF), which provides a "ready reckoner", allowing any organization to assess their current software sustainability and the capabilities and metrics they could focus on to improve sustainable software maturity. This paper also provides detailed assessment criteria, metrics, and a roadmap that can be used by any software organization to enhance their sustainability. [ABSTRACT FROM AUTHOR]

Designing software is an activity in which software developers think and make design decisions that shape the structure and behavior of software products. Designing software is one of the least understood software engineering activities. In a collaborative design setting, various types of distances can lead to challenges and effects that potentially affect how software is designed. To contribute to a better understanding of collaborative software design, we investigate how communication gaps caused by social and geographic distances affect its design thinking and the creativity of its discussions. To this end, we conducted a multiple‐case study exploring the design thinking and creativity of colocated and distributed software developers in a collaborative design setting. Compared with colocated developers, distributed developers spend less time on exploring the problem space, which could be related to different sociotechnical challenges, such as lack of awareness and common understanding. Distributed development does not seem to affect the creativity of their activities. Developers engaging in collaborative design need to be aware that problem space exploration is reduced in a distributed setting. Unless distributed teams take compensatory measures, this could adversely affect the development. Regarding the effect distance has on creativity, our results are inconclusive and further studies are needed. [ABSTRACT FROM AUTHOR]

Summary: Context: Software performance is crucial for ensuring the quality of software products. As one of the non‐functional requirements, the few efforts devoted to software performance have often been neglected until a later phase in the software development life cycle (SDLC). The lack of clarity of what software performance research literature is available prevents researchers from understanding what software performance research fields are available. It also creates difficulty for practitioners to adopt state‐of‐the‐art software performance techniques. Software performance research is not as organized as other established research topics such as software testing. Thus, it is essential to conduct a systematic mapping study as a first step to provide an overview of the latest research literature available in software performance. Objective: The objective of this systematic mapping study is to survey and map software performance research literature into suitable categories and to synthesize the literature data for future access and reference. Method: This systematic mapping study conducts a manual examination by querying research literature in noble journals and proceedings in software engineering in the past decade. We examine each paper manually and identify primary studies for further analysis and synthesis according to the pre‐defined inclusion criteria. Lastly, we map the primary studies based on their corresponding classification category. Results: This systematic mapping study provides a state‐of‐the‐art literature mapping in software performance research. We have carefully examined 222 primary studies out of 2000+ research literature. We have identified six software performance research categories and 15 subcategories. We generate the primary study mapping and report five research findings. Conclusions: Unlike established research fields, it is unclear what types of software performance research categories are available to the community. This work takes the systematic mapping study approach to survey and map the latest software performance research literature. The study results provide an overview of the paper distribution and a reference for researchers to navigate research literature on software performance. [ABSTRACT FROM AUTHOR]

Mobile computing has emerged as a pervasive technology that empowers its users with portable computation and context-aware communication. Smart systems and infrastructures can exploit portable and context-aware computing technologies to provide any time, any place digitized services on the go. Despite the offered benefits, such as portability, context-sensitivity, and high connectivity, mobile computing also faces some critical challenges. These challenges include resource poverty as well as data security and privacy that need to be addressed to increase the pervasiveness of mobile systems. We propose to provide a self-protection mechanism for mobile devices against the unforeseen security threats that can attack the critical resources of mobile devices. We have unified the concepts of autonomic computing and computer security to develop a framework that enables adaptive security to dynamically configure the security measures of a mobile device. We have developed a framework - an android-based prototype - that supports automation and user decision to protect the critical hardware and software resources of a device. Evaluation results demonstrate (i) framework's accuracy for runtime detection and minimization of threats, and (ii) framework's efficiency for device's resource utilization. [ABSTRACT FROM AUTHOR]

Project-based learning (PBL) promotes increased levels of learning, deepens student understanding of acquired knowledge, and improves learning motivation. Students develop their ability to think and learn independently through depending on themselves in searching for knowledge, planning, exploration, and looking for solutions to practical problems. Information availability, student engagement, and motivation to learn all increase with mobile learning. The teaching process may be enhanced by combining the two styles. This paper proposes and evaluates a teaching model called Mobile Project-Based Learning (Mobile-PBL) that combines the two learning styles. The paper investigates how significantly Mobile-PBL can benefit students. The traditional lecture method used to teach the software architecture module in the classroom is not sufficient to provide students with the necessary practical experience to earn a career as software architects in the future. Therefore, the first author tested the use of the model for teaching the software architecture module at Philadelphia University's Software Engineering Department on 62 students who registered for a software architecture course over three semesters. She compared the results of using the model for teaching with those results that were obtained when using the project-based learning (PBL) approach alone. The students' opinions regarding the approach, any problems they had, and any recommendations for improvement were collected through a focus group session after finishing each semester and by distributing a survey to students to evaluate the effectiveness of the used model. Comments from the students were positive, according to the findings. The projects were well-received by the students, who agreed that it gave them a good understanding of several course ideas and concepts, as well as providing them with the required practical experience. The students also mentioned a few difficulties encountered while working on the projects, including student distraction from social media and the skills that educators and learners in higher education institutions are expected to have. [ABSTRACT FROM AUTHOR]

The Object Management Group introduced the Model-Driven Architecture in 2001. Since then, the research community has embraced model-driven engineering (MDE), but to a lesser extent than practitioners had hoped. A good awareness of practitioners' challenges, particularly with modeling, is required to ensure the relevance of a research agenda. Therefore, this study conducts a meta-review on the state of practice in using modeling languages for software engineering over the last five years using Kitchenham's guidelines. This study serves as an orientation within the research field and a basis for further research. It contributes to the literature by focusing on publications discussing the practical use of modeling languages and the benefits and problems perceived by practitioners. The main finding of this review is that practitioners benefit from MDE in the following ways: it is beneficial for several stakeholders; it saves cost; it is easy to use; it improves productivity, quality, and understanding of the system; and it provides support for software development activities. However, practitioners continue to face several serious challenges. The most frequently reported issues are the missing tool functionalities. Many studies have found that adhering to the Physics of Notation principles would improve modeling languages. Other findings include that modeling is mostly used for documentation and requirements elicitation, and UML is the most often used. [ABSTRACT FROM AUTHOR]

Blended modeling aims to improve the user experience of modeling activities by prioritizing the seamless interaction with models through multiple notations over the consistency of the models. Inconsistency tolerance, thus, becomes an important aspect in such settings. To understand the potential of current commercial and open-source modeling tools to support blended modeling, we have designed and carried out a systematic study. We identify challenges and opportunities in the tooling aspect of blended modeling. Specifically, we investigate the user-facing and implementation-related characteristics of existing modeling tools that already support multiple types of notations and map their support for other blended aspects, such as inconsistency tolerance, and elevated user experience. For the sake of completeness, we have conducted a multivocal study, encompassing an academic review, and grey literature review. We have reviewed nearly 5000 academic papers and nearly 1500 entries of grey literature. We have identified 133 candidate tools, and eventually selected 26 of them to represent the current spectrum of modeling tools. [ABSTRACT FROM AUTHOR]

While some areas of software engineering knowledge present great advances with respect to the automation of processes, tools, and practices, areas such as software maintenance have scarcely been addressed by either industry or academia, thus delegating the solution of technical tasks or human capital to manual or semiautomatic forms. In this context, machine learning (ML) techniques play an important role when it comes to improving maintenance processes and automation practices that can accelerate delegated but highly critical stages when the software launches. The aim of this article is to gain a global understanding of the state of ML-based software maintenance by using the compilation, classification, and analysis of a set of studies related to the topic. The study was conducted by applying a systematic mapping study protocol, which was characterized by the use of a set of stages that strengthen its replicability. The review identified a total of 3776 research articles that were subjected to four filtering stages, ultimately selecting 81 articles that were analyzed thematically. The results reveal an abundance of proposals that use neural networks applied to preventive maintenance and case studies that incorporate ML in subjects of maintenance management and management of the people who carry out these tasks. In the same way, a significant number of studies lack the minimum characteristics of replicability. [ABSTRACT FROM AUTHOR]

Background: Cloud-native software systems often have a much more decentralized structure and many independently deployable and (horizontally) scalable components, making it more complicated to create a shared and consolidated picture of the overall decentralized system state. Today, observability is often understood as a triad of collecting and processing metrics, distributed tracing data, and logging. The result is often a complex observability system composed of three stovepipes whose data are difficult to correlate. Objective: This study analyzes whether these three historically emerged observability stovepipes of logs, metrics and distributed traces could be handled in a more integrated way and with a more straightforward instrumentation approach. Method: This study applied an action research methodology used mainly in industry–academia collaboration and common in software engineering. The research design utilized iterative action research cycles, including one long-term use case. Results: This study presents a unified logging library for Python and a unified logging architecture that uses the structured logging approach. The evaluation shows that several thousand events per minute are easily processable. Conclusions: The results indicate that a unification of the current observability triad is possible without the necessity to develop utterly new toolchains. [ABSTRACT FROM AUTHOR]

Various architectures can be applied in software design. The aim of this research is to examine a typical implementation of Jakarta EE monolithic and microservice software architectures in the context of software quality attributes. Software quality standards are used to define quality models, as well as quality characteristics and sub-characteristics, i.e., software quality attributes. This paper evaluates monolithic and microservice architectures in the context of Coupling, Testability, Security, Complexity, Deployability, and Availability quality attributes. The performed examinations yielded a quality-based mixed integer goal programming mathematical model for software architecture optimization. The model incorporates various software metrics and considers their maximal, minimal or targeted values, as well as upper and lower deviations. The objective is the sum of all deviations, which should be minimal. Considering the presented model, a solution which incorporated multiple monoliths and microservices was defined. This way, the internal structure of the software is defined in a consistent and symmetrical context, while the external software behavior remains unchanged. In addition, an intersection point of monolithic and microservice software architectures, where software metrics obtain the same values, was introduced. Within the intersection point, either one of the architectures can be applied. With the exception of some metrics, an increase in the number of features leads to a value increase of software metrics in microservice software architecture, whilst these values are constant in monolithic software architecture. An increase in the number of features indicated a quality attribute's importance for the software system should be examined and an appropriate architecture should be selected accordingly. Finally, practical recommendations regarding software architectures in terms of software quality were given. Since each software system needs to meet non-functional in addition to functional requirements, a quality-driven software engineering can be established. [ABSTRACT FROM AUTHOR]

Power consumption has become a major design constraint, especially for battery-powered embedded systems. However, the impact of software applications is typically considered in later phases, where both software and hardware parts are close to their finalization. Power-related issues must be detected in early stages to keep the development costs low, satisfy time-to-market, and avoid cost-intensive redesign loops. Moreover, the variety of hardware components, architectures, and communication interfaces make the development of embedded software more challenging. To manage the complexity of software applications, approaches such as model-driven development (MDD) may be used. This article proposes a power-estimation approach in MDD for software application models in early development phases. A unified modeling language (UML) profile is introduced to model power-related properties of hardware components. To determine the impact of software applications, we defined two analysis methods using simulation data and a novel in-the-loop concept. Both methods may be applied at different development stages to determine an energy trace, describing the energy-related behavior of the system. A novel definition of energy bugs is provided to describe power-related misbehavior. We apply our approach to a sensor node example, demonstrate an energy bug detection, and compare the runtime and accuracy of the analysis methods. [ABSTRACT FROM AUTHOR]

Migration from a monolithic architecture to a microservice architecture is a complex challenge, which consists of issues such as microservices identification, code decomposition, commination between microservices, independent deployment, etc. One of the key issues is data storage adaptation to a microservice architecture. A monolithic architecture interacts with a single database, while in microservice architecture, data storage is decentralized, each microservice works independently and has its own private data storage. A viable option to fulfil different microservice persistence requirements is polyglot persistence, which is data storage technology selected according to the characteristics of each microservice need. This research aims to propose and evaluate the approach of monolith database migration into multi-model polyglot persistence based on microservice architecture. The novelty and relevance of the proposed approach are double, that is, it provides a general approach of how to conduct database migration from monolith architecture into a microservice architecture and allows the data model to be transformed into multi-model polyglot persistence. Migration from a mainframe monolith database to a multi-model polyglot persistence was performed as a proof-of-concept for the proposed migration approach. Quality attributes defined in the ISO/IEC 25012:2008 standard were used to evaluate and compare the data quality of the microservice with the multi-model polyglot persistence and the existing monolith mainframe database. Results of the research showed that the proposed approach can be used to conduct data storage migration from a monolith to microservice architecture and improve the quality of the consistency, understandability, availability, and portability attributes. Moreover, we expect that our results could inspire researchers and practitioners toward further work aimed to improve and automate the proposed approach. [ABSTRACT FROM AUTHOR]

Quality requirements deal with how well a product should perform the intended functionality, such as start-up time and learnability. Researchers argue they are important and at the same time studies indicate there are deficiencies in practice. Our goal is to review the state of evidence for quality requirements. We want to understand the empirical research on quality requirements topics as well as evaluations of quality requirements solutions. We used a hybrid method for our systematic literature review. We defined a start set based on two literature reviews combined with a keyword-based search from selected publication venues. We snowballed based on the start set. We screened 530 papers and included 84 papers in our review. Case study method is the most common (43), followed by surveys (15) and tests (13). We found no replication studies. The two most commonly studied themes are (1) differentiating characteristics of quality requirements compared to other types of requirements, (2) the importance and prevalence of quality requirements. Quality models, QUPER, and the NFR method are evaluated in several studies, with positive indications. Goal modeling is the only modeling approach evaluated. However, all studies are small scale and long-term costs and impact are not studied. We conclude that more research is needed as empirical research on quality requirements is not increasing at the same rate as software engineering research in general. We see a gap between research and practice. The solutions proposed are usually evaluated in an academic context and surveys on quality requirements in industry indicate unsystematic handling of quality requirements. [ABSTRACT FROM AUTHOR]

Unlike conventional software, robotic software suffers from a lack of methods and processes that could systematize and facilitate development. Thus, the application of software engineering techniques is at the heart of current issues in robotics. The work presented in this paper aims to facilitate the development of robotic software and to facilitate communication between experts in the field through the use of software engineering techniques and methods. It proposes RsaML (Robotic Software Architecture Modeling Language), a Domain Specific Modeling Language (DSML) dedicated to robotics, which takes into account the different categories of robotic software architectures and makes it possible to describe the latter independently from the implementation platform. The conceptual model defining the terminology and the hierarchy of concepts used for the description and representation of robotic software architectures in RsaML are presented in this article. RsaML is defined through a meta-model which represents the abstract syntax of the language. The real-time properties of robotic software architectures are identified and included in the meta-model. The use of RsaML is illustrated through several experimental scenarios of the language: the definition of a robotic system and the description of its software architecture, the verification of the semantics of a robotic software architecture, and the modeling of a robotic system whose software architecture does not belong to the usual categories. The support tool used for implementations and experimentation is Eclipse Modeling Framework (EMF). The results of experimentation showed good working of the proposed solution and made it possible to validate the main concepts of the RsaML language. [ABSTRACT FROM AUTHOR]

Mobile robots operate in various environments (e.g. aquatic, aerial, or terrestrial), they come in many diverse shapes and they are increasingly becoming parts of our lives. The successful engineering of mobile robotics systems demands the interdisciplinary collaboration of experts from different domains, such as mechanical and electrical engineering, artificial intelligence, and systems engineering. Research and industry have tried to tackle this heterogeneity by proposing a multitude of model-driven solutions to engineer the software of mobile robotics systems. However, there is no systematic study of the state of the art in model-driven engineering (MDE) for mobile robotics systems that could guide research or practitioners in finding model-driven solutions and tools to efficiently engineer mobile robotics systems. The paper is contributing to this direction by providing a map of software engineering research in MDE that investigates (1) which types of robots are supported by existing MDE approaches, (2) the types and characteristics of MRSs that are engineered using MDE approaches, (3) a description of how MDE approaches support the engineering of MRSs, (4) how existing MDE approaches are validated, and (5) how tools support existing MDE approaches. We also provide a replication package to assess, extend, and/or replicate the study. The results of this work and the highlighted challenges can guide researchers and practitioners from robotics and software engineering through the research landscape. [ABSTRACT FROM AUTHOR]

The open‐source phenomenon has reached unimaginable proportions to a point in which it is virtually impossible to find large applications that do not rely on open‐source as well. However, such proportions may turn into a risk if the organizational and socio‐technical aspects (e.g., the contribution and release schemes) behind open‐source communities are not explicitly supported by open‐source forges by‐design. In an effort to make such aspects explicit and supported by‐design in open‐source forges, we conducted empirical software engineering as follows: (a) Through online industrial surveying, we elicited organizational and social aspects relevant in open‐source communities; (b) through action research, we extended a widely known open‐source support system and top‐level Apache project Allura; (c) through ethnography, we studied the Allura community, and learning from its social and organizational structure, (d) we elicited a metrics framework that support more explicit organizational and socio‐technical design principles around open‐source communities. This article is an experience report on these results and the lessons we learned in obtaining them. We found that the extensions provided to Apache Allura formed the basis for community awareness by design, providing valuable and usable community characteristics. Ultimately, however, the extensions we provided to Apache Allura were deactivated by its core developers because of performance overheads. Our results and lessons learned allow us to provide recommendations for designing forges, like Github. Architecting a forge is a participatory process that requires active engagement, hence remarking the need for mechanisms enabling it. At the same time, we conclude that a more active support for the governance is required to avoid the failure of the forge. [ABSTRACT FROM AUTHOR]

The object of research is a distributed order processing system for a restaurant chain. The subject of the research is the analysis of the use of Redis for managing event queues in distributed systems. When implementing a distributed order processing system in a restaurant chain with a possible load of up to 20,000 users per day, the Redis system was used. Management of 9 distributed subsystems was organized through Redis. This solution showed an increase in the performance of the system under heavy load (from 50 transactions per second), but the response time of the system in some cases of its operation was longer than without using Redis. When working systems using Redis, it is necessary to take into account the amount of data with which Redis will work, since it does not exceed the amount of RAM, the absence of differentiation into users and groups, and the absence of a query language, which is replaced by a key-value scheme. This research is aimed at analyzing the operation of the system during trial operation under real load. We compared the operation of a configured system with Redis enabled and disabled. The main indicators for the analysis were the system response time and the maximum request execution time. The research was carried out for 2 weeks, the first week using the system settings with disabled Redis, the second – with enabled Redis. We selected 2 days with a similar load on the system to each other. Especially indicative are the results of comparing the durations of the longest queries, which show an almost constant value of the duration for the system in the mode of enabled Redis. The hypothesis of an increase in the system response time at low loads was confirmed, but this value not only leveled off at a load of 500 unique users but also became less at loads of 1000 unique users. [ABSTRACT FROM AUTHOR]

We define perceived diversity as the diversity factors that individuals are born with. Perceived diversity in Software Engineering has been recognized as a high-value team property and companies are willing to increase their efforts to create more diverse work teams. The current diversity state-of-the-art shows that gender diversity studies have been growing during the past decade, and they have shown the benefits of including women in software teams. However, less is known about how other perceived diversity factors such as race, nationality, disability, and age of developers are related to Software Engineering. Through a systematic literature review, we aim to clarify the research area concerned with perceived diversity in Software Engineering. Our goal is to identify (1) what issues have been studied and what results have been reported; (2) what methods, tools, models, and processes have been proposed to help perceived diversity issues; and (3) what limitations have been reported when studying perceived diversity in Software Engineering. Furthermore, our ultimate goal is to identify gaps in the current literature and create a call for future action in perceived diversity in Software Engineering. Our results indicate that the individual studies have typically had a gender diversity perspective focusing on showing gender bias or gender differences instead of developing methods and tools to mitigate the gender diversity issues faced in SE. Moreover, perceived diversity aspects related to SE participants’ race, age, and disability need to be further analyzed in Software Engineering research. From our systematic literature review, we conclude that researchers need to consider a wider set of perceived diversity aspects for future research. [ABSTRACT FROM AUTHOR]

Software engineering is decision intensive. Evidence‐based software engineering is suggested for decision‐making concerning the use of methods and technologies when developing software. Software development often includes the reuse of software assets, for example, open‐source components. Which components to use have implications on the quality of the software (e.g., maintainability). Thus, research is needed to support decision‐making for composite software. This paper presents a roadmap for research required to support evidence‐based decision‐making for choosing and integrating assets in composite software systems. The roadmap is developed as an output from a 5‐year project in the area, including researchers from three different organizations. The roadmap is developed in an iterative process and is based on (1) systematic literature reviews of the area; (2) investigations of the state of practice, including a case survey and a survey; and (3) development and evaluation of solutions for asset identification and selection. The research activities resulted in identifying 11 areas in need of research. The areas are grouped into two categories: areas enabling evidence‐based decision‐making and those related to supporting the decision‐making. The roadmap outlines research needs in these 11 areas. The research challenges and research directions presented in this roadmap are key areas for further research to support evidence‐based decision‐making for composite software. [ABSTRACT FROM AUTHOR]

Sustainable computing is a rapidly growing research topic spanning several areas of Computer Science. Particularly, it has received increasing attention in the Software Engineering field in the last years, with several studies discussing the topic from a range of perspectives. However, few studies have demonstrated the awareness of software practitioners about the underlying concepts of sustainability in the software development practice. In an earlier investigation, we performed a preliminary study on the practitioners' perception under four main perspectives: economic, social, environmental, and technical. This study extended the previous survey and reached a number of ninety-seven respondents from Brazilian companies. The extension aims to expand the results to compare and explore the previous findings in a more in-depth way. The novel results confirmed the evidence raised in the original survey that sustainability in the context of Software Engineering is a new subject for practitioners. However, professionals have shown interest in the topic, and there is a general understanding that sustainability should be treated as a quality attribute. Among the observed perspectives, we generated an initial theory that shows software practitioners know the subject around 'Green in Software', even unconsciously. This study brings evidence of how the industry understands and perceives sustainability practices in the software development process. [ABSTRACT FROM AUTHOR]

Purpose: This paper reviews existing business process (BP) modeling languages that are widely used in the industry as well as recent research work on modeling and analysis of BPs in the service-oriented environment and Internetware-based software paradigm. BPs in such environment are different from traditional BPs due to loose coupling of partner services, dynamic and on-the-fly selection of partners and run-time process adaptability. The unique characteristics of these BPs require formal modeling of the requirements and constraints in each phase of their life cycle, including design phase, implementation and deployment phase and execution phase. Design/methodology/approach: The paper first provides a categorization of typical user requirements in each phase of the BP life cycle. Then a detailed comparison of the selected languages with respect to their requirement modeling and analysis capabilities in each of the identified categories is provided. The paper also discusses new requirements engineering research challenges arising from future software needs and emerging trends in software engineering in the context of Web-services-based BPs and Internetware. Findings: There is a need to have a framework that provides support for user requirements modeling and analysis for all the phases of BP life cycle in an integrated manner. Such a framework would be useful not only in resolving the inconsistencies between requirements across phases but also in addressing the issues related to BP evolution due to changes in user requirements over time. Moreover, with the Internet of things (IoT) adoption in BPM, there is a need to have an integrated environment that provides support for capturing the resilience requirements of enterprise BPs as well as the mobility constraints of the underlying IoT devices. Originality/value: This paper reviews existing BP modeling languages and frameworks and discusses the new requirements engineering research challenges arising from future software needs and the emerging trends in BP management in the service-oriented environment and Internetware-based software paradigm. [ABSTRACT FROM AUTHOR]

Code reading is one of the most frequent activities in software maintenance. Such an activity aims at acquiring information from the code and, thus, it is a prerequisite for program comprehension: developers need to read the source code they are going to modify before implementing changes. As the code changes, so does its readability; however, it is not clear yet how code readability changes during software evolution. To understand how code readability changes when software evolves, we studied the history of 25 open source systems. We modeled code readability evolution by defining four states in which a file can be at a certain point of time (non-existing, other-name, readable, and unreadable). We used the data gathered to infer the probability of transitioning from one state to another one. In addition, we also manually checked a significant sample of transitions to compute the performance of the state-of-the-art readability prediction model we used to calculate the transition probabilities. With this manual analysis, we found that the tool correctly classifies all the transitions in the majority of the cases, even if there is a loss of accuracy compared to the single-version readability estimation. Our results show that most of the source code files are created readable. Moreover, we observed that only a minority of the commits change the readability state. Finally, we manually carried out qualitative analysis to understand what makes code unreadable and what developers do to prevent this. Using our results we propose some guidelines (i) to reduce the risk of code readability erosion and (ii) to promote best practices that make code readable. [ABSTRACT FROM AUTHOR]

The emergence of collective adaptive systems—i.e., computational systems made up of an ensemble of autonomous components that have to operate in a coordinated and adaptive way in open-ended and unpredictable environments—calls for innovative modeling and software engineering tools, to support their systematic and rigorous design and development. In this paper, we present a general model for collective adaptive systems called SOTA ("State Of The Affairs"). SOTA brings together the lessons of goal-oriented requirements modeling, context-aware system modeling, and dynamical systems modeling. It has the potential for acting as a general reference model to help tackling some key issues in the design and development of collective adaptive systems. In particular, as we will show with reference to a scenario of collectives of autonomous vehicles, SOTA enables: early verification of requirements, identification of knowledge requirements for self-adaptation, and the identification of the most suitable architectural patterns for self-adaptation. [ABSTRACT FROM AUTHOR]

Due to the critical role of a software‐intensive system in society, software engineers have a responsibility to add sustainability as a goal while developing a software system. However, there is a lack of practical guidelines providing a tangible decomposition of the sustainability aspect. Moreover, there are limited quantifiable methods to support sustainable design and analysis. Therefore, we propose a systematic approach that allows software practitioners to accommodate sustainability concerns that are aligned with other software quality attributes to enhance sustainable development. By using the combination of a goal‐scenario‐based approach and feature modeling, sustainability requirements are elicited along with their functional compositions. Our approach is a comprehensive reference model that decomposes sustainability requirements, enabling analysis, support, and assessment of sustainability risk analysis and guiding the designer to construct a feature model as a system functional decomposition. From the conducted theoretical evaluation and empirical study, our proposed approach can derive more significant sustainability‐related requirements and key features by providing a practical guideline with the integration of well‐known methods to address sustainability in requirements engineering. With the help of the provided approach, we can solve more conflicting goals in different sustainability dimensions. [ABSTRACT FROM AUTHOR]

For the systematic development of logical, message-driven architectures, automating parallel decomposition of software components is important to achieve efficient modular and parallel system development. During development, monolithic components that realize multiple independent concerns need to be decomposed to obtain a higher quality architecture of cohesively encapsulated, better comprehensive components. Previous work did not address automated parallel decomposition of finite message-driven and logically timed components with respect to the influence of messages received via input channels on the messages sent via output channels. This, however, is a necessary prerequisite to enable the analysis of event chains across logically distributed architectures. To address this, we present a concept of influence between channels of components that supports automated semantics-preserving parallel decomposition of finite deterministic component implementations into independent, more comprehensible components that are better accessible for analysis and development. Therefore, we extend the Focus theory of time-synchronous components with the concept of influence, present a decomposition procedure leveraging this, and prove that the resulting system is semantically equivalent. This enables automatically decomposing monolithic software components (e.g., for stepwise refinement or refactoring) into smaller components of better cohesion and comprehensibility and thus facilitates automated software engineering. [ABSTRACT FROM AUTHOR]