One of the goals of the MoDSE project is to build actual enterprise software in a model-driven manner. Doesn’t that sound cool? Apparently, and sadly, enterprise software is not cool. Pity. The question then becomes, if enterprise software is not cool, then, what is it? I was reminded of this question again when I read this article, which states the following about enterprise software:
Enterprise software is all about helping organizations conduct their basic business in a better, more cost-effective manner. In software jargon, it’s intended to “enable core business processes” with a high degree of reliability, security, scalability, and so on. These aren’t sexy, cool attributes, but are absolutely essential to the smooth running of businesses, organizations, and governments around the world.
This description of the purpose of enterprise software is quite clear. But whenever I hear things like “enable core business processes”, “implement business rules”, “business logic”, I’m like, what the hey are you really talking about? A few years ago, just for “fun”, I decided to look into Enterprise Java Beans (version 2 at the time). The main reason was probably that I thought it sounded cool. Man, was I disappointed. EJB was not cool, far from it. To me, it seemed like yet another overly-complex way (involving writing 5 types of Java interfaces to the same thing) of managing and manipulating rows in a database and keeping state. And honestly, now that we are generating EJB (albeit EJB 3.0) from our WebDSL code, I cannot conclude anything more than that EJBs are not much more than that. Simply data entities and variables — database tables essentially. Polished-up and prefixed by the enterprise “E” to look shiny to the enterprise.
The nice thing is that in WebDSL, data entities just look like simple database rows again. And state really is not much more than a set of variables. We demoed WebDSL to some “enterprise programmers”, and they seem hooked, but will that be enough?
We will have to work on an extra shiny logo to compensate for the lack of complexity 
I’ve been starting to experiment with my twitter account a bit again. It’s kinda nice for brief notes on the progress of my research for example. Maybe I should build something like twitter as a test case in WebDSL. Should only take a few lines…
Thomas asks in response to my brief post on WebDSL:
Do you think that languages like this will be the Next Big Thing in web development world?
The MoDSE project that I’m working on has the belief that languages like this will not only be the Next Big Thing in the web development world, but in software engineering in general. We work with big companies such as Atos Origin, Getronics PinkRoccade and others that are also taking their first steps in this kind of software development. “This kind of software development” being model driven engineering.
The general idea is that we feel in software development you still work at a very low level. In web applications you still deal with request parameters, type checking them, handling sessions, writing database schemas. We want to abstract from all that and let you work at a higher level of abstraction. In MDE this is the general idea: come up with some language that offers you an as high level of abstraction as is suitable, then use this language to describe/build your software in. Then compile this high level language to the low-level language that you otherwise would have to code in. Of course the question is what is a suitably high level of abstraction, and how do you design and implement a compiler for such a (domain specific) language. Both these issues are things we’re researching in this project.
The “E” in MoDSE, stands for Evolution. Once you come up with a language to describe your applications in, how do you evolve your program. What if, for example, I would add a field to an entity in my WebDSL application. That would mean the database schema has to be adapted and still the current data should be retained. Adding a field is a simple one to solve; it becomes more difficult when you start moving fields, or renaming them. But this only one type of evolution, another is evolving the language itself. An example is syntax changes. In an old version of WebDSL an entity was described as follows:
SomeEntity {
title :: String
}
But then we decided it really needed a keyword:
entity SomeEntity {
title :: String
}
The result of this change was that all our old WebDSL software no longer compiled. We had to add the “entity” keyword everywhere. Ideally you would automate this process, your applications should evolve with the language.
Just some issues we’re looking at.
I intend to make my posting here more regular from now on, basically I haven’t been posting anything at all lately. So here’s the first one.
As you may or may not know, I recently (well, three months ago) start with my Ph.D. It’s part of the MoDSE project (Model Driven Software Evolution). I have a post in my drafts folder about what exactly that is all about, but I have a hard time finishing it, so I’ll just briefly explain what I’m work on at the moment.
We’re working on a DSL (Domain Specific Language) for the web, called WebDSL (better website, built with WebDSL is coming up). The idea behind this language is that web development today always consists of combining many different technologies and languages. Some examples are HTML, CSS, PHP and some database. WebDSL attempts to combine all these things into one language. It has language constructs to define page structure, business logic and data access (through embedded HQL, a kind of SQL). Layout currently is still a separate thing (done in CSS), but this will be integrated as well. The nice thing about this is that not only do you have to learn half a dozen frameworks and languages, it is also easier to check that all the different components work well together (you can do type checking for example).
We translate WebDSL applications into a J2EE applications, using Java, JSF, Hibernate and SEAM (running on JBoss), a script will then compile all that and you will end up with a .ear file that you can deploy on any JBoss Java application server. For the parsing and translating we use SDF and Stratego/XT.
WebDSL is essentially an exercise in designing and building such programming languages geared towards a particular domain. There will be more information when the first WebDSL version will be released, (planned on December 20th), but here’s a piece of WebDSL code (a very bare-bone wiki system), so you can get a flavor of what it looks like (the only thing missing are some simple templates and the CSS):
application com.example.wiki
description {
This is an automatically generated description
}
imports templates
section data model
entity Page {
name :: String (name, id)
text :: WikiText
}
section global variables
globals {
var mainPage : Page := Page {
name := "HomePage"
text := "This is text for the main page.\n\n
Here's a link to [[page(AnotherPage)|another page]]"
};
}
section pages
define page home() {
main()
define body() {
section {
header {"All page"}
list {
for(p : Page) {
listitem { output(p) }
}
}
}
}
}
define page page(p : Page) {
init {
if(p.text = "") {
goto editPage(p);
}
}
main()
define body() {
section {
header {output(p.name)}
output(p.text)
section { navigate(editPage(p)) { "Edit this page" } }
}
}
}
