Autonomous systems are increasingly deployed across critical domains, yet research on trustworthy autonomous systems (TAS) appears to lack an agreed-upon, operationalizable taxonomy for trustworthiness characteristics. While trustworthy artificial intelligence (TAI) frameworks offer measurable characteristics with more established metrics, TAS literature tends to be fragmented with high-level models that can be difficult to apply in practice. This paper investigates the extent of alignment in TAS trustworthiness research and identifies potential sources of misalignment, including differences in system definitions, autonomy properties, stakeholder perspectives, and domain requirements. Based on this analysis, we synthesize a foundational two-pillar core of trustworthiness, the system’s ability to dependably do what it is intended to do and the extent to which stakeholders can assess and justify confidence in this behavior. We propose an initial operationalization of this core using characteristics adapted from established TAI frameworks for which metrics and evaluation methods exist, and outline how it can be applied to specific application contexts. An example shows how stakeholder analysis guides characteristic adaptation.

This publication presents an established engineering-driven framework for pipelining large language model (LLM) agents for automatic code translation. The framework is applied in a long-term ongoing industrial project with Danfoss Power Solutions aimed at translating five million lines of Delphi to C#. To manage this scale, the source codebase is divided into translatable chunks, which are processed independently through an agentic LLM pipeline, with subsequently the reassembly of the translated code chunks in the target language. Due to the inherent stochasticity of LLMs, the framework incorporates processing and validation functions to ensure consistency and correctness. As an extended version of our short paper (Bruneel et al., 2025), this paper provides a significantly more comprehensive architectural blueprint. Specifically, we present an in-depth background & related work section, formalise the chunking and reassembly strategies, detail the internal mechanics of agent stages, and introduce sequential agent orchestration alongside the dynamic LLM pipeline architecture. Furthermore, we report early empirical observations regarding the pipeline’s computational overhead, validation dynamics, and translation quality, noting a practical impact of an initial 10x acceleration over estimated manual translation efforts. Ultimately, we share these expanded insights to inform future development and application in similar large-scale translation tasks.

As simulation applications become vital for understanding and predicting complex systems, analyzing data from repeated simulation runs is essential to gauge model uncertainty and identify optimal parameter settings. This paper presents a visualization tool for analyzing time series ensemble data generated by discrete-event simulations, focusing on feature importance within clustering results. The tool combines dimensionality reduction, clustering, and SHapley Additive exPlanations (SHAP) to highlight influential features and identify trends within clustered simulation data, advancing previous approaches focusing solely on visualization or clustering without analyzing specific feature contributions. By analyzing a manufacturing use case, we show how the visualization supports decision-makers by depicting the main features driving cluster formation and displaying time intervals critical to characterizing distinct system behaviors.

Self-adaptation equips a software system with a feedback loop that resolves uncertainties during operation and adapts the system to deal with them when necessary. Most self-adaptation approaches today use decision-making mechanisms that select for execution the adaptation option with the best-estimated benefit expressed as a set of adaptation goals. A few approaches also consider the estimated (one-off) cost of executing the candidate adaptation options. We argue that besides benefit and cost, decision-making in self-adaptive systems should also consider the estimated risk the system or its users would be exposed to if an adaptation option were selected for execution. Balancing all three concerns when evaluating the options for adaptation to mitigate uncertainty is essential for satisfying stakeholders’ concerns and ensuring the safety and public acceptance of self-adaptive systems. In this article, we present a reference model for decision-making in self-adaptation that considers the estimated benefit, cost, and risk as core concerns of each adaptation option. Leveraging this model, we then present an ISO/IEC/IEEE 42010 compatible architectural viewpoint that aims at supporting software architects responsible for designing robust decision-making mechanisms for self-adaptive systems. We demonstrate the applicability, usefulness, and understandability of the viewpoint through a case study where participants with experience in the engineering of self-adaptive systems performed a set of design tasks in DeltaIoT, an Internet-of-Things exemplar for research on self-adaptive systems.

Antifragility is one of the terms that have recently emerged with the aim of indicating a direction that should be pursued toward the objective of designing Information and Communications Technology systems that remain trustworthy despite their dynamic and evolving operating context. We present a characterization of antifragility, aiming to clarify from a conceptual viewpoint the implications of its adoption as a design guideline and its relationships with other approaches sharing a similar objective. To this end, we discuss the inclusion of antifragility (and related concepts) within the well-known dependability taxonomy, which was proposed a few decades ago with the goal of providing a reference framework to reason about the different facets of the general concern of designing dependable systems. From our conceptual characterization, we then derive a possible path toward the engineering of antifragile systems.

Robots are increasingly adopted in a wide range of unstructured and uncertain environments, where they are expected to keep quality properties such as efficiency, accuracy, and safety. To this end, robots need to be smart and continuously update their situation awareness. Self-adaptive systems pave the way for accomplishing this aim by enabling a robot to understand its surroundings and adapt to various scenarios in a systematic manner. However, some situations, e.g., adjusting adaptation rules, refining run-time models, narrowing a vast adaptation domain, and taking future scenarios into consideration, etc. may require the self-adaptive system to include additional specialized components. In this regard, this work proposes a novel approach combining the MAPE-K, adaptive controllers, and a Digital Twin of the robot to enable the managing system to be aware of new scenarios appearing at run-time and operate safely, accurately, and efficiently. A state-of-the-art robot model is employed to evaluate the suitability of the approach.

Abstract In recent years, we have seen many performance fiascos in the deployment of new systems, such as the US health insurance web. This paper describes the functionality and architecture, as well as success stories, of a tool that helps address these types of issues. The tool allows assessing software designs regarding quality, in particular performance and reliability. Starting from a UML design with quality annotations, the tool applies model-transformation techniques to yield analyzable models. Such models are then leveraged by the tool to compute quality metrics. Finally, quality results, over the design, are presented to the engineer, in terms of the problem domain. Hence, the tool is an asset for the software engineer to evaluate system quality through software designs. While leveraging the Eclipse platform, the tool uses UML and the MARTE, DAM and DICE profiles for the system design and the quality modeling.

The sixth ACM Workshop on Challenges in Performance Methods for Software Development is co-located with the 12th ACM/SPEC International Conference on Performance Engineering (ICPE 2021), 19-23 April 2021. The Conference initially hosted in Rennes, France, will be a virtual event due to COVID-19. The purpose of the workshop is to open up new venues of research on methods for software developers to address performance problems. The software world is changing continuously, and there are new challenges every day. The acronym WOSP-C was chosen to recall the original WOSP, the ACM International Workshop on Software and Performance, which has been a co-organizer of ICPE since 2010.

One of the primary drivers for self-adaptation is ensuring that systems achieve their goals regardless of the uncertainties they face during operation. Nevertheless, the concept of uncertainty in self-adaptive systems is still insufficiently understood. Several taxonomies of uncertainty have been proposed, and a substantial body of work exists on methods to tame uncertainty. Yet, these taxonomies and methods do not fully convey the research community’s perception on what constitutes uncertainty in self-adaptive systems and on the key characteristics of the approaches needed to tackle uncertainty. To understand this perception and learn from it, we conducted a survey comprising two complementary stages in which we collected the views of 54 and 51 participants, respectively. In the first stage, we focused on current research and development, exploring how the concept of uncertainty is understood in the community and how uncertainty is currently handled in the engineering of self-adaptive systems. In the second stage, we focused on directions for future research to identify potential approaches to dealing with unanticipated changes and other open challenges in handling uncertainty in self-adaptive systems. The key findings of the first stage are: (a) an overview of uncertainty sources considered in self-adaptive systems, (b) an overview of existing methods used to tackle uncertainty in concrete applications, (c) insights into the impact of uncertainty on non-functional requirements, (d) insights into different opinions in the perception of uncertainty within the community and the need for standardised uncertainty-handling processes to facilitate uncertainty management in self-adaptive systems. The key findings of the second stage are: (a) the insight that over 70% of the participants believe that self-adaptive systems can be engineered to cope with unanticipated change, (b) a set of potential approaches for dealing with unanticipated change, (c) a set of open challenges in mitigating uncertainty in self-adaptive systems, in particular in those with safety-critical requirements. From these findings, we outline an initial reference process to manage uncertainty in self-adaptive systems. We anticipate that the insights on uncertainty obtained from the community and our proposed reference process will inspire valuable future research on self-adaptive systems.

As part of the DevOps tactics, Infrastructure-as-Code (IaC) provides the ability to create, configure, and manage complex infrastructures by means of executable code. Writing IaC, however, is not an easy task, since it requires blending different infrastructure programming languages and abstractions, each specialized on a particular aspect of infrastructure creation, configuration, and management. Moreover, the more the architectures become large and complex (e.g. Data-Intensive or Microservice-based architectures), the more dire the need of IaC becomes. The goal of this paper is to exploit Model-Driven Engineering (MDE) to create language-agnostic models that are then automatically transformed into IaC. We focus on the domain of Data-Intensive Applications as these typically exploit complex infrastructures which demand sophisticated and fine-grained configuration and re-configuration - we show that, through our approach, called DICER, it is possible to create complex IaC with significant amounts of time savings, both in IaC design as well as deployment and re-deployment times.

The inherent dynamic nature of Cyber Physical Systems (CPS) requires novel mechanisms to support their evolution over their operation life time. Though typically the development of CPS integrates the software (cyber) design with the physical domain, this contribution concentrates mainly on another essential integration plane: The software design level. This paper presents an approach to support the adaptation process of CPS required by their evolution. It is based on the run-time generation of verified system configurations and their analysis to guide the evolution of the system through correct configurations that meet the functional and timing requirements of the new situations. We show its feasibility by presenting and analyzing the results of the execution for a reduced-scale time-sensitive application that employs a complex verification technique to model functional and temporal aspects of the system.

The design of the embedded software for industrial systems progressively integrates more intelligent functions to ease the integration between the factory floor hardware and operator-friendly control front ends. New software development paradigms such as service oriented architecture (SOA) make it possible by embedding small footprint web servers inside small embedded devices that are connected to the actuators which they control. In general, the timing requirements of such distributed systems are not in the front plane and temporal guarantees provided by most solutions are typically best effort. iLAND is an example of a middleware that supports communication and reconfiguration of distributed services, ensuring temporal correctness. It includes the logic for adapting the architectural structure of a service-based application (i.e., number and connections of the software pieces/functions) to respond to operator requests in a time-deterministic way, focusing only on the temporal correctness. In this paper, we apply the principles of autonomic computing to the middleware design, and we provide a high-level description on how its verification process could be extended beyond the purely temporal properties using more comprehensive formal techniques. We exemplify these ideas with a modified on-line verification manager that suits the needs of a kind of systems with specific timing and functional constraints.

The complexity of modern software systems has grown enormously in the past years with users always demanding for new features and better quality of service. Besides, software is often embedded in dynamic contexts, where requirements, environment assumptions, and usage profiles continuously change. As an answer to this need, it has been proposed the usage of self-adaptive systems. Self-adaptation endows a system with the capability to accommodate its execution to different contexts in order to achieve continuous satisfaction of requirements. Often, self-adaptation process also makes use of runtime model evaluations to decide the changes in the system. However, even at runtime, context information that can be managed by the system is not complete or accurate; i.e, it is still subject to some uncertainties. This work motivates the need for the consideration of the concept of uncertainty in the model-based evaluation as a primary actor, classifies the avowed uncertainties of self-adaptive systems, and illustrates examples of how different types of uncertainties are present in the modeling of system characteristics for availability requirement satisfaction.

Software is often embedded in dynamic contexts where it is subjected to high variable, non-stable, and usually bursty workloads. A key requirement for a software system is to be able to self-react to workload changes by adapting its behavior dynamically, to ensure both the correct functionalities and the required performance. Research on fitting variable workload traces into formal models has been carried out using Markovian Modulated Poisson Processes (MMPP). These works concentrate on modeling stable workload states, but accurate modeling of transient times still deserves attention since they are critical moments for the self-adaptation. In this work, we build on research in the area of MMPP trace fitting and we propose a Petri net fine-grained model for highly variable workloads that also accounts for transient times. We analyze differences between models of adaptive software that accurately represent workload state changes and models that do not. We evaluate their performance and availability and compare the results.

Service Oriented Architecture (SOA) is a paradigm where applications are built on services offered by third party providers. Behavior of providers evolves and makes a challenge the performance prediction of SOA applications. A proper decision about when a provider should be substituted can dramatically improve the performance of the application. We propose hidden Markov models (HMM) to help service integrators to foretell the current state of third-parties. The paper leverages different algorithms that change providers based on predictions about their states. We also integrate these algorithms and HMMs in an architectural solution to coordinate them with other challenges in the SOA world.