They're self produced album Pleased to Meet You is available online, for those who like hard rock as it was played in the seventies and nineties, but with a modern production sound.

A few highlights... Tracks like Pleased to Meet You and In My Head remind me of Styx and Boston. Not because they are rip offs, but the sound of the vocals and guitars contain hints of these bands. This leads to surprise by the time I get to Seven Sins, which is suddenly a lot darker and heavier, maybe even a bit Black Sabbath like. Amazing is again a different thing altogether, starting with a clean guitar intro and a Thunder like intro before developing into a slow rocker again, this time even with a backing chorus. As a bass player, I have to love the prominent bass in Fakin', although I think there was more room for (bass) creativity there.

Talking about bass, the production of the album is quite good. But as with a lot of hard rock albums, I always end up feeling that the guitars are a bit too prominent in the mix, sometimes they even muffle the vocals - which is a pity. There are five fine musicians in the band, not only 2 guitarists. Luckily, the album also contains the semi-balled Hope You Will, where the band proves there's a different balance possible as well.

Overall, this band reminds me of music I used to listen to about 20-25 years ago (now I feel old...), when a lot of young Dutch and Belgian bands were trying to get into 'the scene' by playing their favourite hard rock. They took ideas of Van Halen, Styx, Boston, Led Zeppelin and then created their own sound - with varying levels of success. Bunch of Bunk does something similar, although their influences clearly also include some younger bands than the ones listed above.

Apparently, this style of music is not dead, and there are still people who take the time to write it, record it and bring it to the audience. Not the audience that brings you millions, but as stated on their web sites, these guys play their music, and recorded the CD, mainly for the fun of being able to do it. It's a pity I missed their gig on February 19th, might have been a good old 'hard rockin' party'.

So, after fiddling around with various tools, including MetaEdit+, MPS and XText, and always ending up doing things the old fashioned way, simply because I didn't have the time (or rather take the time) to develop a proper solution I decided that maybe I should finally look into developing that PHP backend for WebDsl myself. Of course, nothing comes for free, and my time is very limited, so I will be investigating the feasibility first, before starting. Danny Groenewegen and Eelco Visser helped me on my way today, by providing some initially ideas on how to attack the implementation side, and by pointing me to an interesting short research paper they wrote: When frameworks let you down...

In this paper, they indicate that the WebDsl DSL was built as a very thin wrapper around Seam, They continue to explain how this made it difficult on one hand to keep the DSL in sync with the framework (they wanted more and different things than Seam could provide out of the box). On the other hand, because the concepts supported by Seam show through in the WebDsl DSL in certain points, it may also be not-so-trivial to replace the target platform with e.g. the PHP CodeIgniter framework which I would like to see supported. Come to think of it, things might get worse if I would add something like qooxdoo or ExtJS 4 for the user interface.

So, in the next few days, I'll have a thread running in the back of my head, thinking through these issues and defining the steps to be taken. In fact, even if my time is limited, I might just be able to spark the development of a very useful extension to WebDsl, that would bring both this tool and the benefits of model driven software development to the far-from-small domain of PHP based web sites (I haven't found any up to date statistics, but at least Google Insight indicates that PHP is the most searched for web programming language - for what it's worth).

I'll keep you posted on further developments in this area, shortly.

Since then, we've seen numerous activities in the area of certification of software and IT architects. However, a lot of those certify the knowledge of an architect on a specific technology or framework (did I hear TOGAF?), not so much on their general skills as architects.

This, I believe is not the way to go. Knowing a framework, especially the current frameworks that focus mainly on either specific processes or technology, does not make an architect a good architect. An architect should not only understand processes and technology, he should also be aware of what business he operates in, what business the customers and (end)users of the sytem he's designing operate in. Then, he needs to be able to convince general management, project management and engineers of the usefulness of the architecture he provides, and guard its realisation. 'No shortcuts allowed' is a nice credo, but it requires quite a bit of human interaction skills to realize. In my opinion, an architect should be certified on the taxonomy of skills that are required to fulfill the job, not solely on his technical abilities and good memory for process manuals. A nice overview is provided in the IASA taxonomy, which is in line with what I've been living by the past 10 years, Gerrit Muller's views on Systems Architecting.

With that, certification gets a completely different meaning - it will allow companies to select the best architect for the job, knowing that they are hiring the person that has the right skill set and distinguish between the real architects and the ones that merely adopted the title because it was hip. To stress that last part: in the context of what I wrote above, I still have no clue what a Java Architect actually is. As someone said a while ago: 'there are only two Java Architects: the guys who set up the architeture for Java itself, almost 20 years ago, all the others are just Java expert users'.

Certification of architects on this generic skill set, with some refinements for specific roles an architect may play, is at the core of the IASA certification, which was launched a few years ago. This certification is in that respect, comparable to the already existing, and succesful certification of Systems Engineers by INCOSE.

The certification is already quite well adopted in the USA, India and the UK and Ireland - and more countries, including The Netherlands are picking up. Together with the Dutch IASA Chapter board, my goal is to bring this certification, and the benefits it brings, to The Netherlands. For this purpose, the IASA Netherlands Chapter organises events for architects 4 to 5 times each year, and will facilitate trainings for IASA Core Cerfication and board exams for IASA CITA-P certification from this fall.

After summer holidays, we have planned the following activities:

September 6th: IASA Chapter event at Achmea, Tilburg. Check our Chapter Web page for the registration form (will be published shortly)

October 3-7: IASA Architect Core certification and exam, Amsterdam region (exact location to be defined)

Late 2011/Early 2012: CITA-P certification of 3-5 Dutch IASA members so we can start our own CITA-P board sessions

One a final note, I would like to make explicit that this type of certification and the skills it focuses on are not limited to what we tend to call 'the IT world', meaning the people working on enterprise systems, business process support and information management. The skills tested and certified in the IASA program are equally valid for software architects in embedded software, high tech systems and product engineering.

Language Workbench Competition Workshop 2011

On Tuesday, I chaired, together with my beloved egg timer, the first Language Workbench Competition workshop. In this workshop, as announced earlier in this workshop 10 presenters show cased how they addressed the same assignment.

The assignment summary, as taken from the documentation on the LWC web site reads:

0. Basics
This phase is intended to demonstrate basic language design, including IDE support (code completion, syntax coloring, outlines, etc).

• 0.1 Simple (structural) DSL without any fancy expression language or such.
• 0.2 Code generation to GPL such as Java, C#, C++ or XML
• 0.3 Simple constraint checks such as name-uniqueness
• 0.4 Show how to break down a (large) model into several parts, while still cross-referencing between the parts

1. Advanced
This phase demonstrates advanced features not necessarily available to the same extent in every LWB.

• 1.1 Show the integration of several languages
• 1.2 Demonstrate how to implement runtime type systems
• 1.3 Show how to do a model-to-model transformation
• 1.4 Some kind of visibility/namespaces/scoping for references
• 1.5 Integrating manually written code (again in Java, C# or C++)
• 1.6 Multiple generators

2. Non-functional
Phase 2 is intended to show a couple of non-functional properties of the LWB. The task outlined below does not elaborate on how to do this.

• 2.1 How to evolve the DSL without breaking existing models
• 2.2 How to work with the models efficiently in the team
• 2.3 Demonstrate Scalability of the tools

3. Freestyle
Every LWB has its own special "cool features". In phase three we want the participants to show off these features. Please make sure, though, that the features are built on top of the task described below, if possible.

All of the presenters showed that they were capable of completing phase 0 and phase 1 of the assignment, i.e. creating a basic language for entities, properties and relationships. From these, code generation to a 3rd party language of choice and splitting up (entity) models into smaller models also proved to be no problem for the participants. The main difference was the effort required to get things done, depending on the user interface and modeling paradigm applied by the different tools. It is obviously quite different to enter a metamodel (and use it) in a text oriented tool than it in a graphical or projection environment. With two truly graphics oriented workbenches (Obeo Designer and MetaEdit+), three projectional workbenches (MPS, Intentional Workbench and The Whole Platform) and five text based solutions (Xtext, Rascal, Spoofax, OOMEGA and Essential) we had a nice mix of what is possible in this area.

Issues like scalability and working in teams were addressed in different manners and level of detail in the presentations, mainly due to the hard constraint that presentations should last no longer than 40 minutes including questions. Only two of our speakers managed to not get caught mid-sentence by the egg-timer.

Overall, my personal impression was that we had put together a nice, workable assignment, that was - although simple at first sight - not something to neglect. The tutorials published on the LWC web site are proof of that - some run up to 150 pages in PDF format. I would encourage anyone looking for a good comparison or tutorial to check out said page, and learn from it. We will be publishing complimentary videos of all presentations, as well as a short summary video online within the next 2-3 weeks, so that everyone can enjoy the results of this great workshop. Meanwhile, have a look at the blogs by Johan den Haan, Markus Völter and Marco Brambini, the MD* Examiner or the Twitter archives.

Also, in an extra session during Code Generation 2011 on Thursday, we collected ideas from the audience (after having Mats Helander and Christian Merenda give a 15 minute demo of what they did for the workshop) for a new workshop some time next year. This should provide us with a new assignment and hopefully another good workshop. One thing is for sure though - in the short term we will drop the term Competition and switch to Challenge or Comparison instead, which are better monikers for what we did, do and will continue to do.

Participants of the LWC11 workshop - posing on the Murray Edwars patio

Code Generation 2011

After this energizing workshop, and a great dinner at Indian restaurant Café Naz in Cambridge, it was time for Code Generation 2011. Here, we found the usual crowd of Model Driven Development practitioners, but also quite a lot of new faces. The audience seems to grow a little bit every year, and those who don't come back are replaced by new faces, while it is clear from dicsussions and greetings that Code Generation regulars stay in touch with each other outside the conference as well. I would consider that a good development, for which we may thank Mark Dalgarno and his team at Software Acumen and the Model Driven Software Network. This year I was only able to be present the first two days of the conference, and keeping an eye on the Twitter feed made me feel sorry to have missed the third day while it was still in progress.

At the conference this year, I was present and listening on a number of presentations, on different topics and with different messages.

Ian Goodsall (Raytheon) presented a comparison between Visual Studio and Eclipse, not so much targeting language developers, but more addressing the needs of modeling language user. Not a usual suspect at Code Generation conferences, this does show that after all the technical bits and detais we need to start/keep caring about those who actually use the MDSD solutions we love so much.

Bernhard Merkle (SICK AG) treated us to a penalty shoot out between textual language workbenches. Similar to the LWC11 workshop, he decided to not have a winner, but rather focus on the different aspects addressed by the various tools. Nice comparison, I hope the results will appear online - he referred to a paper he wrote on this for which I have not yet found a link.

Juha-Pekka Tolvanen (MetaCase) chaired a panel with Pedro Molina, Jos Warmer and Johan den Haan (the consultant, the inhouse developer and the tool vendor) on who should own DSLs and generators - the developer, the customer or the tool vendor. This lead to some interesting discussions, including one where Markus Völter and Andrew Watson alsmost took over the panel and started discussing the (in)sanity of standardization of modeling languages. A nice effort, with many opinions and (if I recall correctly - cg2011 really was a case of information overflow) no generic answer to the question posed by the panel title.

Markus Völter (independent) then treated us to a tutorial on Type Systems, using his favourite tools MPS and XText to show how to implement them. A lightning fast presentation, which may require some additional reading for those new to the topic. From me, the most important thing to remember here is that Type Systems help you prevent user errors, and that their support is available in many modern language workbenches, not just MPS.

Johan den Haan (Mendix) was the only presenter of a lightning talk on Wednessday, and spend 10 minutes presenting why he things model driven development and version control don't have to be foes, but can actually be very good friends. Mendix seems to have a working solution for that in their tool, with sufficient ideas for others to create something similar. Contrary to the nature of lightning talks, this lead to a one hour follow up discussion.

On Thursday, we starte with the first key note presentation of the conference, by Terence Parr, the father of ANTLR. A good choice for a keynote, it had been a while since someone actually showed to be proud of being so lazy that they automate their own work. Years ago my first manager told me that the best developer would fulfill a three week task by spending two weeks writing a tool that would do the work for him in the third week. Terence is one of those.  An inspiring talk, which made me feel like getting back to work right away.Luckily I didn't, because there was more to come.

Stefano Butti and Emanuele Molteni (WebRatio) did a nice tutorial on their language and code generation environment for web developers. The tool contains a graphical language that allows one to define web site structure, flow and persistence. Seems akin to WebDSL, but taking the graphical rather than the textual approach. This is one tool that I will check out some time soon. Their colleague Marco Brambini was sitting next to me, and we seem to share quite a bit of ideas on how to do model driven development. Who knows what that will bring in the future....

After lunch, we used a time slot that became unexpectedly available (Heiko Behrens and Peter Friese were not able to get to Cambridge, due to the Icelandic ash cloud) to allow people who weren't there a look at the LWC workshop. After I rehashed the introduction of the workshop, Christian Merenda (OOMEGA) and Mats Helander (Intentional) presented their LWC demos in even more condensed form (15 minutes), once again controlled by the egg timer. After that, we collected quite a bit of ideas for a new LWC assignment from the audience (thanks all!) so that we can continue to next year.

Marko Boger (University of Applied Science Konstanz) presented his ideas on creating graphical DSLs, using his tool Poseidon for DSLs and Xtext to create the bridge between the textual and graphical world. His search for a new framework, in order to become Eclipse based, led him to Graphiti. The need to create textual DSLs and related generators for creating graphical editors using Graphiti resulted in possibly the first future Eclipse Modeling project born at LWC: Spray. Results to be presented next year at Code Generation 2012? I also attended the follow up Birds-of-a-Feather session end of the day, where this project was born. Since some developers involved have to be freed up from other tasks, anyone interested in this project and willing to invest is hereby invited to contact the project owners.

The last presentation I attended (before the BoF and my departure from Code Generation 2011) was by Jos Warmer (Independent) and Wim Bast (Modeling Value Group). They presented a case study on building a language and code generation environment for an insurance product line. An interesting projects, where domain standards, regulations and modern software engineering come together. Jos has now also become one of the owners of the Spray project mentioned above, because the (Graphiti based) solution Wim and he presented may become the basis for the DSLs to be developed in that project.

Once again, I had a good and useful time at Code Generation, and will be back next year. Thanks to Mark, Jacqui and Nick for the splendid organisation!

Hope to see you all on the Model Driven Software Network, and at LWC12 and CG2012.

However, this attention has a downside - in the form of many different solutions, with varying functionality and qualiy, which makes the choice for the right workbench a non-trivial exercise. Maybe we should all build our own?

The challenge starts with the question what type of language one would like to develop: graphical, textual or maybe a mixture. In relation to that, do we aim for a home grown domain specific language, a standardized language like UML or SysML, or is it more efficient to create an extension to an existing programming language?

It doesn't end there - we also have to decide what to do with the models. Are they intended to become diagrams that support written documentation, or will we actually use them as a basis for code generation, the ultimate goal of a model driven development approach?

All these questions are dependent from the environment we work in, and the goals we want to achieve. This was one topic that was discussed heavily during Code Generation 2010, especially over lunch, diner and breakfast (in that order). As a result, a group of people, mainly members of the model driven network, including Markus Völter, Steven Kelly, Eelco Visser and Jos Warmer concluded that an objective comparison would be useful - focusing on key characteristics of language workbenches. Mid July 2010, a concept assignment for a so called Language Workbench Competition was drafted. Participants were requested to show a solution to a rather generic case, on three levels of complexity, what their language workbench of choice is capable of.

So, what should a language workbench adhere to? First of all, it must be possible to create structural languages, including support for correct usage, let's say a built-in grammar check. These languages should then be used to create models, from which code can be generated in a mainstream programming language.

Apart from that, and less basic, functionality is required to support project based development in average size teams. This implies the models will have to be allowed to become larger than your average 'Hello modelling world' example, and should be splittable into smaller, but consistently managed pieces. Team members should be able to work with these pieces independently, without losing model coherence.

Beyond that, it is useful to support multiple languages in a mixed environment, with as many or more code generators. After all, software systems have a mixed nature - data, behavior and maintenance all require different languages and thus code generators. This includes integration with existing programming languages, if not only then at least because of the fact that most model driven development projects start from an existing code base, which is considered an investment that should not be thrown away. Projects starting from scratch are almost as rare as tropical snakes on Antartica.

Finally, continuity in development plays an important role. This means that a workbench must natively support evolution of modelling languages and code generators, with or without the support of external configuration and life cycle management systems. Scalability plays another important role - just like the amount of code in a product will grow from release to release, models will do the same. This of course directly affects the need to allow teams teams to work on the same modeling base.

The only question remaining now is whether the ideal workbench, which supports all of the above, actually exists. I have my doubts, although there is hope for the future. What I do know is that the Language Workbench Competition acquired it's 12th participant this week, and that 10 of them will be presenting their solutions in a one day workshop on May 24th. This is the first in what I hope to be a series of Language Workbench Competiton workshops, and it will be held in conjunction with Code Generation 2011, in Cambridge.

Not a bad result for what started as a discussion over a barbecue lunch at Code Generation 2010. I can only hope that we will be discussing and preferably using the results. See you all on May 24th!!!

As part of the IASA certification program, an Architect Core course, including the Foundation exam, will be organised from May 30th to June 3rd. Seats are still available, so if you are interesest, please register at the IASA Global web site.

Last week I set up a presentation schedule for the Language Workbench Competition workshop of May 24th in Cambridge. This will be your opportunity to compare 10 language workbenches which have been used to implement a solution for the same software modeling and code generation case. Here's the program that we will be presenting:

This program will be available on the Language Workbench Competition web site from tomorrow, the Windows problems mentioned above prevented me from publishing them there this weekend - a blog post to make up for it.

The video below is the recording of an earlier interview, with MetaCase CTO Steven Kelly.

CodeGeneration 2011

First of all, as a member of the program committee, I reviewed all proposals submitted for CodeGeneration 2011. After the committee reviewed everything, this resulted in once again an interesting program, full of experience sharing, new developments and hands-on sessions. So, hopefully we meet you all on May 25th - May 27th in Cambridge.

I almost feel pity that I will be missing out on the last day of the conference, but I have to travel back to The Netherlands on the 27th, to visit what could once again be my last chance to see my all time favouris Rush live on stage.

Language Workbench Competition 2011

Next to CG2011, I've been preparing a workshop that will be held at the same venue on May 24th, the first Language Workbench Competition workshop. During a few meetings at CG2010, the idea for a language workbench comparison was coined by Markus Völter, and about 10 of us jumped on the bandwagon to arrange it. After the, too ambitious, attempt to get a Birds-of-a-feather arranged on SPLASH2010, we decided that a workshop during CG2011 would be more feasible. And so it is - we have 12 submissions in the making that attempt to implement the proposed case, and 10 of those will be presented by their creators during the workshop. In fact, we are currently looking into the options to extend the workshop from a half day to a full day session, to be able to cover all 10 submissions in sufficient detail.

Attending the workshop is open for anyone interested, either as part of the CodeGeneration 2011 conference package, or as a separate item (95 pounds). Hope to see you there, now that we know what is possible with DSLs and code generation, getting the right workbench is the next step to take.

MDSN interview with Chris Raistrick

Finally, I am also preparing the third interview in the series that Peter Bell and myself are conducting for the Model Driven Software Network. On March 31st, at 6PM BST, I will be interviewing veteran modeler and executable UML expert Chris Raistrick. Keep an eye on this announcement to find instructions for joining the interview at GotoMeeting.

Last monday, I conducted the first in a series of interviews for the Model Driven Software Network. I talked with Steven Kelly for a little over an hour, about his background in model driven software development, his views on arguments against model driven development and the benefits of using it. We also discussed the importance of learning from the past, and whether or not Martin Fowler is right in saying that the productivity benefits of model driven development have not yet been proven.

The interview recording is available on Vimeo now (at the time of writing, it is still being converted, so it may not be available immediately).

NEW LWC PARTICIPANT: OOMEGA

On the day of the interview, I also registered a new participant to the Language Workbench Competition, the OOMEGA project. Team lead Christian Merenda wrote a guest post on Jordi Cabot's Modeling Languages Blog about this project.