An important bottleneck in model-based design of embedded systems is the cost of constructing models. This cost can be significantly decreased by increasing the reuse of existing model components in the design process. This paper describes a tool suite, which has been developed for component-based model synthesis. The DESERT tool suite can be interfaced to existing modeling and analysis environments and can be inserted in various, domain specific design flows. The modeling component of DESERT supports the modeling of design spaces and the automated search for designs that meet structural requirements. DESERT has been introduced in automotive applications and proved to be useful in increasing design productivity.

Embedded computer-based systems are becoming highly complex and difficult to implement due to the large number of concerns designers must address. These systems are tightly coupled to their environments, requiring an integrated view that encompasses both the information system and its physical surroundings. Mathematical analysis of such systems necessitates formal modeling of both "sides," including their interaction. There exist a number of suitable modeling techniques for describing the information system component and the physical environment, but the best choice changes from domain to domain. We propose a two-level approach to modeling that introduces a meta-level representation. Meta-level models define modeling languages, but they can also be used to capture subtle interactions between domain level models. We show how the two-level approach can be supported with computational tools, and what kinds of novel capabilities are offered.

We present an end-to-end tool-chain for model-based design and analysis of component-based embedded realtime software, with Avionics Mission Computing as an application domain. The tool-chain covers the entire system development life-cycle including modeling, analysis, code generation, and runtime instrumentation. Emphasis is placed on integration of tools developed by multiple institutions via standardized interface format definitions in XML. By capturing all relevant information explicitly in models at the design level, and performing analysis that provides insight into nonfunctional aspects of the system, we can raise the level of abstraction for the designer, and facilitate rapid system prototyping. 1

The process of specifying an embedded system involves capturing complex interrelationships between the hardware domain, the software domain, and the engineering domain used to describe the environment in which the system will be embedded. Developers increasingly turn to domain-specific modeling techniques to manage this complexity, through such approaches as Model Integrated Computing and Model Driven Architecture. However, the specification of domain-specific modeling language syntax and semantics remains more of an art than a science. Typically, the syntax of a DSML is captured using a metamodel; however, there are few best-practices for metamodeling and no public collection of reusable metamodel b to address common language specification requirements. There is a need for an advanced, comprehensive language design environment that offers tool support for a wide range of metamodel reuse strategies and the preservation of metamodeling best-practices. We outline existing techniques for the reuse and composition of metamodels, and propose a new metamodel composition technique we call Template Instantiation. 1

Abstract. Current software systems increasingly consist of distributed interacting components. The use of web services and similar middleware technologies strongly fosters such architectures. The complexity resulting from a high degree of interaction between distributed components – that we face with web service orchestration for example – poses severe problems. A promising approach to handle this intricacy is service-oriented development; in particular with a domain-unspecific service notion based on interaction patterns. Here, a service is defined by the interplay of distributed system entities, which can be modeled using UML Sequence Diagrams. However, we often face functionality that affects or is spanned across the behavior of other services; a similar concept to aspects in Aspect-Oriented Programming. In the service-oriented world, such aspects form crosscutting services. In this paper we show how to model those; we introduce aspect-oriented modeling techniques for UML Sequence Diagrams and show their usefulness by means of a running example. 1

Abstract. Embedded systems represent fundamentally new challenges for software design, which render conventional approaches to software composition ineffective. Starting with the unique challenges of building embedded systems, this paper discusses key issues of model-based technology for embedded systems. The discussion uses Model-Integrated Computing (MIC) as an example for model-based software development. In MIC, domainspecific, multiple view models are used in all phases of the development process. Models explicitly represent the embedded software and the environment it operates in, and capture the requirements of the application, simultaneously. Models are descriptive, in the sense that they allow the formal analysis, verification and validation of the embedded system at design time. Models are also generative, in the sense that they carry enough information for automatically generating embedded systems from them using the techniques of program generators. 1

Commercial off-the-shelf (COTS) middleware is now widely used to develop distributed real-time and embedded (DRE) systems. DRE systems are themselves increasingly combined to form "systems of systems" that have diverse quality of service (QoS) requirements. Earlier generations of COTS middleware, such as Object Request Brokers (ORBs) based on the CORBA 2.x standard, do not facilitate the separation of QoS policies from application functionality, which makes it hard to configure and validate complex DRE applications. The new generation of component middleware, such as the CORBA Component Model (CCM) based on the CORBA 3.0 standard, addresses the limitations of earlier generation middleware by establishing standards for implementing, packaging, assembling, and deploying component implementations. There has been little systematic empirical study of the performance characteristics of component middleware implementations in the context of DRE systems. This paper therefore provides three contributions to the study of CCM for DRE systems. First, we describe the challenges involved in benchmarking different CORBA Component Model (CCM) implementations. Second, we describe key criteria for comparing different CCM implementations using key black-box and white-box metrics. Third, we describe the design of our CCMPerf benchmarking suite to illustrate test categories that evaluate aspects of CCM implementation to determine their suitability for the DRE domain. We demonstrate CCMPerf by using it to collect metrics from a CCM implementation designed for DRE applications.

Domain-Specific Modeling Languages (DSMLs) are a promising means of simplifying the development of a large class of systems. There are many domains, however, where the domain constraints are so restrictive and the solution spaces so large that it is extremely difficult for a modeler to manually produce a correct solution using a DSML. For example, modeling the deployment of software components to nodes and observing configuration and resource constraints, even when only a few tens of model entities are present, can easily generate solution spaces with millions or more possibile deployments and few correct ones. This paper address the challenge of creating a Domain-Specific Intelligence Framework (DSIF) to help a modeler solve combinatorically challenging modeling problems. The paper provides five key

In this paper, we present a concrete textual notation, called AsmetaL, and a general-purpose simulation engine, called AsmetaS, for Abstract State Machine (ASM) specifications. They have been developed as part of the ASMETA (ASMs mETAmodelling) toolset, which is a set of tools for ASMs based on the metamodelling approach of the Model-driven Engineering. We briefly present the ASMETA framework, and we discuss how the language and the simulator have been developed exploiting the advantages offered by the metamodelling approach. We introduce the language AsmetaL used to write ASM specifications, and we provide the AsmetaL encoding of ASM specifications of increasing complexity. We explain the AsmetaS architecture, its kernel engine, and how the simulator works within the ASMETA tool set. We discuss the features currently supported by the simulator and how it has been validated.

Abstract. Model-Integrated Computing is a proven technology for designing and implementing complex software systems. Making the designtime models available at run-time benefits the development of dynamic embedded systems. This paper describes a paradigm-independent, general infrastructure for the design and implementation of model-integrated embedded systems that is highly applicable to self-adaptive systems. 1