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.
New looks for Consultants United
Today, I finally upgraded the Consultants United newsletter archives (in Dutch) to our new house style. New services to be launched after summer. Feel free to join our forums to share your ideas on being an independent consultant in The Netherlands.
SE Radio aims at quality – rather than quantity
It's been a while since I wrote here - been too busy otherwise. Follow up posts on the Web DSL are in the making, but today I have some other news.
The SE Radio team announced they will be lowering the frequency of their PODCasts to once every 4 weeks instead of once every 2 weeks. Reasons are busy schedules mainly - guess that could be considered a pay-off of doing a good job.
Anyway, check out their continuing PODCasts at http://www.se-radio.net
The Google Wonder Wheel
Thanks to Twitter I only needed 6 months to discover the existence of the Google Wonder Wheel. It's been there since May, but I only just now learned about it in an article about how children search the web to find out about.
What is it?
The wheel basically resembles a multi-level mindmap, that allows you to see where you are going when following a thread of search results. When you search, next to a list of resulting pages, videos and images you get a small mindmap like image with your query in the middle and a set of links to (groups of) search results around it. When you click a link, another similar wheel is added, but centered around the search term you clicked. The image next to this post shows the image I got after searching for 'domain specific languages' and then clicking 'domain specific modeling' on the wheel.
With each click, the shape of the mindmap changes, showing always the wheel you came from, and the wheel for the term you came from. Next to the wheel, the search results (pages, images, and videos) for the term you clicked are shown, in the familiar way.
Useful!
I like this idea, and I'll be using it a lot from now on when researching topics of interest. I've been creating my own mindmaps on-and-off for years, although not as structurally as some, and this will only make it easier to do so when collecting input for articles, columns and blog posts.
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.
Authority inversion kills architecture
Who hasn't heard stories about managers who don't have a clue what their engineers, architects or quality officers are trying to achieve? And who has tried to go over their manager's head to try and fix the problem that way? Out of frustration, or to strenghten their own position, like this lady? I know I did, on a few occasions, and in one case I actually did it - be it without much success.
Earlier this week I was talking to an system architect and friend, working at a high tech electronics company. He's running into something that is related, and that I have experienced in the past as well - something which we agreed could be called 'authority inversion'.
The issue with going over your boss's head is that you contact his boss (substitute manager if you don't like the word boss), to get support for your ideas and have your boss instructed to implement them. Not a very decent thing to do, unless your relation with the person in question is really screwed up. In the case we were discussing, a similar thing happens, but with architects instead of managers. When engineers, regardless of their core discipline like software engineering or electronisch engineering, become more experienced, they eventually get a promotion. They become designers, or architects and are assigned responsibility for technical quality and soundness of systems, or parts of systems, and for guiding other engineers in achieving that.
'Guiding' is the key word here: they have no formal authority, because they are not part of line or project management - in the end the project manager or the development manager is the one to make the final call. This is not necessarily a bad thing, these people have been assigned responsibility for time and budget while the designer or architect was not. However, it can become problematic when the deadline gets nearer and the team contains a few engineers who feel like doing things their own way. Unfortunately, every team of more than 5 people tends to have at least one of those. They do their job, and they are very good at it to a certain level, but they are allergic to making agreements on interface, showing concern for other people's key interests and tend to focus on their key technical interests.
At some point, near the deadline of a project, the architect is confronted with choices made by these people that were not communicated or which they refused to reverse when communication was in place. At that point, the deadline is so close, as well as the end of the budget, that the architect's arguments about long term quality guarantees are overruled for the sake of time-to-market and delivering-on-budget. This is what we agreed to call 'authority inversion': an architect or designer is asked to take responsibility for quality of design, and made a recognised authority in that area. Some of the members on the projects he works on do not go along with that, and in the end get their way in front of the project manager or line manager. 'It works now, and it's too expensive or too late to fix it. If it becomes a problem later on, others will deal with it', is the final remark in a lot of cases.
Painful, for the architect, and painful for software or systems architecture as a discipline. There are still a lot of people who think we have a high tech industry that can sustain itself and it's products by this way of working, who don't believe we need requirements engineering, architecture or test management - but also not agile development or model driven development. As long as we have to deal with authority inversion as described here, we have a long way to go.
Just to make sure: this is not a rant against engineers, or meant to say they don't believe in quality. Every engineer believes in quality, but not all of them see what is important for overall system quality, and that makes them dangerous when combined with ignorant managers.
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.
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)