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.

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 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 , 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.

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.