BookPDF Available

Model-Driven Software Engineering in Practice

  • September 2012
DOI:10.2200/S00441ED1V01Y201208SWE001
  • Publisher: Morgan & Claypool Publishers
Authors:
Marco Brambilla at Politecnico di Milano
Marco Brambilla
Jordi Cabot at Luxembourg Institute of Science and Technology (LIST)
Jordi Cabot
Manuel Wimmer at Johannes Kepler University Linz
Manuel Wimmer
Download full-text PDF
Read full-text
Download citation

Abstract

This book discusses how model-based approaches can improve the daily practice of software professionals. This is known as Model-Driven Software Engineering (MDSE) or, simply, Model-Driven Engineering (MDE). MDSE practices have proved to increase efficiency and effectiveness in software development, as demonstrated by various quantitative and qualitative studies. MDSE adoption in the software industry is foreseen to grow exponentially in the near future, e.g., due to the convergence of software development and business analysis. The aim of this book is to provide you with an agile and flexible tool to introduce you to the MDSE world, thus allowing you to quickly understand its basic principles and techniques and to choose the right set of MDSE instruments for your needs so that you can start to benefit from MDSE right away. The book is organized into two main parts. The first part discusses the foundations of MDSE in terms of basic concepts (i.e., models and transformations), driving principles, application scenarios and current standards, like the well-known MDA initiative proposed by OMG (Object Management Group) as well as the practices on how to integrate MDSE in existing development processes. The second part deals with the technical aspects of MDSE, spanning from the basics on when and how to build a domain-specific modeling language, to the description of Model-to-Text and Model-to-Model transformations, and the tools that support the management of MDSE projects. The book is targeted to a diverse set of readers, spanning: professionals, CTOs, CIOs, and team managers that need to have a bird's eye vision on the matter, so as to take the appropriate decisions when it comes to choosing the best development techniques for their company or team; software analysts, developers, or designers that expect to use MDSE for improving everyday work productivity, either by applying the basic modeling techniques and notations or by defining new domain-specific modeling languages and applying end-to-end MDSE practices in the software factory; and academic teachers and students to address undergrad and postgrad courses on MDSE. In addition to the contents of the book, more resources are provided on the book's website http://www.mdse-book.com/, including the examples presented in the book. Table of Contents: Introduction / MDSE Principles / MDSE Use Cases / Model-Driven Architecture (MDA) / Integration of MDSE in your Development Process / Modeling Languages at a Glance / Developing your Own Modeling Language / Model-to-Model Transformations / Model-to-Text Transformations / Managing Models / Summary
Content uploaded by Marco Brambilla
Author content
All content in this area was uploaded by Marco Brambilla on Dec 10, 2015
Content may be subject to copyright.
Model-Driven Software Engineering in Practice
Morgan & Claypool
Synthesis Lectures on Software Engineering
by Marco Brambilla (Author), Jordi Cabot (Author), Manuel Wimmer (Author)
(Kindle Edition now at less than 9$!)
The complete set of slides is available:
Chapter 1 - http://www.slideshare.net/mbrambil/modeldriven-software-
engineering-in-practice-chapter-1-introduction
Chapter 2 - http://www.slideshare.net/mbrambil/modeldriven-software-
engineering-in-practice-chapter-2-mdse-principles
Chapter 3 - http://www.slideshare.net/jcabot/model-driven-software-
engineering-in-practice-chapter-3-mdse-use-cases
Chapter 4 - http://www.slideshare.net/jcabot/modeldriven-software-
engineering-in-practice-chapter-4
Chapter 5 - http://www.slideshare.net/mbrambil/modeldriven-software-
engineering-in-practice-chapter-5-integration-of-modeldriven-in-
development-processes
Chapter 6 - http://www.slideshare.net/jcabot/mdse-bookslideschapter6
Chapter 7 - http://www.slideshare.net/mbrambil/model-driven-software-
engineering-in-practice-book-chapter-7-developing-your-own-modeling-
language
Chapter 8 - http://www.slideshare.net/jcabot/modeldriven-software-
engineering-in-practice-chapter-8-modeltomodel-transformations
Chapter 9 - https://www.slideshare.net/mbrambil/model-driven-software-
engineering-in-practice-book-chapter-9-model-to-text-transformations-
and-code-generation
Chapter 10 - http://www.slideshare.net/jcabot/mdse-
bookslideschapter10managingmodels
This book discusses how approaches based on modeling can improve the
daily practice of software professionals. This is known as Model-Driven
Software Engineering (MDSE) or, simply, Model-Driven Engineering (MDE).
MDSE practices have proved to increase efficiency and effectiveness in
software development. MDSE adoption in the software industry is
foreseen to grow exponentially in the near future, e.g., due to the
convergence of software development and business analysis.
This book is an agile and flexible tool to introduce you to the MDE and
MDSE world, thus allowing you to quickly understand its basic principles
and techniques and to choose the right set of MDE instruments for your
needs so that you can start to benefit from MDE right away.
The first part discusses the foundations of MDSE in terms of basic
concepts (i.e., models and transformations), driving principles, application
scenarios and current standards, like the wellknown MDA initiative
proposed by OMG (Object Management Group) as well as the practices
on how to integrate MDE in existing development processes.
The second part deals with the technical aspects of MDSE, spanning from
the basics on when and how to build a domain-specific modeling
language, to the description of Model-to-Text and Model-to-Model
transformations, and the tools that support the management of MDE
projects.
The book covers the MD* world, metamodeling, domain specific
languages, model transformations, reverse engineering, OMG's MDA,
UML, OCL, ATL, QVT, MOF, Eclipse, EMF, GMF, TCS, xText.
Find more at:
http://www.mdse-book.com
Preview of the book on Amazon:
Model-Driven Software Engineering in Practice
!

Supplementary resource (1)

MDSE-book-slides-links
Data
December 2015
Marco Brambilla · Jordi Cabot · Manuel Wimmer
... Decor has been developed by leveraging model-driven software engineering techniques [11]. In particular, we exploit a metamodel-centric design for (i) specifying a MAPE-K Control Modeling Language, (ii) defining a graphical modeling environment, and (iii) transforming the modeled MAPE-K Control into a simulation model. ...
... To this end, Decor combines established analytic theories and model-driven engineering practices [11] to implement such key elements (see gray boxes in Fig. 3) and support the Reasoning activity. ...
... For example, the ITS scenario is modeled in MovSim [51], the Smart Power Grid in Modelica [30], and the Cloud Computing system in CloudSim [13]. Indeed, the interpretation is a model transformation [11] from the specific input modeling language to DEVS. In particular, I nter pretation M S is a model-to-model transformation from a Domain Specific modeling language to DEVS, whereas I nter pretation C is a model-to-model transformation from MAPE-K Modeling Language (Sect. ...
Architecting decentralized control in large-scale self-adaptive systems
Article
Full-text available
Architecting a self-adaptive system with decentralized control is challenging. Indeed, architects shall consider several different and interdependent design dimensions and devise multiple control loops to coordinate and timely perform the correct adaptations. To support this task, we propose Decor, a reasoning framework for architecting and evaluating decentralized control. Decor provides (i) multi-paradigm modeling support, (ii) a modeling environment for MAPE-K style decentralized control, and (iii) a co-simulation environment for simulating the decentralized control together with the managed system and estimating the quality attributes of interest. We apply the Decor in three case studies: an intelligent transportation system, a smart power grid, and a cloud computing application. The studies demonstrate the framework’s capabilities to support informed architectural decisions on decentralized control and adaptation strategies.
View
... In this sense, a better support to define and execute complex IoT systems and their (self)adaptation rules to semi-automate the deployment and evolution process is necessary [2]. A usual strategy when it comes to modeling complex domains is to develop a domain-specific language (DSL) for that domain [3]. In short, a DSL offers a set of abstractions and vocabulary closer to the one already employed by domain experts. ...
... A DSL is defined by three core ingredients [3]: the abstract syntax (i.e., the concepts of the DSL and their relationships), the concrete syntax (the notation to represent those concepts), and its semantics which are hardly ever formalized but based on the shared understanding of the domain. In this chapter, we present our DSL for modeling multi-layered IoT architectures (Sect. ...
A model-based infrastructure for the specification and runtime execution of self-adaptive IoT architectures
Article
Full-text available
To meet increasingly restrictive requirements and improve quality of service (QoS), Internet of Things (IoT) systems have embraced multi-layered architectures leveraging edge and fog computing. However, the dynamic and changing IoT environment can impact QoS due to unexpected events. Therefore, proactive evolution and adaptation of the IoT system becomes a necessity and concern. In this paper, we present a model-based approach for the specification and execution of self-adaptive multi-layered IoT systems. Our proposal comprises the design of a domain-specific language (DSL) for the specification of such architectures, and a runtime framework to support the system behaviuor and its self-adaptation at runtime. The code for the deployment of the IoT system and the execution of the runtime framework is automatically produced by our prototype code generator. Moreover, we also show and validate the extensibility of such DSL by applying it to the domain of underground mining. The complete infrastructure (modeling tool, generator and runtime components) is available in a online open source repository.
View
... Instead of using textual code it uses visual models, offering an even higher level of abstraction. These models are then transformed into an application by code generation or model interpretation [12]. This increase in level of abstraction for programming languages is demonstrated in Figure 1. ...
... Instead of writing difficult and complex code, visual interfaces and models can be used. These are then transformed into high-code using code generation principles or model interpretation [12]. Most low-code and no-code development platforms still need high-code when applications require functionality that is not supported by default. ...
Quantifying the effectiveness of low-code development platforms in the Dutch public sector
Thesis
Full-text available
  • Jun 2022
Low-code development platforms (LCDPs) can be described as software devel opment platforms utilizing prebuilt and prefigured modules to develop applications with minimal or no procedural code via advanced graphical user interfaces. They are designed to allow users who have little developer experience to make business applications or increase the productivity of existing developers, or both. LCDPs are often advertised as a silver bullet, solving many of the great challenges large enterprises deal with today to stay flexible, scalable and competitive. Market analysts suggest that by 2023 over half of all medium or larger companies will have adopted a LCDP as a strategic development platform. These promises and predictions sound great, yet there is a severe lack of research looking into the performance of LCDPs in practice. Currently, researchers use many ‘grey’ sources to evaluate and analyze this new technology, limiting the accuracy and objectivity of the current scientific literature. The focus of this research will be on the public sector, as preliminary research showed LCDPs may be particularly effective in the context of the sectors unique dynamics. An exploratory sequential mixed study was performed to assess whether LCDPs contribute to a more effective use of IT in the public sector. For this research, a conceptual framework was developed that links LCDPs advantages to public sector organizational capabilities to public value categories. This framework was iteratively built, checked, and improved via interviews with domain experts. Based on this framework, a survey was developed and conducted among 16 public officials from 14 organizations in the public sector. Based on the outcomes of the guiding questions, the expert interviews, and the survey responses, we can conclude that LCDPs contribute to a more effective use of IT in the Dutch public sector for the sample researched. This is achieved through a combination of advantages of LCDPs over traditional programming methods which improve the organizational capabilities important for digitalization. These may in turn lead to improvements in duty oriented and service oriented public values, but the evidence on this from this sample is inadequate. The research outcomes can help public organizations better understand which of the potential advantages of LCDPs are actually realized in practice within the context of public sector organizations. The conceptual framework also provides a basis for future research into the application of LCDPs
View
... Templates are used as inputs for the Accleo Project to automatically generate source code files[9]. ...
View
... Nonfunctional properties define the quality requirements for a software system such as performance and security requirements [15]. Nonfunctional requirement properties can also be specified during the architectural design of software systems and further used for analyzing models. ...
Modeling Languages for Internet of Things (IoT) Applications: A Comparative Analysis Study
Article
Full-text available
  • Mar 2023
Modeling languages have gained ever-increasing importance for the Internet of Things (IoT) domain for improving the productivity and quality of IoT developments. In this study, we analyzed 32 different modeling languages that have been designed for IoT software development in terms of a set of requirements that were categorized into three groups: language definition, language features, and tool support. Some key findings are as follows: (1) performance is the most supported quality property (28%); (2) most languages offer a visual notation set only, while 6% provide both textual and visual notation sets; (3) most languages (88%) lack formally precise semantic definitions; (4) most languages (94%) support the physical, deployment, and logical modeling viewpoints, while the behavior, logical, and information viewpoints are rarely supported; (5) almost none of the languages enable extensibility; (6) Java (34%) and C (21%) are the most preferred programming languages for model transformation; (7) consistency (77%) and completeness (64%) are the most supported properties for the automated checking of models; and (8) most languages (81%) are not supported with any websites for sharing case studies, source code, tools, tutorials, etc. The analysis results can be useful for language engineers, practitioners, and tool vendors for better understanding the existing languages for IoT, their weak and strong points, and IoT industries’ needs in future language and modeling toolset developments.
View
... Context In model-based engineering (MBE), models play the central role in information exchange and serve as the base of derived artefacts and analysis (Brambilla et al., 2012). Models are expressed using various modelling languages. ...
Assessing the specification of modelling language semantics: a study on UML PSSM
Article
Full-text available
Modelling languages play a central role in developing complex, critical systems. A precise, comprehensible, and high-quality modelling language specification is essential to all stakeholders using, implementing, or extending the language. Many good practices can be found that improve the understandability or consistency of the languages’ semantics. However, designing a modelling language intended for a large audience is still challenging. In this paper, we investigate the challenges and typical issues with assessing the specifications of behavioural modelling language semantics. Our key insight is that the various stakeholder’s understandings of the language’s semantics are often misaligned, and the semantics defined in various artefacts (simulators, test suites) are inconsistent. Therefore assessment of semantics should focus on identifying and resolving these inconsistencies. To illustrate these challenges and techniques, we assessed parts of a state-of-the-art specification for a general-purpose modelling language, the Precise Semantics of UML State Machines (PSSM). We reviewed the text of the specification, analysed and executed PSSM’s conformance test suite, and categorised our experiences according to questions generally relevant to modelling languages. Finally, we made recommendations for improving the development of future modelling languages by representing the semantic domain and traces more explicitly, applying diverse test design techniques to obtain conformance test suites, and using various tools to support early-phase language design.
View
... In the case of modeling collaborative systems, there are some works that propose software engineering resources to model groupware systems [19,20]. However, initiatives that combine models with transformation to code, as Model Driven software Development approaches (MDD) [21,22], that proposes to improve quality and efficiency of the software construction processes are more appropriate. In this paradigm models assume a leading role in the software development process, going from being contemplative entities to becoming productive entities from which implementations are automatically derived. ...
An Approach to Model Haptic Awareness in Groupware Systems
Chapter
  • Jan 2023
Awareness is of paramount importance to effective collaboration. Groupware systems have traditionally implemented awareness in the form of visual cues. With the advent of alternatives user interface strategies, such as haptic feedback, new ways of implementing awareness are available. The lack of documented experience on the design of effective, haptic awareness mechanisms makes it important to count on flexible prototyping and evaluation tools that can support and shorten an exploratory design process. We argue that design of awareness features should consider modalities from the start. To support the discussion, we present a modeling language and supporting tools to express haptic awareness features, and we show how the language can be used in the context of model driven development of groupware.KeywordsHaptic interfacesAwarenessGroupwareModel driven development
View
View
Modelling the Top Floor: Internal and External Data Integration and Exchange
Chapter
  • Feb 2023
Digital representations of top floor entities are inherent in higher level software suites such as enterprise resource planning (ERP) systems or manufacturing execution systems (MESs). Typical implementations utilise proprietary conceptual models that lead to a plethora of both import and export filters between different systems. In this chapter we will highlight the modelling of top floor entities by adopting international standards and discussing arising interoperability issues. With the selected standards, we outline an approach for vertical integration between the ERP and MES levels as well as horizontal integration among organisations in a value added network. We complement our structural, model-based and data-driven perspective with business process stencils that are to be customised to specific business case needs. With that, we establish a purely model-based perspective on the coupling of top floor internal and external data exchange matters.
View
View
Design Guidelines for Domain Specific Languages
Article
Full-text available
  • Sep 2014
Designing a new domain specific language is as any other complex task sometimes error-prone and usually time consuming, especially if the language shall be of high-quality and comfortably usable. Existing tool support focuses on the simplification of technical aspects but lacks support for an enforcement of principles for a good language design. In this paper we investigate guidelines that are useful for designing domain specific languages, largely based on our experience in developing languages as well as relying on existing guidelines on general purpose (GPLs) and modeling languages. We defined guidelines to support a DSL developer to achieve better quality of the language design and a better acceptance among its users.
View
Different Models for Model Matching: An analysis of approaches to support model differencing
Conference Paper
Full-text available
  • May 2009
Calculating differences between models is an important and challenging task in Model Driven Engineering. Model differencing involves a number of steps starting with identifying matching model elements, calculating and representing their differences, and finally visualizing them in an appropriate way. In this paper, we provide an overview of the fundamental steps involved in the model differencing process and summarize the advantages and shortcomings of existing approaches for identifying matching model elements. To assist potential users in selecting one of the existing methods for the problem at stake, we investigate the trade-offs these methods impose in terms of accuracy and effort required to implement each one of them.
View
Advanced Traceability for ATL
Conference Paper
Full-text available
  • Jul 2009
Tracing information is an essential part of the ATLAS Trans-formation Language (ATL). It is used to support interaction between transformation rules, where each rule can use the output of other rules by means of the implicit tracing mechanism. However, tracing informa-tion is often useful outside the scope of the transformation execution as well. Currently, ATL offers limited access to the implicit tracing informa-tion via the resolveTemp() method. In addition, the tracing information is always discarded after the transformation execution. We propose a method that allows richer runtime access to the tracing information, as well a method for efficiently storing the tracing information in a separate model.
View
View
View
View
View
View
View
Conceptual data modelling in theory and practice
Article
  • Aug 1995
Conceptual data modelling (CDM) refers to the phase of the information systems development process that involves the abstraction and representation of the real world data pertinent to an organization. When CDM is properly and rigorously performed, the delivered system is expected to be functionally richer, less error-prone, more fully attuned to meet user needs, more able to adjust to changing user requirements and less expensive. However, there is little evidence that conceptual data modelling for the enterprise is actually conducted. There is the feeling that the 'corporate reality' is much different. In many organizations, CDM is never employed. In others, it is applied in a haphazard, project-to-project basis, thus leading to considerable redundancy. The academic community has mainly focused on proposing semantic data models but has not demonstrated a rigorous basis for conceptual data modelling. Specifically, the community has failed to show how a conceptual data model can map to an accurate logical data model. It is the purpose of this paper to discuss and compare the perspectives of academic and practitioner communities regarding the application of conceptual data modelling.
View