Software

Software-intensive organizations increasingly face the challenge of integrating ethical considerations into routine work practices while maintaining process quality and organizational performance. This study develops the Quality Value Driver (QVD) framework, a managerial approach for embedding ethical reflection into everyday organizational processes. The framework links ethical values, organizational drivers, and observable quality indicators, providing a structured mechanism through which ethical values can be operationalized and evaluated. Following constructive research methodology, the study introduces the framework and illustrates its application through a proof-of-concept case involving an Agile team developing an AI-based facial palsy classification system. In the demonstrated application, collaboration was selected as the target value, Balint Groups served as the organizational driver, and process-quality indicators were used to assess development outcomes. The findings do not establish causal effectiveness but illustrate the feasibility of operationalizing ethical values through routine organizational practices within the specific context examined. The study contributes a software-engineering perspective that conceptualizes ethical values as potential process-quality drivers and advances the Ethics by Design approach by integrating ethical reflection into everyday software-development decision-making. Full article

Parallel performance depends not only on programming language and runtime design, but also on how the dominant execution bottleneck changes as parallelism increases. We present a controlled cross-language study of Rust, Julia, Haskell, and Python using Merge Sort, Closest Pair of Points, and Numerical Sum in a multicore environment. For each of the three workloads, we evaluate four language-based implementations at five worker counts $p\in \{1,2,4,8,16\}$ using two input sizes and 10 untrimmed trials per configuration, yielding 3 $\times$ 4 $\times$ 5 $\times$ 2 $\times$ 10 = 1200 benchmark observations. We propose a decomposition-based diagnostic framework built on three measured components: slowest-worker computation ($C_p$), algorithmic merge/combine work ($B_p$), and residual parallel overhead ($R_p$). Their normalized fractions, together with observed speedup, form a Workload–Runtime Scaling Signature (WRSS). Tracking WRSS across worker counts identifies Bottleneck Transition Points (BTPs). We additionally apply a standardized 20% component-reduction sensitivity analysis to express how strongly total parallel-region time depends on each measured component under an explicit ceteris-paribus assumption. Across the 3 $\times$ 2 $\times$ 4 = 24 workload–size–implementation conditions, each tracked over $p\in \{1,2,4,8,16\}$, 10 (41.67%) exhibit a bottleneck transition: six of eight Merge Sort conditions and four of eight Closest Pair conditions, whereas none of the eight Numerical Sum conditions exhibits a transition. At $p=16$, Merge Sort reaches only 2.02–3.19$\times$ median speedup because merge work dominates several configurations; Numerical Sum reaches 7.61–12.72$\times$ while remaining almost entirely computation-dominant. A separate 100-observation Python shared-memory ablation reduces Merge Sort residual overhead substantially, but leaves the merge stage dominant. The results show that useful parallelism depends on how workload structure and runtime mechanisms shape the evolution of the dominant bottleneck as worker count increases. Full article

We present SimDSL, a domain-specific language (DSL) for executing large-scale simulations on the GPU using an Entity Component System (ECS) architecture. Systems written in SimDSL are analyzed, lowered into an intermediate representation, and compiled by a CuPy-based backend into CUDA kernels operating over structure-of-arrays archetype tables. We evaluate SimDSL on five workloads: Particle Fountain, Traffic Ring, Reaction Diffusion, Ant Colony, and Tower Defense. The evaluation compares SimDSL with straightforward CuPy and CUDA baseline implementations under matched simulation configurations. Results show that SimDSL sustains GPU-resident execution and achieves favorable performance relative to these baselines. These findings demonstrate that high-level ECS simulation programs can be compiled into efficient GPU execution without requiring users to manually implement and coordinate low-level kernels. Full article

Background: Researchers dealing with software engineering often express some concern about the lack of a core theory for this discipline. In fact, even the most basic concepts of software engineering—like the organization of software development life cycles—are usually described informally, with no reference to an underlying theory. Methods: In this paper, a well-known model for requirements and specifications is used as a basis for a rigorous and uniform description of software development activities. Results: The proposed approach proved suitable to describe the most popular software life cycles, as well as to describe the properties of software development activities. The proposed approach was also used to describe the properties of the software product in a way that is precise enough to support the definition of metrics. Conclusions: The proposed approach seems suitable for describing most software engineering issues and reasoning about them. Full article

In cross-project defect prediction (CPDP), divergence in feature distribution between the source and target often fails when predicting defects across unrelated projects. Such a mismatch is typical rather than exceptional in real deployment scenarios. To address this, the Transfer Component Analysis (TCA) technique projects the source and target into a shared subspace, where Maximum Mean Discrepancy is minimized. However, combining fixed ensemble classifiers with TCA on NASA datasets is yet to be explored. Previous studies either searched ensemble compositions adaptively or conflated alignment with source selection. In this study, we trained a two-layer hybrid ensemble of Bagging and AdaBoost classifiers, alongside a Logistic Regression meta-learner, on TCA-aligned features across 20 directed source–target pairs. We used five PROMISE datasets, each having 21 McCabe and Halstead features. Experiments were conducted, and the findings show that, against an unaligned baseline using the same ensemble, TCA alignment increased mean AUC by 0.131 (0.625 to 0.755), mean F1 by 0.155, and mean MCC by 0.125. Wilcoxon signed-rank tests confirmed significance across all three metrics (p < 0.003, rank-biserial r = 0.714, Cliff’s Delta d ≥ 0.545). A full ablation showed that alignment was the dominant contributor to performance, with TCA improving AUC by +0.131 over the unaligned baseline. In contrast, SMOTE traded a small AUC reduction (−0.014) for substantial F1 gains (+0.134), while the stacking layer provided modest improvements in F1 and MCC. TCA reduced MMD across all 20 source–target pairs by a mean of 83.3%. Sensitivity analysis further showed that the TCA subspace dimensionality parameter, k, exhibited non-monotone, pair-specific AUC sensitivity, with optimal values ranging from 5 to 30. These findings indicate that alignment parameter selection substantially influences CPDP performance and that a fixed global default is inadequate. Full article

The incorporation of human values into software engineering processes is increasingly recognised as crucial, yet there is still a lack of practical methods to ensure their inclusion. A key challenge in this area is to identify a representative set of stakeholders while maintaining equality and diversity throughout the development process. This study aims to leverage stakeholder salience—defined by the attributes of power, legitimacy, and urgency—to partition stakeholders using a quantile-based statistical approach, establishing stakeholder groups that prevent discrimination and marginalization in requirements engineering processes. We propose a quantile-based statistical method for systematic stakeholder partitioning to ensure that diverse interests are considered and formalize equality and diversity through quantitative metrics in order to operationalize fairness. We applied the proposed method to the RALIC dataset to evaluate its applicability, considering two and three levels of granularity (binary medians and ternary terciles) for each salience component to assess its effectiveness in maintaining equality and diversity. Integrating quantile-based stakeholder salience partitioning into the identification process provides a structured approach to incorporating human values into software engineering, demonstrating that tercile partitioning significantly optimizes group balance and spatial coverage, ultimately contributing to more inclusive and equitable decision-making in requirements gathering. Full article

Domain-Specific Languages (DSLs) are essential in software engineering for safely expressing complex domain logic. However, Large Language Models (LLMs) struggle to generate syntactically and semantically correct code for niche DSLs due to sparse representation in pre-training corpora. While Grammar-Constrained Decoding (GCD) resolves syntactic hallucinations by masking logits through a formal Context-Free Grammar (CFG), empirical evidence shows that strict GCD disrupts the autoregressive Chain-of-Thought (CoT) reasoning of modern models, frequently forcing them into irreversible semantic dead-ends. To overcome the friction between internal neural reasoning and external symbolic constraints, we propose a Dual-Phase Cascaded Neurosymbolic framework. In the first phase, the model is provided with dynamically injected grammar rules and is permitted to reason unconstrained, producing an optimistic code draft. If the draft fails native compiler checks, the system enters a second phase: it preserves the successful semantic reasoning from Phase 1 but re-generates the code under strict GCD enforcement. This cascaded architecture utilizes the formal FSM not as an adversarial constraint, but as a localized syntax repair engine guided by the model’s own prior reasoning. We construct a comprehensive benchmark of 100 MiniZinc constraint programming tasks and evaluate our approach using a $pass@k$ metric with a strict semantic LLM judge. Our findings demonstrate that this dual-phase “think-then-constrain” approach significantly outperforms zero-shot, pure few-shot, and pure GCD baselines, achieving highly reliable, training-free code generation for unseen DSLs. Full article

Microservice-based systems evolve continuously through API changes, service splits and merges, dependency churn, and deployment-topology drift driven by DevOps practices. This rapid evolution erodes the assumptions encoded in formal models, test suites, and architectural descriptions, leaving practitioners with limited guidance on how to keep verification artifacts aligned with evolving implementations. Prior surveys cover microservices design, deployment, performance, and isolated verification techniques, but, to our knowledge, none consolidate the intersection of evolution and formal/rigorous verification, nor map how repository-derived signals and CI/CD pipelines support continuous verification of microservice-based systems. This paper addresses that gap through a systematic literature review (SLR). Following the Kitchenham et al. guidelines and PRISMA-style reporting, we defined a review protocol with four research questions covering (i) formal modeling and verification approaches, (ii) the impact of architectural and API evolution on verifiability, (iii) repository-derived signals for updating formal artifacts, and (iv) continuous and incremental verification in CI/CD pipelines. Structured searches in IEEE Xplore, ACM Digital Library, SpringerLink, and Scopus returned 1187 records, which were screened in seven stages and reduced to 18 included studies (13 primary studies that supply evidence and five background studies retained for transparency and framing) through inclusion/exclusion criteria and a weighted 15-item quality-assessment instrument. We synthesized the included studies thematically and compared them along five dimensions: verification technique, evolution dimension, automation level, empirical evidence, and tool/artifact availability. The synthesis shows that actor-based model checking, TLA⁺ control-plane verification, static code analysis, continuous certification, and runtime/self-adaptive testing form five complementary clusters, but empirical evaluation is dominated by small academic case studies, only a minority of approaches automate model updates from repository signals, and few are integrated end-to-end into CI/CD. We discuss methodological limitations of the body of work, including a lack of industrial-scale validation and shared datasets, contrast intrinsic (build-time, model-driven) and extrinsic (recovery-based) verification strategies, and outline a research agenda toward repository-aware, pipeline-integrated verification for evolving microservices. The present synthesis distils a set of immediate, evidence-based actions for practitioners together with a focused agenda of open research challenges. Full article

Autonomous Cyber–Physical Systems (CPS) must jointly satisfy energy efficiency, accuracy, and real-time constraints, which are typically treated separately in existing methods. This paper proposes a verifiable service-oriented CPS framework for energy-aware autonomous navigation using a high-fidelity cyber–physical twin. The approach integrates physics-based Model Predictive Control (MPC) with explicit power modeling ($P=F·v$) and Dubins curve-based trajectory generation under the 5C (connection, conversion, cyber, cognition, and configuration) architecture using CARLA for synchronized cyber–physical interaction. The proposed method achieves 30.7% reduction in mean power consumption and 12.5% reduction in total energy usage while maintaining sub-centimeter tracking error (<0.05 m). Mission duration increases by 26.3% with only 7% computational overhead, confirming real-time feasibility. The framework provides a verifiable CPS methodology that unifies physics-based control, digital twin synchronization, and service-oriented design for energy-aware autonomous navigation. Full article

Vision–Language Models (VLMs) have emerged as powerful tools for image understanding tasks, yet their practical deployment remains hindered by significant architectural heterogeneity across model families. This paper introduces UVLM (Unified Vision–Language Model), a pip-installable Python (v3.9+) package that provides a unified interface for loading, configuring, and running multiple VLM architectures on custom image analysis tasks. UVLM currently supports two major model families which differ fundamentally in their vision encoding, tokenization, and decoding strategies: LLaVA-NeXT and Qwen2.5-VL. The package abstracts these differences behind a single inference function and eliminates all architecture-specific code from the user’s workflow. UVLM is organized as eight modular Python components (model loading, dual-backend inference, response parsing, consensus validation, batch processing, prompt assembly, model registry, and utilities) and can be deployed in three modes: Google Colab for zero-install cloud access, local Jupyter notebooks for on-premises GPU use, and as a programmatic API for integration into automated pipelines. Key features include a multi-task prompt builder supporting four response types (numeric, category, boolean, text), a consensus validation mechanism based on majority voting, a flexible token budget (up to 1500 tokens) for custom reasoning strategies, and built-in truncation detection. The package is designed for extensibility: adding a new VLM family requires implementing one backend-specific inference section and adding entries to the model registry, without modifying any other module. An illustrative example on 120 street-view images across 16 model configurations is provided to demonstrate the software’s evaluation workflow. Full article

Public sector organizations are under increasing pressure to modernize service delivery while preserving transparency, interoperability, accountability, and citizen trust. Blockchain technology offers relevant capabilities for these objectives, particularly through shared ledgers, cryptographic verification, and programmable rules. However, its adoption in public sector contexts remains constrained by the lack of architectural guidance tailored to inter-organizational services. This study proposes BRA-PS, a Blockchain Reference Architecture for Public Sector Citizen-Centric Applications, developed from a real-world digitalization project in Quebec, Canada. The architecture organizes components into six layers (presentation, business, communication, smart contract, blockchain, and data) with cross-cutting concerns addressing governance, access control, security, and monitoring. A key design principle is the public–private workflow separation, which enables inter-organizational collaboration while preserving each organization’s operational autonomy and data confidentiality. We validated the architecture through a case study involving a vehicle registration process between two public agencies, supported by a proof-of-concept implementation using Hyperledger Fabric. An Architecture Trade-off Analysis Method (ATAM) evaluation, conducted with a panel of five domain experts, identified six architectural risks, including InterPlanetary File System (IPFS) confidentiality exposure and smart contract inflexibility, six non-risks, six sensitivity points, and six trade-offs across three key quality attributes: autonomy, collaboration, and functional suitability. The results show that BRA-PS can support implementation decisions, clarify stakeholder responsibilities, and expose relevant architectural trade-offs. The recommendations derived from the evaluation provide practical guidance for the adoption of blockchain in citizen-centric public sector services. Full article

We present OptimSolution, an open-source, cross-platform framework for the systematic benchmarking and analysis of continuous optimisation methods, available for Windows, Linux and macOS and operable via both a command-line interface (CLI) and a Qt-based Graphical User Interface (GUI). The framework supports four execution modes: Single mode for single method–problem runs with convergence and distribution analysis; Batch mode for automated multi-method, multi-problem experimentation with aggregated statistical summaries; Method Sensitivity Analysis for quantifying the effect of algorithmic hyperparameters on solution quality; and Problem Sensitivity Analysis for assessing how problem-defining parameters influence instance difficulty and inter-method rankings. Complexity analysis is provided along two-axes method scalability across problem dimensionalities and problem difficulty profiles across method portfolios. Statistical validation is embedded natively through Wilcoxon signed-rank and Friedman tests with post-hoc pairwise analysis, complemented by rank tables and box-plot visualisations. All outputs are exportable as CSV files or publication-ready PNG figures. The framework is designed for extensibility: new methods and benchmark problems can be registered and activated through the GUI without modifications to the core codebase, supporting rapid experimental iteration. Full article

The rapid emergence of generative AI tools is transforming software development. Consequently, software engineering education must adapt to ensure that students not only learn traditional development methods but also understand how to use these new technologies effectively and responsibly. In particular, project-based courses provide an effective setting in which to explore and evaluate the integration of AI assistance into real-world development practices. This paper presents our approach and a user study conducted in the context of a university programming project in which students collaboratively developed computer games. The study investigates how participants used generative AI tools across different phases of the software development process, identifies the tasks for which these tools were perceived as most useful, and analyzes the challenges students encountered. Building on these insights, we further examine a repository-aware, locally deployed large language model (LLM) assistant designed to provide project-contextualized support. The system employs retrieval-augmented generation (RAG) to ground its responses in relevant documentation and source code, thereby enabling a qualitative analysis of model behavior, parameter sensitivity, and common failure modes. These findings deepen our understanding of context-aware AI support in educational software projects and inform the future integration of AI-based assistance into software engineering curricula. Full article

Prompt specifications for multi-agent large language model (LLM) systems carry data contracts and integration logic across interdependent files but are rarely subjected to structured-inspection rigor. We report a single-system case study of iterative, agent-driven auditing applied to AEGIS (Autonomous Engineering Governance and Intelligence System), a seven-lane production pipeline whose 7152-line specification surface was audited across nine rounds, surfacing 51 consistency defects (per-round counts of 15, 8, 12, 2, 8, 1, 4, 1, 0). We present a seven-category post hoc taxonomy with explicit coding rules, non-monotonic convergence consistent with cascading edits and audit-scope expansion, and a locked audit protocol. We further report two partial replications on a public synthetic mini-specification: a cross-LLM panel of four frontier vendors (OpenAI, Anthropic, Google, xAI; 12 traces; multi-vendor union detects all five seeded defects) and an inter-rater reliability check on a stratified subsample (Cohen’s $\kappa$ = 0.80 on category, 0.46 on severity). The full reproducibility bundle accompanies the submission. Full article

Web Application Programming Interfaces (Web APIs) have become fundamental components of modern software ecosystems. At the same time, they have emerged as major attack surfaces in web applications and distributed services. Although many web API vulnerabilities are well documented, a critical gap remains in understanding how insecure development practices, usability limitations, and developer-related issues contribute to recurring API security problems. To address this gap, this study presents a systematic review of web API security research using a PRISMA-guided methodology and a taxonomy-driven analytical approach. The review synthesizes findings from 50 selected studies covering web API architectural styles, usability concerns, authentication and access-control weaknesses, and common vulnerabilities. These vulnerabilities include SQL Injection (SQLi), Cross-Site Scripting (XSS), Broken Authentication, and Denial-of-Service (DoS) attacks within the context of the OWASP API Security Top 10 framework. The findings indicate that recurring web API vulnerabilities are associated not only with technical weaknesses but also with API usability issues, insecure development practices, inconsistent security guidance, and increasing implementation complexity. The review also identifies persistent research gaps involving usability-security integration, API evolution, secure-by-design development practices, and empirical validation of security tools and frameworks. By synthesizing these dimensions into a unified conceptual perspective, this study provides researchers and practitioners with a clearer understanding of the factors contributing to web API insecurity. The study also highlights directions for developing more resilient and developer-aware API security practices. Full article

Artificial Intelligence Chatbots based on Large Language Models are becoming important cornerstones in education, professional, and personal contexts. Users frequently disclose sensitive information without the necessary awareness of how their data is processed, stored, and later used, creating risks of unintended exposure and violation of data protection regulations such as GDPR and the EU AI Act. In this paper, we present a dynamic privacy-by-design framework that introduces a novel privacy-oriented middleware layer between the users and the AI Chatbots. Our framework intercepts user prompts, detects and sanitizes sensitive information, and enables explicit user control over data retention and disclosure through our dedicated Information Manager Dashboard. To develop our framework around real-world needs, we conducted a survey with 83 participants investigating privacy concerns, regulatory awareness, and preferences for transparency and control in conversational AI. Our results indicate that better and more transparent privacy safeguards can be achieved without significantly compromising usability or performance, supporting the development of trustworthy and user-centric AI chatbots. We also evaluate our solution against other state-of-the-art implementations and relevant metrics. Full article

Socio-technical congruence (STC) theory posits that software development effectiveness depends on the degree to which developer coordination aligns with technical requirements. However, much existing research treats congruence as a static project attribute, overlooking the dynamic coordination needs that arise during periods of intensive development. This study addresses this gap by examining development bursts, brief episodes of significant technical change and collaboration that alter coordination demands. Using fixed-effects regression models, the analysis examines 45,981 development bursts from 6401 open-source software projects. The findings show that higher burst intensity is positively associated with both congruence and delivery throughput, suggesting that effective collaboration often centers on shared integration challenges. Conversely, higher coordination complexity is associated with lower congruence and reduced delivery reliability, indicating that the main risks associated with bursts stem from structural rather than purely volumetric factors. Team experience also mitigates the negative effects of complexity on congruence, highlighting the importance of accumulated coordination capability. However, after accounting for demand-side factors, the relationship between congruence and delivery reliability becomes negative, indicating that congruence observed during bursts reflects not only alignment quality but also coordination burden. These findings extend STC theory by reconceptualizing congruence as a dynamic state and emphasizing the need to understand its evolution in high-frequency coordination contexts. Full article

The increasing adoption of artificial intelligence (AI) in smart learning environments has heightened the need for systematic, reliable testing of AI-driven educational applications. Existing studies primarily rely on benchmark accuracy, manual testing, or user-based assessment, offering limited insight into robustness, coverage, and failure behavior. These limitations are driven by the lack of standardized intelligence quality criteria, inadequate test automation support, complex diversity in Q&A tasks, and the difficulty of automatically validating test results in smart learning applications. This paper investigates model-based AI testing for Q&A-based smart learning applications, using ChatGPT (GPT-5) as a case study to evaluate its intelligence quality in college algebra question answering tasks that support student learning. A three-dimensional (3D) AI testing framework structures testing along input, context, and output dimensions to enable model-driven test generation, controlled contextual variation, and consistent validation. College algebra problems selected from a standard undergraduate textbook are used to construct representative test cases. Controlled image-based data augmentation and structured similarity-based validation mechanisms are employed to support automated test execution and result analysis. Empirical results demonstrate that the proposed approach improves intelligence quality coverage and provides more diagnostic insight than ad hoc evaluation methods. Full article

While anonymity is often considered as a binary property that is either satisfied or not satisfied, a closer analysis shows that there are different degrees of anonymity and that an appropriate degree of anonymity must be selected depending on application and context. For this purpose, different models have been developed that allow for defining the degree of anonymity needed for a given application and evaluating whether this required degree has been achieved. The current paper identifies the properties that such a model of anonymity should satisfy and evaluates the most common models based on these properties, thereby providing a basis for implementing anonymity in software development and verifying that an adequate degree of anonymity has been achieved in a particular application. To achieve this, the paper starts with an outline of the reasons for creating anonymity models and the legal framework of anonymity. Subsequently, the main threats to and relevant properties of anonymity are identified. In the main body of the paper, the available models of anonymity are then summarized and evaluated against these properties. Full article