International audience

The vision of 6G goes beyond incremental improvements in network performance, representing a paradigm shift toward a programmable, intelligent “network of networks.” In this context, digital twins (DTs) emerge as key enabling technologies for 6G, providing virtual replicas of physical, virtual, and logical infrastructures. The capabilities of 6G, such as ultra-high-speed transmission, massive connectivity, and integration with Artificial Intelligence, are essential for enabling accurate, real-time, and synchronized DTs. However, developing DT systems poses significant challenges, including integrating heterogeneous data sources, ensuring real-time synchronization, and ensuring interoperability across distributed environments. This article presents MidDiTS, a middleware solution that supports the modeling, synchronization, and management of DT systems. MidDiTS provides a comprehensive set of services, including physical entity connection, model and instance management, data ingestion, API integration, and device management. By abstracting away system complexities and promoting interoperability, MidDiTS enables developers to focus on higher-level business logic and accelerates the development of robust, synchronized DT systems for next-generation networked environments. We validated MidDiTS in a 6G-based scenario, demonstrating significant improvements in timeliness, reliability, and operational stability. The results highlight the role of advanced network capabilities in sustaining real-time DT synchronization and confirm the suitability of MidDiTS for supporting DT systems under next-generation network conditions.

Abstract Modern systems are increasingly connected and more integrated with other existing systems, giving rise to systems‐of‐systems (SoS). An SoS consists of a set of independent, heterogeneous systems that interact to provide new functionalities and accomplish global missions through emergent behavior manifested at runtime. The distinctive characteristics of SoS, when contrasted to traditional systems, pose significant research challenges within software engineering. These challenges motivate the need for a paradigm shift and the exploration of novel approaches for designing, developing, deploying, and evolving these systems. The International Workshop on Software Engineering for Systems‐of‐Systems (SESoS) series started in 2013 to fill a gap in scientific forums addressing SoS from the software engineering perspective, becoming the first venue for this purpose. This article presents a study aimed at outlining the evolution and future trajectory of software engineering for SoS based on the examination of 57 papers spanning the 11 editions of the SESoS workshop (2013–2023). The study combined scoping review and scientometric analysis methods to categorize and analyze the research contributions concerning temporal and geographic distribution, topics of interest, research methodologies employed, application domains, and research impact. Based on such a comprehensive overview, this article discusses current and future directions in software engineering for SoS.

Abstract A multi‐tenant microservice architecture involving components with asynchronous interactions and batch jobs requires efficient strategies for managing asynchronous workloads. This article addresses this issue in the context of a leading company developing tax software solutions for many national and multi‐national corporations in Brazil. A critical process provided by the company's cloud‐based solutions encompasses tax integration, which includes coordinating complex tax calculation tasks and needs to be supported by asynchronous operations using a message broker to guarantee order correctness. We explored and implemented two approaches for managing asynchronous workloads related to tax integration within a multi‐tenant microservice architecture in the company's context: (i) a polling‐based approach that employs a queue as a distributed lock (DL) and (ii) a push‐based approach named single active consumer (SAC) that relies on the message broker's logic to deliver messages. These approaches aim to achieve efficient resource allocation when dealing with a growing number of container replicas and tenants. In this article, we evaluate the correctness and performance of the DL and SAC approaches to shed light on how asynchronous workloads impact the management of multi‐tenant microservice architectures from delivery and deployment perspectives.

In the last years, Internet of Things (IoT) platforms have been designed to provide IoT applications with various services such as device discovery, context management, and data filtering. The lack of standardization has led each IoT platform to propose its own abstractions, APIs, and data models. As a consequence, programming interactions between an IoT consuming application and an IoT platform is time-consuming, is error prone, and depends on the developers’ level of knowledge about the IoT platform. To address these issues, this article introduces IoTvar , a middleware library deployed on the IoT consumer application that manages all its interactions with IoT platforms. IoTvar relies on declaring variables automatically mapped to sensors whose values are transparently updated with sensor observations through proxies on the client side. This article presents the IoTvar architecture and shows how it has been integrated into the FIWARE, OM2M, and muDEBS platforms. We also report the results of experiments performed to evaluate IoTvar, showing that it reduces the effort required to declare and manage IoT variables and has no considerable impact on CPU, memory, and energy consumption.

In the Smart Cities context, a plethora of Middle-ware Platforms had been proposed to support applications execution and data processing. Despite all the progress already made, the vast majority of solutions have not met the requirements of Applications’ Runtime, Development, and Deployment when related to Scalability. Some studies point out that just 1 of 97 (1%) reported platforms reach this all this set of requirements at same time. This small number of platforms may be explained by some reasons: i) Big Data: The huge amount of processed and stored data with various data sources and data types, ii) Multi-domains: many domains involved (Economy, Traffic, Health, Security, Agronomy, etc.), iii) Multiple processing methods like Data Flow, Batch Processing, Services, and Microservices, and 4) High Distributed Degree: The use of multiple IoT and BigData tools combined with execution at various computational levels (Edge, Fog, Cloud) leads applications to present a high level of distribution. Aware of those great challenges, we propose Sapparchi, an integrated architectural model for Smart Cities applications that defines multi-processing levels (Edge, Fog, and Cloud). Also, it presents the Sapparchi middleware platform for developing, deploying, and running applications in the smart city environment with an osmotic multi-processing approach that scales applications from Cloud to Edge. Finally, an experimental evaluation exposes the main advantages of adopting Sapparchi.

Academia and industry have recently acknowledged the many benefits of architecting with microservices. Nonethe-less, adopting a microservice architecture does not immediately guarantee the achievements promised by such an architectural style. A crucial architectural decision is why and where multi-tenancy should be adopted in microservice architectures. This paper presents a multi-tenant microservice architecture conceived to meet the requirements of a company to serve multiple customer applications (tenants). By reporting the migration and modern-ization of a monolith legacy architecture towards microservices, this paper discusses how a multi-tenant microservice architecture could benefit scalability, management, and third-party system integration. This paper also presents empirical results of a scalability evaluation to assess the adoption of multi-tenancy in the proposed architecture and quantify its impact on the system's performance.

Emerging IoT applications with stringent requirements on latency and data processing have posed many challenges to cloud-centric platforms for Smart Cities. Recently, Fog Computing has been advocated as a promising approach to support such new applications and handle the increasing volume of IoT data and devices. The Fog Computing paradigm is characterized by a horizontal system-level architecture where devices close to end-users and IoT devices are used for processing, storage, and networking functions. Fog Computing platforms aim to facilitate the development of applications and systems for Smart Cities by providing services and abstractions designed to integrate data from IoT devices and various information systems deployed in the city. Despite the potential of the Fog Computing paradigm, the literature still lacks a broad, comprehensive overview of what has been investigated on the use of such paradigm in platforms for Smart Cities and open issues to be addressed in future research and development. In this paper, a systematic mapping study was performed and we present a comprehensive understanding of the use of the Fog Computing paradigm in Smart Cities platforms, providing an overview of the current state of research on this topic, and identifying important gaps in the existing approaches and promising research directions.

Missions represent a key concern in the development of Systems-of-Systems (SoS) since they are related to both capabilities of constituent systems and interactions among these systems that contribute to the accomplishment of global goals of the SoS. In a mission-oriented approach to design software-intensive SoS, the activity towards the concretization of the mission model is its refinement to an architectural model. This paper addresses this synergetic relationship between mission and architectural models. As main contribution, we introduce a model-based refinement process supported by model-to-model transformations intended to apply mission models represented in mKAOS, a language to model missions, for automatically generating architecture descriptions in SosADL, a formal language to describe SoS software architectures.

SysADL is a SysML profile for describing architectures using the well-known and consolidated abstractions from the software architecture community. It defines a systematic use of SysML specifically supporting architecture descriptions. For this purpose, it encompasses three integrated viewpoints: structural, behavioral, and executable. This paper focuses on the behavioral viewpoint that relies on the SysML activity and parametric diagrams to capture the behavior of atomic and composite architectural elements. We use an air-conditioning systems as a case study to illustrate SysADL behavioral views and investigate the applicability of SysADL through a controlled experiment.

The cloud lock-in problem is commonly addressed by three strategies: (i) use of intermediate layer between cloud services consumers and providers, (ii) use of standardized interfaces to access cloud services, or (iii) use of models with open specifications. This paper evaluated these strategies and concluded that despite the advances they introduced, none of them actually solves the cloud lock-in problem. To address this issue, this paper proposes the use of Semantic Web concepts to avoid cloud lock-in. The strategy consists of using RDF models to specify the features of a cloud service, which are managed by SPARQL queries. The contribution of this paper is fourfold: (i) to evaluate three multi-cloud solutions for the cloud lock-in problem in the context of three cloud platforms, (ii) to propose a strategy using RDF and SPARQL for managing cloud resources, (iii) to present the Cloud Query Manager (CQM), an SPARQL server that implements the proposal, and (vi) to compare three multi-cloud solutions with CQM in terms of response time and the effectiveness in the resolution of the cloud lock-in problem.

Wireless Sensor and Actuator Networks (WSANs) are highly heterogeneous regarding hardware, software, and application requirements. Developing WSAN applications is a hard task, as it requires domain and network knowledge and there is a lack of methodologies, architectures, and patterns to help software developers with such task. Moreover, non-functional requirements play an essential role to ensure the application and network performance, and must be taken into account from the early stages of application development. We propose a ModelDriven Architecture framework to develop WSAN applications that enables developers to express functional and non-functional requirements. The framework encompasses a generic middleware meta-model including: (i) features shared among different WSAN middleware, (ii) meta-model of a target middleware including features of a specific WSAN middleware, and (iii) model transformations. We evaluate our approach by verifying the support to specify non-functional requirements and the automatic code generation of a middleware tailored to the requirements ofa target application.

Dynamic software architectures are those that describe how components and connectors can be created, interconnected, and/or removed during system execution. Most existing architecture description languages (ADLs) provide a limited support to expressively describe these architectures and entail architectural mismatches and inconsistencies between architecture and implementation due to their decoupling from implementation. In this paper, we introduce the dynamic reconfiguration support provided by π-ADL, a formal, well-founded theoretically language for describing dynamic software architectures under structural and behavioral viewpoints. π-ADL provides architectural-level primitives for specifying programmed dynamic reconfigurations, i.e., Foreseen changes described at design time and triggered at runtime. In addition, π-ADL allows enacting dynamic reconfiguration by means of: (i) an exogenous approach, in which it is possible to control all elements of the software architectures and to apply the changes on the whole structure, and (ii) an endogenous approach, in which the architectural elements can manage dynamic reconfiguration actions. Furthermore, π-ADL is integrated with the Go programming language, thus enabling to automatically generate implementation code from architectural descriptions, thus tackling the existing gap between them. We hereby use a real-world flood monitoring system as an illustrative example of how to describe dynamic software architectures in π-ADL and automatically generate source code in Go.

Adaptation is an important concern in cloud-based applications composed of services provided by different cloud providers since cloud services can suffer from Quality of Services(QoS) fluctuations. Other conditions that can also trigger an adaptation process at runtime are the unavailability of services or the violation of user-defined policies. Moreover, the detection and reaction on such changes must be done in an autonomic way, without the need of user intervention. This paper presents a dynamic adaptation approach for multi-cloud applications supported by a Branch-and-Bound (B&B) algorithm in order to optimize the adaptation process itself when selecting the services to be deployed within the application. Computational experiments comparing the B&B algorithm with another algorithm that evaluates all possible configurations for adapting an application showed that the B&B algorithm is faster than the previous version. This new algorithm brings benefits to the scalability of the adaptation process, which can deal with large configurations of multi-cloud applications composed by a plethora of cloud services.

The Internet of Things (IoT) has emerged as a paradigm in which smart things actively collaborate among them and with other physical and virtual objects available in the Web in order to perform high-level tasks. IoT environments are typically characterized by a high degree of heterogeneity, thus encompassing devices with different capabilities, functionalities, and network protocols. In such a scenario, it is necessary to provide abstractions for physical devices and services to applications and end-users, as well as means to manage the interoperability between such heterogeneous elements. In this context, we introduce EcoDiF (Web Ecosystem of Physical Devices), a Web-based platform for integrating heterogeneous physical devices with applications and users in order to provide services to support real-time data control, visualization, processing, and storage. In this paper, we present the main features of EcoDiF and detail its architecture and implementation, which is based on well-known Web technologies such as HTTP, REST, EEML, and EMML. Furthermore, we present a preliminary evaluation of an EcoDiF prototype through proof-of-concept applications from different domains as well as a performance analysis of the platform.

Software systems have become increasingly large and complex, often resulting from the integration of several operationally independent systems, thus leading to a new class of systems called Systems-of-Systems (SoS). Moreover, SoS have currently become essentially software-dependent systems, thus arising the Software-intensive Systems-of-Systems (SiSoS). However, in spite of their relevance, there is a lack of a common understanding of what exactly SiSoS are, their characteristics and types, as well as other elements that surround them. In this context, the main contribution of this work is to provide a conceptual model that provides a comprehensive understanding about them. For this purpose, we have extended the ISO/IEC/IEEE 42010 International Standard by considering related studies and previous taxonomies about SoS. In order to illustrate the use of our model, two software-intensive systems were analyzed and discussed. By establishing a common understanding about SiSoS, results achieved until now have showed us that this model can provide an important support to the research on SiSoS and, as a consequence, it can contribute to the development of these systems.

SUMMARY When reflecting upon driving system requirements such as security and availability, software architects often face decisions that have a broadly scoped impact on the software architecture. These decisions are the core of the architecting process because they typically have implications intertwined in a multitude of architectural elements and across multiple views. Without a modular representation and management of those crucial choices, architects cannot properly communicate, assess and reason about their crosscutting effects. The result is a number of architectural breakdowns, such as misinformed architectural evaluation, time‐consuming trade‐off analysis and unmanageable traceability. This paper presents an architectural documentation approach in which aspects are exploited as a natural way to capture widely‐scoped design decisions in a modular fashion. The approach consists of a simple high‐level notation to describe crosscutting decisions, and a supplementary language that allows architects to formally define how such architectural decisions affect the final architectural decomposition according to different views. On the basis of two case studies, we have systematically assessed to what extent our approach: (i) supports the description of heterogeneous forms of crosscutting architecture decisions, (ii) improves the support for architecture modularity analysis, and (iii) enhances upstream and downstream traceability of crosscutting architectural decisions. Copyright © 2012 John Wiley & Sons, Ltd.

With the advance of the Cloud Computing paradigm, new challenges in terms of models, tools, and techniques to support developers to design, build and deploy complex software systems that make full use of the cloud technology arise. In the heterogeneous scenario of this new paradigm, the development of applications using cloud services becomes hard, and the software product lines (SPL) approach is potentially promising for this context since specificities of the cloud platforms, such as services heterogeneity, pricing model, and other aspects can be catered as variabilities to core features. In this perspective, this paper (i) proposes a seamless adaptation of the SPL-based development to include important features of cloud-based applications, and (ii) reports the experience of developing HW-CSPL, a SPL for the Health Watcher (HW) System, which allows citizens to register complaints and consult information regarding the public health system of a city. Several functionalities of this system were implemented using different Cloud Computing platforms, and run time specificities of this application deployed on the cloud were analyzed, as well as other information such as change impact and pricing.

This paper describes the architecture, implementation and illustrates the usage of WebFlowAH, an environment for ad-hoc specifying and executing Web services-based business processes. WebFlowAH build on the adoption of common domain ontology to describe Web services and business processes. It enables the specification of processes in terms of high level users' goals that are expressed based on the concepts of such common domain ontology, thus independently on the syntax of the service provided operations. WebFlowAH provides a unique environment for specifying and executing goal-oriented business processes, allowing services discovery, composition and invocation on the fly.

Ubiquitous environments still suffer from low availability given that any device may fail and it is hard to replace a failed element. In this paper we present AdaptUbiFlow (Adaptive Ubiquitous Workflow), an OpenCOPI´s element that aims to increase the availability of an ubiquitous system. When a device fails, AdaptUbiFlow supports the automatic reconfiguration of the system replacing the failed device (or service) by an equivalent one, this makes the system fault-tolerant without the need of any manual intervention. The replacing of a device/service is chosen taking into account not only the QoS and QoC (Quality of Context) provided but also the application's execution flow to ensure that the best adaptation option will be chosen. AdaptUbiFlow evaluation showed encouraging results.

Developing Wireless Sensor Networks (WSN) applications is not an easy task, since it demands different expertise and knowledge. To address this problem, we propose a model-driven approach to build WSN applications. It promotes the separation of concerns between two levels of requirements involved: (i) domain experts, with no knowledge on WSN platforms, contribute to the development of applications, (ii) network experts, with no knowledge on the application domain, program nodes to meet application requirements. Our approach also promotes the reuse of software artifacts: an application model can be reused on different sensor platforms and a platform model can be reused for different WSN applications.

To ensure a consistent correlation between the requirements model and the architecture representation of Software Product Lines (SPL), this paper proposes an integration between goal models (described in PL-AOV-Graph) and architectural specification (described in PL-AspectualACME). We define the mapping process between these models and transformation rules between their elements. We also present a case study (e-commerce system), to evaluate the mapping process.

This paper presents the results of an exploratory study on the fault-proneness of aspect-oriented programs. We analysed the faults collected from three evolving aspect-oriented systems, all from different application domains. The analysis develops from two different angles. Firstly, we measured the impact of the obliviousness property on the fault-proneness of the evaluated systems. The results show that 40% of reported faults were due to the lack of awareness among base code and aspects. The second analysis regarded the fault-proneness of the main aspect-oriented programming (AOP) mechanisms, namely pointcuts, advices and intertype declarations. The results indicate that these mechanisms present similar fault-proneness when we consider both the overall system and concern-specific implementations. Our findings are reinforced by means of statistical tests. In general, this result contradicts the common intuition stating that the use of pointcut languages is the main source of faults in AOP.

Architectural aspects are expected to modularize widely-scoped concerns that naturally crosscut the boundaries of system components at the software architecture level. However, there is no empirical knowledge about the positive and negative influences of aspectual decompositions on architecture stability. This paper analyzes the influence exerted by the aspect-oriented composition mechanisms in the stability of crosscutting concerns in an evolving multi-agent software architecture. Our investigation encompassed a comparative analysis of aspectual and non-aspectual decompositions based on different architectural styles. In particular, we assessed various facets of components' and compositions' stability through such alternative designs of the same multi-agent system using conventional quantitative indicators. The evaluation focused upon a number of architecturally-relevant changes that are typically performed through real-life maintenance tasks.

Recent research has recognised the potential of coupling ADLs with underlying runtime environments to support systematic and integrated "specification-todeployment" architectures. However, while some promising results have been obtained, much of this research has not considered the crucial issue of causally-connected dynamic reconfiguration and has considered only domain-specific areas. In this paper we discuss a specification-to-deployment architecture called Plastik that employs an extended generalpurpose ADL and is underpinned by an efficient runtime that is suited both for high-level application development and low-level systems development (e.g. embedded systems). Runtime reconfiguration is supported both at the ADL level and at the runtime level, and both programmed reconfiguration and adhoc reconfiguration are supported. The paper focuses on the mapping of ADL-level specifications to runtime instantiations and on the necessary runtime support for causally-connected dynamic reconfiguration.