Language Workbench Competition: Case is online!!
Sometimes, things can go faster in software engineering. That's why we were able to agree on the content of the LWC case already two weeks ago, and on the final version over the past week. So, about three weeks before the planned date, we have now published the case description for the first round of the Language Workbench Competition (LWC). A description of the case is online, as well as submission instructions.
What is still missing is a deadline, which will be added during or after the summer holidays season. We are aiming to organise a first activity during SPLASH 2010 (TAFKAO - The ACM-conference Formerly Known As OOPSLA), but the exact form and contents of that session are yet to be defined.
Language Workbench Competition
Last week I was in a Skype conference call with a number of model driven development specialists to discuss how the Language Workbench Competition should be shaped. We decided that, instead of aiming for one specific workshop deadline at a conference, the competition will be an online event. Participants will be provided with a case description, which they should implement in their Language Workbench of choice, showing how they meet the criteria set by the case, and what additional strengths their Language Workbench offers. The results, in the form of papers and online demos will be published through the competition web site at http://www.languageworkbenches.net, and on various occasions we will submit workshops, Birds-of-a-Feather and other sessions at conferences to demonstrate and discuss the results with competition participants and other interested parties.
The goal of the competition is to provide insight in which workbenches are moste suitable for different purposes and environments. There's no prize, except infinite fame and our gratitude, just like (at least in our perception) there's no ultimate general purpose language workbench.
Trends in model driven development (cont’d)
After spending 2 days (one more to go) at Code Generation 2010 I feel it's time to add something to the trends I perceived earlier. I'll prepare a third installment on this based on the comments I received at the Model Driven Software Network later.
The first observation I had was concerning language workbenches becoming more and more of a buzz. During the Code Generation conference we actually started planning a Language Workbench Competition, which will likely be co-located with the conference next year. Based on input from Eelco Visser, Markus Völter, Jos Warmer, Pedro Molina, Karsten Thoms, Bernhard Merkle and others we are defining a case right now - to be resolved by different parties (suppliers as well as users of current workbenches). If workbenches weren't a buzz already it is now, with MetaEdit+, MPS, XText, Essential, CodeFluent, Concrete and others being presented and the workshop in the making.
Second, the integration between graphical and textual DSLs, and combination of different DSLs as part of one solution is also taking place. With MPS, integration between DSLs and programming language is available in a reasonably easy way as well now. Reasonably easy hear means that the tree based concept underlying MPS requires some 'getting-used-to'. It's too bad that the integraion of graphical and textual , as attempted in e.g. Papyrus was not presented at the conference this year. Next year will hopefully show more.
Then, I mentioned the 'multiple views on the same content', also known as projectional modeling or projectional editing. This seems to be mainly a case for the secretive folks at Intentional, but MPS is getting closer and closer to that. Also, at least one solution combining GMF and XText to show the same models exists (I'll provide a link later, if it's a public project). A nice new kid on the block here is Concrete, a web based solution developed at Lear Corporation.
Finally I listed the models@run-time concept seems to be something people are really enthousiastic about, although many haven't heard about it yet. Also, not many solutions are available. In a discussion with Johan den Haan and Steven Kelly, we concluded that in e.g. web or cloud based projects the technical limitations of that environment might get in the way, in relation to performance, usability as well as reliability.
On top of these trends that seem to be at least partially confirmed during the conference, I have to add the following:
First of all, there is still a large community that is not working on DSL based solutions, but has produced more and less successful solutions based on (executable) UML. Although DSL and DSM advocates may deny the feasibility of such solutions, the fact that some of them are succesful cannot be ignored.
Then, adoption of model driven approaches is still very much an issue. It seems to be something that depends on the market in which one is active how easy or difficult it is to get MDSD trials and project started. One discussino led to the conclusion that in markets where (software) engineers are working in closer cooperation with end users (e.g. in insurance and banking domains) the adoption of solutions based on domain modeling and domain specific languages is easier to achieve than in high tech environments, where developers tend to be more technology oriented and hardly ever meet with a customer or end user. This based on differences in aspects like developer focus, customer communication and organisational structures. Tomorrow's workshop discussion around Spring Roo may shed more light on this, if so I'll get back to it.
All in all, the presentations at CG2010 and the discussions I had during the breaks and in the evenings seem to confirm some of my observations, but also lead to new ones.
To be continued....
Trends in modeldriven software development
Looking over the past few months, say since PPL 2009, I perceived the following trends in model driven development.
- language workbench is a term that seems to be replacing the notions of MDA-tool and DSL-toolkit very rapidly now. Of course the term is not new, but it is becoming more common.
- in DSL world, the distinction between graphical and textual DSLs is rapidly being replaced by integration of the two, see cooperation between Itemis and MetaCase, but also recent attempts to integrate XText with GMF
- language workbenches with multiple views on the same content, like Intentional has been promoting, are showing up in multiple places right now (MPS, Spoofax, the integration mentioned above)
- given what I read in the ACM Journal a couple of months ago various articles in IEEE Computer ed. October 2009, models@runtime will become more visible shortly as well
Which trends do you, MDSNetwork members, perceive, both in practise and in research? I'd be glad to hear from you, since I've been asked to do an article on trends in this area (for a Dutch magazine) over the next few weeks. Of course an English translation will follow shortly afterwards on my blog.
I'd be more than happy to receive ideas here, in mail, through the Model Driven Software Network, through twitter or face-to-face during CG2010 next week.
An architecture for model driven web development (1)
This is the first post in a series that I announced this weekend. In this post, I will introduce the core architecture I use to create my DSL based web development environment. Although not mentioned in the announcement, this post will have multiple editions - hence the (1) in the title - because no architecture is finished and correct the first time. Every time it's revised, a new post on this subject will appear.
Components of the architecture
The key components of the architecture I have in mind are twofold: a run-time environment and a design time environment. The reason for having both environments explicitly as a part of my architecture is based on my interpretation of the IEEE 1471 definition of architecture:
Architecture: the fundamental organization of a system embodied in its components, their relationships to each other, and to the environment, and the principles guiding its design and evolution.
I strongly value the bold parts, more than many architects I have met over the past 15 years. I interpret these parts as meaning that the relationship between the components that form a system strongly determine the acceptance and usability of the system by it's intended users, and that an architecture needs to take into account the way the system is going to be designed, realized and extended, including the components used to achieve that.
In the run-time environment we find the typical components of a web application: a web server (e.g. Apache), a database (e.g. MySQL) and a scripting engine (e.g. PHP) or an application server (e.g. JBoss). The design time environment contains tools for scripting (a PHP and JavaScript editor), DSL creation, code generator editing, and code generator execution. Oh, and of course a versioning system like Subversion and a tracking tool like Trac.
With these components in place, we have everything to support a model driven software development process.
A model driven development process
The model driven software development process is based on domain specific languages, and generating code from models defined in those languages.
The process I have in mind here consists of an interative approach, in which three items have to be maintained: a (set of) domain specific modeling language(s) and models created using those languages, a (set of) code generator(s) to generate code from the models, and a generic framework containing the foundation on top of which we generate code. It's no use generating all the code in the framework, since that is not application specific.
Each iteration in my process consists of the following steps:
- Select content of the iteration, in terms of features to realize
- Model the features using the available domain specific modeling language(s), extending it (them) where necessary.
- Generating the code for the new feature, if necessary by prototyping it first and then extending the code generator(s) and/or the framework.
In the experiment described in this series of blog posts, the process is mainly executed by me, myself and I, but past experiences show that this approach works well in cooperation with others, including the domain experts you need to develop an application. I should add here, that my DSL is based on domain terminology from the web application development domain, for which the web itself provides a great dictionary, and the terminology I use when discussing a new web based venture I am starting with two partners. These partners do not speak "W3C", they only speak 'end-user' and 'money maker'.
My selection of components
For my first attempt at building applications based on this architecture, I selected the following components.
- The XAMPP platform, which contains a web server, database and scripting engine:
- Apache 2.1.x web server
- MySQL 5.1.x database
- PHP 5.3.x scripting engine
- CodeIgniter 1.7.x - a Model-View-Controller framework based on PHP, to get a headstart w.r.t. generic stuff
- jQuery UI 1.7.x - a JavaScript library for CSS manipulation and other useful UI things, included in the same vein as CodeIgniter
- Eclipse Galileo PDT, an Eclipse based IDE for PHP and JavaScript development
- MetaEdit+, a graphical DSL creation and modeling environment by MetaCase. This is the only component in my set up that is not Open Source
- Subversion and Trac for version management and issue/progress tracking
That's what we start with...
...and the next post in this series will contain an overview of how these items fit together, and what the first iteration looked like.
DSL for web applications
Most web sites are interactive nowadays, in the sense that they require data from users, and provide other data or information in return. That's a very generic way of describing just about every only store, community and company web site.
For our new venture, Consultants United, we require such a web site as well, and we're not too fond of CMS-es like Joomla, which offer more than you need in features and often too little in relation to the features that you do need. That's why I decided to base our new site on CodeIgniter, like my own company site for Delphino Consultancy. For the latter, I was already building a DSL that would allow me to generate all the stuff required for the MDSD Tooling index and integrate it smoothly into my site.
Given that the new web site had higher priority than the index, but I want to build both, I decided to go for it and create a DSL and code generator for interactive web sites, using MetaEdit+. Once the site is up and running, I want to redo the effort using XText and MPS, to get some first hand experience the differences between graphical DSL modeling, textual DSL modeling and intentional modeling. To this list, I will probably add WebDSL as well, once it's PHP support is released. I have no use for the Java/Tomcat version, since my provider, like many others, doesn't support that platform unless I buy a dedicated server.
Right now, the first stage of building the DSL in MetaEdit+ is almost done. I build a DSL that allows me to model the basic data model that needs to be supported by the site, and I'm able to generate all the models, views and controllers that I need in CodeIgniter from that, as well as language/translation information, SQL to generate the database and form validation code.
That was a nice step
, but I need more. I don't want to do the navigation by hand, and there's a workflow that we need to go through in order to get data into the system (an interactive project marketplace) in the right manner. So, right now I'm working on a small DSL for that, which I hope to combine with the Entity DSL to be able to generate the static and dynamic parts of the site completely.
I will publish separate entries on this in the not too distant future:
- An architecture for model driven web development (MDWD)
- A structural DSL for web applications
- A workflow DSL for web applications
- Combining DSLs into a web application MDSD solution
- Adding a DSL for look and feel, or not?
- Extending the architecture: precooked features
After the launch of the first site, and hopefully also the MDSD Index, this will be followed by some more posts:
- MDWD: revisited with XText and MPS
- MDWD: revisited using WebDSL
This looks like a lot of work, so I'm not going to predict any dates. Just keep an eye on this blog.
CG2010: first keynote agreed, CfS still open!
Last week Eelco Visser accepted our invitation to do a keynote presentation at Code Generation 2010. I expect this to become an interesting experience, given the broad mix of academic research and practical implementations he is involved in. In fact, WebDSL is on my todo-list as an item to check out some time soon. Unfortunately, that list seems to be only getting longer rather than shorter these days.
With the first keynote announced, the call for speakers is still open - please submit your ideas before January 15th.
Bearskin – fear of change
At certain stages of during your life as a software architect's life, you encounter so many new things that it becomes overwhelming. At these times, you would be more than happy to put on a bear skin, and move into a cave. Preferably without 'the wheel' and 'fire', to avoid falling back into old habits. To be honest, sometimes I actually enjoy this 'leaving the new behind and going back into history'.
What I often notice when talking to people in industry, but also when our government discuss issues like our ongoing traffic congestion, is that only very few people try to see their challenges as part of something bigger. Each challenge, or problem as they are often called, is regarded by itself, even though they are part of a bigger system - be it a machine, a piece of software or the concept of rush hour.
Looking back 10 years, at the time I worked in Philips Research, that surprises me. Back then, the notion of 'systems-of-systems' (every system consists of set of smaller, cooperating systems) looked like something that would really catch on. Then-guru on the subject, Mark Maier, defined a number of criteria to which such a system-of-systems should adhere. Each of the composing systems should be operationally independend and managerially independent - i.e. it should operate, and be developed and maintained independently. On top of that, the complete system-of-systems should develop in an evolutionary way, and show emergent behavior - go beyond the behavior of the individual subsystems. No doubt we'll find such systems nowadays, in fact, I identified a few with some PDEng in Software Design students last week. However, there are but a few - except maybe in the US Defense Industry, where the concept seems to a have been adopted quite well.
A similar reasoning applies to systems thinking, a concept discussed in many books, lectures and projects in books by Peter Senge, Eliyah Goldratt and many others. Roughly, systems thinking works from the notion that everything is connected (like systems-of-systems!), and that the cause of each problem is rarely the nearest link in the chain. Based on this, interesting discoveries were made in areas like economy and logistics over the past few decades. In systems industry unfortunately, we still find ourselves dealing mainly with the symptoms rather than the root cause of our challenges.
In between reading and pondering over these things from my past, I also read a summary (and a lot of tweets) of a presentation by Barbara Liskov, at OOPSLA 2009. She's a software engineering specialist, who recently received the ACM Turing Award for her contribution to software engineering as a discipline. In her presentation she stressed amongst others that 'young software engineers know to little about the history of software engineering'. That got me interested, after all history and bear skin mix very well. As examples, she mentioned that 'extensible programming languages are a nightmare' and 'it's more important for code to be easy to read than to write'. I tend to agree with here, in a way. After all, some of our modern 'extensible' programming languages haven't fully achieved their goal. Python for example didn't go through a complete rewrite without a reason, and we'll still have to wait and see what Lua and Ruby will go through in the next few years.
Also, from a maintenance perspective, I can only agree that readable code is very useful. After all, many companies and developers still document their software only poorly and that legacy is carried for years. On the other hand though, easy to write code will improve our productivity, and DSLs and code generation were introduced for a reason (don't they serve both sides?).
All in all, I get the feeling Barbara addressed things quite well, taking into account pro's and con's, based on over 30 years of software engineering experience. New developments are useful and necessary, but we seem to be continuously returning to old habits and old mistakes and ineffective solutions, because we fail to see the past and the bigger picture. With that, she addresses a pitfall which seems to already have swallowed that other giant from the past, Grady Booch. He stated in an interview, around the same time as Liskov's presentation, that ' we should go back to the roots of UML' and that 'the main artifact is raw, naked code, everything else is secondary to that'. Just now, at the time model driven development and code start showing their real advantages...
After reading Barbara's story, and Grady's interview, I shrugged off my bear skin once again, and sat down by the fire to read an article on the latest developments in IT and software engineering. Sometimes it's good to look back, but let's start trying to pick up the right new things and hold on to them, rather than giving in to our old fear of change.
[to be published in Dutch in Bits & Chips magazine #18, 2009]
CodeGeneration 2010 Call for Speakers
The call for speakers for Code Generation 2010 is open. Click for details...
CodeGeneration 2010
Well, PPL2009 was last week, SPA2010 is closing it's call for proposals, OOPSLA is currently underway and OOP 2010 is in January. So, why not announce Code Generation 2010 right now 
The site is up, and the call for speakers is open. If time allows, I'll submit a proposal to present a comparison of building the same application with MetaEdit+, XText and MPS.
Only drawback is that I have to make the comparison first, hence the 'if time allows'.
Categories
SysML Software engineering Content Management World The architect Progressive Rock Blogging Abstraction Code generation Model Driven Architecture
Recent posts
- Language Workbench Competition: Case is online!!
- Language Workbench Competition
- Trends in model driven development (cont’d)
- Trends in modeldriven software development
- New looks for Consultants United
Twitter...
- Somerset was too far to drive in one day. Changed plans and did crash landing in Forest of Dean. 2 weeks ago
- Left Yorkshire, lunch at Sherwood Forest and then on to Oxford, or Somerset. 2 weeks ago
- @stevekmcc Finland some other time, maybe in 2 years. Canada next year, unless market crashes again. in reply to stevekmcc 2 weeks ago
- More updates...
Powered by Twitter Tools
Recent comments
- Andriy Levytskyy on An architecture for model driven web development (1)
- Tweets die vermelden Language Workbench Competition « New Thoughts -- Topsy.com on Language Workbench Competition
- Jean-Sebastien on Trends in model driven development (cont’d)
- Angelo on Trends in model driven development (cont’d)
- Rafael Chaves on Trends in model driven development (cont’d)