Rapid Prototyping of Domain-Specific Architecture Languages Romain Rouvoy, Philippe Merle To cite this version: Romain Rouvoy, Philippe Merle. Rapid Prototyping of Domain-Specific Architecture Languages. International ACM SIGSOFT Symposium on Component-Based Software Engineering (CBSE’12), Jun 2012, Bertinoro, Italy. pp.13-22, 10.1145/2304736.2304741. hal-00690607 HAL Id: hal-00690607 https://hal.inria.fr/hal-00690607 Submitted on 2 May 2012 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Rapid Prototyping of Domain-Specific Architecture Languages Romain Rouvoy Philippe Merle University Lille 1, LIFL CNRS UMR 8022 Inria Lille – Nord Europe, France Inria Lille – Nord Europe, France University Lille 1, LIFL CNRS UMR 8022 [email protected] [email protected] ABSTRACT which can be particularly error prone. Therefore, software Software architecture has become a sensitive discipline, which architects are rather tempted to manipulate domain-specific consists in concretizing the user requirements into a set of concepts which could be seamlessly converted to technical artifacts that can be used to model and reason about the artifacts. Nonetheless, the definition of such domain-specific software to be developed. However, the architect often relies languages is a tedious process, which requires a lot of experi- on its own knowledge to map domain-specific requirements ence from the architect to identify the relevant constructions onto generic software abstractions. Most of the time, this and a lot of time to develop the appropriate toolchain. leads to the definition of repetitive tasks and architecture We therefore believe that architects need a more flexible fragments, which can be particularly error prone. We there- approach to cope with the definition of domain-specific ar- fore believe that architects need a more flexible approach chitectures by leveraging general purpose Architecture De- scription Languages (ADLs). In this paper, we therefore in- to cope with the definition of domain-specific architectures FraSCAla by leveraging general purpose architecture description lan- troduce the framework as an adaptive architec- guages. This paper introduces the FraSCAla framework tural framework that can be used to rapidly prototype and as an adaptive architectural framework that can be used to experiment domain-specific ADLs in order to catalyze the definition and to improve the reliability of software architectures— rapidly prototype and experiment domain-specific ADLs in FraSCAla order to catalyze the definition and to improve the reliabil- i.e., is a framework for building “`ala carte” ity of software architectures. We demonstrate the merits of ADLs. In particular, we promote a layered approach (as de- this approach on two representative architectural patterns picted in Figure 1) to isolate the definition of the structural of component-based software architectures. architectural model from the language statements used to describe software architectures. We demonstrate the merits of this approach on two architectural patterns that are de- Categories and Subject Descriptors fined by the FraSCAti middleware platform [21] and the D.2.11 [Software Architectures]: [Domain-specific archi- COSMOS context framework [19]. tectures, Languages, Patterns] Keywords Software M2 Architecture Descriptions language prototyping, component-based architectures (section 4) 1. INTRODUCTION Domain-Specific Architecture Software architecture has become a sensitive discipline, Patterns which consists in concretizing the user requirements into a (section 3.3) set of artifacts that can be used to model and reason about M1 Domain-Specific the software to be developed. This task becomes even more Architecture Language (section 3.2) critical when the complexity of the developed software in- creases or when the software addresses a specific domain. In Domain-Specific Architecture Model both cases, the architect relies on its own knowledge to map (section 3.1) domain-specific requirements onto generic software abstrac- tions, like components. However, this process can lead to the definition of repetitive tasks and architecture fragments, FraSCAla M0 Meta-model (section 2) Figure 1: Overview of the contribution. Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are The remainder of this paper is therefore organized as fol- not made or distributed for profit or commercial advantage and that copies lows. We first introduce the FraSCAla framework, which bear this notice and the full citation on the first page. To copy otherwise, to groups the essential concepts of our contribution (cf. Sec- republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. tion 2). Then, we build on this kernel to demonstrate the Copyright 20XX ACM X-XXXXX-XX-X/XX/XX ...$10.00. definition of an ADL for the Service Component Architec- ture (SCA) industrial standard (cf. Section 3). The result- extends extends ing ADL is assessed by the illustration of two case studies 0..* 1..1 controls 0..* FraSCAla Concept composes Controller which exploit to describe complex software ar- 1..* chitecture that exhibit architectural patterns (cf. Section 4). In the last part of the paper, we compare our contribution with the state-of-the-art (cf. Section 5) before concluding Element introduces Parameter and sketching some of the perspectives for this work (cf. + name: String Section 6). 0..* + optional: Boolean points + multiple: Boolean 2. THE FRASCALA FRAMEWORK FraSCAla is a framework for prototyping the definition Reference Value of Architectural Description Languages (ADL). The objec- + type: DataType tive of FraSCAla is to leverage the construction of ADLs by providing an homogeneous environment to introduce new architectural concepts according to domain-specific require- Figure 2: FraSCAla Meta-Model. ments. Although it mostly targets prototyping activities, FraSCAla promotes a structured approach to build ADLs by adopting an incremental design approach. First, FraS- 2.2 Deriving a CBSE Model CAla defines a meta-model to introduce the essential con- Software architectures have already been adopted by vari- cepts required to prototype an ADL. Then, instances of this ous Software Engineering communities [4]. In the context of meta-model are used to describe categories of ADL (e.g., this paper, we focus on the definition of an ADL conforming component-based ADLs). Each FraSCAla model can be to the principles of Component-Based Software Engineer- further refined to fit the specificities of a given component ing [8]. In particular, we demonstrate that FraSCAla can model (e.g., Service Component Architecture standard [2]). be used to describe a generic component model, which can Once a target model is defined, FraSCAla introduces the be incrementally refined towards a more concrete component associated language by constraining this model with a con- model and ultimately a domain-specific component model. crete syntax. This concrete syntax introduces the keywords Figure 3 depicts the generic component model we designed of the ADL as well as the associated operations it supports using the stereotypes introduced by the FraSCAla meta- for describing software architectures. The last feature of model. This model is strongly inspired from the Fractal FraSCAla consists in supporting the definition of architec- component model, as described in [5]. Our model is struc- tural patterns. Software architecture patterns are a power- tured around the concept of Membrane, basically defined as ful construction for isolating reusable fragments of software a composition of a Name and an Annotation controller. A architecture descriptions. By enabling the definition of ar- Membrane is an empty software cell extended as a Compo- chitectural patterns, FraSCAla captures domain-specific nent Membrane, which includes the Port and Property con- architectures as advanced patterns. To reduce the burden trollers. One can observe that both the Membrane and the of using the complex MDE technologies like the Eclipse Gate concepts (inherited by the Port and Property concepts) Modelling Framework (EMF) [22], FraSCAla builds on include the Annotation controller. Annotations provide a the Scala programming language [17, 18]. In particular, variability point in this generic model in order to decorate a FraSCAla benefits from Scala’s support for type inference, Membrane or a Gate with specific metadata. SubMembrane genericity, implicit definition, trait, closures, as well as na- and Composite Membrane are themselves defined as a Mem- tive XML support. The remainder of this section therefore brane extension integrating specific controllers. describes the core of FraSCAla and how it can be used to The definition of this yet another generic component model sketch an ADL for component-based systems. provides an architectural pivot, which can be used to auto- matically instrument concrete component models (e.g., in- 2.1 Defining an ADL Meta-Model trospection,