Aug 2026· Journal of Systems and Software· 0 citations· 57 references
Computer Science
TL;DR
Algorithm-Driven Development is introduced, a methodology developed from industrial practice to address recurring challenges in translating requirements into reliable, testable, and maintainable software behavior that provides systematic coverage of functional scenarios from the outset of development.
Abstract
Ensuring software quality while meeting deadlines and adapting to evolving requirements is a persistent challenge in software engineering practice. This paper introduces Algorithm-Driven Development (ADD), a methodology developed from industrial practice to address recurring challenges in translating requirements into reliable, testable, and maintainable software behavior. ADD translates requirements into algorithmic flowcharts from which acceptance tests are systematically derived. These flowcharts serve both as specification artifacts and as technical blueprints, supporting shared understanding between stakeholders and developers. By linking requirement modeling with automated test generation, ADD provides systematic coverage of functional scenarios, including edge cases, from the outset of development. The approach was evaluated over a four-year period within an industrial project at Dassault Syst\`emes, involving two development teams, 22,444 lines of production code for Team 1, and 157 APIs analyzed for Team 2. The evaluation combined longitudinal quality and delivery indicators with a comparative analysis of ADD, TDD, and test-last development practices across API functions of different complexity levels. Empirical data collected from internal lifecycle management and CI/CD systems show that ADD supported sustained code coverage above 95%, low defect density in both QA and post-release phases, and a stable delivery cadence. These findings provide evidence of ADD's potential to strengthen the connection between requirements, testing, and implementation in industrial software development contexts.
An integrated reference architecture is proposed that combines TDD's fine-grained unit-level feedback loop with BDD's stakeholder-readable acceptance criteria inside a single continuous integration and continuous delivery (CI/CD) pipeline.
Urvish Gajjar· International Journal of Sci...· 0 citations
A lifecycle-aware framework that integrates quantitative software quality assessment with Large Language Model (LLM)-based code refinement is proposed and the potential of metric-driven LLM feedback for research software quality improvement is demonstrated while highlighting its inherently multi-objective nature.
Nafis Tanveer Islam, N. Soveizi, Yutong Li et al.· 0 citations
A guide that facilitates the step-by-step adoption of five practices: version control, change requests controlled with manual code inspection, continuous integration, static code analysis, and implementing an automated pipeline for continuous integration is proposed.
M. Pastrana, Hugo-Armando Ordoñez-Erazo, C. Cobos-Lozada et al.· 0 citations
Today, IT organizations, in particular, have to provide quick, reliable and high-quality software solutions for meeting
the changing market requirements. While the development process has been structured by traditional software engineering
paradigms (Waterfall, Agile and Spiral Models), traditional workflows often involve operational bottlenecks. In particular, the
lack of communication and coordination between development and operations can lead to delivery delays. DevOps has come
about as a transformative approach that fuses software design and IT operations into a single, streamlined and automated
process that aims to overcome these systemic inefficiencies. DevOps is used to streamline the software delivery pipeline, when
paired with Cloud Computing infrastructure, including SaaS, PaaS, and IaaS solutions from AWS, Azure, and GCP. In this
project, one will be working on building a Continuous Integration and Continuous Deployment (CI/CD) pipeline using
Microsoft Azure to automate software delivery and improve overall efficiency
Ashwani Kumar, Geetanjali Amarawat· International Journal for Re...· 0 citations
In the rapidly evolving field of software development, open‐source software (OSS) has gained significant momentum due to its collaborative nature and emphasis on knowledge sharing. OSS source code is available under a license that allows users to inspect, improve, and modify it. In OSS, requirements are often created through informal online discussions, developer brainstorming, feature requests, and user feedback. Ambiguous or conflicting requirements can harm the software development process. The requirements engineering (RE) process in OSS faces several challenges, such as incomplete and ambiguous requirements, poor requirements prioritization, and conflicts among stakeholders over requirements. This research aims to identify and validate key challenges and their solutions within the RE process for open‐source software development (OSSD). A Multivocal Literature Review (MLR) was conducted using a customized search string aligned with our research questions (RQs). Following the MLR, an empirical study using a questionnaire survey (QS) was conducted to validate the findings. The results from the QS align with the conclusions drawn from the MLR. We identified a total of nine challenges across 47 selected articles (37 formal literature, 10 gray literature). To address these challenges, 66 practices/solutions are proposed. The best practices include involving developers and users in the RE process, along with formal requirements documentation and prioritization. The findings from this research will help OSS practitioners and academic researchers gain insights into the RE process, thereby improving it within OSS projects.
Fazli Rabi, Muhammad Ilyas, Nasir Rashid et al.· Journal of Software: Evoluti...· 0 citations
Understanding large, complex software architectures is difficult and time-consuming. Software architecture recovery aims to extract explanatory artefacts from code, but existing methods often lack generalisability. To address this, we previously proposed Deductive Software Architecture Recovery (DSAR) to extend current techniques. This paper presents a qualitative evaluation of DSAR in an industrial setting. Using a large language model-assisted prototype, we examined the recovered architecture's content quality, presentation quality, and usefulness for understanding and maintaining real-world systems. To ensure practical relevance, we conducted an in-depth judgement study with software engineering teams at ASML applying DSAR to 17 Java repositories across diverse teams. We contribute: an empirical assessment indicating that DSAR supports comprehension, architectural reasoning, and communication; qualitative evidence on the strengths and limitations of the generated explanatory artefacts; and recommendations for practitioners and researchers on adopting and further developing DSAR for architectural sense-making.
S. A. Rukmono, Lina Ochoa, Thijs Bressers et al.· SIGSOFT FSE Companion· 0 citations