Software Engineering Practices Research Articles

How Scrum adds value to achieving software quality?

Scrum remains the most popular agile software development method implementation for a variety of reasons; one important motive is to improve software quality. Yet many organizations fail to achieve quality improvements through the use of Scrum, and existing research sheds little light on the value-add of Scrum for software quality. More specifically, (1) how notions of software quality among Scrum practitioners relate to established quality perspectives, (2) how Scrum helps teams to achieve higher software quality and (3) why some teams fail to meet the objective of higher quality. We addressed these gaps through a two-phased qualitative study based on 39 interviews and two in-depth case studies. We find that Scrum practitioners emphasize established notions of external quality comprising of conformity to business needs and absence of defects, while they also value internal quality, especially sustainable software design. Our results show that Scrum helps teams achieve both dimensions of quality by promoting some social antecedents (collaboration, psychological safety, accountability, transparency) and process-induced advantages (iterative development, formal inspection, and adaptation). Our findings unveil how these factors contribute to achieving software quality and under what conditions their effects can fail to materialize. These conditions include inconsistent Scrum implementations, cultural constraints, team tensions, and inaccessibility of end-users. In addition, the complexity of the project aggravates the impact of these conditions. Taken together, these findings show that Scrum can complement established quality assurance and software engineering practices by promoting a social environment that is conducive to creating high-quality software. Based on our findings, we provide specific recommendations for how practitioners can create such an environment.

Philanthropic conference-based requirements engineering in time of pandemic and beyond.

As software engineering (SE) practitioners, we can help society by using our communities of experts to address a software need of a socially conscious organization. Doing so can benefit society in the locale of a SE conference and provide access to international experts for local organizations. Furthermore, established SE researchers as well as practitioners and students have the opportunity for a unique learning experience. While the SE community has already realized the importance of addressing human values and promoting social good objectives in software development, we are unaware of previous attempts to leverage SE conferences for this activity. Conferences present an opportunity to enjoy the assembly of SE practitioners, researchers, and students for the purpose of a philanthropic endeavor. Over the past four years of running a “Requirements Engineering for Social Good” event called RE Cares, co-located with the International Conference on Requirements Engineering, we worked with the stakeholders local to the conference venue. We selected stakeholders who would not necessarily have ready access to requirements engineering, software design, and development expertise otherwise, to build software targeting “good causes.” In the last two years, this event was altered to adapt to the constraints induced by COVID-19, moving to a hybrid mode and changing many of its practices accordingly. This paper summarizes and generalizes our experiences, discussing our lessons learned in the context of the pandemic and beyond and providing a framework for conducting similar social contribution in any SE conferences in general.

The Impact of Covid-19 on Online Final Exam Scores Among Computer Science Students

The main goal of this research is to identify the impact of COVID-19 on online final exam scores among Computer Science students. The correlation matrix we used indicates the interrelationships among learning outcomes and student profile, type of classes, and student online behaviour. Six courses were taken under consideration: Practical Algorithms, Discrete Mathematics, Software Engineering, Programming, Team Projects, and Artificial Intelligence. A total of 4,988 final exam results were examined. After a deep analysis of the literature on the topic, we expected two scenarios. The first scenario constituted a decline in passing grades due to challenges such as learning platform failures, poor internet connections, or poorer quality of lessons due to teachers’ lack of online competence. We hypothesized the second scenario as extraordinary student performance compared to their prior exams, but due to their dishonesty. The results of the study revealed that neither of the scenarios took place. It turned out that the challenges that seemed to be the most difficult ultimately did not matter. The present study finds that there is not a significant difference in the students’ final exam performance between their online and traditional courses. Our strategy as described in this article has demonstrated a smooth transition from traditional to online teaching and assessment in terms of the final assessment.

Towards cost-benefit evaluation for continuous software engineering activities

Context:Software companies must become better at delivering software to remain relevant in the market. Continuous integration and delivery practices promise to streamline software deliveries to end-users by implementing an automated software development and delivery pipeline. However, implementing or retrofitting an organization with such a pipeline is a substantial investment, while the reporting on benefits and their relevance in specific contexts/domains are vague.Aim:In this study, we explore continuous software engineering practices from an investment-benefit perspective. We identify what benefits can be attained by adopting continuous practices, what the associated investments and risks are, and analyze what parameters determine their relevance.Method:We perform a multiple case study to understand state-of-practice, organizational aims, and challenges in adopting continuous software engineering practices. We compare state-of-practice with state-of-the-art to validate the best practices and identify relevant gaps for further investigation.Results:We found that companies start the CI/CD adoption by automating and streamlining the internal development process with clear and immediate benefits. However, upgrading customers to continuous deliveries is a major obstacle due to existing agreements and customer push-back. Renegotiating existing agreements comes with a risk of losing customers and disrupting the whole organization.Conclusions:We conclude that the benefits of CI/CD are overstated in literature without considering the contextual and domain complexities rendering some benefits infeasible. We identify the need to understand the customer and organizational perspectives further and understand the contextual requirements towards the CI/CD.

Technical challenges of modelling real-life epidemics and examples of overcoming these.

The coronavirus disease 2019 (COVID-19) pandemic has highlighted the importance of mathematical modelling in informing and advising policy decision-making. Effective practice of mathematical modelling has challenges. These can be around the technical modelling framework and how different techniques are combined, the appropriate use of mathematical formalisms or computational languages to accurately capture the intended mechanism or process being studied, in transparency and robustness of models and numerical code, in simulating the appropriate scenarios via explicitly identifying underlying assumptions about the process in nature and simplifying approximations to facilitate modelling, in correctly quantifying the uncertainty of the model parameters and projections, in taking into account the variable quality of data sources, and applying established software engineering practices to avoid duplication of effort and ensure reproducibility of numerical results. Via a collection of 16 technical papers, this special issue aims to address some of these challenges alongside showcasing the usefulness of modelling as applied in this pandemic.This article is part of the theme issue ‘Technical challenges of modelling real-life epidemics and examples of overcoming these’.

Aligning Software Engineering Teaching Strategies and Practices with Industrial Needs

Several approaches have been proposed to reduce the gap between software engineering education and the needs and practices of the software industry. Many of them aim to promote a more active learning attitude in students and provide them with more realistic experiences, thus recreating industry software development environments and collaborative development and, in some cases, with the involvement of companies mainly acting as potential customers. Since many degree courses typically offer separate subjects to teach requirements engineering, analysis and design, coding, or validation, the integration of all these phases normally necessitates experience in a project context and is usually carried out in a final year project. The approach described in this article benefits from the close involvement of a software house company which goes beyond the common involvement of a potential customer. Students are integrated into distributed teams comprising students, teachers and IT professionals. Teams follow the agile Scrum methodology and use the OutSystems low-code development platform providing students with the experience of an almost real scenario. The results show that this approach complements the knowledge and practice acquired in course subjects, develops the students’ technical and non-technical skills, such as commitment, teamwork, and communication, and initiates them in the methodologies and development strategies used in these companies. The feedback from the teachers involved, software companies and students was very positive.

Collaborative experience between scientific software projects using Agile Scrum development

AbstractDeveloping sustainable software for the scientific community requires expertise in software engineering and domain science. This can be challenging due to the unique needs of scientific software, the insufficient resources for software engineering practices in the scientific community, and the complexity of developing for evolving scientific contexts. While open‐source software can partially address these concerns, it can introduce complicating dependencies and delay development. These issues can be reduced if scientists and software developers collaborate. We present a case study wherein scientists from the SuperNova Early Warning System collaborated with software developers from the Scalable Cyberinfrastructure for Multi‐Messenger Astrophysics project. The collaboration addressed the difficulties of open‐source software development, but presented additional risks to each team. For the scientists, there was a concern of relying on external systems and lacking control in the development process. For the developers, there was a risk in supporting a user‐group while maintaining core development. These issues were mitigated by creating a second Agile Scrum framework in parallel with the developers' ongoing Agile Scrum process. This Agile collaboration promoted communication, ensured that the scientists had an active role in development, and allowed the developers to evaluate and implement the scientists' software requirements. The collaboration provided benefits for each group: the scientists actuated their development by using an existing platform, and the developers utilized the scientists' use‐case to improve their systems. This case study suggests that scientists and software developers can avoid scientific computing issues by collaborating and that Agile Scrum methods can address emergent concerns.

SOFTWARE MAINTENANCE MANAGEMENT IN MICRO SOFTWARE COMPANIES

Software maintenance is one of the main processes in software companies. It is regarded as more complex and costly compared to software development, and therefore should be carefully planned and managed. Micro software companies are companies with up to 10 employees, and they represent a significant driver of economic development in many countries around the world. However, micro companies have specific internal organizations and a business model, but also have significant constraints on human and financial resources. After outlining the basic concepts of software maintenance and the characteristics of small and micro software companies, the paper presents the author’s experience in software maintenance management in a local micro software company in Serbia. Maintenance management was implemented through a project aimed at improving maintenance processes in the company. The main objective was the improvement of maintenance request processing, which resulted in the implementation of a technical solution related to the timeline of maintenance requests. Since the process improvement project fosters organizational learning and knowledge management activities, a knowledge identification and systematization project was implemented as a subproject. Presented experience gained through fieldwork in the company contributed to the overall knowledge base about software engineering practice in micro software companies, which can be beneficial to both researchers from academia and practitioners from industry.

Implementing DevSecOps Pipeline for an Enterprise Organization

DevSecOps is an organizational software engineering culture and practice that aims at unifying software development (Dev), security (Sec) and operations (Ops). DevSecOps is an extension of DevOps, which is considered as a means to intertwine development, operation and security. The main characteristic of DevSecOps is to improve customer outcomes and mission value by automating, monitoring, and applying security at all phases of the software lifecycle: plan, develop, build, test, release, deliver, deploy, operate, and monitor. Continuous practices, i.e., continuous integration, delivery, and deployment, are the software development industry practices that enable organizations to frequently and reliably release new features and products. DevSecOps means thinking about application and infrastructure security from the start. With the increasing interest in the literature on continuous practices, it is important to systematically review and synthesize the approaches, tools, challenges, and practices reported for adopting and implementing continuous practices. This paper aimed at systematically reviewing the state of the art of continuous practices to classify approaches and tools, identify challenges and practices in this regard, and identify the gaps for future research. We used the systematic literature review method for reviewing the peer reviewed papers on continuous practices published between 2004 and June 1, 2016. We applied the thematic analysis method for analysing the data extracted from reviewing 69 papers selected using predefined criteria. Conclusion: Although DevSecOps is getting increasing attention by industry, it is still in its infancy and needs to be promoted by both academia and industry.

Software Productivity in Practice: A Systematic Mapping Study

Practitioners perceive software productivity as one of the most important subjects of software engineering (SE) because it connects technical to social and economic aspects. Nonetheless, software processes are complex and productivity means different things to different people. In order to realize the full contribution of software productivity research to the industrial practice of SE, the analysis and synthesis of existing practitioner viewpoints and concerns are required. A systematic mapping study is developed here to investigate the existence of diverse empirical perceptions of productivity within the distinct business sectors and knowledge areas covered by the industrial practice of SE, also identifying the commonalities among them. This study adopts the DBLP and Scopus search engines to identify bibliographic references from 1987 to 2021 related to software productivity. References that do not correspond to complete not-later-subsumed articles published in peer-reviewed journals and proceedings are excluded from the analyses. Only papers reporting on empirical studies based on software industry data or that present industry practitioner viewpoints are included in these analyses. In total, 99 papers are analyzed. The mapping found great variability in study findings, particularly concerning the impacts of agile development practices on software productivity. The systematic mapping also drew methodological recommendations to help industry practitioners address this subject and develop further research.

Code Review Knowledge Perception: Fusing Multi-Features for Salient-Class Location

Code review is a common software engineering practice of practical importance to reduce software defects. Review today is often with the help of specialized tools, such as Gerrit. However, even in a tool-supported code review involves a significant amount of human effort to understand the code change, because the information required to inspect code changes may distribute across multiple files that reviewers are not familiar with. Code changes are often organized as commits for review. In this paper, we found that most of the commits contain a salient class(es), which is saliently modified and causes the modification of the rest classes in a commit. Our user studies confirmed that identifying the salient class in a commit can facilitate reviewers in understanding code change. Inspired by the effectiveness of machine learning techniques in the classification field, we model the salient class identification as a binary classification problem and a number of discriminative features is extracted for a commit and used to characterize the salience of a class. The experiments results show that our approach achieves an accuracy of 88 percent. A user study with industrial developers shows that our approach can really improve the efficiency of reviewers understanding code changes in a reviewing scenario without using comment.

Report on the 2nd Workshop on Human Centric Software Engineering & Cyber Security (HCSE&CS 2021)

As the creators, designers, coders, testers, users, and occasional abusers of all software systems-including cyber security systems - humans should be at the centre of all design and development efforts. Despite this, most software engineering and cyber security research and practices tend to be function, data, or process oriented. In contrast, human-centric software engineering focuses on the human-centric issues critical to successful software systems' engineering. The aim of the International Workshop on Human Centric Software Engineering & Cyber Security (HCSE&CS) was to provide a venue for sharing research ideas and outcomes on enhanced theory, models, tools, and capability for next-generation human-centric software engineering and cyber security. The Second HCSE&CS Workshop was held on 15 November 2021 in conjunction with ASE 2021, the 36th IEEE/ACM International Conference on Automated Software Engineering. It was originally intended to be held in Melbourne, Australia but was instead held virtually due to the COVID-19 pandemic. This post-workshop report provides an overview of the aims and motivation of the workshop as well as a summary of the presentations and discussions that took place during the workshop.

Validating the knowledge bank approach for personalized prediction of survival in acute myeloid leukemia: a reproducibility study

Reproducibility is not only essential for the integrity of scientific research but is also a prerequisite for model validation and refinement for the future application of predictive algorithms. However, reproducible research is becoming increasingly challenging, particularly in high-dimensional genomic data analyses with complex statistical or algorithmic techniques. Given that there are no mandatory requirements in most biomedical and statistical journals to provide the original data, analytical source code, or other relevant materials for publication, accessibility to these supplements naturally suggests a greater credibility of the published work. In this study, we performed a reproducibility assessment of the notable paper by Gerstung et al. (Nat Genet 49:332–340, 2017) by rerunning the analysis using their original code and data, which are publicly accessible. Despite an open science setting, it was challenging to reproduce the entire research project; reasons included: incomplete data and documentation, suboptimal code readability, coding errors, limited portability of intensive computing performed on a specific platform, and an R computing environment that could no longer be re-established. We learn that the availability of code and data does not guarantee transparency and reproducibility of a study; paradoxically, the source code is still liable to error and obsolescence, essentially due to methodological and computational complexity, a lack of reproducibility checking at submission, and updates for software and operating environment. The complex code may also hide problematic methodological aspects of the proposed research. Building on the experience gained, we discuss the best programming and software engineering practices that could have been employed to improve reproducibility, and propose practical criteria for the conduct and reporting of reproducibility studies for future researchers.

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

The State of Software Engineering Practices for Machine Learning

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.