Computer Science and Mathematics

Abstract: Live data migration across geographic regions in Internet-scale cloud services requires distributed locking—but dedicated lock services add infrastructure, latency on every request, and atomicity gaps between lock release and location cutover. We present an alternative: embedding lock metadata directly in the routing records that services already read on every user request. Deployed at a large-scale real-time messaging platform processing 6–10 million migrations per day, this approach makes lock enforcement free for the overwhelming majority of requests—lock checks piggyback on the routing lookup every request already performs—with a single extra point read only for the small, transient set of resources that carry an active lock. It also provides atomic cutover (location swap and lock release in a single database write) and deterministically correct lock propagation (passive cache expiry rather than active invalidation). Write-lock duration—the only user-impacting phase—holds at p99 under 20 seconds. We compare against Chubby, ZooKeeper, Redlock, and DynamoDB Lock Client, and discuss the broader applicability of infrastructure-embedded coordination for Internet-scale distributed systems.

Abstract: Software increasingly spans a continuum of independently owned services and heterogeneous stores across regions, and data residency rules force live data to move between regions without interrupting service. A single logical entity spans many services, and no component knows its full dependency graph in advance. An early design that centralized this knowledge reported success while silently omitting data it had never been taught about—a failure invisible to conventional health metrics. We rebuilt it into a contract-based migration platform for a messaging service, resting on three ideas: a stable five-API service contract that keeps domain knowledge with each service; typed dependency semantics that make declarations executable policy; and runtime graph expansion that guarantees completeness without knowing the full graph. It ran 6–10 million migrations per day at 99.9% first-attempt success, growing from 7 to 15 services with no contract change.

Abstract: Software architecture remains conceptually fragmented despite decades of influential definitions, standards, and methods. This study synthesizes this plurality into four recurring worldviews: Architectural Abstractionism, Architectural Multi-Levelism, Architectural Fundamentalism, and Architectural Consequentialism. Using an analytic-conceptual methodology, the schools are systematically characterized through the Meta-Architectural Descriptive (MAD) Framework and evaluated through the Software Architecture Conception Adequacy (SACA) Framework for descriptive, explanatory, practical, and teleological adequacy. The analysis finds that all four exhibit mixed adequacy: each contributes important insights but retains material deficiencies, and none is independently adequate or dominant. Their individual and collective inadequacies also have consequential implications for architectural scope, workmanship, governance, architecture-to-realization continuity, and professional formation. The findings support synthesis rather than selection among the schools and establish requirements for a coherent and comprehensive conception of software architecture that integrates their merits while resolving their respective deficiencies.

Abstract: Software architecture remains foundational to the design and evolution of complex software systems, yet no sufficiently unified conception establishes what architecture encompasses or where its boundaries lie. Rather than proposing another definition, this paper addresses the logically prior meta-conceptual problem: how alternative conceptions can be systematically articulated and evaluated before synthesis. It develops the Meta-Architectural Worldview (MAW), operationalized through the Meta-Architectural Descriptive (MAD) Framework and the Software Architecture Conception Adequacy (SACA) Framework. MAD reconstructs conceptions across eight interrelated dimensions: purpose and value, architectural objects, qualities, form, depth, context, boundary, and explanatory and justification. SACA evaluates conceptions for descriptive, explanatory, practical, and teleological adequacy, with teleological adequacy referenced to the shared disciplinary purpose of software architecture. MAD also yields the concepts of design span and architectural design span. Together, these constructs provide a first-principles foundation for evaluating existing worldviews and rigorously pursuing a more unified, coherent, holistic definition of software architecture.

Abstract: Wind resource assessment increasingly depends on integrating heterogeneous reanalysis, turbine data, geospatial operations, and persistent computational services. This article presents WindAnalysis, a containerized web framework for coastal wind studies in the Colombian Caribbean. Its novelty is architectural and operational: rather than introducing new wind models, the framework integrates scheduled ERA5 and MERRA-2 ingestion, persistent PostgreSQL storage, typed FastAPI services, an authenticated React geospatial interface, experiment retention, turbine-level power curves, and inverse-distance-weighted (IDW) interpolation within a single reproducible workflow. The evaluated database state comprised 32,633,302 ERA5 and 3,941,280 MERRA-2 records. Controlled benchmarks showed a 3962-fold acceleration for planner-based row counts and a 19.4-fold acceleration for 1% block-sampled mean queries, with 0.39% mean absolute relative error. Internal leave-one-grid-point-out IDW cross-validation yielded a 10 m wind-speed RMSE of 0.366 m/s for the deployed p = 2, 50 km configuration. The documented La Guajira case, using direct ERA5 wind at 100 m, produced a gross AEP of 8.901 GWh/year and a gross capacity factor of 61.58% for a Vestas V82 turbine. The evaluation further includes 2839 archived automated tests and release-level UI-to-runner parity. WindAnalysis therefore provides an inspectable, repeatable integration layer for regional wind-resource assessment while keeping computational reproducibility distinct from external physical validation.

Abstract: Software engineering coordination constitutes a substantial and growing proportion of development effort, yet coordination cost remains one of the least rigorously modelled, measured, or estimated aspects of software engineering. Despite decades of research in software development cost estimation and coordination theory, the field lacks a coherent and comprehensive engineering foundation that treats coordination cost as a measurable and analytically estimable quantity with its own theoretical constructs, standardized units, and analytical models. This paper establishes that foundation. It develops a generalized theory of coordination cost dynamics that distinguishes intra-team and inter-team coordination as fundamentally different organizational mechanisms. It introduces unit coordination cost parameters—empirically calibratable engineering parameters that abstract analytically intractable contextual complexity into measurable quantities. It derives closed-form estimation models expressing total coordination cost as a function of project size, team configuration, and unit coordination costs. It proposes standardized efficiency measures—Absolute, Internal Relative, and External Relative Coordination Efficiency, enabling benchmarking and comparative analysis across projects and organizations. The framework provides researchers with a coherent theoretical basis for empirical validation. For practicing project and engineering managers, software cost estimators, and IT quantity surveyors, it offers systematic methods for reliable cost estimation and planning, diagnosis of cost overheads, and coordination efficiency improvement. In so doing the paper lays the foundations for a rigorous specialized discipline of software development cost engineering.

Abstract: A long simulation that checkpoints its random generator and resumes on a different machine is relying on a property that std::mt19937 does not have. The C++ standard fixes the text format of an engine’s stream operators only partially, and the three major standard libraries disagree on both the numeric base of the digits and the order of the 624 state words. A checkpoint written under libstdc++ fails to load under the MSVC standard library, and loads without any diagnostic, at the wrong position,under libc++. This paper describes vphilox, a header-only C++20 library that removes the failure by changing what is stored. The generator is Philox4x32-10, a counter-based construction whose entire state is a key and a position, so a checkpoint is six 32-bit integers and a word offset, not a snapshot of engine internals. The same property gives constant-time seek and gives each worker an independent substream with no coordination, so a task draws the same numbers whatever the thread count and schedule. The cost of those properties is the question the design has to answer, because the earlier attempt to adopt Philox in a production machine-learning library was rejected on the grounds that scalar Philox runs at one tenth the speed of the Mersenne Twister. We report that the tenfold penalty did not reproduce on any of five processors measured, and that interleaving independent counters across SIMD lanes brings the generator to between 0.22× and 0.75× the cost per byte of std::mt19937 on the bulk path. Aggregate cost per byte is flat across thread counts, and the first parallel limit we find is hyperthread co-location, not the generator.

Abstract: Data preparation requires heterogeneous operations to be composed into coherent pipelines while respecting application-specific constraints. Existing approaches span interactive curation, automated pipeline search, provenance, and operator recommendation, yet a complementary need remains for systems that preserve human control while enforcing validity during composition. CAPPERI (Context-Aware data Preparation Pipelines through Explicit Reuse and human Interaction) is an open-source software-intensive framework based on reusable abstractions for context, object type, algorithm, and pipeline. Data types and transformations form a typed directed graph, while explicit hierarchical application contexts determine the admissible portion of the graph and enable reuse through specialization. Step-wise guidance exposes only transformations compatible with the current data state and context, while a modular architecture separates domain abstractions, composition logic, validation, persistence, and interaction. Unlike learned-context automated search, CAPPERI treats context as explicit domain knowledge and an active composition constraint, combining automatic validity enforcement with human intentionality.

Abstract: The European Digital Identity Wallet (EUDI Wallet) is reshaping digital identity management across Europe by enabling citizens to access, manage, and share verifiable digital credentials in a secure and interoperable manner. This paper presents a case study of the Italian digital identity wallet (IT-Wallet), one of the first national implementations of Regulation (EU) 2024/1183, and investigates the factors that enabled its rapid adoption at national scale. The study combines the analysis of regulatory and technical documentation, system architecture decisions, adoption statistics, and a GDPR-compliant telemetry framework integrated into the IO application. Results show that embedding wallet functionality within the widely adopted IO platform, reusing existing national digital infrastructures, and adopting open technical specifications facilitated the activation of more than 12 million wallets and the large-scale issuance of digital credentials. Telemetry data reveal high onboarding completion rates, sustained user engagement, and different usage patterns across credential types. Beyond adoption metrics, the study identifies six critical success factors related to platform integration, interoperability, governance, stakeholder collaboration, user experience, and progressive alignment with evolving European standards. The findings highlight how the success of national digital identity wallets depends not only on regulatory compliance and technical architecture but also on software-engineering decisions, deployment strategies, and ecosystem governance. The Italian experience provides practical lessons for Member States implementing interoperable digital identity ecosystems and demonstrates the value of empirical measurement in evaluating large-scale digital public infrastructures.

Abstract: Positional argument binding, in which f(x, y, z) assigns meaning by slot order, degrades as arity grows, and logic programming suffers it worst: each position's semantics must be remembered rather than read off the call site, and keyword arguments only trade this for a vocabulary that is local to each predicate. We present the Karaka Calling Convention (KCC): arguments are bound by a fixed vocabulary of six semantic roles (agent, object, instrument, recipient, source, locus), drawn from Paninian Sanskrit grammar and carried morphologically by each argument. Because the vocabulary is predicate-independent, a rewrite rule written once against a role applies across all predicates, a property that keyword arguments and PropBank framesets lack. A parsed statement is already a labeled-edge graph, so the same object compiles to Prolog facts and to property-graph writes with no lowering pass, and groundness alone decides whether a statement is an assertion or a query. Rule conflicts resolve by requirement-set subsumption (the Paninian utsarga/apavada discipline), with incomparable rules rejected at registration as ambiguous. We give a formal definition, a worked end-to-end example, and a tested reference implementation with optional real Astadhyayi morphology via vidyut-prakriya; a prior-art search found one contemporaneous system using Karaka roles as call-site labels, and we characterize the overlap from its source. Measured readability benefit is open work, stated as such.

Abstract: Gamified e-learning platforms and Artificial Intelligence (AI)-driven adaptive learning systems have each demonstrated potential for improving learner engagement, yet existing solutions rarely integrate both, and few provide learner-facing explanations for their adaptive decisions. This article addresses this gap by proposing LearnSpace, a hybrid AI–gamification framework incorporating Explainable Artificial Intelligence (XAI) for adaptive e-learning that extends a deterministic reward architecture with an Explanation Layer. The framework combines classical gamification mechanics with an AI personalization module governed by explicit weighted formulas for experience-point calculation, reward modulation, and dynamic difficulty adjustment. Positioned downstream of the Decision Layer, the Explanation Layer identifies the dominant contributing factor behind each adaptive decision and expresses it as a short, learner-facing justification. The framework was informed by a comparative analysis of 14 existing e-learning platforms and was instantiated in a working mobile prototype, LearnSpace, built with Expo/React Native and Supabase. An illustrative decision case demonstrates how the proposed explanation mechanism can expose the reasoning underlying adaptive outputs without modifying the original reward computation. The proposed architecture provides a transparent and interpretable basis for future empirical evaluation of adaptive gamified learning systems.

Abstract: Agentic Large Language Model (LLM) systems that turn wearable streams into daily workout plans need matched-backbone tests with shared post-processing. We compare four system configurations for daily workout generation—Baseline-LLM (raw chart, no precompute), Single Agent, Multi-Agent, and ReAct—on N = 50 matched user-days (5 users × 10 days) from longitudinal wearable data. Four blind LLM judges (claude-opus-4-5, gemini-3.1-pro-preview, GPT-4o, deepseek-chat) scored each plan on eight rubric criteria (0–10). Baseline-LLM had the lowest overall mean (6.23) and sat significantly below each scaffolded arm (Single 7.20, Multi 7.34, ReAct 7.18; Holm-adj. p ≤ 0.0034), so deterministic Sports Data Scientist / Movement Planner (SDS/MP) preprocessing improves same-model output. Among scaffolded configurations, overall differences were not significant after Holm correction even though latency and cost differed sharply. Fleiss’ κ ≈ 0.18 is slight inter-judge agreement; scores measure automated rubric compliance, not clinical ground truth. Put deterministic preprocessing and calculation kernels in place before expecting rubric gains from multi-agent orchestration.

Abstract: There are always repeatable functions like building similar CRUD workflows, implementing authentication layers, role based access control and admin interfaces for various projects on an enterprise web application, and different con-ventions can be used by different developers or code-bases. AI-powered coding tools recently emerged that promise to make this possible, but existing studies have shown that automated LLM-based code generation, vibe coding and free-running multi-agent pipelines have difficulty maintaining consistency between relational schemas, backend APIs, and frontend interfaces as applications grow in size, and become a maintenance night-mare. The main idea is that structural code which can be programmed from an application data model does not need to be probabilistic (only truly ambiguous decisions are language-model decisions such as interpreting the relational semantics, or resolving ambiguous requirements). We build this insight into a system called CodeCraft, where a Prisma schema and its Data Model Meta Format (DMMF) representation are the only source of truth for deterministic generators to generate backend APIs, frontend manifests, RBAC structures and database seeders, while a LangGraph six-agent multi-agent orchestration pipeline (from requirements engineering, schema design, orchestration, backend generation, frontend generation, and containerization) can only be used to clarify requirements, validate schema, and make decisions that cannot be made structurally. Generated systems have a consistent schema representation, as opposed to the prompt-driven tools which are used for each individual file. In all the applications it is demonstrated that schema validation slashes the number of automated iterations required to correct schemas to 2-4 and the end-to-end generation generates deploy-able, containerised applications after requirements and schema approval (no manual effort required). Comparative engineering indicates that the development effort is reduced by 70–80%, compared to manual implementation, but this has not yet been substantiated with a controlled external study.

Abstract: A novel application of function hooking is presented, allowing software that runs on Windows and uses MFC, wxWidgets, or the Win32 API to have its user interfaces translated without modification of the original application or access to source code. A launcher is used to run the target executable, loading it into the launcher’s address space and allowing the launcher to hook into functions that display text in the user interface. These functions then transparently replace original text with the translated version and call the original function. The method is effective, with minimal to no measurable runtime overhead, but visual imperfections remain due to differing lengths of text and potential numerical translations.

Abstract: Test-time refinement aims to improve generated programs through additional inference, but its value after an initial candidate has been produced remains unclear. We conduct a controlled evaluation of one-round Self-Refine and Self-Debug across seven models and three Python code-generation benchmarks. For each model and task, both methods refine the same initial candidate, allowing us to measure refinement gain without variation in initial generation. Self-Debug produced positive refinement gain in 16 of the 21 model-benchmark combinations and no change in the remaining five, with gains reaching +9.57 percentage points. In contrast, Self-Refine reduced correctness in 16 combinations, with losses of up to 8.07 percentage points, and produced positive gains in only four combinations. Repair-regression analysis showed that Self-Debug rarely damaged initially correct candidates, whereas regressions under Self-Refine frequently outweighed its repairs. Further analysis showed that execution feedback was beneficial only when models acted on diagnostic failures and produced effective revisions. Resource analysis showed that Self-Refine incurred greater token overhead despite generally reducing correctness, making its additional inference difficult to justify. Self-Debug provided a more favorable gain-overhead balance, but its monetary efficiency varied with model pricing, and its additional gains may offer limited value when initial generation is already sufficiently accurate. These results show that one-round refinement is not inherently beneficial and should be applied only when its expected gain justifies the additional computation and cost.

Abstract: The efficient operation of lithium-ion battery management systems (BMSs) depends on accurate state-of-charge (SOC) estimation. However, the performance of conventional model-based SOC estimation methods may deteriorate owing to parameter uncertainty, and nonlinear battery dynamics. This study proposes a hybrid SOC estimation framework termed DO-EKFRes comprising two stages. In the first stage, the process and measurement noise covariance matrices are optimized offline using the Adam optimizer with finite-difference gradient approximation. In the second stage, a Bidirectional Long Short-Term Memory (BiLSTM) residual learning network is employed to compensate for the remaining SOC estimation errors. The proposed framework was evaluated using two complementary validation protocols: a synthetic Monte Carlo experiment and a Leave-One-Battery-Out (LOBO) cross-validation framework based on the NASA Prognostics Center of Excellence (PCoE) lithium-ion battery dataset. In the synthetic validation, DO-EKFRes achieved an RMSE of 0.93%, corresponding to reductions of 40.47% and 25.81% relative to the EKF and DO-EKF, respectively. In the NASA LOBO evaluation, the proposed framework achieved a mean RMSE of 4.04%, corresponding to reductions of 49.22% and 29.48% relative to the EKF and DO-EKF, respectively. These results demonstrate that integrating offline covariance optimization with BiLSTM-based residual learning improves estimation accuracy, robustness, and cross-battery generalization, providing a practical solution for lithium-ion battery SOC estimation in battery management systems.

Abstract: Platform engineering is a highly relevant topic for both, customers and vendors when building and maintaining enterprise software. At adesso, a leading IT services and consulting company, platform engineering for Internal Developer Platforms and Golden Paths is a strategic enterprise initiative. This paper investigates the conceptual and architectural foundations within the broader framework of an adaptive Internal Developer Platform. We present a reference architecture and a representative instantiation to demonstrate how platform engineering principles can enhance developer workflows through standardization while maintaining developer autonomy. Furthermore, we discuss findings from early deployments of adaptive Internal Developer Platforms across multiple customer projects, highlighting initial key lessons learned and outlining potential directions for future evolution.

Abstract: God agents, i.e., agents that accumulate excessive responsibilities, have become an increasingly common problem in modern multi-agent systems and agent frameworks. As business logic grows, interaction scenarios become more complex, and agents are expected to be increasingly self-contained, their implementations tend to evolve into large orchestration hubs that are difficult to understand, maintain, and extend. Existing platforms such as AutoGen attempt to alleviate this problem by decomposing a god agent into multiple collaborating agents, whereas many other MAS frameworks pay little attention to this issue during architectural design. However, current solutions are often either heavy-weighted or resource-intensive, resulting in increased development, maintenance, and management costs. To address the god agent problem, this paper proposes an architectural pattern for implementing agents and MASs that systematically separates functional concerns into independently managed aspect entities while preserving the logical identity of agents within a standalone environment. The architecture consists of a Rootstock and multiple Scions. Each Scion manages a specific category of agent functionality by maintaining the corresponding aspect entities, while the Rootstock enables collaborative execution by coordinating interactions among all aspect entities. The proposed architecture is implemented and evaluated through GUSU, a real-time strategy game engine comprising three Scions responsible for collision detection, game logic, and rendering, respectively. A quantitative software metrics study comparing GUSU with 17 representative agent frameworks, including JADE and several recent LLM-based multi-agent frameworks, shows that GUSU exhibits one of the most lightweight structural designs of agent implementation, whereas suggesting a relatively balanced trade-off (rank second) among coupling, cohesion, complexity, inheritance and implementation size at the scale of the entire system. This work addresses the god agent problem through architectural decomposition of agent implementations to improve maintainability and modularity while preserving the semantic integrity of individual agents, rather than through task decomposition or multi-agent orchestration, which commit a relatively light-weighted and resource-free solution.

Abstract: The object of research is the migration of a legacy hospital information system to a Domain-Driven Design architecture. The problem is accurate effort estimation under changing conditions, since use case-based methods rely on global, project-wide adjustment factors that are too abstract to capture localized architectural, logical, and technological anomalies within individual functional blocks. A modified Use Case Size Points method is proposed, integrating a multidimensional Complexity Amplification Factor across the Infrastructure, Logic, and Technology domains, each scored on calibrated indicator scales. The method was calibrated and validated on real functional blocks of the Unified Clinico-Statistical Classification of Disease subsystems of a Ukrainian surgical clinic. Incorporating the Complexity Amplification Factor increased the accuracy of prediction for query-oriented tasks by approximately 7.6 times (mean relative estimation error reduced from 120.0% to 15.8%), and for command-oriented tasks by approximately 3.6 times (mean relative estimation error reduced from 57.2% to 15.7%). In both cases, the resulting error falls within the range generally considered acceptable for reliable project planning, whereas the baseline method's errors were large enough to cause systematic effort underestimation and budget overruns. This improvement occurs because the Complexity Amplification Factor captures non-standard business logic and hidden infrastructural and technological effort that purely structural size metrics overlook. As a result, project managers obtain a more realistic and trustworthy basis for scheduling, cost control, and risk assessment when planning similar legacy migration projects.The method applies to effort estimation, planning, budgeting, and auditing of legacy migration projects, provided the Complexity Amplification Factor weights and the man-hour coefficient are recalibrated per task class and organizational context.

Abstract: The adoption of new statistical software platforms in behavioural and social science research requires rigorous cross-platform validation before any recommendation to the scholarly community. This paper reports the numerical validation of AnalyVa, an Electron-based desktop platform, against SmartPLS 4 across five benchmark studies encompassing covariance-based structural equation modelling (CB-SEM), configural multi-group analysis (MGA), latent growth curve modelling (LGCM), and Gaussian copula endogeneity correction in both OLS regression and PLS-SEM contexts. Using the classic Holzinger-Swineford dataset for CB-SEM studies, a simulated four-wave longitudinal dataset (n = 400) for LGCM, a purpose-built endogenous simulation (n = 500) for OLS copula, and the Corporate Reputation dataset (N = 344) for PLS-SEM copula, concordance was assessed via mean absolute deviation (MAD) against established thresholds. Results revealed a consistent gradient of agreement: perfect concordance in LGCM (MAD = .0000) and OLS copula (MAD = .000), excellent concordance in CFA standardized loadings (MAD = .0003), excellent MGA concordance in both subgroups (MAD = .001; maximum |Δ| = .005), and excellent PLS-SEM copula concordance across outer loadings (MAD = .003), structural paths (MAD = .007), and R² values (|Δ| ≤ .001). Minor deviations were attributable to established statistical artefacts—AGFI sensitivity at small sample sizes, RMSEA computation conventions, and copula-induced multicollinearity—rather than platform-specific algorithmic differences. These findings validate AnalyVa's CB-SEM, LGCM, and Gaussian copula implementations as numerically equivalent to SmartPLS 4, providing applied researchers with an empirically supported basis for adopting AnalyVa in confirmatory factor analysis, longitudinal growth modelling, and endogeneity-corrected regression.