Software Engineering is Dead

Software Engineering is Dead

From many places, authors have been suggesting in the past years that SE is dead.

Tom DeMarco’s article in IEEE Software entitled “Software Engineering: An Idea Whose Time Has Come and Gone?”  In it he recants his early writing on the topic of metrics and control in software engineering projects and says that software projects are fundamentally experimental and uncontrollable.  Consistency and predictability in software development are largely unattainable goals.  Much of what we think of when we think about “software engineering” is a dead end.

This paper has raised several questions, i.e.:







The paper itself may be found at:

I was very lucky to attend a keynote given by Michele Lanza in Sao Paolo last year with the title: Requiem for Software Engineering

Unfortunately I do not find anymore the slides of this presentation, but it was really convincing.

Posted in Software Engineering | Leave a comment

Endangered (technical) species

I am amazed by the rapid disappearance of many references to important technical contributions. It is normal life that new proposals appear and that old proposals disappear. But I find annoying that direct Web references vanishes so quickly. It is sad because some of these proposals were not bad or low quality, they just did not meet their public at the time for reasons that were often more political than technical. It is a problem because so many people now believe that something that is not on the Web does not exist and has never existed.

I started doing some research on pre-MOF metamodeling techniques and my first idea was to look at a very interesting Web site that was built a long time ago by my friend Johannes Ernst. This site was simply  ““. But unfortunately this site appears to have completely disappeared and the Web pointer now redirects to Adaptive, the company of another good friend Pete Rivett.

Fortunately some people have saved small parts of this initial site, for example I managed to find track of the discussion What is metamodeling, and what is it good for? on another site:

This made me realize that we lost most memories of an important metamodeling initiative called CDIF. This was a real achievement in metamodeling. Paraphrasing Tony Hoare, we can say that CDIF was an improvement on most of its successors, including the multiple variants of MOF and also ECORE. It is a pity that the memory of CDIF is disappearing so quickly because there are many lessons that we can still draw today from this interesting proposal.

Fortunately we can still find some interesting archives like the paper by Oscar Nierstrasz and his colleagues on the use of CDIF for reengineering Tools. This paper was published in 1998. Is that so old that we should completely forget about this technology?

I am convinced that MOF and UML have not done so well as to justify that we should delete all references to previous modeling proposals. On the contrary I believe that we can still find a lot of inspiration in older technologies. As we say in french, “C‘est dans les vieux pots que l’on fait la meilleure soupe” (experience always wins the day).

Does someone have a list of pointers on CDIF or better has saved some part of this very valuable technology heritage?

My main reference is still the paper by Rony Flatscher:  “An Overview of the Architecture of EIA’s CASE Data Interchange Format (CDIF)“. I know that Rony also published a book on CDIF, but I understand it was in German and was not translated in English.

Posted in Metamodeling | Tagged | 2 Comments

A history of Metamodeling

In 2010 I was happy to welcome Sridhar Yyengar to give a seminar in Nantes with the following title: A (Meta)modeling Odyssey : Future of modeling, metamodeling, tools integration and the semantic web. The abstract is below (1).

Sridhar Yyengar leads the technical strategy group for Software Tools & Methods at the IBM TJ Watson Research Centre and led the definition of OMG MOF and XMI standards, among many other contributions as member of the OMG Board of Directors. Sridhar has been very influential in developing the MOF vision at OMG (Meta Object Facility).

But what we need now is something much broader that the strict MOF historical vision to understand the pertinence of these reflective languages to describe metamodels, their deep goal, structure, usage, rationale and evolution. We need to revisit these metamodel description DSLs and to look carefully at their positioning towards other DSLs and GPLs.

In January 2012 I was giving a course at the National Institute of Informatics in Tokyo and I started looking at the history of these metamodel description languages. I will try to write down some of my notes on this blog in the future. In the meantime, I will be happy to exchange and discuss on this blog  or on Twitter or Google+ with anyone interested in the history of MOF-like languages.


(1) Abstract: The past 15 years have seen some very interesting advances in the world of modeling, metamodeling and their use in developing tools and middleware across the complete application lifecycle. Industry modeling standards from OMG and web infrastructure standards like XML, WSDL and more recently semantic web standards like RDF and OWL have made their way into tools that cover the entire application lifecycle for both custom developed as well as packaged application implementations. As we start a new decade what can we expect in the next 10 years? This presentation will summarize the historical journey, take a snapshot of where the industry and related standards are as we begin the new decade. We will have a look at how we expect the world of the internet and semantic web will shape modeling, metamodeling and tools integration over the next decade. We will look at how emerging collaborative application lifecycle platforms like Jazz ( and emerging standards like SMOF (Semantic MOF) and future versions of UML and BPMN are evolving to address the challenges of the new decade.

Posted in MDA, MDE, Modeling, MOF, OMG | 4 Comments

Principles and Applications of Model Driven Engineering

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.
Posted in MDE, Uncategorized | Leave a comment

Do we still need modeling languages?

I will be soon giving an invited talk in Ankara at the #UYMS Turkish conference on software engineering:

The title of the talk is: Do we still need modeling languages?

And the abstract is: 
The first assembly programming languages were often complemented by flowchart modeling notations as an aid to produce new programs or to understand already written existing ones. More than half a century later, people are still often using UML or other modeling notations in complement to Scala, Java, Dart or other programming languages. In spite of the continuous improvements to programming languages and their IDEs over this long period of time, there is still no strong convergence between programming and modeling languages. This suggests that both categories are perhaps doomed to coexist and to evolve independently in a scheme of mutual cooperation. But the boundary between them has never been precisely drawn. Some people even question the fundamental distinction between modeling and programming, suggesting that perhaps both activities could merge in the long term. These are more than sufficient arguments to motivate a separate investigation on the subject. In the long parallel evolution track of programming and modeling languages, the recent decade has allowed to understand more clearly the principles underlying MDE (Model Driven Engineering) and how they differ from the classical principles of programming. So the time may have come to ask if modeling and programming are really different and to provide definitions that will help developing this debate on a more rigorous and positive basis.

After a short introduction to the long history of modeling languages, the talk will summarize some lessons learnt in the last MDE iteration, insisting on the central role of metamodeling and model transformation. It will show how the modeling vision puts a stronger focus on the “representation” relation (how a model represents a system) and how the programming vision favorites interpretation, executability and thus stronger integration of domain, platform and application views. As a consequence of this, the needs for modularity features may be different in the context of modeling and programming languages. The talk will also examine how these two branches of languages engineering (modeling and programming) have differently integrated the tension between DSL and GPL approaches (Domain Specific vs. General Purpose Languages).


About the #UYMS Conference:

National Software Engineering Symposium (UYMS), Turkey, software, researchers, engineers, and educators in the field of software innovations, trends, experiences and discussed the basic problems of software engineering platform.

UYMS, research results to stakeholders, experiences and proposals will be presented doctoral sessions, training seminars, panel discussions and product promotion offers. UYMS conducted since 2003, providing an environment beyond the sharing of research results, plays an active role in shaping the future of the national software engineering research field. The main target of 2012 UYMS repeating the success of its predecessors, and the future of the national software engineering research field to shed light on the present document.

UYMS containing original results in the field of Software Engineering 2012, all the conceptual, theoretical and practical studies are invited. 2012 The main areas of UYMS including without limitation, as follows:

  • Software Development Process, Agile Software Development, Service-Oriented Methods, relevance-Oriented Software Development and Software Product Lines
  • Software Requirements Engineering, Software Requirements Management
  • Software Quality Assurance, Testing, Verification and Validation
  • Software Project Management, Configuration Management
  • Software Quality Management, Process Improvement Model, ISO 15504, CMMI
  • Software Engineering Education
  • Software Development Tools
  • Ethics in Software and Software Policies
  • Experimental Software Engineering
  • Model Driven Software Development
  • Software Architecture, Software Frameworks and Patterns
  • Software Components and Reuse
  • Software Metrics, Software Estimation Methods
  • Embedded and Real-Time Software Systems Engineering
  • Distributed Software Engineering
  • Human-Computer Interaction
  • Industrial Software Applications
  • Innovative Software Solutions and Applications

Collected in 2012 in the following categories UYMS suggestions:

  • Research Papers
  • Proceedings of Experience
  • Panel Proposal
  • Proposal for Training Seminar
  • Proposal for Special Session

Symposium Schedule

For Special Session Proposal Submission Deadline: January 16, 2012 (closed)
Paper / Panel / Seminar for Proposal Submission Deadline: March 5, 2012 (closed)
Paper / Panel / Seminar Approval / Rejection Notice Date: April 9, 2012
Submission of camera-Prepared for Proceedings Last Date: April 24, 2012
Symposium Date: May 30-June 1, 2012

Posted in Modeling, Programming | Tagged | Leave a comment

A list of software conferences

I am currently trying to understand how Google+ pages are working.

Just to have one example, I set up a G+ page on some 2012 conferences on software related subjects.

The name of the page is +Conferences.
Here is the link.
If you see one conference that should be added, please send me a note.

Posted in Uncategorized | Tagged | Leave a comment

Definition of an MDE tool

My own definition of an MDE tool is:

An MDE tool is a tool that uses at the same time metamodeling and model transformation to achieve some automation goal in the production, maintenance or operation of software-intensive systems.

There are many ways to use metamodeling or model transformations.

Posted in Uncategorized | Tagged , | 2 Comments