Computer Science and Mathematics

Abstract: diffct is a CUDA-accelerated computed tomography library that exposes differentiable forward operators and their exact discrete adjoints for 2D parallel beam, 2D fan beam, and 3D cone beam imaging. The main branch provides the stable circular-orbit lineage released on PyPI, including Siddon and separable-footprint (SF) projector families, while the dev branch extends the Siddon-based projector/backprojector interface to arbitrary per-view trajectories through explicit source and detector arrays. This report rewrites the project description directly from the current source code, examples, tests, and the related CT literature. We formalize the geometry parameterization used by the implementation, derive the differentiable Siddon-style projector and its exact discrete adjoint, explain how gradients are transported through torch.autograd.Function wrappers backed by Numba CUDA kernels, document the analytical filtered backprojection and Feldkamp–Davis–Kress pipelines implemented on main and ported into the dev, and record how the circular-orbit SF algorithms from main fit into the broader architecture.

Abstract: The efficiency of data-driven research relies not only on high-quality data and sufficient computational resources but also depends sensitively on the personal knowledge management of the researcher. The multitude of digital artefacts created during the researcher’s daily workflow might comprise experimental results, simulation results, literate programming notebooks analysing experiments and simulations, statistical models, machine learning models, figures, tables, and conversations with generative artificial intelligence systems. In order to trace and track these interconnected research artefacts over several months of research or even extended research periods and different research projects, these artefacts need to be systematically named so that they can be referenced in note-keeping systems and research outputs. Therefore, the naming and referencing scheme for research artefacts needs to be flexible, consistent, efficient and support the linking of artefacts across different software frameworks and even classical laboratory notebooks. This article introduces a hierarchical naming scheme and the supporting open-source Python package contexere together with best practises for the personal knowledge management for postgraduate students and early career researchers, which provides a clear and linkable structure for data artefacts and thus supports effective personalised research workflows.

Abstract: Smart microgrids combining photovoltaic arrays, wind turbines, and battery storage generate telemetry that existing open-source monitoring tools cannot process with per-mechanism energy loss visibility in real time. This paper presents a design, im-plementation, and evaluation of an open-source IoT Monitoring Framework. The framework incorporates a physics-based microgrid simulator, a hierarchical MQTT communication architecture, and a React-based web-based user interface that supports WebSocket-based real-time data visualization. The open-source framework consists of twelve containerized microservices that can be started with a single command: docker compose up -d. The code has been released under the permissive MIT license. All stack performance testing was conducted using a simulated 1 hour test case based on a 100kWp PV system, 10kW wind turbine, and 50kWh battery powered campus mi-crogrid. Average P50 end-to-end latency was 27.2 ms and P99 end-to-end latency was 48.3 ms with 100% message delivery across 5,840 test messages with per-topic analy-sis revealing a 25 ms serialization-order effect in sequential MQTT publishing. Com-parative analysis against ten existing platforms including OpenEMS, VOLTTRON, Eclipse Ditto, and pymgrid confirms that no prior open-source framework unifies physics-based loss telemetry, IoT communication, time-series storage, and real-time visualization in a single reproducible deployment.

Abstract: Independent journalists, human rights documentarians, and at-risk publishers overwhelmingly operate on shared-host WordPress installations nfrastructure they do not control and cannot audit. Existing tamper-evident publishing solutions require dedicated servers, compiled native libraries, or HSM-backed key storage, placing them beyond reach of the population most exposed to infrastructure-level content suppression. We present ArchivioMD, a cryptographic content integrity system deployable on shared-host PHP 7.4+ without native extensions, root access, or Composer dependencies. ArchivioMD combines four composable integrity layers: Deterministic content hashing across 22 algorithms with four-level HMAC hardening Six independent signing methods including a pure-PHP NIST FIPS 205 SLH-DSA post-quantum implementation Simultaneous anchoring to four independent external trust registries via a persistent queue with exponential backoff DANE/DNSSEC key corroboration An OpenPGP identity companion plugin (ArchivioID) adds configurable multi-signer threshold workflows and public proof pages for external verification. This paper formally defines the adversary model across four adversary classes (hostile infrastructure operator, law enforcement with legal compulsion, state-level attacker, and compromised administrator), maps each deployment scenario to its applicable adversary class, and proves that modification is detectable under any single-anchor compromise. Benchmark results are reported across shared hosting, VPS, and dedicated server tiers. The adversarial robustness of the 14-channel steganographic canary token system is analysed, including a formal keyspace proof of approximately 2198 combined subset configurations. To our knowledge, this is the first complete FIPS 205 SLH-DSA implementation deployable on commodity PHP hosting without native library dependencies.

Abstract: Load testing is a critical component of performance engineering, but traditional script-based methodologies often fail to accurately represent the dynamic, stochastic behavior of real users in modern distributed systems. As web applications grow in complexity, linear testing sequences leave critical execution paths untested, obscuring concurrency bottlenecks. This paper proposes a hybrid conceptual framework that integrates probabilistic navigation graphs with Markov transition models to simulate realistic, chaotic user behavior. The proposed model represents application workflows as directed graphs, employing Markov chains to dictate virtual user navigation across system states based on probabilistic weights. By shifting from deterministic scripting to stochastic workload generation, the framework theoretically increases state space coverage and path diversity while providing a more flexible representation of user navigation behavior. We detail the multi-layered system architecture, formalize the mathematical foundation of the traversal engine, and introduce rigorous analytical metrics including transition entropy and state coverage probability. Ultimately, this framework introduces a probabilistic graph traversal approach that enables the stochastic exploration of application state spaces and emergent concurrency behavior.

Abstract: The design and reliability assurance of embedded systems is a complex issue, since they need to handle not only digital behavior but also physical quantities such as time, cost, and sometimes randomness. In addition, since many embedded systems, such as networks and automobiles, have systems in which errors can be fatal, design verification for reliability assurance is an important research topic. With the above background, we adopt the approach of specifying and verifying embedded systems by formal models. Specifically, we focus on a priced probabilistic timed automaton as a specification description language, and propose a reachability analysis method based on Counterexample-guided abstraction refinement (CEGAR) to reduce the state explosion. To demonstrate the effectiveness of the proposed method, we attempt to verify the design of important wireless sensor networks (WSNs). In this paper, we model WSNs by a priced probabilistic timed automaton that can express their power characteristics in terms of cost, uncertainty in terms of probability, real-time in terms of time, and attribute WSNs’ characteristics to the cost bound probabilistic reachability problem. To the best of our knowledge, this paper is the first CEGAR development and implementation of a priced probabilistic timed automaton. We have developed a prototype of the verifier and confirmed that it is verifiable.

Abstract: The preparation of annotated datasets remains a critical bottleneck in the machine learning (ML) pipeline. Existing tools are fragmented across cloud-hosted services, self-hosted web applications, and lightweight desktop tools—none simultaneously ad-dressing diverse annotation modalities, offline-first operation, integrated training, and serverless collaboration. We present Annotix, an open-source, cross-platform desktop application built on a Rust backend (Tauri 2) and React 19 frontend, designed to unify the entire ML data preparation workflow within a single privacy-preserving environ-ment. To evaluate its practical utility, we conducted a controlled annotation efficiency study using 60 synthetic images (bounding box and mask tasks) annotated by three expert evaluators across Annotix, CVAT, and Label Studio, analyzed via Krus-kal-Wallis with Dunn–Bonferroni post-hoc tests, and a heuristic usability evaluation over standardized tasks on real medical images (retinographies and otoscopies). Re-sults demonstrate that Annotix achieves statistically significant annotation efficiency relative to established tools while offering substantially broader feature coverage, in-cluding 7 image annotation primitives, 19 ML training backends, ONNX-based infer-ence-assisted labeling, and serverless P2P collaboration. Annotix provides a complete, privacy-preserving ML data preparation workflow suited to regulated domains such as medical imaging and ecological monitoring and is freely available under the MIT license.

Abstract: Immutable code and steep transaction fees make smart contract deployment uniquely unforgiving. While continuous integration (CI/CD) pipelines excel at catching standard software bugs, applying exhaustive security tests to Web3 applications severely bottlenecks development through massive computational overhead and gas consumption. This paper presents a testing architecture designed specifically to resolve this tension between security depth and execution speed. The system pipelines three core engines. First, an AI-driven pre-execution gate flags immediate vulnerabilities. Next, a structural reduction module applies the k + 1 symmetric pattern to strip out redundant test permutations. Finally, the system constrains the remaining test suite using the NSGA-II evolutionary algorithm. This multi-objective optimizer dynamically schedules execution to maximize fault detection against strict, predefined gas budgets. To evaluate the model empirically, I bridged a localized EVM sandbox with a Python optimization engine. Results confirm the framework collapses exponential test generation and throttlesexecution costs without sacrificing critical security coverage. Ultimately, it offers a highly scalable path forward for modern DevSecOps.

Abstract: The contemporary education landscape is often marred by escalating costs and centralized pedagogical structures, which collectively create significant barriers to entry for millions of potential learners worldwide. This paper presents \textbf{Skill Link}, a sophisticated decentralized platform designed to democratize skill acquisition through a specialized credit-based barter system. Unlike conventional e-learning platforms that rely on traditional currency transactions, Skill Link enables a frictionless exchange of knowledge by utilizing a virtual credit economy where participants earn and spend "learning credits." To address the critical issue of credential fraud in decentralized environments, the platform integrates Ethereum-based blockchain technology to ensure the absolute immutability and verifiable authenticity of all earned certificates. Key innovations include a multi-tiered course classification system, an automated mock assessment framework with negative marking capabilities, an intelligent context-aware AI assistant powered by advanced language models, and a rigorous verification mechanism for professional social links (LinkedIn, GitHub, Indeed). Developed using the robust Django framework, Python-based Web3 utilities, and a secure PostgreSQL/SQLite back-end, Skill Link provides a highly secure, transparent, and scalable ecosystem for peer-to-peer knowledge sharing, ultimately fostering a global community of experts and lifelong learners. The system's architecture emphasizes data integrity through atomic transactions and cryptographic verification, ensuring a trustless environment for global skill exchange.

Abstract: This study quantitatively evaluates the performance of a non-invasive hybrid brain–computer interface (BCI) compared to a conventional mouse in pointing (point-and-click) tasks. A commercial wearable BCI (Brainfingers), based on electromyography (EMG) and electrooculography (EOG) signals with low-level electroencephalography (EEG) components, was assessed against a Microsoft Optical Mouse using ISO/TS 9241-411-based one-dimensional (1D) and two-dimensional (2D) target acquisition tasks. Pointer coordinates were recorded and analyzed using Fitts’ law metrics. A total of 48 non-disabled participants completed the experiments. The results reveal significant performance differences between the two input devices. The BCI device exhibits substantially lower performance than the mouse across the reported Fitts’ law measures. Mean throughput was 0.35 bits/s for the BCI and 6.03 bits/s for the mouse in the 1D tests, and 0.43 bits/s for the BCI and 5.17 bits/s for the mouse in the 2D tests. Despite the BCI’s low performance and although the present experiments involved non-disabled participants, the findings, considered alongside prior literature on Brainfingers and non-invasive BCIs for computer access, suggest that the device may still have assistive technology value for users with severe motor impairments.

Abstract: Except for coding, Large Language Models (LLMs) are increasingly explored as assistants for software design and architectural tasks. However, it remains unclear to what extent LLMs can reliably apply explicitly requested software architectural patterns when provided with user-defined specific requirements. In this paper, we empirically evaluate the ability of multiple LLMs to instantiate specific architectural styles under controlled conditions. We conduct a series of experiments in which models are prompted with problem descriptions expressed at different levels of structure, ranging from free-structured requirement lists to complete Software Requirements Specification (SRS) documents. The models are instructed, using single-shot prompts, to generate architectures in four representative styles: client–server, 3-tier, Model–View–Controller (MVC), and microservices. The authors assess the generated architectures with respect to structural correctness, requirement coverage, and adherence to the requested architectural pattern. Our results show that while LLMs can correctly apply simpler architectural patterns, performance decreases as architectural complexity and problem size increase. Model size and requirement representation significantly influence pattern adherence, whereas Retrieval Augmented Generation (RAG) exhibits mixed effects depending mainly on the material context and the LLMs capacity. These findings provide insight into the current capabilities and limitations of LLMs in architectural pattern application and inform the design of future AI-assisted architectural tools.

Abstract: Microservice-based architecture has become a dominant style for building cloud-native systems, but their rapid and continuous evolution makes it difficult to understand, verify, and control the impact of change. Although many works address microservices from the perspectives of design, deployment, and operation, there is still limited consolidated knowledge on how the evolution and verification of microservice-based systems are supported in the research literature. This paper reports on a systematic literature review (SLR) on methods and tools for analyzing evolution and providing verification support in microservice-based systems. Following established SLR guidelines, we defined a review protocol with focused research questions, executed structured searches in major digital libraries, and applied explicit inclusion and exclusion criteria tailored to cloud-native microservices. Candidate studies were screened through multiple stages, supported by an academic queries table, a statistics table summarizing the selection process, and a quality assessment checklist. For each included primary study, we extracted data on the type of evolution or change considered, the analysis or verification technique used, the form of tool support, and the nature of empirical evaluation. The review highlights a small but emerging body of work that combines microservice evolution with formal verification, runtime monitoring, and model-based analysis. However, empirical evidence is often limited to small case studies, with few industrial-scale evaluations and little shared tooling or datasets. We conclude by identifying gaps and outlining a research agenda for more robust, empirically grounded approaches to microservice evolution and verification.

Abstract: Code smells are indicators of potential design problems in software systems and are commonly used to guide refactoring activities. Recent advances in representation learning have enabled the use of embedding-based models for analyzing source code, offering an alternative to traditional approaches based on manually engineered metrics. However, the effectiveness of different embedding representations for multiclass code smell detection remains insufficiently explored. This study presents an empirical comparison of embedding models for the automatic detection of three widely studied code smells: Long Method, God Class, and Feature Envy. Using the Crowdsmelling dataset as an empirical basis, source code fragments were extracted from the original projects and transformed into vector representations using two embedding approaches: a general-purpose embedding model and the code-specialized CodeBERT model. The resulting representations were evaluated using several machine learning classifiers under a stratified group-based validation protocol. The results show that CodeBERT consistently outperforms the general-purpose embeddings across multiple evaluation metrics, including balanced accuracy, macro F1-score, and Matthews correlation coefficient. Dimensionality reduction analyses using PCA and t-SNE further indicate that CodeBERT organizes code smell instances in a more structured latent representation space, which facilitates the separation of smell categories. These findings provide empirical evidence that domain-specific pretraining plays an important role in representation learning for software engineering tasks and that embedding choice significantly influences the separability of code smell categories in multiclass detection settings.

Abstract: This research work deals with the challenges in software fault prediction (SFP) such as class imbalance in benchmark datasets, noisy features, and high-dimensional feature spaces. To overcome the above limitations, we propose a novel hybrid feature selection framework, FS-BWOA–COA, which incorporates Coati Optimization Algorithm (COA) for local exploitation and Beluga Whale Optimization Algorithm (BWOA) for global exploration. The two-phase optimization approach helps to avoid duplication and improves the stability of the classifier and also helps in maintaining the balance between exploration and exploitation. The framework was tested using several classifiers such as Decision Tree, SVM, KNN, and Naïve Bayes on eleven NASA PROMISE datasets. The hybrid outperforms single BWOA and COA, with an average accuracy of 0.9033 and peak values of 0.95 on the MC1 and JM1 datasets. The results of the statistical validation using the Friedman test, Wilcoxon signed-rank test, and paired t-tests confirm the same.

Abstract: Recent advances in large language models (LLMs) have made it feasible to use them as automated debugging tutors, but it remains unclear how much can be gained by moving from single-model tutors to multi-agent councils with separated roles. We study this question in an offline simulation on 200 debugging cases drawn from an online judge, spanning 20 problems split into course-style and contest-style challenge tracks. We compare four single-model tutors based on current frontier models with four councils that assign models to Architect, Skeptic, Secretary, Pedagogue, and Mentor roles and operate in both Blind and Guided modes. Single-model tutors achieve near-perfect repair on course problems but perform less reliably on challenge cases and often rewrite large portions of student code, show non-negligible false positive rates, and leak full or near-full solutions in a substantial share of hints. Councils designed around measured model strengths improve both technical and pedagogical behaviour. On the challenge track, the best council raises patch success by 12.2 percentage points over the best single tutor, while reducing false positives, shrinking median patch size, improving hint localisation, and cutting solution leakage in Blind mode from about one fifth of hints to under ten percent. Councils also exhibit higher stability across reruns and produce hints that two independent instructors consistently rate as more useful and better scaffolded. Guided mode, where internal components see a reference solution, yields further technical gains but introduces leakage risks that require prompt tightening and a sanitising Secretary to control the flow of ground truth. Additional trap experiments with poisoned reference solutions show a mix of resistance and fail-safe collapse rather than systematic poisoning of hints. These results indicate that orchestration and information flow are powerful levers and that well-designed councils can provide more reliable and pedagogically aligned debugging support than strong single-model tutors alone.

Abstract: A common recommendation for preventing brute-force authentication, credential stuffing, scraping, and resource exhaustion is rate limiting, a standard control for API availability and security. Uncertain semantics under horizontal scaling, proxy-induced client-IP ambiguity, unsafe identity binding, ambiguous policy resolution, canonicalization gaps in endpoint matching, and unbounded in-memory state are some of the reasons why deployments frequently fail. In this paper, we propose an endpoint-aware mechanism that uses token buckets with bounded bucket state to enforce per-endpoint RPS limits that are configured in a database and cached for low-latency lookup. The mechanism offers robust endpoint normalization (including an explicit UNKNOWN bucket for unmatched paths), deterministic policy precedence, strict identity validation, trusted-proxy boundaries for client IP extraction, optional per-endpoint cost weights, and operational controls for safe defaults and cache reload. We propose adversarial test suites and microbenchmarks for reproducible evaluation and structure a security analysis by attack surfaces (identity, endpoint normalization, state management, configuration, and distributed enforcement). Additionally, we compare the mechanism to commonly used gateway/edge systems and shared-state primitives, and place it within related work on distributed algorithms, adaptive controllers, overload control, and API rate-limit adoption patterns.

Abstract: Repeated measures ANOVA is the statistical method for comparing means of the same sample measured at least two different times, or two different contexts. It may also be used to compare means between two or more related groups. This paper serves as a tutorial for repeated measures ANOVA using R. It will introduce readers to parametric, nonparametric and robust one-way repeated measures ANOVA using the rstatix, afex, WRS2, and ARTool packages.

Abstract: The philanthropic sector faces persistent challenges in transparency and accountability that fundamentally undermine donor trust. While blockchain technology offers an immutable transaction ledger, it cannot inherently verify whether donated funds achieve their intended real-world impact. This paper presents a novel decentralized application that addresses this critical gap through the integration of Ethereum Smart Contracts with an AI-driven auditing pipeline. The system introduces a milestone-based fund release mechanism requiring NGOs to submit vendor invoices as documentary proof of expenditure. These documents undergo Optical Character Recognition followed by credibility assessment using Google Gemini, a Large Language Model that performs semantic analysis of financial documents. A two-thirds multi-signature consensus by platform administrators authorizes direct on-chain payments to verified ven dors. The primary innovation lies in bridging the oracle problem through automated AI verification of off chain documentary evidence controlling on-chain fund disbursement. Experimental validation demonstrates that this hybrid approach effectively automates credibility verification while ensuring every released fund is backed by verifiable evidence, achieving significant performance improvements in fraud detection and accountability enforcement compared to purely manual or purely blockchain-based systems.

Abstract: Software engineering activities have shifted from building new systems to maintaining 2 code bases. Yet teaching software engineering rarely echoes that reality. It is easier to teach 3 students to develop software from scratch rather than guide them to maintain an existing 4 project by suggesting and implementing modifications and enhancements. We believe that 5 the best way to teach maintenance is through practical experience. This paper describes the 6 evolution of an agent modelling tool called AMMBER. It started as a software engineering 7 team project eight years ago. Tens of students have been involved in the subsequent years 8 in maintaining and extending the software through projects in capstone units, internships 9 and casual employment. The paper authors are the current team maintaining the software. 10 The maintenance activities have included corrective maintenance, adaptive maintenance 11 and perfective maintenance, and we describe lessons learned through our failures and 12 successes. We advocate exposing students to maintenance activities on active code bases 13 and share lessons learned about increasing the capability of software engineering students 14 to usefully perform maintenance activities.

Abstract: The augmented assembly language @Asm is proposed in order to transcend the fragmentation of architecture-specific dialects, to provide a unified framework for diverse processing paradigms as a universal assembly language and to function as a self-compiling bootstrap instrument adaptable to any processor system. The language augmentations include: flexible machine-language descriptions, general memory and data management directives, custom lexical identification through regular expressions, parsing facilities, generalized macroprocessing, flexible assembly control instructions, customizable encoding and code generation features, compiler-oriented abstraction mechanisms at the language level. The native abstraction augmentations enable expressive and concise high-level descriptions within assembly language for any present, emerging, or future systems.