Abstract: Building large and complex systems in one step (the 'big bang' approach) is a very challenging task, given that humans can only deal with a limited measure of complexity at a time. A more practical approach would be to build such systems incrementally, i.e. iteratively increment an incomplete version of the system under construction until the system is completed. In software engineering, there are such approaches, but they are generally top-down, and not component-based. In this paper we present a component-based approach, which is bottom-up, and demonstrate its feasibility by applying it to the CoCoME example.

Abstract: Strong pressure on deployment of embedded control systems on a low-cost hardware leads to the need of optimizing software architectures to minimize resource demands. Nevertheless, releasing the resources not needed in specific phases of system execution is only rarely supported by todays component frameworks, mainly since information about the system state is spread over several components, which makes the idea hard to implement.The paper introduces a formal model of property networks allowing for efficient capture of modifications of architecture-relevant information and shows, how this model can be used to employ the concept of modes for system architectures in hierarchical component systems.

Abstract: The recent trend towards applying component-based and model-driven approaches also to the development of safety-critical real-time embedded systems, opens new possibilities for model-level analysis of aspects that traditionally are analysed very late in the development when the system has been fully implemented. For real-time systems, the temporal aspect is as important as the functional to the overall correctness of the system, and thus timing analysis in different forms play a key role in their development. This paper presents the timing analysis of ProCom, a component model specifically targeting distributed real-time embedded systems, focusing in particular on three methods for compositional model-level analysis of worst-case execution time.

Abstract: Today's real-time embedded systems operate in frequently changing environments on which they react by self-adaptations Such an approach needs adequate modeling support of these reconfigurations to enable verification of safety properties, eg, by timed model checking Component-based development of such systems realizes these self-adaptations by structural reconfigurations of components and their connectors However, component models proposed in literature do not support reconfigurable components in real-time embedded context but focus on other domains like business information systems In this paper, we present an extension of our modeling language MechatronicUML to support structural reconfigurations taking the specific requirements of our domain into account Based on the proposed extension we outline our research roadmap to achieve verification and realization of systems modeled in MechatronicUML

Abstract: An important aspect of the quality assurance of large component repositories is the logical coherence of component metadata. We argue that it is possible to identify certain classes of such problems by checking relevant properties of the possible future repositories into which the current repository may evolve. In order to make a complete analysis of all possible futures effective however, one needs a way to construct a finite set of representatives of this infinite set of potential futures. We define a class of properties for which this can be done. We illustrate the practical usefulness of the approach with two quality assurance applications: (i) establishing the amount of "forced upgrades" induced by introducing new versions of existing components in a repository, and (ii) identifying outdated components that need to be upgraded in order to ever be installable in the future. For both applications we provide experience reports obtained on the Debian distribution.

Abstract: In 2012, the International Symposium on Component-based Software Engineering (CBSE) is being organized for the 15th time. This is a great opportunity to take a step back and reflect on the impact of the symposium over these 15 years. Several interesting questions immediately come to mind: What were the main topics of interest in the community? What is the maturity of the field? What is the research CBSE Symposia impact? Who are the mots involved researches and researchers centers? In order to answer these questions we have performed a systematic review of 318 papers published under CBSE. In this paper we provide answers about the impact of the event, list and categorize the most frequent topics, and give some statistical data about the event during this period.

Abstract: Modern service-oriented enterprise systems have increasingly complex and dynamic loosely-coupled architectures that often exhibit poor performance and resource efficiency and have high operating costs. This is due to the inability to predict at run-time the effect of dynamic changes in the system environment and adapt the system configuration accordingly. Architecture-level performance models provide a powerful tool for performance prediction, however, current approaches to modeling the execution context of software components are not suitable for use at run-time. In this paper, we analyze the typical online performance prediction scenarios and propose a novel performance meta-model for expressing and resolving parameter and context dependencies, specifically designed for use in online scenarios. We motivate and validate our approach in the context of a realistic and representative online performance prediction scenario based on the SPECjEnterprise2010 standard benchmark.

Abstract: Component-based software engineering (CBSE) is becoming a prominent solution to the development of complex embedded systems. Meanwhile, partitioning system behavior into different modes is an effective approach to reduce system complexity. Combining the two, we get a component-based multi-mode system, for which a key issue is its mode switch handling. The mode switch of such a system corresponds to the joint mode switches of many hierarchically organized components. Such a composable mode switch is not trivial as it amounts to coordinate the mode switches of different components. In this paper, we identify the major challenges of the composable mode switch handling and classify existing approaches with respect to how they handle these challenges. We also provide a more detailed presentation of the corresponding solutions included in our approach -- the Mode Switch Logic (MSL).

Abstract: One of the key issues that should be considered when addressing reliable evolution is to place a software system in a consistent status before and after change. This issue becomes more critical at runtime because it may lead to the failure on running mission-critical systems. In order to place the affected elements in a safe state before dynamic changes take place, the notion of tranquility has been proposed to make quiescence criterion less disruptive and easier to obtain. However, it only ensures consistency in applications with restrictive black-box design. In this paper, an architecture-based approach is proposed to preserve global consistency during runtime reconfiguration of component-based systems in distributed contexts. An initial evaluation through a prototypical implementation shows that this approach not only enables tranquility to be applicable for distributed transactions, but also significantly reduces required time to achieve a safe state and increases system availability during runtime evolution.

Abstract: While the notion of components has had a major positive impact on the way software architectures are conceptualized and represented, they have had relatively little impact on the processes and procedures used to develop software systems. In terms of software development processes, use case-driven iterative and incremental development has become the predominant paradigm, which at best ignores components and at worse is even antagonistic to them. However, use-case driven, I&I development (as popularized by agile methods) and component-based development have opposite strengths and weaknesses. The former's techniques for risk mitigation and prioritization greatly reduce the risks associated with software engineering, but often give rise to suboptimal architectures that emerge in a semi-ad hoc fashion over time. In contrast, the latter gives rise to robust, optimized architectures, but to date has poor process support. In principle, therefore, there is a lot to be gained by fundamentally aligning the core principles of component-based and I&I development into a single, unified development approach. In this position paper we discuss the key issues involved in attaining such a synergy and suggest some core ideas for merging the principles of component-based and I&I development.

Abstract: In-production performance monitoring is required for dynamic and modular systems open to third-party applications such as the OSGi-based smart home box that home actors envision today. Existing approaches are not suitable for inproduction monitoring as they generally induce a strong persistent overhead. This paper proposes a progressive and localized monitoring system that is able to dynamically activate/deactivate and tune the accuracy of monitoring mechanisms depending on detected performance issues. In particular, it proposes to build a proxy-aware service registry in order to inject proxies on-the-fly without stopping bundles and it advocates the use of localized sampling. Our evaluation shows that the overhead of our monitoring system is only 2% when idle and comparable with traditional systems when completely active(around 20%).

Abstract: Dynamic evolution is a key aspect of the design, development, and maintenance of complex and distributed software systems built by integrating components. Evolution, traditionally obtained by producing software upgrades, may derive from changes in the requirements or in the environment, from the need to incorporate new implemented versions and optimizations. Upgrades typically require the software system to be shutdown, updated and restarted. However a large number of applications require to offer a continuous service and need to be updated at run-time. This paper addresses the problem of dynamic update of software components. A model-based approach is proposed to classify different classes of dynamic component update. For each of these classes, a set of updatable states of the current component is identified and mapped into a state of its new version. The proposed state transformation allows the component to be updated at run-time and satisfies the correctness criterion we defined in an earlier work.

Abstract: Dynamic runtime adaptations are a key feature for long-running applications. One of the most used languages for writing this kind of applications is Java, due to its reflection features, popularity and dynamism. However, as dynamic scripting languages (such as Python and Javascript) increase in popularity, it is desirable to be able to conceive long-running applications with them too. This paper introduces iPOPO and Pelix, a Python-based service-oriented component model and dynamic service platform respectively, which are inspired on two popular Java technologies for the development of long-running applications: the iPOJO component model and the OSGi Service Platform. To illustrate the approach, a usage of iPOPO and Pelix is presented on the context of mediation software.

Abstract: Software architecture has become a sensitive discipline, which consists in concretizing the user requirements into a set of artifacts that can be used to model and reason about the software to be developed. However, the architect often relies on its own knowledge to map domain-specific requirements onto generic software abstractions. Most of the time, this leads to the definition of repetitive tasks and architecture fragments, which can be particularly error prone. We therefore believe that architects need a more flexible approach to cope with the definition of domain-specific architectures by leveraging general purpose architecture description languages. This paper introduces the FraSCAla framework as an adaptive architectural framework that can be used to rapidly prototype and experiment domain-specific ADLs in order to catalyze the definition and to improve the reliability of software architectures. We demonstrate the merits of this approach on two representative architectural patterns of component-based software architectures.

Abstract: We present a new automata-based interface model describing the interaction behavior of software components. Contrary to earlier component- or interface-based approaches, the interface model we propose specifies all the non-blockable interaction behaviors of a component with any environment. To this end, we develop an algorithm to compute the unblockable interaction behavior, called the interface model of a component, from its execution model. Based on this model, we introduce composition operators for the components and prove important compositionality results, showing the conditions under which composition of interface models preserves unblockable sequences of provided services.

Abstract: Engineering of highly reliable systems requires support of sophisticated design methods allowing software architects to competently decide between various design alternatives already early in the development process. Architecture-based reliability prediction provides such capability. The formalisms and analytical methods employed by existing approaches are however often limited to a single reliability measure (the probability of failure on demand) and consideration of behavioural uncertainty (focusing on the uncertainty in model parameters, not the behaviour itself). This paper presents a formal reliability assessment approach for component-based systems based on the probabilistic model checking of various reliability-related properties specified in probabilistic linear temporal logic (PLTL). The systems are formalized as Markov decision processes (MDP), which allows software architects to encode behavioural uncertainties into the models in terms of nondeterministic (scheduler-decided) choices in the MDP.

Abstract: It is considered good practice in control software design to distinguish computation and coordination on the architectural level Current component models largely fail to provide distinct abstractions for that purpose In this paper, we introduce such distinct abstractions In particular, we introduce controller patterns, an abstraction for defining coordination in the context of component-based software development We present their definition and demonstrate their usage in a case study, conducted in our prototype tool

Abstract: Invasive Software Composition (ISC) provides a generic, flexible and powerful approach for software composition. Based upon the principles of grey-box composition, ISC systems can compose partial programs (fragments) and provide syntactic (context-free) correct composition results. However, many composition domains require additional composition constraints for fragments (fragment contracts) to guarantee well-formedness of composition results. In this paper, we propose the application of reference attribute grammars (RAGs) for the implementation of ISC systems supporting fragment contracts. We show how RAGs can be used to specify semantics-aware fragment component models on top of a language specification and introduce RAG-based fragment contracts to enable advanced guarantees for fragment composition.

Abstract: Pervasive systems have experienced an increase in demand due to the evolution and popularity of mobile devices and embedded systems. The development of applications for these systems imposes new challenges due to the necessity of adapting these applications both to the changes in the environment and to the resource-constrained devices (e.g. limited battery, memory and CPU) in which they run. These challenges are: (1) the same services are required by most applications for pervasive systems, and thus should be modeled as separate, ready-to-use (re)usable solutions; (2) services need to be customized to the requirements of applications, by generating different versions of the same service containing only the required functionality, and (3) the same service needs to be customized to the different devices in which a same application will run (e.g. with different operating systems, different memory and CPU capacities or different communication technologies). In order to consider all of the above challenges, in this paper we present a software product line approach that permits modelling the variability of these services using feature models, automatically generating different configurations of their software architecture depending on the particular requirements of each application. We use this approach to model typical services of pervasive systems, such as context-awareness and communication, and to evaluate the degree of variability, of reuse and of separation of concerns of these services.

Abstract: Regarding the design and the development of distributed applications, service, component and agent oriented approaches provide their own interests and characteristics. Most of current applications are designed according to a single approach but it would be interesting to use these approaches simultaneously to provide a more efficient paradigm for developing distributed applications. Our goal is to integrate these three approaches by focusing on the concepts of service and interaction as key points, notably regarding cooperation between agents and components. The service is the business abstraction of a component or agent and it represents a pivot to support its interactions. We presented previously our service, component and agent models for this purpose. In this paper, we establish the semantic mapping rules between the concepts of each of these domains to be able to move on from one model to another.

Abstract: The 15th ACM SIGSOFT Symposium on Component Based Software Engineering (CBSE 2012) marks a milestone in the research on using components to build software systems in an efficient way. Over the years, this symposium has established a track record of bringing together researchers and practitioners from a variety of disciplines to promote a better understanding of CBSE from diverse perspectives, and to engage in active discussion and debate. Component-based software engineering continues to attract interest and evolve as a discipline for the rapid assembly of flexible software systems. CBSE combines elements of software requirements engineering, architecture, design, verification, testing, configuration and deployment. The role of and need for CBSE in industrial application remains critical. New trends in global services, distributed systems architectures, dynamically adaptable systems, and large-scale software systems often cross organizational boundaries and push the limits of established component-based methods, tools, and platforms. Innovative solutions from diverse paradigms (e.g., service-, aspect-, and agent-oriented) are needed to address these emerging trends. Topics of interest for CBSE 2012 therefore include, but are not limited to, the following: Specification, architecture, and design of component models and component-based systems Software quality assurance for component-based engineering Verification, testing and certification of component-based systems Component composition, binding, and dynamic adaptation Component-based engineering with agents, aspects, or services Component-based product line engineering Non-functional properties (quality of service attributes) in component-based engineering Patterns and frameworks for component-based engineering Tools and methods for component-based engineering Industrial experience using component-based software development Empirical studies in component-based software engineering Teaching component-based software engineering In addition to the above, this year we have a special theme: Components for Achieving Long-Lived Systems. Many industrial systems have very strict requirements for uninterrupted operation. There are examples of systems that have aimed to provide continuous operation for more than 15 years (that is, since the first CBSE!). Such requirements place significant demands on the underlying architecture, mandating that the architecture be very well understood and carefully designed. In turn, the architecture, if implemented correctly, forms a foundation for achieving critical quality attributes such as dependability, robustness, usability, and flexibility. The principles of component-based software engineering offer a promise for achieving effective architectures for long-lived systems. This is especially so since this approach natively provides the ability to add, remove, replace, and/or modify components during operation. A related class of approaches deals with self-management in component-based systems in order to ensure continuous operation. CBSE 2012 received 50 submissions, each of which received at least three independent reviews by the CBSE Program Committee. The careful review process included an on-line discussion, after which 11 papers (22%) have been accepted for publication in this volume as full papers. Eleven more submissions have been selected as short papers. We have assembled an exciting program that shows that this is still a very vibrant and relevant community. We hope to see you at CBSE 2012 in Bertinoro! This year, CBSE is again part of the federated event CompArch, together with "QoSA 2012: 8th International ACM SIGSOFT Conference on the Quality of Software Architectures," "ISARCS 2012: 3rd International ACM SIGSOFT Symposium on Architecting Critical Systems," "WCOP 2012: 17th International Doctoral Symposium on Components and Architecture," and "ROSS 2012: Workshop on Reusing Open-Source Components."

Abstract: It is our great pleasure to welcome you to the 8th International ACM Sigsoft Conference on the Quality of Software Architectures -- QoSA'12. For almost a decade, QoSA aims at advancing the state of the art in the quality assessment and management for software architectures. Specific issues of interest are defining quality measures, evaluating and managing architecture quality, linking architecture to requirements and implementation, and preserving architecture quality throughout the lifetime of the system. Past themes for QoSA include Quality throughout the Software Lifecycle (2011), Research into Practice -- Reality and Gaps (2010), Architectures for Adaptive Software Systems (2009), and Models and Architecture (2008). The umbrella theme of QoSA 2012 is Evolving Architectures. The QoSA'12 call for papers attracted 52 abstracts leading to the final number of 44 submissions from Europe, North and South America, Australia, Asia, and Africa. The program committee accepted 11 long papers and 7 short papers that cover a variety of topics related to the quality of software architectures. In addition, the program includes two keynote speeches, first by Alberto Montresor (University of Trento, Italy) on Designing Extreme Distributed Systems: Challenges and Opportunities, and second by Johan Bendz (Convenor of the ISO/IEC-JTC1-SC7 Working Group on Architecture) on International Standards Supporting Quality in Software Architecture. QoSA is part of the federated event CompArch, this year together with "CBSE 2012: 15th International ACM SIGSOFT Symposium on Component Based Software Engineering," "ISARCS 2012: 3rd International ACM SIGSOFT Symposium on Architecting Critical Systems," "WCOP 2012: 17th International Doctoral Symposium on Components and Architecture," and "ROSS 2012: Workshop on Reusing Open-Source Components." We are grateful to the organizers of all these events for making CompArch a successful federated event on Component-based Software Engineering and Software Architecture.

Abstract: The nature of software system development is changing. Rather than building systems according to specification, innovation processes and customer intimacy are at the heart of software development, requiring unprecedented levels of agility and speed. In addition, software is increasingly built in the context of a software ecosystem where other companies and independent developers add value as well. As these trends require small teams to work efficiently and rapidly in the context of large complex systems, the role of software architecture (and that of a software architect in particular) is more important in this new world, but there is significant evolution in its implementation. This keynote starts by characterizing the new approach to software engineering and the role of compositionality. It then explores the implications for software architecture and the role of the software architect. The talk will present examples from several industries to illustrate specific focus areas.

Abstract: In this work we present a strategy for addressing synchronization requirements in the model-driven component-based development of high-integrity real-time systems. The strategy we use regards separation of concerns as the cornerstone of the component-based development process, seeking to distinguish the responsibilities involved in specifying the system needs with regard to synchronization, from the responsibilities involved in the elaboration of a solution that provably satisfies those needs. In our vision the user expresses requirements related to the synchronization behavior of system components declaratively. This is done by attaching specification attributes to the affected elements of the system model. The underlying design environment is then in charge of producing a solution that guarantees that that behavior is achieved at run time. In contrast to classic component-oriented approaches, we consider synchronization requirements from the perspective of the client component instead of the provider one. We address the problem of high-level data races resulting from the lack of support for atomicity in the execution of sequences of operations that invoke multiple required interfaces.

Abstract: The Digital Home (DH) is emerging as a distributed platform hosting services for the end user. This promising home environment depends on availability of numerous value-added services for the DH. Therefore DH implies to fullfil several requirements. (i) New services should easily invoke existing ones so as to build rich services. (ii) The Platform should be adapted to resource-constrained DH devices. (iii) Service providers should easily develop and deploy services onto the DH platform that must be shared between many providers without any security and reliability aws. We propose Jasmin: a DH middleware following the SOA paradigm [9] to host applications based on the MIND framework that implements the Fractal [3] component model. Applications run inside isolation containers with selectable isolation levels on top of an OS abstraction layer. Our evaluation shows that Jasmin is suitable for legacy code reuse, urges clean design, and automates dynamic application deployment. Jasmin selected virtualization container technology to implement the highest level of isolation containers. Jasmin not only has a low resource usage, but also incurs a very low overhead on hosted applications, making it appropriate for embedded environments.