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.

Data has become the lifeblood of modern business. However, as the volume of data grows exponentially, managing it has become an increasingly daunting task. The challenge is compounded by data coming from various sources, in different formats, and at different speeds. This is where data architecture provides a roadmap for describing, collecting, storing, processing, and analyzing data to meet business needs. A well-designed data architecture provides an abstract view of data-intensive applications, making it easier to transform data into valuable information. We must take these challenges seriously and invest in robust data architecture to effectively manage and use data to our advantage. To propose a comprehensive data architecture framework to improve data quality monitoring through automated quality checks. The architecture framework utilizes Model Driven Engineering (MDE) techniques. Its support for data-intensive architecture descriptions enables the automated generation of data quality checks. DAT Framework offers a comprehensive solution for data-intensive applications to model their architecture efficiently and monitor the quality of their data. It automates the entire process and improves precision and consistency in data quality monitoring. With DAT, architects and analysts gain access to a tool that simplifies their workflow and empowers them to make informed decisions based on reliable data insights. We have evaluated the DAT in five cases within various industry domains, demonstrating its effectiveness and efficiency. The evaluation demonstrates that the DAT framework achieves around 96% modeling accuracy and reduces modeling time by 63%, enhancing efficiency. Its automated data quality validation ensures reliable and consistent monitoring in data-intensive applications.

Context - The Internet of Things (IoT) refers to a distributed network of smart, connected devices that collaboratively sense, process, and act upon real-world environments. Designing such systems requires managing complex architectural concerns spanning software logic, hardware configuration, and spatial deployment, as well as validating non-functional properties like energy consumption and communication efficiency. Objective - To provide a unified, architecture-centric framework that supports the description, simulation, and automated code generation of IoT applications across software, hardware, and physical space dimensions. Method - We use Model Driven Engineering(MDE) approaches to develop CAPS, a framework that uniquely integrates multi-view architectural modeling, energy- and traffic-aware simulation via CupCarbon, and seamless generation of deployable Arduino code from high-level design models. Result - CAPS enables a traceable and cohesive development process from architectural design to physical deployment. Case studies from diverse domains demonstrate its ability to improve modeling expressiveness, maintain transformation fidelity, and reduce development time through automation. Conclusion - CAPS unifies architectural modeling, simulation, and code generation into a novel, end-to-end toolchain, addressing fragmentation in the IoT development lifecycle and enhancing early validation and traceability.

In the contemporary landscape of software development, the transition towards microservices architecture is often a critical step for organizations aiming to enhance scalability and maintainability. However, maintaining quality standards during this transition is of paramount importance to ensure the continued success of the software system. In this paper, we introduce a migration to microservices approach that strictly considers quality constraints as the main driver of the migration. The approach is built on top of the knowledge acquired in our previous work where we used antipatterns analysis for the refactoring of microservices derived from the monolith. We applied our quality-driven migration approach to the industrial case study of BIM Italia. To measure the effectiveness of our approach we performed a comparative analysis of the time, cost, and effort-related dimensions between the quality-driven migration and the refactoring processes presented and applied in the same company in our previous work. Our findings highlight the effectiveness of our quality-driven migration process in reducing time, costs, and effort, showcasing its merits in practice. This research emphasizes the importance of quality-driven migration strategies when transitioning from monolithic systems to microservices. By employing these principles, organizations can migrate to microservices not only realizing the expected benefits of microservices adoption but also upholding essential quality standards.

The Internet of Behaviors (IoB) puts human behavior at the core of engineering intelligent connected systems. IoB links the digital world to human behavior to integrate human-driven design, development, and adaptation processes. This paper defines the novel IoB concept with a constructed model based on a collective effort interacting with software engineers, human-computer interaction scientists, social scientists, and cognitive science communities. The model for IoB is created based on an exploratory study that synthesizes state-of-the-art analysis and experts interviews. The architecture of a real industry 4.0 manufacturing infrastructure helps to explain the IoB model and its application. The conceptual model was used to successfully implement a socio-technical infrastructure for a crowd monitoring and queue management system for the Uffizi Galleries, Florence, Italy. The experiment, which started in the fall of 2016 and was operational in the fall of 2018, used a data-driven approach to feed the system with real-time sensory data. It also incorporated prediction models on visitors’ mobility behavior. The system’s main objective was to capture human behavior, model it, and build a mechanism that considers changes, adapts in real-time, and continuously learns from repetitive behaviors. In addition to the conceptual model and the real-life evaluation, this paper provides recommendations from experts and gives future directions for IoB to become a significant technological advancement in the coming years.

Abstract Software product line engineering emerged as an effective approach for the development of families of software‐intensive systems in several industries. Although its use has been widely discussed and researched, there are still several open challenges for its industrial adoption and application. One of these is how to efficiently develop and reuse shared software artifacts, which have dependencies on the underlying electrical and hardware systems of products in a family. In this work, we report on our experience in tackling such a challenge in the railway industry and present a model‐based approach for the automatic generation of test scripts for product variants in software product lines. The proposed approach is the result of an effort leveraging the experiences and results from the technology transfer activities with our industrial partner Alstom SA in Sweden. We applied and evaluated the proposed approach on the Aventra software product line from Alstom SA. The evaluation showed that the proposed approach mitigates the development effort, development time, and consistency drawbacks associated with the traditional, manual creation of test scripts. We performed an online survey involving 37 engineers from Alstom SA for collecting feedback on the approach. The result of the survey further confirms the aforementioned benefits.

In this work, we report on our experience in defining and applying a model-based approach for the automatic generation of test scripts for product variants in software product lines. The proposed approach is the result of an effort leveraging the experiences and results from the technology transfer activities with our industrial partner Bombardier Transportation. The proposed approach employs metamodelling and model transformations for representing different testing artefacts and making their generation automatic. We demonstrate the industrial applicability and efficiency of the proposed approach using the Bombardier Transportation Aventra software product line. We observe that the proposed approach mitigates the development effort, time consumption and consistency drawbacks typical of traditional strategies.

Context: Managing Non-Functional Requirements (NFRs) in software projects is challenging, and projects that adopt Model-Driven Development (MDD) are no exception. Although several methods and techniques have been proposed to face this challenge, there is still little evidence on how NFRs are handled in MDD by practitioners. Knowing more about the state of the practice may help researchers to steer their research and practitioners to improve their daily work. Objective: In this paper, we present our findings from an interview-based survey conducted with practitioners working in 18 different companies from 6 European countries. From a practitioner's point of view, the paper shows what barriers and benefits the management of NFRs as part of the MDD process can bring to companies, how NFRs are supported by MDD approaches, and which strategies are followed when (some) types of NFRs are not supported by MDD approaches. Results: Our study shows that practitioners perceive MDD adoption as a complex process with little to no tool support for NFRs, reporting productivity and maintainability as the types of NFRs expected to be supported when MDD is adopted. But in general, companies adapt MDD to deal with NFRs. When NFRs are not supported, the generated code is sometimes changed manually, thus compromising the maintainability of the software developed. However, the interviewed practitioners claim that the benefits of using MDD outweight the extra effort required by these manual adaptations. Conclusion: Overall, the results indicate that it is important for practitioners to handle `NFRs in MDD, but further research is necessary in order to lower the barrier for supporting a broad spectrum of NFRs with MDD. Still, much conceptual and tool implementation work seems to be necessary to lower the barrier of integrating the broad spectrum of NFRs in practice.

Architecting IoT systems able to guarantee Quality of Service (QoS) levels can be a challenging task due to the inherent uncertainties (induced by changes in e.g., energy availability, network traffic) that they are subject to. Existing work has shown that machine learning (ML) techniques can be effectively used at run time for selecting self-adaptation patterns that can help maintain adequate QoS levels. However, this class of approach suffers from learning bias, which induces accuracy problems that might lead to sub-optimal (or even unfeasible) adaptations in some situations. To overcome this limitation, we propose an approach for proactive self-adaptation which combines ML and formal quantitative verification (probabilistic model checking). In our approach, ML is tasked with selecting the best adaptation pattern for a given scenario, and quantitative verification checks the feasibility of the adaptation decision, preventing the execution of unfeasible adaptations and providing feedback to the ML engine which helps to achieve faster convergence towards optimal decisions. The results of our evaluation show that our approach is able to produce better decisions than ML and quantitative verification used in isolation.

The use of IoT systems is increasing day by day. However, these systems due to their heterogeneity and inherently dynamic nature, face different uncertainties from the context, environment, etc. Such uncertainties can have a big impact on the overall system QoS, especially on energy efficiency and data traffic. This calls for better ways of architecting IoT systems that may self-adapt to keep the desired QoS. This paper presents an approach that leverages the use of machine learning (ML) techniques to perform a proactive adaptation of IoT architectures using self-adaptation patterns. It i) continuously monitors the QoS parameters; ii) forecasts possible deviations from the acceptable QoS parameters; iii) selects the best adaptation pattern based on forecasts using reinforcement learning (RL) techniques; iv) checks the quality of the selected decision using feedback mechanisms; and v) continuously performs the loop of the forecast, adaptation, and feedback. The results of our evaluations show that our approach can provide accurate QoS forecasts and further improve the energy efficiency of the system while maintaining the required data traffic.

This proposal is about a study we recently published in the IEEE Transaction of Software Engineering journal [4].

Context: Collaborative Model-Driven Software Engineering (MDSE) consists of methods and techniques where multiple stakeholders manage, collaborate, and are aware of each others' work on shared models. Objective: Collaborative MDSE is attracting research efforts from different areas, resulting in a variegated scientific body of knowledge. This study aims at identifying, classifying, and understanding existing collaborative MDSE approaches. Method: We designed and conducted a systematic mapping study. Starting from over 3,000 potentially relevant studies, we applied a rigorous selection procedure resulting in 106 selected papers, further clustered into 48 primary studies along a time span of 19 years. We rigorously defined and applied a classification framework and extracted key information from each selected study for subsequent analysis. Results: Our analysis revealed the following main fidings: (i) there is a growing scientific interest on collaborative MDSE in the last years; (ii) multi-view modeling, validation support, reuse, and branching are more rarely covered with respect to other aspects about collaborative MDSE; (iii) different primary studies focus differently on individual dimensions of collaborative MDSE (i.e., model management, collaboration, and communication); (iv) most approaches are language-specific, with a prominence of UML-based approaches; (v) few approaches support the interplay between synchronous and asynchronous collaboration. Conclusion: This study gives a solid foundation for classifying existing and future approaches for collaborative MDSE. Researchers and practitioners can use our results for identifying existing research/technical gaps to attack, better scoping their own contributions, or understanding existing ones.

This paper proposes CAPS, an architecture-driven modeling framework for the development of Situational Aware Cyber-Physical Systems. Situational Awareness involves being aware of what ishappening in the surroundings, and using this information to decide and act. It has been recognized as a critical, yet often elusive, foundation for successful decision-making in complex systems. With the advent of cyber-physical systems (CPS), situational awareness is playing an increasingly important role especially in crowd and fleets management, infrastructure monitoring, and smart city applications. While specializing cyber physical systems, Situational Aware CPS requires the continuous monitoring of environmental conditions and events with respect to time and space. New architectural concerns arise, especially related to the sense, compute & communication paradigm, the use of domain-specific hardware components, and the cyber-physical space dimension. This work illustrates the CAPS modeling languages used to describe the software architecture, hardware configuration, and physical space views for a situational aware CPS.

Model-Driven Development (MDD) is no longer a novel development paradigm. It has become mature from a research perspective and recent studies show its adoption in industry. Still, some issues remain a challenge. Among them, we are interested in the treatment of non-functional requirements (NFRs) in MDD processes. Very few MDD approaches have been reported to deal with NFRs (and they do it in a limited way). However, it is clear that NFRs need to be considered somehow in the final product of the MDD process. To better understand how NFRs are integrated into the existing MDD approaches, we have initiated the NFR4MDD project, a multi-national empirical study, based on interviews with companies working on MDD projects. Our project aims at surveying the state of the practice for this topic. In this paper, we summarize our research protocol and present the current status of our study. The discussion will focus on the peculiarities of our study's context and organization involving about 20 researchers from 8 European countries.

A previous study, run by some of the authors in collaboration with practitioners, has emphasized the need to improve architectural languages in order to (i) make them simple and intuitive enough to communicate effectively with project stakeholders, and (ii) enable formality and rigour to allow analysis and other automated tasks. Although a multitude of languages have been created by researchers and practitioners, they rarely address both of these needs. In order to reconcile these divergent needs, this paper presents an approach that (i) combines the rigorous foundations of model-driven engineering with the usability of semantic wikis, and (ii) enables continuous syncronization between them, this allows software architects to simultaneously use wiki pages for communication and models for model-based analysis and manipulation. In this paper we explain how we applied the approach to an industry-inspired case study using the Semantic Media Wiki wiki engine and a model-driven architecture description implemented within the Eclipse Modeling Framework. We also discuss how our approach can be generalized to other wiki-based and model-driven technologies.

When architecting software systems, architects (with the contribution of other stakeholders) make several design decisions. These decisions could be related to the selection of the right components and connectors, the architectural style to be used, the distribution of various components, the deployment of software components into hardware devices, etc. Many methods have been proposed by the research community to help documenting several aspects of architectural design decisions including design alternatives, stakeholder concerns, decisions and the rationale for making such decisions and enhancing the decision-making process. Still, very little has been done to truly understand how architectural design decisions are made by group of practitioners, what information is documented, the tools used for helping documenting and how conflicts are managed. This study, by looking at principles and techniques for group decision making coming from other disciplines, aims to understand: a) how practitioners make group decisions in architecting software systems, b) how practiced group decision-making techniques relate to state-of-the-art techniques, and c) challenges companies face when making architecture-related group decisions. The study is conducted by using a questionnaire distributed to practitioners and researchers involved in group design decisions in industry. The results are used to drive some recommendations to improve the current group design decision process.

Mobile-enabled systems make use of mobile devices, RFID tags, sensor nodes, and other computing-enabled mobile devices to gather contextual data from users and the surrounding changing environment. Such systems produce computational data that can be stored and used in the field, shared between mobile and resident devices, and potentially uploaded to local servers or the cloud — a distributed, heterogeneous, context-aware, data production and consumption paradigm. Mobile-enabled systems have characteristics that make them different from traditional systems, such as limited resources, increased vulnerability, performance and reliability variability, and a finite energy source. There is significantly higher unpredictability in the execution environment of mobile apps. This workshop brings together experts from the software engineering and mobile computing communities — with notable participation from researchers and practitioners in the field of distributed systems, enterprise systems, cloud systems, ubiquitous computing, wireless sensor networks, and pervasive computing — to share results and open issues in the area of software engineering of mobile-enabled systems.

This paper is a report on The 8th IEEE/ACM International Workshop on Automation of Software Test (AST 2013) at the 35th International Conference on Software Engineering (ICSE 2013). It sets a special theme on testing-as-a-service (TaaS). Keynote speech and charette discussions are organized around this special theme. Eighteen full research papers and six short papers will be presented in the two-day workshop. The report will give the background of the workshop and the selection of the special theme, and report on the organization of the workshop. The provisional program will be presented with a list of the sessions and papers to be presented at the workshop.

Many times we are faced with the proliferation of definitions, concepts, languages, and tools in certain (research) topics. But often there is a gap between what is provided by existing technologies and what is needed by their users. The strengths, limitations, and needs of the available technologies can be dubious. The same applies to software architectures, and specifically to languages designed to represent architectural models. Tens of different architectural languages have been introduced by the research and industrial communities in the last two decades. However, it is unclear if they fulfill the user's perceived needs in architectural description. As a way to plan for next generation languages for architectural description, this study analyzes practitioners' perceived strengths, limitations, and needs associated with existing languages for software architecture modeling in industry. We run a survey by interviewing 48 practitioners from 40 different IT companies in 15 countries. Each participant is asked to fill in a questionnaire of 51 questions. By analyzing the data collected through this study, we have concluded that 1) while practitioners are generally satisfied with the design capabilities provided by the languages they use, they are dissatisfied with the architectural language analysis features and their abilities to define extra-functional properties; 2) architectural languages used in practice mostly originate from industrial development instead of from academic research; 3) more formality and better usability are required of an architectural language.

SUMMARY To teach global software engineering, we devised a complementary distributed module with a shared project involving both local and international teams. In local teams, students are located at the same university and trained in one of the two complementary topics. In international teams, students are located at two different universities and trained in one of the two complementary topics. This study empirically investigates whether the students in the international teams can compensate the extra effort required to deal with communication, coordination, and collaboration issues that characterize global software engineering projects with learning by osmosis (i.e., by transferring knowledge among globally distributed teams trained on different topics). The results show that there was no statistically significant difference between the performance of local and international teams. We assert that the students in the international and local teams perform equally well, thanks to learning by osmosis. However, our analysis of the self‐reported questionnaire data revealed that most of the participants (i.e., 70%) would like to work in local teams in real‐life project, 74% of the participants thought international teams were less efficient, and 41% of the participants reported lack of trust in their international team members compared with their local team members. Copyright © 2011 John Wiley & Sons, Ltd.

In run-time evolving systems, components may evolve while the system is being operated. Unsafe run-time changes may compromise the correct execution of the entire system. Traditional design-time verification techniques difficultly cope with run-time changes, and run-time monitoring may detect disfunctions only too late, when the failure arises. The desire would be to define advanced monitors with the ability to predict and prevent the potential errors happening in the future. In this direction, this paper proposes CASSANDRA, a new approach that by combining design-time and run-time analysis techniques, can “look ahead” in the near execution future, and predict potential failures. During run-time we on-the-fly construct a model of the future k-step global state space according to design-time specifications and the current execution state. Consequently, we can run-time check whether possible failures might happen in the future.

This paper summarizes the workshop on Architecture-Based Testing and System Validation which was organized in conjunction with the 9th Working IEEE/IFIP Conference on Software Architecture. The main goal of the workshop was to bring together researchers and practitioners both from the architecture design and software testing community to enable architecture-based software testing.

Despite the flourishing of languages to describe software architectures, existing Architecture Description Languages (ADLs) are still far away from what it is actually needed. In fact, while they support a traditional perception of a Software Architecture (SA) as a set of constituting elements (such as components, connectors and interfaces), they mostly fail to capture multiple stakeholders concerns and their design decisions that represent a broader view of SA being accepted today. Next generation ADLs must cope with various and ever evolving stakeholder concerns by employing semantic extension mechanisms.

Most practising software architects operate within an architecture framework which is a coordinated set of viewpoints, models and notations prescribed for them. Whereas architecture frameworks are defined to varying degrees of rigour and offer varying levels of tool support, they tend to be closed: constituent elements are defined in different non-standard ways, they are not re-usable, and the creation of other frameworks requires a complete rework.With the aim to manage this issue, this paper presents MEGAF, an infrastructure for realizing architecture frameworks, which can be used to create architecture descriptions. It builds upon the conceptual foundations of ISO/IEC 42010 for architecture description. MEGAF is realized through megamodeling techniques and is implemented via Eclipse plugins.

The Web Services Choreography Description Language (WS-CDL) is a specification developed by the W3C and can be viewed as a blueprint for the development of end-point services. Consequently, it is worth providing a systematic approach for its modeling, analysis and verification. The Unified Modeling Language (UML) is an industry standard for modeling. Applying UML to model WS-CDL is obviously a promising solution to bring together academics and practitioners through a unique standard language. In this paper, we propose to use different UML diagrams to model WS-CDL. UML Component Diagram is used to model the underlying structure of WS-CDL. UML Sequence Diagram is utilized to model the activities in WS-CDL. UML State Machine Diagram is utilized to model the behaviors of each role participating in a WS-CDL specification. We then enrich the UML State Machine Diagram with data by the use of UML Class Diagram. Given the UML specification of WS-CDL, we then provide a systematic way of formally analyzing and verifying WS-CDL against desired properties. Some experiments show that our approach can verify structural, behavioral and data properties in a middle-scale data-enriched WS-CDL specification.

Many architectural languages have been proposed in the last 15 years, each one with the chief aim of becoming the ideal language for specifying software architectures. What is evident nowadays, instead, is that architectural languages are defined by stakeholder concerns. Capturing all such concerns within a single, narrowly focused notation is impossible. At the same time, it is also impractical to define and use a "universal" notation, such as UML. As a result, many domain-specific notations for architectural modeling have been proposed, each one focusing on a specific application domain, analysis type, or modeling environment. As a drawback, a proliferation of languages exists, each one with its own specific notation, tools, and domain specificity. No effective interoperability is possible to date. Therefore, if a software architect has to model a concern not supported by his own language/tool, he has to manually transform (and, eventually, keep aligned) the available architectural specification into the required language/tool. This paper presents DUALLy, an automated framework that allows architectural languages and tools interoperability. Given a number of architectural languages and tools, they can all interoperate thanks to automated model transformation techniques. DUALLy is implemented as an Eclipse plugin. Putting it in practice, we apply the DUALLy approach to the Darwin/FSP ADL and to a UML2.0 profile for software architectures. By making use of an industrial complex system, we transform a UML software architecture specification in Darwin/FSP, make some verifications by using LTSA, and reflect changes required by the verifications back to the UML specification.

DUALLY is a framework that allows architectural languages interoperability through automated model transformation techniques. Any transformation among ADLs is defined in DUALLY by passing through A0that is an extensible semantic core set of modeling elements. In this paper we describe the integration of AADL and the corresponding OSATE tool-set in DUALLY. Once AADL is hooked to A0, it is automatically integrated with the network of languages already integrated in DUALLY. In particular, we show how it is possible, in an easy way, to obtain a UML specification and to model check AADL and behavioral annex specifications through LTSA.

Introduced in the early stages of software development, the Charmy framework assists the software architect in making and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move forward to the construction of a suboptimal software architecture. Charmy aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. Charmy simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.

Present-day software engineering combines technical and social skills, as well as collaboration among people with different backgrounds (e.g. due to global development and outsourcing). In this paper we address the problem of teaching "globally distributed development", and specifically software design. Our goal is to develop a joint Master course teaching software design in a global setting. To this end, we contribute with a list of characteristics to be developed, in the form of an 'orientation map' for educators. We use this map to build a joint course between two European universities.

The Web Services Choreography Description Language (WS-CDL) is a specification developed by the W3C that can be viewed as a blueprint for the development of end-point services. Considering that it is the W3C candidate recommendation for web service choreography, it is worth providing a systematic approach for its modeling, analysis and verification. The Unified Modeling Language (UML) is the de facto industry standard for modeling. Applying UML to model WS-CDL is obviously a promising solution to bring together academics and practitioners in through a unique standard language. This paper proposes to use different UML diagrams to model WS-CDL. Given the UML specification of WS-CDL, we then provide a systematic way of formally analyzing and verifying WS-CDL.

Provides notice of upcoming conference events of interest to practitioners and researchers.

Nowadays different notations for architectural modeling have been proposed, each one focussing on a specific application domain, analysis type, or modeling environment. No effective interoperability is possible to date. DUALLY is an automated framework that aims to offer an answer to this need allowing architectural languages and tools interoperability. DUALLY has been implemented as an Eclipse plugin and it is based on model transformation techniques. This demonstration paper shows DUALLY by applying its approach to two outstanding architectural description languages.

Simulation is a mean for verifying the quality of an architectural specification. Some approaches have been proposed in the past. Each approach has its own internal simulation engine, and allows for certain types of simulations. Goal of this paper is to propose SASlM, a software architecture-level simulation technique for modeling and simulating architectural specifications. It improves existing techniques, by permitting various kinds of simulation, and making use of SPIN as external simulator. This allows a real and useful integration between simulation and exhaustive verification. The paper discusses SASlM and compares it with existing techniques.

This paper presents a European Master programme on global software engineering (SE), being put forward by four leading institutions from Sweden, UK, Netherlands and Italy. The Global SE European Master (GSEEM) programme aims to provide students with an excellence in SE based on sound theoretical foundations and practical experience, as well as prepare them to participate in global development of complex and large software systems. GSEEM has been designed with three noteworthy aspects: 1) Three specialization profiles in which the consortium excels: Software Architecting, Real-time Embedded Systems Engineering, and Web Systems and Services Engineering. 2) Two market-driven routes: "professional" to work as professionals, and "scientific" to continue the education towards research degrees. 3) An innovative concept of "shared modules", delivered together by multiple institutions. Four types of shared modules are foreseen: "parallel" twin modules which run remotely between universities, "shifted" modules which teach SE concepts incrementally with shifts in study locations and timeline ,"complementary" modules in which complementary SE concepts are taught in parallel through shared projects, and "common" modules which share the presentations and the project. The profiles realize "integrated knowledge" by complementing partial knowledge available at partner institutions. The paper explains how GSEEM achieves the objectives of educating global software engineers.

This year ESCE/FSE launches the new Widened Software Engineering (WISE) track with an explicit aim to widen international participation, especially from countries which are usually under-represented in the conference audience.

Fault tolerance engineering has been advocated as one of the main approaches to ensuring the overall system dependability. The 2nd International Workshop on Engineering Fault Tolerant Systems (EFTS 2007) aims to investigate how fault tolerance mechanisms can be taken into account when engineering complex software systems and to improve our understanding of where and how fault-tolerance should be integrated in the software life-cycle. The focus of the workshop is on developing novel models to be applied at different abstraction levels (requirements, architecture and design models for fault tolerance, together with new implementation schemes), innovative technologies (tools and frameworks for implementing distributed fault tolerant systems) and advanced verification environments (to assess the achieved level of fault tolerance and to evaluate the dependability properties of the systems). Recently there has been a growing interest in the areas directly related and overlapping with fault tolerance, such as self-healing, resilience, self-adaptation and self-management. The topics related to engineering of systems with such properties are in the scope of the workshop as the intention is to improve the current understanding of how fault tolerance engineering can benefit from research on these areas.

Has software architecture-based testing any characteristic which makes it unique with respect to other testing techniques? This recurrent question will be analyzed in this short paper, providing some initial solution, while leaving ample space for discussion.

While typical solutions focus on fault tolerance (and specifically, exception handling) during the design and implementation phases of the software life-cycle (e.g., Java and Windows NT exception handling), more recently the need for explicit exception handling solutions during the entire life cycle has been advocated by some researchers. Several solutions have been proposed for fault tolerance via exception handling at the software architecture and component levels. This paper describes how the two concepts of fault tolerance and software architectures have been integrated so far. It is structured in two parts (overview on fault tolerance and exception handling, and integrating fault tolerance into software architecture) and is based on a survey study on architecting fault tolerant systems where more than fifteen approaches have been analyzed and classified. This paper concludes by identifying those issues that remain still open and require deeper investigation.

Two main issues need to be covered when dealing with the dependability of component-based systems: quality assurance of reusable software components and quality assurance of the assembled component-based system. By focussing on the assembly, a software architecture specification of a component-based system allows to explicitly model the structure and required system behavior by specifying how components and connectors are intended to interact. Software architecture-based conformance testing techniques can yield confidence on the implementation conformance to expected structural and behavioral properties as specified in the architectural models. In this paper we explore software architecture-based regression testing methods that enable reuse of earlier saved results to test if a different assembly of components conforms to the evolved software architecture. The approach is presented through a running example.

CHARMY is a framework for designing and validating architectural specifications. In the early stages of the software development process, the CHARMY framework assists the software architect in the design and validation phases. To increase its usability in an industrial context, the tool allows the use of UML-like notations to graphically design the system. Once the design is done, a formal prototype is automatically created for simulation and analysis purposes. The framework provides extensibility mechanisms to enable the introduction of new design and analysis features.

Many formal languages have been proposed so far to describe software architectures (SA), but only very few of them are still supported and used in practical contexts. Many UML profiles and extensions have been provided when UML became a standard, in order to model as much as possible architectural concepts. They allow for an easy integration in industrial processes, however, different analysis techniques and domains still require different notations. In fact, since different communities require different information to be put into a diagram, depending on which architectural design aspects should be represented and analyzed, the idea of an unified UML language for SA is not adequate. Building on these considerations, we propose DUALLY, a core set of UML concepts, well suited for SA modeling, together with a framework which provides extensibility mechanisms to adapt the initial notation, in order to meet different needs.

In a software system, software processes can be concurrently run by system actors (e.g. agents, components), by making use of shared or dedicated software resources. Coordination is a research area oriented to understand, explicitly model and analyze how activities can depend on each other, in a concurrent system. Many coordination models and languages have been presented in the last few years in order to make coordination a first class entity in the development of a software system. However, what usually happens, is that coordination is described late in the software development and it is not integrated in a typical software process. What we claim, with our research, is that if coordination becomes explicit and formalized as soon as possible in the software life cycle, then it is possible to create coordination-aware software systems, which are easily maintained and developed. What we present, in the following, is a software engineering view of coordination. Diagrams produced during a UML-based software modeling, are analyzed in order to help a software engineer in the difficult task to elicit coordination requirements from informal ones. We show how UML models can drive an elicitation process in order to identify coordination requirements, and can graphically describe which elements need coordination.

Our research deals with the use of software architecture (SA) as a reference model for testing the conformance of an implemented system with respect to its architectural specification. We exploit the specification of SA dynamics to identify useful schemes of interactions between system components and to select test classes corresponding to relevant architectural behaviors. The SA dynamics is modeled by labeled transition systems (LTSs). The approach consists of deriving suitable LTS abstractions called ALTSs. ALTSs offer specific views of SA dynamics by concentrating on relevant features and abstracting away from uninteresting ones. Intuitively, deriving an adequate set of test classes entails deriving a set of paths that appropriately cover the ALTS. Next, a relation between these abstract SA tests and more concrete, executable tests needs to be established so that the architectural tests derived can be refined into code-level tests. We use the TRMCS case study to illustrate our hands-on experience. We discuss the insights gained and highlight some issues, problems, and solutions of general interest in architecture-based testing.

In recent years the necessity for handling different aspects of the system separately has introduced the need to represent SA (software architectures) from different viewpoints. In particular, behavioral views are recognized to be one of the most attractive features in the SA description, and in practical contexts, state diagrams and scenarios are the most widely used tools to model this view. Although very expressive, this approach has two drawbacks: system specification incompleteness and view consistency. Our work can be put in this context with the aim of managing incompleteness and checking view conformance: we propose the use of state diagrams and scenario models for representing system dynamics at the architectural level; they can be incomplete and we want to prove that they describe, from different viewpoints, the same system behavior. To reach this goal, we use the SPIN model checker and we implement a tool to manage the translation of architectural models in Promela and LTL.

The paper presents an approach to derive test plans for the conformance testing of a system implementation with respect to the formal description of its Software Architecture (SA). The SA describes a system in terms of its components and connections, therefore the derived test plans address the integration testing phase. We base our approach on a Labelled Transition System (LTS) modeling the SA dynamics, and on suitable abstractions of it, the Abstract Labelled Transition Systems (ALTSs). ALTSs oer specic views of the SA dynamics by concentrating on relevant features and abstracting away from uninteresting ones. ALTS is a tool we provide the software architect with allow him/her to focus on relevant behavioral patterns and more easily identify those ones that are more meaningful for validation purposes. Intuitively deriving an adequate set of functional test classes means deriving a set of paths appropriately covering the ALTS. In the paper we describe our approach in the scope of a...

Software architectures can play a role in improving the testing process of complex systems. In particular descriptions of the software architecture can be useful to drive integration testing, since they supply information about how the software is structured in parts and how those parts (are expected to) interact. We propose to use formal architectural descriptions to model the "interesting" behaviour of the system. This model is at a right level of abstraction to be used as a formal base on which integration test strategies can be devised. Starting from a formal description of the software architecture (given in the CHAM formalism), we first derive a graph of all the possible behaviours of the system in terms of the interactions between its components. This graph contains altogether the information we need for the planning of integration testing. On this comprehensive model, we then identify a suitable set of reduced graphs, each highlighting specific architectural properties of the system. These reduced graphs can be used for the generation of integration tests according to a coverage strategy, analogously to what happens with the control and data flow graphs in unit testing.