Computer Science and Mathematics

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.

Abstract: Availability-oriented monitoring may require low-latency anomaly inference, but deploying a lightweight model as a separate service adds process, serialization and network-path overhead. This article evaluates the inference-path architecture used by a prototype availability-response loop; it does not evaluate the effectiveness of a new DoS/EDoS detector or claim production attack mitigation. The same IsolationForest model and telemetry vectors were executed through an external Python/FastAPI sidecar and through ONNX Runtime embedded in a Spring Boot JVM. The prototype also included an LSTM Autoencoder and a bounded rule layer producing SCALE_UP, RETRY, FALLBACK or NONE. The main Kubernetes benchmark used Docker Desktop 4.73.1 (Docker Engine 29.4.3) with Kubernetes v1.34.3 on a single-node cluster. Embedded ONNX reduced request-response latency from 26.090 ms to 4.839 ms on average, from 62.065 ms to 5.367 ms at P95 and from 76.487 ms to 6.244 ms at P99; calculated sequential throughput increased from 38.3 to 206.7 requests/s. Additional checks covered concurrent load, gRPC transport, cold start, memory footprint and limited Kubernetes actions. In an extended comparison using 15 runs of 950 s for each active configuration, CPU-based HPA, rules-only and AI-plus-rules produced overlapping aggregate SLA-violation rates; no aggregate benefit of the ML gate over rules alone was observed under the tested degradation proxies. The evidence supports a narrow architectural conclusion: in-process ONNX is a lower-latency and lower-footprint execution path for the tested lightweight model. Detection quality, superiority over rule-only or established autoscaling mechanisms, and effectiveness against real adversarial traffic remain open validation tasks.

Abstract: The thread-per-request model's concurrency ceiling is not a theoretical concern — it manifests as latency collapse the moment an edge node saturates its OS thread pool. On constrained hardware with 2–8 cores and 4–16 GB of RAM, that ceiling arrives far sooner than in a data center, and no amount of pool tuning recovers throughput once you hit it. We built an asynchronous, non-blocking gateway framework around an event-driven I/O model, a lock-free request pipeline, and a back-pressure-aware routing layer, then measured it against an Apache mpm_prefork synchronous baseline on a commodity i5-1235U edge node. Peak sustainable throughput capacity reached 112,400 req/s — 3.8× the baseline's peak capacity of 29,600 req/s — with P99 latency falling from 69 ms to 18 ms at 80% offered load and CPU utilization dropping by 31% at equivalent offered load (range: 29–33% across five runs). Back-pressure propagation from an overloaded upstream to client-visible flow control ran a median of 4.2 ms (IQR: 3.8–4.9 ms). M/M/c queuing bounds for throughput, queuing delay, and resource utilization were derived before benchmarking; measurements stayed within 5% of model predictions for ρ ≤ 0.8 under stable load. At edge scale, async design is the baseline requirement for sustaining cloud-native connection counts.

Abstract: Partial least squares structural equation modeling (PLS-SEM) is a widely used method in behavioral and social science research, but its use is limited by software access and specialized desktop software. AnalyVa is a desktop statistical analysis platform (offline, locally installed) based on Electron that provides complete PLS-SEM capabilities, such as reflective model estimation, moderation analysis, and second-stage interaction modeling, without the need for internet connection or programming skills. This tutorial compares AnalyVa with the current reference standard, SmartPLS 4, for three model specifications: (1) a simple four-construct reflective model, (2) an extended moderation model with one multi-item moderator, and (3) a multiple interaction model with three single-item moderators and all higher-order interaction terms. We compare outer loadings, construct reliability and validity, discriminant validity (HTMT and Fornell-Larcker criterion), structural path coefficients, effect sizes (f²), and model fit indices (SRMR and NFI) using an existing data set (n = 344) from the corporate reputation literature. Results show good agreement, with the largest absolute differences being less than .010 for path coefficients and less than .006 for outer loadings for all three models. Systematic divergences in model fit reporting are identified and explained: AnalyVa separately reports saturated and estimated model fit indices—a distinction SmartPLS 4 collapses for simple models. AnalyVa’s Smart Model Health diagnostics flagged an elevated outer VIF in the extended moderation model not surfaced by SmartPLS 4. The results indicate that AnalyVa is a methodologically sound and diagnostically useful desktop alternative to PLS-SEM practitioners.

Abstract: New statistical software requires independent numerical validation before it can be trusted in peer-reviewed research. This paper benchmarks AnalyVa's CB-SEM and PLS-SEM engines against SmartPLS 4 across two model specifications: a CB-SEM model of socioeconomic status and alienation (Wheaton et al., 1977; N = 932, AMOS Example 6) and a ten-construct PLS-SEM model of occupational burnout (N = 592). AnalyVa demonstrated near-perfect agreement with SmartPLS 4 in both studies: standardized factor loading MAD ≤ .001, structural path MAD = .001. These results establish AnalyVa as a validated dual-framework SEM platform for social, behavioral, and organizational research, with a maximum absolute difference of .003 across parameters.

Abstract: In today’s increasingly complicated network environments, effective cybersecurity analytics necessitate scalable data processing systems that can handle massive amounts of diverse traffic data. This article compares relational, graph-based, and streaming data systems for cybersecurity analytics using the CICIDS2017 dataset. We specifically compare a columnar cloud data warehouse (Amazon Redshift) with a graph database (Neo4j) using example analytical queries to investigate trade-offs in query expressiveness, performance, and data modeling flexibility. In addition, we evaluate a real-time data intake pipeline built on Apache Kafka and Apache Cassandra to investigate ingestion throughput and low-latency storage features under simulated streaming workloads. The systems are examined independently to highlight their strengths and weaknesses in batch analytics, relationship-centric analysis, and real-time monitoring. The findings offer practical insights into how alternative data models and processing paradigms impact cybersecurity analytical tasks, as well as recommendations for selecting optimal data systems for network traffic analytics and intrusion detection use cases.

Abstract: Background. This article addresses the challenge of estimating the engineering effort required to migrate high-performance computing business logic from legacy monolithic services to microservice architecture. While the study is grounded in empirical tasks within the financial sector, its findings are highly relevant to a broad spectrum of similar domain-agnostic software migration problems.Objective. The primary objective of this work is to develop a software migration effort estimation method that explicitly accounts for infrastructure overhead by integrating Complexity Amplification Factors (CAF) and Complexity Control Factors (CCF).Methods. A modified Use Case Size Points (USP) method was developed, integrating infrastructure-specific CAF and CCF factors to systematically enhance structural estimation precision.Results. Empirical results demonstrate that the predictive model incorporating both CAF and CCF significantly increases the accuracy of development effort predictions compared to standard baseline approach. Migration effort remains stable within dedicated architectural task classes, yielding a Mean Relative Error (MRE) within acceptable bounds. However, use-case classes exhibit diverging prediction profiles: 0.24 for the Write Model and 0.54 for the Read Model. Furthermore, predictive precision depends on isolating internal step heterogeneity within individual use cases (e.g. 0.33 for validation steps).Conclusions. This work provides a framework for estimating the effort required to migrate data-intensive monolithic systems to microservice-oriented architectures. The proposed framework optimizes resource allocation by transforming an inherently unpredictable migration process into a manageable workflow, offering a scalable foundation for managing the lifecycle of complex computer systems.

Abstract: 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.

Abstract: 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 method-ology, 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. 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.

Abstract: Early identification of academic risk remains a major challenge in public higher education, where institutional data are often fragmented and underused. This study proposes a multi-output deep learning model to predict five formative indicators during the semester: assignment performance, missing assignments, procrastination rate, exam performance, and exam accuracy. The dataset included 4,230 student-course records and 26 features extracted from learning and assessment platforms. A multitask regression architecture with shared and task-specific layers was optimized through Bayesian search and regularization. The model achieved strong predictive performance (R² = 0.9803; MAE = 0.0239; RMSE = 0.0404), outperforming traditional machine learning baselines. SHAP analysis identified temporality and engagement variables as the most influential predictors. Additional ordinal and clustering analyses revealed engagement profiles useful for early feedback and support. Results highlight the value of multi-output learning analytics for timely and privacy-aware academic intervention.

Abstract: Many companies are re-examining their integration architectures as the pace of Digital Transformation in enterprise E-Commerce (B2B and B2C) accelerates. New integration architectures will depend on the ecosystem of services offered by partners. Integration patterns, including API-led connectivity and Pub-Sub messaging, have become essential in implementing such changes. This paper details a comparative study of two API orchestration paradigms synchronous request-response and asynchronous event-driven using MuleSoft Platform. This paper provides an example of the orchestration and reusability capabilities of the MuleSoft platform. The paper assesses several factors scalability, resilience, resource usage, and operational expenses and the influence of each orchestration model. The paper brings to the fore the performance trade-offs of each of these strategies using production deployment benchmark and industry-reported data: Thread-blocking constraints of synchronous systems. Eventual-consistency issues of an asynchronous messaging system. Trade-offs of point-to-point integration architecture. Thus, we can conclude that asynchronous integration architecture is applicable for the organizations where same data must be sent to multiple different downstream systems. Also, synchronous integration is useful where real time processing is needed for the end user. Research introduces a decision roadmap for integration architects to navigate modernization programs. Based on the business context and significance of the service, hybrid orchestration will create the most scalable and cost-effective results. This research was also conducted on the real production deployed applications using API-LED architecture pattern (experience layer, process layer and system layer) and evaluated 14M+ transactions in production system.