The paradigm of Smart Environments (SE) has transitioned from simple remote automation to proactive, context-aware ecosystems driven by Artificial Intelligence. However, orchestrating heterogeneous AI subsystems, which range from high-frequency sensor streams to computationally intensive Large Language Models (LLMs), imposes significant challenges regarding latency, interoperability, and data privacy. To address these issues, we present ARGUS, a distributed, event-driven software architecture designed to orchestrate intelligent decision-making across the Edge-Cloud continuum. We validate the architecture through a reference implementation and performance evaluation, demonstrating that ARGUS effectively accommodates heavy computational workloads, such as those used in generative AI and recommendation systems, to create intelligent environments that dynamically adapt to user needs.
One primary quality objective for modern microservice-based systems is autonomy in the management of computing resources—often referred to as elasticity. To enable elasticity, numerous autoscaling proposals exist in both literature and open-source software, yet almost all require critical decisions in configuration and design space. The widespread adoption of large language models (LLMs) for software engineering tasks brings both promises and risks for implementing and configuring microservice elasticity. To objectively determine these promises and risks, we synthesize three fundamental architectural alternatives that differ in the role and integration point of LLM agents for autoscaling: baseline (no LLM), design-time support, and runtime MAPE-K loop. We perform an experimental evaluation of eight implementations across six workload scenarios in a production-like public cloud environment using the TeaStore application. Results show that baseline reactive autoscalers (HPA, KEDA) achieve the best performance, reliability, and efficiency. Runtime LLM-based autoscaling (Llama, Deepseek) underperforms baselines, with only 2 of 24 configurations achieving sufficient performance. However, design-time LLM support with GPT-5 achieves competitive results when feedback is incorporated, demonstrating promise for LLM-assisted configuration while highlighting risks of runtime deployment.
Large Language Models (LLMs) are increasingly used in software engineering, yet their role in architectural refactoring, particularly in decomposing monolithic systems into microservices, remains largely unexplored, even though such decomposition, when necessary, is difficult and error-prone, especially when identifying meaningful service boundaries.This exploratory study investigates how LLMs can support architects through a multi-step decomposition process that applies seven summarisation strategies and four LLMs to generate architectural views and candidate decompositions. We assess these decompositions using six established metrics across four open-source systems that provide both monolithic and microservice versions, enabling comparison with reference architectures.Results show that LLM-based decompositions outperform traditional techniques on Cyclic Independence (+22.7), approaching reference architectures and indicating better technical dependency management. Traditional automated approaches remain stronger at recovering the ground-truth structure (MoJoFM +24.1), team alignment (TC +11.0), and domain-oriented boundaries (DI +10.7). No significant differences appear for Code Modularity or Business Context Purity, suggesting that LLMs produce clean decompositions with few cyclic dependencies but still struggle to reproduce the exact target decomposition.
Chaos Engineering (CE) and Software Performance Engineering (SPE) are increasingly important for validating the resilience and performance of cloud-native microservice systems. Yet, existing CE tools remain limited by environment-specific assumptions, narrow fault models, or substantial manual integration with load testing, resulting in high overhead, a high required level of technical expertise, and low reproducibility. To address these shortcomings, we present Ceres, a system-independent and infrastructure-agnostic framework that unifies configurable chaos injection, structured workload generation, and automated observability in a coordinated experimentation workflow. While the tool is independent of any specific system under test, we complement it with MiSArch, a realistic microservice reference architecture that enables reproducible evaluations and supports research on architectural resilience. We evaluate the tool through a usability study with researchers and industry engineers, as well as through empirical experiments using MiSArch that explore performance limits under varying load and failure scenarios and allow the derivation of initial service-level objective boundaries. The results demonstrate that the tool substantially reduces the effort required to design, execute, and analyze combined CE and SPE experiments. Researchers and DevOps engineers benefit from a reusable, accessible, and system-independent experimentation framework that lowers the barrier to systematic and reproducible resilience assessments.
Architectural smells have been widely studied in the literature, and some approaches have been developed to assess their impact on software quality metrics. Yet, empirical evidence bridging architectural smells and software quality metrics, while jointly considering security and performance issues, is limited. In this study, we investigate whether refactoring architectural smells can improve software quality and address security and performance issues that frequently occur in open-source projects. To this end, we analyze software code across various application domains and automatically detect architectural smells, as well as security and performance issues, using a diverse set of tools. Then, we manually remove detected instances of architectural smells and check whether their removal affects quality, security, and performance metrics originally collected in the selected projects. Our results indicate that refactoring architectural smells improves software quality and performance indicators, but we observe a less significant impact on security vulnerabilities.
Reinforcement Learning (RL) is increasingly used in modern Industry 4.0 systems, enabling intelligent control and adaptation in dynamic production environments. However, the management and operationalization of RL models is less mature than established machine learning operations (MLOps) practices, which are primarily designed for traditional machine learning and deep learning workflows. Unlike these conventional approaches, which rely on static datasets and predefined training pipelines, RL agents learn continuously and interact with evolving environments, adding to the complexity of model management. This work investigates how RL models are managed in practice and how their training pipelines are architected and maintained. We study an industrial RL pipeline through a real production-automation case study, analyzing system artifacts and configurations using a catalog of RL-specific Architectural Design Decisions (ADDs) as the analytical lens. The work contributes a structured catalog of 15 ADDs for RL model management and pipeline implementation and demonstrates how static analysis can assess conformance to these practices. To further support our findings, we present a tool that detects architectural patterns and identifies missing practices, enabling engineers to build more reliable, traceable, and reproducible RL systems.
Data mesh is a decentralized data architecture that underpins the building, sharing, governance, and management of analytical domain data in enterprises as autonomous products. An interconnected mesh of data products emerges when data products from different domains are composed, enabling the successful implementation of organization-wide data use cases. To ensure data products are interoperable and compliant, data mesh advocates federated computational governance, in which data governance policies are defined and enforced at the domain level while respecting organization-wide standards and regulations. Nevertheless, there is no structured framework to help developers systematically design and implement data governance for their data products. To fill this gap, this paper proposes an architectural decision framework comprising 8 design decisions and 104 options, along with forces that can guide the selection of the most appropriate options. We conducted a systematic literature review of 49 industrial gray literature articles to build the framework, which was further refined through semi-structured interviews with six data mesh practitioners.
Architecture Decision Records (ADRs) are lightweight artifacts for documenting critical architectural decisions and supporting collaboration in software projects. Although ADRs have gained traction in open-source communities, adoption remains inconsistent, and their impact on repositories and developers is not well understood. This study presents an in-depth quantitative analysis of ADR practices in open-source software. Using a dataset of 921 GitHub repositories and 5800 ADRs from earlier ADR studies, we investigate (1) repository-centric patterns, relating ADR attributes such as length, frequency of updates, and lifecycle status to project quality and activity metrics, and (2) developer-centric factors, examining who contributes to ADRs, how core and peripheral developers differ, and how ADR engagement relates to their productivity and maintenance activities. Data extraction and analysis combine PyDriller for repository metadata and SonarQube for quality metrics. Our results show that ADR-related variables exhibit predominantly small correlations with code quality and productivity metrics, suggesting that ADR adoption is associated with, at most, modest observable effects at scale. At the same time, ADR adoption practices in open-source projects are inconsistent: about 63% of ADRs are opened directly with a status of "accepted" or equivalent, bypassing the deliberative context that ADRs are intended to capture. These findings highlight both the promise and the practical challenges of integrating ADRs into open-source software development.
Data spaces enable organisations to expose data and services without relinquishing control, yet running Machine Learning (ML) workflows across organisations remains largely ad hoc. Techniques such as Federated Learning and split learning allow model optimisation without centralising data, while data-space infrastructures support sovereign data sharing. What is missing is the architectural "glue" that turns these ingredients into dependable collaborative ML workflows. This paper proposes a reference software architecture for collaborative ML on federated data spaces. The architecture organises coordination into six layers implemented as coordination services operating over a distributed knowledge base, making explicit how collaborations are established, adapted, and governed across autonomous domains. We evaluate the architecture through scenario-based analysis and a cross-hospital FL prototype. Experiments on three benchmark datasets with heterogeneous, non-IID clients show improved accuracy over isolated training with comparable training times, indicating that collaborative ML in federated data spaces can be effectively addressed as a software-architecture problem.
With the software landscape continuing to grow in complexity, there is an increasing risk that system misconfigurations will violate confidentiality requirements. The consequence will be that data breaches occur more frequently and inflict more damage. Therefore, it is imperative that confidentiality violations be detected early and repaired swiftly, because the later in development an issue gets addressed, the higher the costs incurred by the development. Fortunately, architecture-based approaches are already capable of detecting confidentiality violations. However, repair by these approaches is manual or at best, semi-automated. This limitation originates from the basic fact that it is considerably harder to optimize for a discrete attribute (like confidentiality) than it is for a continuous and therefore incrementally improvable attribute (like performance). Yet, this same discreteness of confidentiality may actually be harnessed to tackle the resultant combinatoric explosion. If the constraint-driven nature of confidentiality is exploited, then it may be used to construct satisfiability problems that can easily be solved with efficiency. In this paper, we propose automatically and efficiently repairing confidentiality violations in software architectures. We differentiate between two types of efficiency: The one enables the fast repair of violations, and the other ensures the highest possible cost-effectiveness of a system change. Our evaluation on 51 models shows that our approach repairs 826 violations in just 1.6 seconds, while also costing significantly less than the human baseline. Our approach achieves a fully automatic repair that is both runtime-efficient and cost-efficient, thereby helping architects in designing confidential systems.
Digital twins (DTs) are virtual replica of a physical/digital system that mirror the state and behaviour of physical entities via continuous synchronisation or predictive simulation. The engineering of DT not only involves several effort-intensive and complex tasks such as selecting physical aspects to be replicated, onboarding data streams, and developing a DT model. Moreover, it has places significant cognitive load on DT engineers, who manually interpret unstructured technical document to construct DT models and deploy compliant instances within DT platforms. The emergence of Large Language Models (LLMs), particularly Agentic AI, has motivated us to leverage these technologies for supporting engineering DT in collaboration with human. We intended to focus on the capabilities of Natural Language Processing (NLP) capabilities of LLM to transform and synthesise the unstructured technical documents into DT models. We devised an integrated architecture-centric approach that combines AI agents and human-in-the-loop (HITL) work-flows with traditional DT platform capabilities to develop, deploy and operate DTs. This paper reports the foundation of our research that has conceptualise our vision of Agentic AI based platform for engineering DT, identification of requirements, and an architecture for Agentic AI based framework for engineering DT. We have present a Proof-of-Concept (PoC) implementation of the devised architecture using open-source components. Preliminary evaluation results show measurable reduction in modelling effort, whilst revealing the challenges in schema compliance and semantic consistency.
Refactoring service-oriented software is crucial for competitiveness, security, and reliability. While the migration of monoliths to (micro-)services is well-studied, the evolution of a service-oriented architecture – particularly, the integration of API patterns – falls short, leaving practitioners with little knowledge on the impact of architectural refactorings. In this article, we employ an existing framework for applying refactorings either internally in the refactored service(s), adjacently (in the same application but another service component), or externally in a remote service. We study the impact on performance as observed on the client side of these implementation variants. Our work offers evidence-based guidance for building competitive service-oriented architectures upon evolution.
Architectural decay can manifest as the evolution of architectural smells, degrading integrity, and increasing maintenance costs. Existing techniques capture smells post hoc or predict on component level, acting too late or on too coarse a granularity. We investigate if the risk of introducing architectural smells can already be predicted when issues are opened. Thus, we propose an issue-level prediction approach that utilizes the semantic representations of Large Language Models (LLMs).To enable training and evaluation, we construct a dataset from three GitLab-hosted projects by linking issues to smells via smell-inducing changes. On this dataset, we train classifiers to identify high-risk issues and conduct an empirical study comparing seven different representations and nine classifiers.Our best-performing classifier (SVM with OpenAI embeddings) achieves F1-scores of up to 0.506, with a recall of about 0.74. This means that our approach can identify approximately 74% of smell-inducing issues before implementation begins. When design alternatives are still being considered. Our approach provides early warnings of potential architectural risks. This work shifts from reactive remediation to proactive quality assurance, raising awareness of potential architectural risks.
The increasing popularity of Machine Learning (ML) has prompted companies to adopt it to enhance their business processes and generate additional value. To leverage ML, companies must build robust platforms for ML training and serving pipelines/systems. Three key components of such platforms are the feature store, model repository, and metadata store that enable developers to store, share, govern, and discover features, models, and metadata. Nevertheless, implementing and using these components is challenging, as platform developers and users must identify potential design options and their dependencies, and select the most appropriate options by balancing competing quality trade-offs. To support the systematic development and use of these platform components, this paper presents a framework comprising 15 Architectural Design Decisions (ADDs), 76 decision options, and 40 decision drivers, based on a review of 44 industrial gray literature sources.
Software architects are central to the design and evolution of modern software systems, yet it remains unclear whether academic programs prepare students for the competencies required in practice. This study compares 658 Software Architect job postings from 38 countries with 588 software architecture courses from the top 100 CSRankings institutions. Using TF-IDF, n-gram analysis, a 19-topic LDA model, and SWEBOK-based coding, we analyze industry expectations (RQ1), academic coverage (RQ2), and alignment (RQ3). Industry emphasizes cloud and DevOps competencies (69% cloud, 44% DevOps, 30% containers, 25.8% microservices) and stakeholder engagement (50.2%), while curricula focus on structural concepts (50% patterns) and technical foundations (74.3%) but provide limited coverage of lifecycle practices (16.3%), operational tasks (9.4%), and soft skills (13.4%). These gaps highlight the need for curricula that integrate cloud-native, continuous, and sociotechnical dimensions of architecture practice.
Cloud-native microservice systems increasingly rely on autoscaling to maintain performance under fluctuating workloads, yet scaling decisions strongly influence energy consumption and carbon emissions, making sustainability a growing concern for modern cloud infrastructures. Traditional mechanisms such as the Kubernetes Horizontal Pod Autoscaler optimize only performance metrics and ignore the carbon intensity of electricity sources, leading to excessive provisioning and higher emissions. To address this limitation, this paper proposes a Carbon-Aware Autoscaling System based on Spatio-Temporal Graph Convolutional Networks that jointly model workload dynamics and inter-service dependencies while integrating real-time regional carbon intensity. The autoscaler dynamically moderates scaling levels using carbon-aware thresholds, enabling adaptive tradeoffs between performance and sustainability. We evaluated our approach on three benchmark microservice applications using a synchronized monitoring stack for performance, energy, and carbon metrics. Experimental results show that the proposed approach achieves an average carbon emission reduction of approximately 24% in high-intensity regions (300 gCO2/kWh) and 17% in low-intensity regions (100 gCO2/kWh) as compared to HPA while maintaining comparable performance in low-carbon conditions.
Event Storming (ES), as the key modeling technique within the Domain-Driven Design (DDD) methodology, provides teams with a fast, visual approach that helps them deeply understand and explore complex business domains, thereby enabling more effective software system design and development. Compared to traditional UML modeling techniques, ES emphasizes collaborative exploration and rapid iteration. However, its effectiveness is highly dependent on the facilitation of domain experts. Moreover, since ES sessions are typically conducted using physical or digital whiteboards, they often incur high coordination costs, especially in distributed or asynchronous environments. With the recent advances in Large Language Models (LLMs), there is growing interest in leveraging their reasoning and text generation capabilities to support software modeling tasks. This paper presents a controlled experiment to investigate the effectiveness of LLMs in facilitating ES modeling. A total of 240 postgraduate participants (60 teams) were assigned to three conditions: manual ES, LLM-assisted ES with basic prompts, and LLM-assisted ES with optimized prompts. The generated models were quantitatively evaluated in terms of Accuracy, Completeness, and Consistency. The findings show that while LLM-generated ES elements are generally reliable, LLMs tend to overlook or omit a substantial number of critical model elements. Optimized prompts can effectively steer LLMs towards inferring previously missing elements; however, for complex business logic, a single optimized prompt remains insufficient to achieve consistently high-quality modeling.
Migrating monolithic applications to microservices requires the identification of module groupings to form coherent and independent services. This paper presents a dataflow–driven decomposition approach that employs a hypergraph-based representation to guide the migration process. Unlike traditional graph-based methods, the hypergraph model captures dependencies that span multiple modules such as shared databases and cross-cutting concerns, and allows the integration of quality attributes such as scalability, performance, and security. By leveraging existing hypergraph partitioning algorithms, we identify microservice boundaries that reflect both structural and quality-related dependencies. We conduct an empirical evaluation using two experimental objects: a well-known open-source benchmark system and a software system developed within an industrial context. The results demonstrate that the proposed method produces well-structured, cohesive, and quality-aware microservices, as confirmed by both quantitative metrics and expert evaluations.
Software supply chain attacks have become a significant threat to modern software systems. By exploiting the complex and transitive nature of dependencies, malicious actors have been able to perform significant attacks, also taking advantage of the dynamic relationship between software components and their dependencies. In Continuous Integration and Continuous Deployment (CI/CD) ecosystems such as GitHub Actions, developers assemble workflows out of reusable Actions. However, these Actions—in particular JavaScript ones—come with an intricate network of dependencies. As they evolve, these dependency networks expose GitHub CI/CD pipelines to subtle vulnerabilities that may be introduced without any modification of the workflows themselves. This paper investigates such phenomenon, which we call "rug pull" within GitHub workflows. Through formalization and an empirical analysis of real-world workflows, we characterize the propagation and persistence of such vulnerabilities as well as their remediation. Our findings highlight architectural considerations needed when designing secure yet maintainable CI/CD pipelines, emphasizing the need for careful dependency management and coordinated responsibility across the software supply chain.
The deployment of modern containerized architectures depends on container orchestration tools, because their configuration critically influence performance, robustness, and cost. Container orchestration tools manage scaling, health checking, failure recovery, and resource distribution among containers. Configuration evaluation as well as suitability of container orchestration are nontrivial at design time, not to mention expensive. For informed decision-making in container architectures, modeling and simulation provide lightweight alternatives.In this paper, we present a novel approach to modeling and simulating dynamic container architectures. Implemented as an extension of the Palladio Component Model, our approach captures essential orchestration mechanisms such as autoscaling, container scheduling, and the configuration of requests and limits. Our qualitative evaluation uses two example applications and load scenarios. The results show that our approach closely simulates dynamic containerized architectures while enabling lightweight comparison between different configurations and traditional deployment techniques.
