Software Engineering Practices Research Articles

Which builds are really safe to skip? Maximizing failure observation for build selection in continuous integration

Continuous integration (CI) is a widely used practice in modern software engineering. Unfortunately, it is also an expensive practice. Google and Mozilla estimate their expenses for their CI systems in millions of dollars. To reduce the cost of CI, researchers developed multiple approaches to reduce its computational workload requirements. However, these approaches sometimes make mispredictions and skip failing builds which are not desirable to be skipped. Thus, in this paper, we aim to save computational cost in CI, while also maximizing the observation of failing builds, i.e., to skip builds more safely. First, we perform empirical studies to understand which builds are safe to skip, starting from CI-Skip rules (Abdalkareem et al., 2019) that characterize builds that developers decide to skip. We observe that CI-Skip rules are not so safe as expected. We then develop a collection of CI-Run rules that can complement these rules. Based on our findings, we propose PreciseBuildSkip, a novel approach that maximizes build failure observation and reduces the cost of CI through the strategy of build selection. We evaluate our approach and results show that our approach saved more cost (5.5%) than the safest existing technique but reduced the falsely skipped failing builds from 4.1% to 0% (median value).

Knowledge activities applied | towards a holistic knowledge management approach in the software industry

PurposeThis paper aims to close the gap between the generic concept of knowledge activities (KAs) and implementing them in the context of software engineering organisations concentrating on the non-technical aspects, such as team organisation and practices.Design/methodology/approachThis qualitative research used a questionnaire with practitioners such as software developers and team leads who were asked to provide feedback on a set of team practices and measures typically used in software engineering projects and assess their relation to the activities of acquiring, codifying, storing, maintaining, transferring and creating knowledge. The obtained results were analysed using frequency analysis and further descriptive statistics yielding a matrix linking the investigated team practices and measures to KAs.FindingsTeam practices and measures commonly applied in software engineering can be facilitated to trigger particular KAs. While most of these team practices and measures originate from agile methods, they are not restricted to these. A purposeful composition can help in assembling a balanced set of KAs aimed at fostering given knowledge goals in software engineering organisations.Practical implicationsBy bridging the communication and terminology gap between knowledge management research and software engineering practitioners, this work lays the foundation for assessing software teams’ knowledge profiles more easily and creating prerequisites for implementing knowledge management by facilitating common practices and measures often already part of their daily work. Hence, overhead can be avoided when implementing knowledge management.Originality/valueTo the best of the authors’ knowledge, this is the first study investigating application and relevance of KAs in the software industry by linking them to practices and measures well-accepted in software engineering, thus providing the necessary vocabulary for the implementation of knowledge management in software development teams.

Strategies to Evolve ExM Notations Extracted from a Survey with Software Engineering Professionals Perspective

Contemporary complex systems often exhibit dynamic structures and behaviors, several components/systems involved, and multiple interoperability links. Those systems have been exposed to fragilities of traditional software specification languages (e.g. UML and SySML), since such languages were designed to document single (not multiple interoperating) systems. Those limitations can potentially further compromise the quality of the final software product. In this context, Executable Models (ExM) technology, such as simulation models, models@runtime and executable UML, satisfy the aforementioned requirements by supporting engineers with visualization of the system structures (still at design-time) and the ability to exercise their behaviors and interactions. In our prior study, we presented the results of an exploratory study on the perceptions of those professionals (from both industry and academia) regarding the use of ExM to solve problems in their current practice. We exposed 58 professionals (researchers and practitioners) to situations to solve problems using a specific type of ExM (DEVS simulation models), based on survey research. Responses were quantitatively and qualitatively analyzed. In this article, we extended the obtained results by analyzing and compiling a list of strategies to improve ExM notations to better address the needs of software engineering professionals. Later, we assessed those strategies with software engineering researchers to confirm the importance of the proposed strategies. Results revealed that executable languages still require advances to bring them even closer to the current software engineering practice and towards a more significant adoption in the future. The proposed strategies focus on improvements on the robustness of the ExM notations, visual representation of the models, the usability of the models, and user support.

Modelling in low-code development: a multi-vocal systematic review

In 2014, a new software development approach started to get a foothold: low-code development. Already from its early days, practitioners in software engineering have been showing a rapidly growing interest in low-code development. In 2021 only, the revenue of low-code development technologies reached 13.8 billion USD. Moreover, the business success of low-code development has been sided by a growing interest from the software engineering research community. The model-driven engineering community has shown a particular interest in low-code development due to certain similarities between the two. In this article, we report on the planning, execution, and results of a multi-vocal systematic review on low-code development, with special focus to its relation to model-driven engineering. The review is intended to provide a structured and comprehensive snapshot of low-code development in its peak of inflated expectations technology adoption phase. From an initial set of potentially relevant 720 peer-reviewed publications and 199 grey literature sources, we selected 58 primary studies, which we analysed according to a meticulous data extraction, analysis, and synthesis process. Based on our results, we tend to frame low-code development as a set of methods and/or tools in the context of a broader methodology, often being identified as model-driven engineering.

Improving bioinformatics software quality through incorporation of software engineering practices.

BackgroundBioinformatics software is developed for collecting, analyzing, integrating, and interpreting life science datasets that are often enormous. Bioinformatics engineers often lack the software engineering skills necessary for developing robust, maintainable, reusable software. This study presents review and discussion of the findings and efforts made to improve the quality of bioinformatics software.MethodologyA systematic review was conducted of related literature that identifies core software engineering concepts for improving bioinformatics software development: requirements gathering, documentation, testing, and integration. The findings are presented with the aim of illuminating trends within the research that could lead to viable solutions to the struggles faced by bioinformatics engineers when developing scientific software.ResultsThe findings suggest that bioinformatics engineers could significantly benefit from the incorporation of software engineering principles into their development efforts. This leads to suggestion of both cultural changes within bioinformatics research communities as well as adoption of software engineering disciplines into the formal education of bioinformatics engineers. Open management of scientific bioinformatics development projects can result in improved software quality through collaboration amongst both bioinformatics engineers and software engineers.ConclusionsWhile strides have been made both in identification and solution of issues of particular import to bioinformatics software development, there is still room for improvement in terms of shifts in both the formal education of bioinformatics engineers as well as the culture and approaches of managing scientific bioinformatics research and development efforts.

A Comprehensive Formalization of AADL with Behavior Annex

In safety-critical fields, architectural languages such as AADL (Architecture Analysis and Design Language) have been playing an important role, and the analysis of the languages and systems designed by them is a challenging research topic. At present, a formal method has become one of the main practices in software engineering for strict analysis, and it has been applied on the tools of formalization and analysis. The formal method can be used to find and resolve the problems early by describing the system with precise semantics and validating the system model. This article studies the comprehensive formal specification and verification of AADL with Behavior annex by the formal method. The presentation of this specification and semantics is the aim of this article, and the work is illustrated with an ARINC653 model case study in Isabelle/HOL.

On the Concept of Transparency: A Systematic Literature Review

Over a decade since transparency was introduced as a first-class concept in computing, transparency is still an emerging concept that is quite poorly understood. Also, despite existing research contributions, transparency is yet to be incorporated into the software engineering practice, and the promise it holds remains unfulfilled. Although there is evidence of increasing stakeholders’ demand for software and process transparency, the realization of such demand is yet to be fully witnessed within the software engineering practice. There is a need to uncover transparency and how it has so far been conceptualized, operationalized, and challenges faced. We applied a systematic literature review method in search of articles published between January 2006 and March 2022. This study reports a systematic review of the explicit conceptualization and application of transparency in 18 articles out of a total of 162 selected for review. Our study found that transparency remains an under-researched non-functional quality requirement concept, especially as it impacts information and software systems development. Of the 18 articles reviewed, only three studies representing 16.67% conceptualized transparency in software development and focused on the transparency of software artifacts. The remaining 83.33% of studies conceptualized transparency in information systems, focusing on general information and fully functional information systems. Transparency is yet to be fully explored from a theoretical gathering point of view and as a non-functional indicator of software quality hence its slow adoption and incorporation into mainstream software practice. Apart from providing a catalog of transparency factors that stakeholders can use to evaluate transparency achievement, the paper proposed a roadmap to enhance transparency implementation and also provides future research directions.

Landscape of Automated Log Analysis: A Systematic Literature Review and Mapping Study

Logging is a common practice in software engineering to provide insights into working systems. The main uses of log files have always been failure identification and root cause analysis. In recent years, novel applications of logging have emerged that benefit from automated analysis of log files, for example, real-time monitoring of system health, understanding users’ behavior, and extracting domain knowledge. Although nearly every software system produces log files, the biggest challenge in log analysis is the lack of a common standard for both the content and format of log data. This paper provides a systematic review of recent literature (covering the period between 2000 and June 2021, concentrating primarily on the last five years of this period) related to automated log analysis. Our contribution is three-fold: we present an overview of various research areas in the field; we identify different types of log files that are used in research, and we systematize the content of log files. We believe that this paper serves as a valuable starting point for new researchers in the field, as well as an interesting overview for those looking for other ways of utilizing log information.

The Internet of Things and Architectures of Big Data Analytics: Challenges of Intersection at Different Domains

The current exponential advancements in the Internet of Things (IoT) technologies pave a vast intelligent computing platform by integrating smart objects with sensing, processing and communication capabilities. The core element of IoT is the complex big data generated from different interconnected sources at real-time, presenting divergent processing and analysis challenges. Best practices in software engineering have been continuously addressed in IoT technologies to handle such big data efficiently at different domains. Despite of the massive studies dedicated for IoT, no explicit processing architecture is proposed based on real investigation of software engineering concepts and big data analytics characteristics in IoT. This paper provides a systematic literature review for the current state-of-the-art of IoT systems in different domains. The study investigates the current techniques and technologies that serve IoT systems from the big data analytics and software engineering perspectives, revealing a matrix for the specific IoT data features and their encountered challenges and gaps for each domain. The review deduces a proposed domain-independent software architecture for big IoT data analytics, maintaining various IoT data processing challenges, including data scalability, timeliness, heterogeneity, inconsistency, confidentiality and correlations. Finally, the main research gaps are emphasized for future considerations.

Reuse in Contemporary Software Engineering Practices – An Exploratory Case Study in A Medium-sized Company

Background: Software practice is evolving with changing technologies and practices such as InnerSource, DevOps, and microservices. It is important to investigate the impact of contemporary software engineering (SE) practices on software reuse. Aim: This study aims to characterize software reuse in contemporary SE practices and investigate its implications in terms of costs, benefits, challenges, and potential improvements in a medium-sized company. Method: We performed an exploratory case study by conducting interviews, group discussions, and reviewing company documentation to investigate software reuse in the context of contemporary SE practices in the case company. Results: The results indicate that the development for reuse in contemporary SE practices incurs additional coordination, among other costs. Development with reuse led to relatively fewer additional costs and resulted in several benefits such as better product quality and less development and delivery time. Ownership of reusable assets is challenging in contemporary SE practice. InnerSource practices may help mitigate the top perceived challenges: discoverability and ownership of the reusable assets, knowledge sharing and reuse measurement. Conclusion: Reuse in contemporary SE practices is not without additional costs and challenges. However, the practitioners perceive costs as investments that benefit the company in the long run.

Exception Handling in SARL as a Responsibility Distribution

Exception handling has been successfully proposed in software engineering practice as a simple, but effective, technology to address abnormal situations possibly occurring at runtime. Such mechanisms support the robust composition of heterogeneous software components, promoting code modularity, decoupling, and separation of concerns. Multi-agent systems bring these features to an extreme, but often lack systematic mechanisms for treating exceptions as part of their design. In this paper, we show how exception handling mechanism can be introduced in SARL, leveraging the abstractions that characterize its programming model. We introduce a new kind of space, supporting the responsibility distribution among agents concerning the handling of exceptional situations.

Introduction to the Special Issue on: Grey Literature and Multivocal Literature Reviews (MLRs) in software engineering

In parallel to academic (peer-reviewed) literature (e.g., journal and conference papers), an enormous extent of grey literature (GL) has accumulated since the inception of software engineering (SE). GL is often defined as “literature that is not formally published in sources such as books or journal articles”, e.g., in the form of trade magazines, online blog-posts, technical reports, and online videos such as tutorial and presentation videos. GL is typically produced by SE practitioners. We have observed that researchers are increasingly using and benefitting from the knowledge available within GL. Related to the notion of GL is the notion of Multivocal Literature Reviews (MLRs) in SE, i.e., a MLR is a form of a Systematic Literature Review (SLR) which includes knowledge and/or evidence from the GL in addition to the peer-reviewed literature. MLRs are useful for both researchers and practitioners because they provide summaries of both the state-of-the-art and -practice in a given area. MLRs are popular in other fields and have started to appear in SE community. It is timely then for a Special Issue (SI) focusing on GL and MLRs in SE. From the pool of 13 submitted papers, and after following a rigorous peer review process, seven papers were accepted for this SI. In this introduction we provide a brief overview of GL and MLRs in SE, and then a brief summary of the seven papers published in this SI.

An approach to explore sequential interactions in cognitive activities of software engineering

: The study of cognitive aspects around software activities can provide valuable insights to improve software engineering practices. Objective: This paper presents an approach based on distributed cognition and sequential analysis to explore cognitive activities in the software development context by analyzing the interactions between software practitioners and the resources used to support them. Method: We conducted nine laboratory-based observation sessions to record qualitative audio/video data of interactions between the study participants and at-hand resources during the planning and managing of software analytics tasks. Results: The interaction strategies of the resources model included 21 emergent actions, and the sequential analysis revealed two different patterns of interaction over time. Conclusion: Our approach has been useful for evaluating how well an artifact works to support a team in software analytics activities. Furthermore, it can be applied to explore and discover interaction patterns in different software activities.

The Value Creation Determinants of the Global Software Engineering Industry

Every requirement in the software application does not add value to the end users equally where the stakeholders are benefited through them. Majority of the current software engineering practices are formed and done in a value neutral way. With the recent demand for the global software engineering, many organizations have decided to either initiate their own technology centers in the low-cost countries or to partner with outsourced companies to get the benefits of it. However, the practitioners tried applying the traditional software development processes without a proper customization of them to best suit for the distributed teams. Due to the nature of this industry, those traditional processes have further eroded the value with unnecessary checkpoints and gates. This research therefore was carried out to identify the value creation dimensions and their influence creating value with special reference the global software engineering industry. For that, a systematic literature review was carried out and findings were categorized to five areas based on the research questions. They are benefit realization in the delivery process, eliciting and reconciling the requirements for stakeholder value proposition, business case analysis against the business processes, assessment of the value, risk, and opportunity through the frameworks and finally value based monitoring and control through the software development methodology. Mapping the development processes against these areas can change the value addition on the global software engineering industry.

The state of research on software engineering competencies: A systematic mapping study

Considering the critical role of software in modern societies, we face an urgent need to educate more competent software professionals. Software engineering competencies (SEC) are considered the backbone of successfully developing software products. Consequently, SEC has become a hotspot for software engineering research and practice. Although scientific literature on SEC is not lacking, to our knowledge, a comprehensive overview of the current state of SEC research is missing. To that end, we conducted an extensive and systematic review of the SEC literature. We provide an overview of the current state of research on SEC, with a particular focus on common SEC research areas. In addition to reporting the available SEC models and frameworks, we compile a list of 49 unique essential competencies of software professionals. Finally, we highlight several gaps in the literature that deserve further research. In particular, we call for a better understanding of how the essential competencies of software professionals change over time, as well as fresh accounts of the essential competencies of software professionals. Additionally, considering recent shifts toward Agile and DevOps methods, future research must explore the competencies required for developing software products in modern development environments.

A Security-Specific Knowledge Modelling Approach, Software Practices, and Data Centre Infrastructure for Securing Software Engineering Technologies

The advancement of emerging technological tools in software engineering is an important element in the design and development of software systems. In this paper, we present an analysis of theory and practice including methodology of software products for both large and complex requirements and development analysis, and synthesis. The paper is presented in two folds: Part-I describes a security-specific knowledge of modelling approach for securing software engineering and typical projects implemented in data centre infrastructure. In relation to software engineering practice and theory, we analysed the key parameters indicators of software development projects and the elements of a system that encapsulate the customer, developer, and the researcher as stakeholders in a software development project, whereas the elements of a system entail computer, data validation, mailroom, and computation with paychecks and pay-information. The modelling process and life cycle model includes some major processes in software development such as users’ resources, production of the final product, subprocesses with hierarchy links, process activity, guiding principles, and outcomes of a software requirement specification. In Part-II, an overview of data centre infrastructure and with some schematic illustration for each phase of the construction and implementation of a data centre. The project involves a system and process that creates it with prepare, design, acquire, and implement as a process model whereas actors create the project model. In the context of data centre life cycle model, prepare and design form the construct or build phase, and maintainability and optimization form the engineering phase. All these formulates the project model as the building blocks of data centre. The business need for the construction of the data centre (prepare, design, acquire, and implement) are the knowledge-based of the process model phases to produce an overall system we called the four phases of data centre project process.

Ensuring scientific reproducibility in bio-macromolecular modeling via extensive, automated benchmarks

Each year vast international resources are wasted on irreproducible research. The scientific community has been slow to adopt standard software engineering practices, despite the increases in high-dimensional data, complexities of workflows, and computational environments. Here we show how scientific software applications can be created in a reproducible manner when simple design goals for reproducibility are met. We describe the implementation of a test server framework and 40 scientific benchmarks, covering numerous applications in Rosetta bio-macromolecular modeling. High performance computing cluster integration allows these benchmarks to run continuously and automatically. Detailed protocol captures are useful for developers and users of Rosetta and other macromolecular modeling tools. The framework and design concepts presented here are valuable for developers and users of any type of scientific software and for the scientific community to create reproducible methods. Specific examples highlight the utility of this framework, and the comprehensive documentation illustrates the ease of adding new tests in a matter of hours.

SERP4IoT'21 Workshop Report

We face a new software crisis. In 1968, computer scientists learned that developing robust software requires skills, methods, and tools. Today, software and hardware engineers realize that developing a robust Internet of Things (IoT) also pushes the states of their art and practice. Recent news illustrate the many problems faced by IoT: from lack of interoperability to broken updates to massive security attacks. In this context, the 3rd International Workshop on Software Engineering Research and Practices for the Internet of Things (SERP4IoT) aims to provide a highly interactive forum for researchers and practitioners to address the challenges of, nd solutions for, and share experiences with the development, release, and testing of robust software for IoT systems.

Developers perception of peer code review in research software development

Background: Research software is software developed by and/or used by researchers, across a wide variety of domains, to perform their research. Because of the complexity of research software, developers cannot conduct exhaustive testing. As a result, researchers have lower confidence in the correctness of the output of the software. Peer code review, a standard software engineering practice, has helped address this problem in other types of software. Aims: Peer code review is less prevalent in research software than it is in other types of software. In addition, the literature does not contain any studies about the use of peer code review in research software. Therefore, through analyzing developers perceptions, the goal of this work is to understand the current practice of peer code review in the development of research software, identify challenges and barriers associated with peer code review in research software, and present approaches to improve the peer code review in research software. Method: We conducted interviews and a community survey of research software developers to collect information about their current peer code review practices, difficulties they face, and how they address those difficulties. Results: We received 84 unique responses from the interviews and surveys. The results show that while research software teams review a large amount of their code, they lack formal process, proper organization, and adequate people to perform the reviews. Conclusions: Use of peer code review is promising for improving the quality of research software and thereby improving the trustworthiness of the underlying research results. In addition, by using peer code review, research software developers produce more readable and understandable code, which will be easier to maintain.

An Interview with Nachiappan Nagappan - ACM Fellow 2020

Nachiappan (Nachi) Nagappan is one of the five ACM Fellows of the 2020 cohort who are also active SIGSOFT members. To celebrate his award, we invited him to a question/answer session. Nachi earned his PhD from North Carolina State University (NCSU), USA, in 2005. Afterwards he was with Microsoft Research for more than 15 years, rising through the ranks from Software Engineer to Partner Researcher. In January 2021, he started in a new position with Facebook. Nachi's research interests are in the field of Software Engineering focusing on Software Reliability, Developer Productivity, Software Data Analytics and Empirical Software engineering. More broadly, he works on software analytics for improving software engineering practices. His work is strongly interdisciplinary and his research projects span the spectrum of software analytics ranging from developer productivity, large scale mining for GitHub, empirical software engineering analytics for the development process, intelligent software design for games, to predicting software service outages for cloud services. Nachi has been the recipient of many honors and best paper awards. For example, in 2019 and 2021, he and his co-authors won the ESEC/FSE test-of-time award, and in 2020 Nachi received the prestigious Harlan D. Mills Award.