I was happy recently to give four lectures on MDE at NII Tokyo on the subject of “Principles and Applications of Model Driven Engineering“.
- Lecture 1: History and context of MDE
- Tuesday, January 17, 2012, 13:30-15:00
- This first course will present the modern history of MDE (Model Driven Engineering) as a specific branch of software modeling. The differences with simulation will be outlined. A survey of semi-formal modeling notations will first show how the rich variety of these formalisms has been important in the history of computer science (SADT, Flow-charts, State-charts, Petri nets, Entity-association diagrams, to name only a few of them). Unfortunately the lack of unification and automation has quite often limited the utility of these formalisms but they have allowed gaining a good understanding of visual and textual semi-formal notations. In the long history of “contemplative” modeling, there were probably some missed opportunities but one outcome was certainly the progressive convergence of Object Oriented Analysis and Design methods towards the consensual and normative definition and use of the UML software artifacts description language. This UML proposal triggered in fact a lot of innovations in the area of software modeling. Many of these innovations will probably survive the UML language itself, and are probably much more important. Since UML was not a method, another language like SPEM was necessary to describe the various software development processes (who is doing what, when, why and how?). Having two languages was like having an arbitrary number of them: a need for a metalanguage (i.e. a language to define languages) became necessary. The MOF was then proposed and the idea of precise characterization of domain specific languages by metamodels came then to life, even if there is still much progress to achieve in this field. Then the evolution of software systems, for example when changing platforms, was described as possible transformations from languages more or less dependent on these platforms. This suggestion was made in the OMG MDA™ white paper in November 2000 and became quite popular. Today MDE may be seen as a generalization of MDA. This first lecture will acknowledge the influences of previous approaches on modern modeling practices developed in the last decade and pursuing the goal of full automation.
- Lecture 2: Theory and Basic Principles of MDE
- Tuesday, January 24, 2012, 13:30-15:00
- The second course will present the basic principles of MDE from a conceptual and theoretical point of view. MDE uses typed graphs for most of the representation tasks and rule-based declarative transformations for most of the operation tasks. It relies essentially on the concepts of metamodel and model transformation. Sometimes called Modelware, MDE is thus a graph-based and transformation based technical space. The notion of technical space will be defined and used to compare similarities and differences with other technologies like Grammarware. Metamodels provide some sort of typing system on top of the models themselves. The essence of MDE is however most related to the unification of abstract models. Terminal models, metamodels and metametamodels are the most important categories of abstract models. Different operations like storage, retrieval and transformation may be applied on all abstract models. One of the important characteristics of MDE is to represent systems by models. This relation of representation which is central to all modeling activities will be analyzed and discussed. If metamodels provides a precise, regular and strong support for representation, they have however not the power to reason or more generally to act upon these representations. Of course it is always possible to use an imperative general purpose language to put these metamodel-based representations to work, but this solution has many drawbacks that will be outlined. A more constructive MDE approach usually suggested consists in using model transformations as the core and main operation on models. The advantages of this solution will be discussed; particularly in the case when the transformation language is declarative and rule-based. Additional advantages may also be reaped when the transformation program may be considered itself as a model. In this case it is much easier to deal with domain specific transformation languages, providing maximum impact to the regular MDE architecture based on metamodels and transformations.
- Lecture 3: Applications of MDE
- Tuesday, January 31, 2012, 13:30-15:00
- The subject of applications of MDE is vast and rapidly evolving. Usually one may consider three important areas: Generation of software artifacts, Discovery of models from structured systems and Interoperability between heterogeneous systems. This course will show how these three areas of increasing complexity are constantly evolving. Another classification of MDE applications considers various domains like health care, military operations, automotive, aeronautics, embedded, information systems, Web engineering, etc. A short survey of application areas of MDE will be provided. An interesting way to look at MDE applications is also through the various forms of model transformations. These transformations may be performed at system design, system maintenance or evolution and at system operation. This third course will also show how the typology of applications may be related to a classification of metamodels. This will allow talking in a similar manner of product and process models, of static and dynamic models, of code and data models and many more. The systematic classification of metamodels and transformations helps identifying the deployment perimeter of MDE, as it is today and as it may evolve tomorrow.
- Lecture 4: Where will be MDE in 2030?
- Tuesday, February 14, 2010, 13:30-15:00
- One of the main promises of MDE is that, by raising the level of abstraction, it should be possible to achieve more sustainability in time for software intensive systems. This was the initial MDA objective. With Platform Independent Models (PIMs) that one could map on various new technological platforms, the heavy software investments could be protected. In a period of rapid technological obsolescence, this guarantee of durability was most welcome. Unfortunately this idea has not met widespread success yet and sometimes contributes to the impression that MDE partly missed the boat. This last lecture will thus take a critical eye to MDE and compare the promises with the deliveries. In spite of the immense hopes that greeted the initial MDA proposal as a possible way to regenerate the entire software engineering practices, we must recognize today that its impact is more limited and its perspectives more confined. We consequently propose the view in this last lecture that the current iteration may not be the last one. This piece of technology may need an additional cycle to mature and produce maximum impact. The lecture will summarize the important lessons learnt in the current iteration and examine some of the difficulties that may have hampered a wider adoption. Among these difficulties some loose or contradictory goals will be discussed as well as the ambiguous relation between programming languages and modeling languages. At a time when software engineering is being much questioned – not only in its operation but also in its essence – we may consider the necessary adaptation of MDE as a chance for the future. To this purpose we need to reflect on the past and select the good set of properties and practices that will tomorrow allow MDE to play a central role to produce, maintain and operate software based systems. In the critical analysis of the first decade of MDE, the course will propose on one side a list of successful items that should absolutely be kept (like the central concepts of DSL or transformations) and on the other side a list of elements that may be questioned (like the notion of exclusive visual modeling or the idea of a general purpose modeling language). Asking the question of where will be MDE in 2030 amounts to proposing a research agenda for revisiting the whole area of software modeling.
