Starting November 1, 2007, I will work as a "Senior Independent Consultant" for Intentional Software. I will stay independent and also work with other customers, but the majority of my work will be for Intentional. I will also continue my involvement with openArchitectureWare. Note that when I will talk, present or write publicly, I will always make clear whether I am acting in my role related to Intentional, or simply as myself :-)
As I had already pointed out in previous posts, I think that their technology supports a qualitatively better way for building domain-specific languages. Actually, their Intentional Domain Workbench is one of the first incarnations of what Martin Fowler calls a Language Workbench. I am really looking forward to working with the technology and the team!
Of course I also used OOPSLA to capture a bunch of interviews for the SE Radio podcast. Here's what I recorded: Galen Hunt on Singularity, Olaf Zimmermann on Webservices, Dick Gabriel on Lisp, as well as Erich Gamma and Dave Thomas (OTI-Dave). So you can expect good stuff to appear on SE Radio over the winter :-)
Friday, October 26, 2007
Reasons to go to OOPSLA
In case you've ever considered going to OOPSLA, here are a couple of reasons that make it somewhat special compared to other conferences. For example, ...
... there were keynotes by various "old guys" such as Dave Parnas (architecture guru), Freed Brooks ("No Silver Bullet") and John McCarthy (Lisp). Not all of those presentations were necessarily exciting and enlightening, but seeing these folks talk is certainly a treat you'll only get at OOPSLA.
... I was sitting in the bar one evening listening in to a discussion about programming language concepts. What made this conversation special was the fact that the people discussing were Anders Hejlsberg (Turbo Pascal, Delphi, C#), Eric Meijer (LINQ, and general "language pimper"), Martin Odersky (Scala) and Dave Thomas (an old Smalltalk guy).
... there was a really extremely cool eveining keynote by Guy Steele and Dick Gabriel. The keynote was basically about interesting features in various historical programming languages. What made this talk stand out, however, was the fact that it was almost like a theater: superbly prepared slides, music and poems (and this really nice Lisp song :-)). Dick and Guy didn't talk -- they recited their prepared script. At one point, Guy actually did some rap thing about a programming language :-) This was really different, absolutely great and the first talk on a tech conference, where the audience actually stood up at the end to applaud!
In case you've always wanted to know (but never got the chance to ask :-)) what I am up to in the AMPLE research project, here's a bunch of videos of the stuff I did together with Christa Schwanninger and Iris Groher.
This moring I ran my tutorial on Software Architecture Documentation. Although Documentation is an inherently unsexy topic, I had about 40 participants and I think it was fun for everybody. Yesterday I already ran my tutorial on Best Practices for MDSD, I had about 45 participants, and feedback was really good. Today I spent the rest of the day in the DSM workshop. It was much more interesting today, since we've actually had discussions as opposed to paper presentations.
I am currently in the Domain Specific Modeling 2007 workshop at the OOPSLA 2007 conference. Their are so many papers that the organizers had to make it a two-day workshop. Good sign for the whole MDD/DSL/DSM trend!
I am once again a little bit frustrated by the way universities work - they seem not to care what happens in the rest of the world (I had blogged about this last year) and are happy to reinvent wheels over and over again :-( Some event invent their own (really bad!) notation for showing concepts and their relationships, as opposed to using well-known notations (for example, UML class diagrams).
Otherwise it's very nice here. It's my first OOPSLA without a jet lag, since I had already spend a week in Seattle.
Thursday, October 18, 2007
API vs. DSLs
The discussion of what is the difference between an (internal) DSL and an API comes up over and over again.
So, what is it that distinguishes a DSL from a (really well designed) API? Is it method chaining ("fluent APIs")? Is it the fact that the API/DSL is readable by a domain expert?
In my view, the two important differences are:
(1) domain-specific syntax: the syntax does not look like a 3GL program. It might be a completeley different syntax in an external DSL or syntax "tweaks" in an internal DSL that make it look sufficiently different than typical host language code
(2) domain-specific validation: if something's wrong in your "DSL program" I want error messages on the same level of abstraction as the program (which is: domain-specific) as opposed to strange compiler or runtime errors (because you somehow misused a weird host language feature)
I am not sure these two points are good enough to distinguish things. What do you think?
Monday, October 15, 2007
Metaprogramming Approaches compared
I was recently thinking about different approaches of meta programming. Specifically, I was comparing the approach taken by converge, and the one taken by Ruby. Of course, the primary difference is that Converge is compile-time, whereas Ruby is runtime meta programming. But there's another difference:
In Converge, the process works as follows: the parser reads your DSL-specific code into a parse tree based on a custom grammar. Then you as the meta programmer get a chance to process that parse tree - and what you'll typically do is to transform it into a regular converge AST. To make that simple, Converge provides macro facilities.
In Ruby things work completely differently. You (mis)use all kinds of more or less obvious language features to somehow make your own DSL be valid Ruby code. As a consequence, the meta program often looks awkward, it is not easily understandable what happens. Also, you cannot use *any* syntax you want - because it has to be valid Ruby syntax.
I really think the approach taken by Converge is cleaner - since you have one clear transformation step, as opposed to using all kinds of eval, block and other trickery. It would be interesing to use it in a dynamic environment.
Today at the Eclipse Summit Europe there was another workshop called "BigModels". The idea was to discuss the challenges in building model management solutions for really big models in the enterprise -- particularly with EMF.
Yesterday there was the 2007 edition of the Modeling Symposium, where I served as the chair and moderator. It is interesting to see that there's really quite a lot of innovation going on. If you want to read more, please refer to Ed Merks' Blog Entry about the event :-)
I have always been interested in programming languages in general, and I have read books about quite a large variety (no, I am not saying that I am a professional in using those languages, just that I think I have a good overview). Recently, the interest in languages and language features (as opposed to bloated frameworks) has increased in the mainstream. Examples of somewhat advanced languages (compared to Java :-)) are Ruby, Scala, C# 3 (to some extent), Erlang (wrt. to concurrency) and of course the whole DSL movement.