A panel at May’s Code Generation 2007 event will look at the evolution of tools and technologies in these areas. Here’s the panel description:

“MDSD, DSLs, MDA, DSM, Software Factories - a whole bunch of terms, all basically addressing the same idea: using notations that are specific to a given domain to formally describe structures or behaviour in that domain in order to automatically “manufacture” software systems for that domain. But how will these approaches evolve over the next couple of years? What are some of the promising technologies? Which standards will most likely gain practical importance? In this session we try to look into the future and discuss promising innovations and developments in the field.”

The panel, titled The next few years, will be led by Markus Völter, co-author of Model-Driven Software Development, and his panellists will include Steven Kelly (MetaCase), Andrew Watson (OMG), Laurence Tratt (University of London) and one other to be confirmed.

A panel at Code Generation 2007 will consider the question UML vs. Domain-Specific Languages - a false dichotomy?. Here’s the session description:

“Standardised modelling languages, such as OMG UML and its younger cousins SysML and BPMN, emerged from the melee of competing modelling languages available in the mid-1990s. By creating widely used notations for common modelling concepts, these standard languages have made software modelling a mainstream activity supported by dozens of excellent tools. However, the Domain-Specific Language movement has a long and honourable tradition, recently given renewed impetus by Microsoft’s support for DSLs in its Visual Studio tool set. DSL advocates argue that designing a modelling language specifically for a particular application domain allows clearer and more precise models than using a standard language. So who is right? When do the benefits of bespoke domain languages outweigh the advantages of using universally understood notations? Are the two approaches really in competition, or can they co-exist? Our panel of DSL and UML experts will lead the debate.”

The panel will be led by Andrew Watson (OMG) and will include Steve Cook (Microsoft), Juha-Pekka Tolvanen (MetaCase), Chris Raistrick (Kennedy Carter), Matthew Fowler (NT/e) and Tony Clark (Xactium).

Steve Cook has already noted that the panel could be somewhat controversial…

Things have been busy here as the countdown to Code Generation 2007 continues.

Most significantly we’ve overhauled the event web site to give it a crisper look and feel and to make it a bit easier to see what’s on when. Let me know what you think.

We’ve also sent out the final information to our sponsors - if you’ve ever exhibited at one of these types of events - as I have - you’ll know that a lot of work has to go on behind the scenes to bring together the right people at the right point with the right stuff. Hopefully we’ve achieved this with Code Generation 2007.

Aside from this there’s been the usual administration that goes on at these sorts of things. Dealing with enquiries and bookings, answering speaker and sponsor requests, promoting the event, finalising arrangements with the venue etc.

I made my tutorial submission for the Software Product Line Conference 2007 (SPLC 2007) yesterday.

As for SPLC 2006 I have offered to run The Scoping Game - a session that explores Software Product Line Scoping through game-play.

If you want to get a feel for what the session is about, then have a look at my posts on The Scoping Game at SPA 2007 and The Scoping Game at SPLC 2006.

SPLC 2007 will take place in Kyoto, Japan from September 10th - 14th 2007.

The deadline for tutorial submissions is 1st May - more details here.

Some of the speakers and sponsors at Code Generation 2007 have been kind enough to offer some quotes endorsing the event but I haven’t been quite brave enough to include this one  on the event web site yet:

“This looks like the hottest conference on this hot topic, with very prominent contributors. I’m really looking forward to learning lots at this one.”

I’ve written a little opinion piece for Matt Deacon’s newsletter for software architects. It’s entitled Model-Driven Software Development - ready for prime time?

–

The history of software development has seen a steady lifting of the level of abstraction at which practitioners operate. Languages such as COBOL and FORTRAN largely replaced assembly language programming. Higher-level languages such as C have largely displaced these languages, and C itself has been marginalized by C++ and Java with the widespread adoption of object-orientation.

Some see Model-Driven Software Development (MDSD) as the next evolutionary step in programming technology. A recent survey by MediaDev  established that 39% of developers were either already using model-based code generation or were planning to use it. Awareness of some of the key approaches “ Software Factories and MDA - is also high - running at around 70%.

A personal illustration of this interest came last year when I started running a series of software talks in Cambridge, England with Alan Cameron-Wills, now part of Microsoft’s Solutions Framework group. As our first speaker we invited Steve Cook to give a talk on Software Factories. Now with this being a first-time event we hoped for around 20 people to show up so you can imagine our surprise when 55 people turned up - we only just had a big enough room for everyone!

But like our audience that evening, most developers approach model-driven techniques with a healthy dose of scepticism. Some tool vendors aren’t shy of promoting their latest offerings as the next silver bullet, and old hands may remember being burned by CASE tools in the late eighties and early nineties. So is anything different this time around?

One difference this time around is of course that it’s not our first time around. We’re older and wiser and have learned some lessons from the broad failure of earlier approaches.

One of the most promising outcomes from this experience has been a shift in focus, at least for some people, away from general-purpose modelling languages to Domain-Specific Languages (DSLs). Instead of trying to support all possible software problems, these languages concentrate on a specific subset of problems (a problem domain) such as mobile games, security policy enforcement or generation of GUIs. By focussing on a specific problem domain such languages should map more closely to the desired solution and so should be easier to develop, optimise and use.

However, despite interest in DSLs and the undoubted success of some MDSD projects the issue of trust is still present - How can developers be confident that the generated code is as good as code they could have written themselves?

One answer is that the same issue has cropped up before when moving from assembler to high-level languages and from C (say) to C++ and once compilers were good enough most people adopted them - it was simply more productive to do so.

A second answer is that some MDSD tools allow the developer very precise control over the generated code. The issue then becomes one of how good your developers are at writing generators to map from the model into code.

A related point is the area of round-trip engineering - being able to generate models from code as well as code from models while keeping both sets of artefacts in step. In some cases there may be a need to add to the generated code in order to address some deficiency in the modelling or generation process. One solution is to allow hand-written code to be mixed with the model and then integrated with the generated code. The emerging power of language annotations may help address the reverse code to model transformation process.

Pressure for solutions in these areas comes from the fact that software systems are getting bigger and more complex and new technologies are emerging at such a rate that our existing tools and approaches are reaching their limits. Some new paradigm is required to address problems of comprehension, productivity and maintainability and MDSD is emerging as a strong candidate.

–

I expect there will be some healthy debate around these issues at May’s Code Generation 2007 event.

The highlight of Day 3 of the ACCU Conference (for me at least) was Schalk Cronjé’s talk on Generative Programming. Schalk has run a sequence of sessions at past ACCU conferences and this session focussed on the real problems of applying Generative Programming. His focus on doing things with today’s tools and on practical problem solving was a welcome change. According to Schalk C++ Generative programming is a vastly untapped field.

Schalk began by noting that many engineers build components with little reuse potential. This leads to excessive time when adapting the software for another system. Sometimes when developing there may be artefacts that you can reuse or generate to save time later. You just need to think about this when starting out.

One question he is commonly asked is - Is it too difficult? – His answer is that this isn’t the issue; the problem is usually motivation. If the semantics are correct then the concepts are straightforward. An audience member noted that the organisation must value code reuse in order to implement these approaches.

As an example of creating generative library Schalk described the process of building a rule evaluator: Web and mail protocols are very different but there is an essential need to provide a custom, optimised evaluator for different protocols. I’m hoping that Schalk will write up his talk for the Code Generation Network so I’ll miss out the technical details here and focus on some of his general comments.

Schalk began by noting that Generative C++ can lead to a large number of configuration classes or meta-classes being generated – it is not uncommon to work with 50+ tag classes within a single type list. Effective integration of meta-programming, compile-time paradigms and run-time paradigms is required. Typical problems if done wrongly in C++ are code bloat or long symbolic names. In some cases you can’t always use a pure template-driven approach.

Schalk uses the Boost libraries for meta-programming as he feels this is the only practical C++ meta-programming environment and all his examples made use of Boost. In particular the Boost metaprogramming preprocessor has a number of macros to deal with the complexity of generated C++ (e.g. commas between typenames in templates). Use of Boost is also in line with Schalk’s “Principle of least surprise” – stick to what other people have been doing especially in a pretty new field.

After taking us through 5 idioms for C++ Template Metaprogramming Schalk closed his session with a number of observations:

• Generative Programming pushes C++ skills beyond the knowledge of existing practitioners. This explains the slow uptake of such techniques and also raises the question of how to recruit people with these skills?
• Compiler time reduction is a big issue – his current builds run at around 45 minutes – and what happens if you hit a compiler error after this amount of time? Some compilers also can’t deal with the complexity of some of the generated programs.
• Introducing a new technology can be political:
  • Some people will have a mental block about the technology
  • There is a distrust of tools
• Generative Programming teaches very good skills outside the C++ domain
  Separation of generative stuff from non-generated stuff
• Am I in the wrong language? (Schalk’s answer - Yes)
  • The problem is that languages aren’t good enough to solve these complex problems.
  • Some languages are easier to generate in than others. An audience member – not me – noted that “All languages will become Lisp eventually.”
• Generative Programming in C++ shows requirements for future languages
  • Powerful syntax
  • Simplicity of expression

I also owe thanks to Schalk for mentioning Code Generation 2007 and the Code Generation Network at the start of his session.

There’ll be a book stall at May’s Code Generation 2007 event with 10% off all purchases.

I’ve been collecting book suggestions from the speakers and thought it might be interesting to let you know what people have suggested so far. I’ve yet to hear from a number of people so this sample is a little biased - particularly as one speaker sent me a whole load of suggestions on MDA. I’ve also highlighted books where the author or a co-author will be speaking at the conference.

It’s also worth mentioning that the book stall should have several copies of the new Microsoft book “Domain Specific Development with Visual Studio DSL Tools” hot off the presses. Two co-authors of this book - Alan Cameron-Wills and Steve Cook - will speaking at CG2007.

If you’re coming to the event (or even if you’re not coming) I’d like to hear your suggestions…

Regular readers will know that I am organising May’s Code Generation 2007  conference. This is a developer event aimed at offering practical advice on topics such as Software Factories, Model-Driven Architecture, Domain-Specific Languages and Generative Programming. The speakers are industry veterans who have been-there, done-thought and bought the t-shirt when it comes to model-driven software development so this is a unique opportunity to come and to find out about the dos and don’ts of these emerging techonologies.

After a number of people commented that they couldn’t make the whole Code Generation 2007  conference we’ve decided to make it possible to book for just one or two days.

This means that the following one day packages are now available:

Friday 18th May - This day has sessions on the following themes: Getting started with model-based code generation, Domain-Specific Languages - including two sessions on Microsoft’s DSL tools, Model-Driven Architecture, Model-Driven Development in the Enterprise - including a keynote speech from Axel Uhl of SAP AG. In the morning there’s also an in-depth tutorial on Code Generation of GUIs. (£185 - includes lunch, tea / coffee, delegate pack etc.)

Saturday 19th May - This day has sessions on the following themes: Generative Software Development - including a keynote and a tutorial led by Krzysztof Czarnecki, more sessions on Domain-Specific Languages, Software Product Line case studies, Model-Driven Development in the Embedded space, and several additional sessions on Model-Driven Development in the Enterprise. (£185 - includes lunch, tea / coffee, delegate pack etc.)

Sunday 20th May - Several hand-on sessions and workshops including an in-depth session on the Naked Objects Framework. A top-quality panel looking at the future of model-driven software development. An in-depth discussion session where you can quiz a panel of experts and other session leaders on any issues you have and work with peers to discuss collaboration and problem-solving. (£135 - includes lunch, tea / coffee, delegate pack etc.)

There are also a couple of two day packages allowing you to see all the sessions in a particular theme or to explore a variety of topics. These have a lower per-day rate to reflect the cost-savings we make when someone books for more than one day.

Friday 18th May and Saturday 19th May - £345 (includes lunch on both days, tea / coffee and delegate pack etc.)

Saturday 19th May and Sunday 20th May - £300 (includes lunch on both days, tea / coffee and delegate pack etc.)

The conference dinner on Saturday 19th May is also separately bookable at £35 for three courses including wine. However, if you book the three day package for £450 the conference dinner is included. With my sales hat on I can tell you that this is incredible value.

All prices are quoted exclusive of VAT at 17.5%. Book now at http://www.codegeneration.net/cg2007/booking.php

I took part in Charles Weir’s Supporting Many Platforms session at the ACCU conference (URL) yesterday.

Charles heads up Penrillian, a company specialising in porting applications between mobile platforms and between different implementation languages.

The first question was why port? why not just start again from scratch? The answer is that rewriting from scratch is in most cases very expensive, it’s almost impossible to reimplement from a specification (or rather to rewrite the specification from what you’ve implemented). Furthermore, while you’re rewriting you’re not advancing and so you lose time in which other software may be moving forward in the marketplace. (Internet Explorer overtook Netscape while Netscape was being rewritten.) In a Software Product Line setting you have to produce so many product variants that it’s simply not practical to rewrite from scratch each time.

Charles presented three key techniques to perform the porting process:

Code Triage – Begin by dividing the codebase to be ported into portable code, potentially portable code (which would be portable if it was refactored) and platform-specific code (examples of this are typically found where the code talks to the outside world – e.g. device hardware, networks, UIs etc.). Charles also noted that this triage process implies some architectural decisions to minimize the size of the non-portable code.

Refactoring to produce portable code - Much code could be portable if it was refactored – business logic and rendering code are prime examples. Typical issues Penrillian have encountered include UI event handlers that do business logic, rendering code for a fixed-size screen, communication interfaces that aren’t abstracted.

Test-driven porting - Changing code introduces bugs and so you need a safety net. The process used at Penrillian starts by ensuring that the code is under test on the original platform. When this has been achieved logging is used to record calls and responses at the points where the program calls non-portable code. This logging data is then used to generate mock objects (URL) to mock-out code for your new platform. Once you have this in place you can begin your reimplementation of platform-specific code safe in the knowledge that your safety harness will catch any problems in your new implementation.

Charles concluded by noting the two worst mistakes when porting:

• Thinking something isn’t needed when you port – it usually will be.
• Not using testing to support your construction process.

At the end of the talk I asked everyone what his or her thoughts were on device convergence in the mobile space. I’ve participated in a few of the sessions run by Cambridge Wireless’s Mobile Games s group and these always seem to end with the hope for greater convergence in the device space. As I’ve previously noted, 50% of the development budget for a mobile game can be consumed by porting costs.

The first observation was that convergence is nice because there’s so much of it. More seriously it was also observed that vendor lock-in relies on divergence and it’s my own view that the pressures operating in this market will force continued fragmentation in device platforms and capabilities. The forces for convergence are simply not strong enough yet…

Penrillian has a number of links to mobile porting resources on their web site at http://www.penrillian.com/porting.