Last day of CG2008.

Key note: The Domain Specific IDE by Steve Cook (Microsoft)
Steve has introduced DSLs briefly, talked about various patterns of use, then the main topic of software development using DSLs and the evolution of software development. He depicted SW evolution in quadrants and highlighted the path of evolution as: craftmanship > mass production > continuous improvement > mass customization.
A few highlights from the session

It makes sense to model concerns [IT Architecture].

[DSL, code generation] the only way to get some head-way is to make it economical.

To create a language [DSL], it really means to create a tool. The language itself is pretty useless in itself.

We have recognized that Visual Studio is a platform not just an IDE.

Bran Selic: Standardization [software development] goes way beyond standardization of API. One way to do it right is to standardize on semantics.

Experience Report: Evangelizing Code Generation: A case study of incremental adoption by Brooke Hamilton (FM Global)
Brooke’s session was pleasantly different than the other sessions during the conference as he was from the customer side and not a vendor or an academic. His presentation was brilliant, well structured, pleasantly constructed. Brooke had real details of his own and his team’s experience on their project(s) from the last few years. It was definitely one of the best presentations during the conference, it sparked a lot of good discussions.

Code Generation Narcosis – you feel more powerful using code generation than you really are.

Code generation improves architecture. It makes you look for redundant parts and separate concerns.

We cannot make an application serving unknown needs, but we can generate a lot of code!

Versioning of the templates [code generation] is absolutely crucial.

Tutorial: Strategies for generating code from Microsoft DSL tools and T4 text templates by Brooke Hamilton (FM Global)
This session was more of a demo using the Microsoft DSL Tools in the Visual Studio environment. Brooke also tailored in some of his experience with the tool and how it is applicable to their projects at FM Global.

* * *

In summary, it was an excellent conference with a lot of great presentations from the top experts on this field, great discussions during panels, BoFs and Goldfish Bowls. A lot of new ideas, thoughts and questions to take away to consolidate and look for answers until next year's event.

Second day at CG2008.

Tutorial: Model-Driven SOA: Synchronize Business Planning with the IT Design process by Ian Barnard (Telelogic)
Telelogic, recently acquired by IBM, presented a very corporate like view of modeling, the key buzzwords of the session were: EA, BPM, SOA, ELM (Enterprise Lifecycle Management), Model-Driven SOA…

Tutorial: Implementation Techniques for Domain-Specific Languages by Markus Voelter (Independent)
Markus is an entertaining presenter, he has a broad knowledge of the various topics around code generation and DSL. His customer experience also comes across and he makes genuine remarks about IT architectures and business-IT alignment.
This particular presentation was a deep-dive on DSL and implementation, categories of DSLs and their use, DSL implementation techniques and examples including: Scala, Ruby, Converge, EMF/GMF, MetaEdit+

DSL does not have to be turing complete!

execution != precision

Experience Report: Can executable UML make it as a Mainstream Programming Paradigm? by Allan Kennedy (Kennedy Carter)
The presentation started with a fair amount of philosophical discussion, involving the audience, about software intensive systems, software engineering, and modeling. Later Allan introduced the concepts, the use and value of Executable UML (xUML).
xUML seems to have impressive customer base and references including some defense industry customers and NASA.

Tutorial: Best practices for Creating Domain-Specific Modeling Languages by Juha-Pekka Tolvanen (MetaCase)
JP has recently published a book on Domain Specific Modeling (DSM) and I was very much looking forward to hear the details from the author himself. JP gave plenty of examples and details on best practices, lessons learned from his extensive customer experience. A great value from the presentation was to hear concrete numbers for developing with DSL. The statistics included variations for language complexity (number of concepts) and the complexity of artifacts generated (number of them and types).

Panel: Flexibility in Code Generation chaired by Jos Warmer (Ordina), Sven Efftinge (itemis), Anneke Kleppe (CapGemini NL), Laurence Tratt (Uni of Bournemouth), Steven Kelly (MetaCase)
The panel has eluded into many different topics in many directions including flexibility in DSL and code generation. From the questions and comments it seems that these concepts still have a long way to go to be more mature, precise and agreed on.

Unfortunately I’ve missed the Mistery Movie of the evening – Pirates of Silicon Valley – will catch up on that one day…

This week I am attending the Code Generation 2008 event in Cambridge, UK.

The first day passed really fast with lots of great topics and presenters. Below are a few interesting quotes and thoughts from the day.

Keynote: Matching Supply and Demand: Challenges in Model-Based Code Generation for Quality of Service-Constrained Software by Bran Selic (Malina Software Corp)

Bran‘s presentation had many thought provoking statements and questions in the domain of System Engineering with Quality of Services (Non-functional) requirements. Amongst many statements, the following was maybe the strongest hit:

Platform independent != Platform ignorant

Direct Code Generation with Built-in Flexibility by Anneke Kleppe (CapGemini NL)

An interesting talk about hard-coded (programmatic) transformations. She was talking mostly about the Octopus project. She emphasized a lot the importance of decomposition on many levels including not only the target application but also the code generator.

DSL model is not a DSL! Just like a .java file is not the Java language

is a reminder of how misused terminology and jargon has polluted not only this domain [DSL] but the whole IT industry.

Panel: MDD and Software Product Lines – a marriage made in heaven? Mark Dalgarno (Software Acumen), Juha-Pekka Tolvanen (MetaCase), Ian Barnard (Telelogic), Markus Voelter (independent)

On the volatility of investment in DSL and code generators (somebody from the audience):

The value of information captured in models (instances) is orders of magnitude larger than the investment in the meta-model, transformation, tools.

Goldfish Bowl: Approaches to DSL Evolution chaired by Peter Bell

First of all the concept of a goldfish bowl discussion is brilliant! I do not know how these work generally but this instance of it went very-very well.

The discussions were mainly skirting around the situations where the DSL changes. The typical questions came up were:

• What happens to the existing model instances?
• What happens to the existing code generators?
• Is there a way to make the transition (evolution) automated?

Tutorial: Concrete Syntaxes of DSLs by Arno Haase (Haase Consulting) and Sven Effinge (itemis)

It was a fairly basic overview of various DSL and DSM approaches with a demo of openArchitectureWare‘s tools. The demo was a nice example of using textual modelers (xText) together with graphical editors (GMF).

Birds of a Feather: The Art of Abstraction

The main theme for this BoF was to list and discuss the considerations that make a DSL a good DSL.

“This is your captain speaking and I meet minimum standards of English” – started the radio show on BBC4, called PM, the other day (2008 March 5, Wednesday) on communication in aviation and air traffic control.

The stories and the short recording from a real situation would have been funny, except that they were rather horrific, especially if you are a frequent traveller on planes.

Until today, international pilots and air traffic controllers “only” had to use a basic radiotelephony, phraseology restricted set of phrases. Now the so called Operational Level 4 communication skills are mandatory.

While it might be a bit of a stretch to call the phraseology mandated for air traffic controllers and pilots a Domain Specific Language (DSL) in IT terms; it is still a pretty close equivalent to DSLs, and it certainly operates with the same principles for the domain of air traffic control.

One of these principles is clarity in communication and being able to capture and communicate the concepts of a specific domains. I have written about the importance of DSLs in IT Architectures regarding communication before – see the developerWorks article referenced in a previous blog entry.

Recently I have read an excellent article from Markus Völter: Architecture as Language: A Story. Markus uses DSL in his story to achieve clarity in communicating architectural concepts and decisions. The story gets even more interesting when you discover that it is about building a new flight management system.

Play the short snippet from the BBC4 Radio show – PM – is available here.

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

OK, maybe not so new, but it is definitely gaining more ground (again). So why is it interesting, what is the point here?
I say: anybody can hack code these days , but , hacking code that generates code… now that is a skill !!!

I am not trying to despise or lower the value of a good programmer who has the discipline, knows best practices, follows guidelines. These programmers are very rare, even these days. I am writing about a new type of developer here.

These days, even teenager kids can write viruses (have to admit that they need a Microsoft for this, which makes it possible for them). But the real deal is actually writing the virus generator (for example: VBS Worm Generator), one that can generate your home-made-gonna-bring-down-the-internet-worm-peace-out type of stuff.

Of course there are more honourable and nobler purposes than writing a virus generator.

Essentially code generation starts with developing an exemplar - the code basis for the pattern implementation. The real skill here is to ensure that the code is generator or pattern friendly. Friendliness is a subjective measure, meaning how easy it is to develop the pattern implementation from the code.

Pattern implementation is about extracting the variability from the exemplar – the part of the code that is likely to change in the generated instances.

As it happens, these two tasks belong to different roles also likely to be different individuals. How are these two roles going to work together? What is the contract between them?

The contract, similar to an interface definition in OOP, in this case it is going to be a model. Actually I should say a meta-model that captures the elements of variability, and the relationships between them.

Once the pattern implementation is ready, an instance of the meta-model – a model – provides the input for the code generation.

This meta-model and the modelling activity gives us Model Driven Development.

The meta-model can describe a set of interrelated concepts, where these concepts can be captured using for example a Domain Specific Languags (DSL). DSL is a topic for another entry, in the meantime here is an article of mine about it: Explore model-driven development (MDD) and related approaches: Applying domain-specific modeling to Model-Driven Architecture.