OOPSLA VI: Thursday and Wrap up

Thursday started with the tutorial on Model-Driven Development of Distributed Systems that I delivered together with Doug Schmidt. The tutorial went quite well - as usual, we had too many slides :-). However, after the break the power went away, the lights went dark and a fire alarm was sounding. Everybody had to leave the building. After a while, we were allowed back in, but there still was no power, so we had to continze the tutorial without the video projector. So, we just continued talking, with the people looking at the handouts. This was the firs time that handouts were actually useful :-)

In the afternoon I went to a couple of GPCE sessions, where, among other things, Frederic Jouault (in case you read this, Frederic, sorry for omitting the accents :-)) showed the TCS tooling, basically an xText++, i.e. a way to define textual concrete syntax for existing meta models. Very nice.

I would probably have been much more enthusiastic in my description of TCS if it hadn't been for a tool called SAFARI. SAFARI was demoed later, in it basically a framework and generator for building languages and the necessary support infrastructure on top of Eclipse. Based on a grammar definition and a set of wizards, a complete IDE infrastructure is generated. This was *very* impressive. The tool is developed by IBM research. It's currently not yet open source, but they will open source it by mid 2007. This looks very very interesting. Arno, Frederic and myself have been talking to the guys behing the tool to discuss some prospective integration with the Eclipse modeling world. It's obviously quite early wrt. to SAFARI and modeling, but we'll keep them on the radar and make sure there will be some integratioin once SAFARI is open source.

In the evening, I had dinner in a great seafood restaurant with a sizable portion of the MDD/DSM/GP community. It was great fun, and the food was outstanding!

So, to wrap up: although much criticized recently, OOPSLA is still a conference that is very much worth going to. Nowhere else will I meet so many colleagues and friends, especially wrt to the MDD community. Everybody is there, the GME people, Metacase, Eclipse folks, people from Microsoft as well as the guys from INRIA. There have been many inspiring and fruitful discussions. So, thanks to all of you for these discussions, the fun, and the conference in general. I am happy to be part of this community. See you next year :-)  permalink    0 comments

 

More new Material for SE Radio

At OOPSLA '06 Arno and I interviewed a number of folks for Software Engineering Radio. Here's the list of things we recorded:

• Steffen Schaefer on Sensor Networks
  
• Morgan Deters on Compiler Construction and GCC
  
• Niclas Nilsson on Dynamic Languages
  
• Brian Goetz and David Holmes on (advanced) concurrency
  
• Jonathan Aldrich on Static Analysis tools
  
• as well as Doug Schmidt, Linda Northrop, Kevin Sullivan and Gregor Kiczales on Ultra-Large Scale systems.
  

So, lots of cool stuff coming up :-)  permalink    0 comments

 

OOPSLA 5: Wednesday

Wednesday started with the keynote by Guy Steele (he'll be on the SE Radio podcast soon!) about the Fortress language. Keynote was great! Fortress is a language intended for scientific computing: mathematical notations, strong type system, extensible through libraries and parallelism. One thing I was thinking of (and what I forgot to ask him in the podcast interview) was the relationship of Fortran/Fortress to tools like Mathematica. In which situations would you use which of the tools/languages? Later we did a number of interviews for the podcast. In the afternoon there was (once again!) a "great debate" on whether/why/how AOP is good or not. Not too many new things learned there. In the evening we had The Event in the Oregon Museum of Science and Industry. In spite of the cool museum, The Event was mainly about talking to other folks :-)  permalink    0 comments

 

OOPSLA IV: Tuesday

Tuesday began with a telco with a customer and several technical discussions with various people. We then recorded a set of SE Radio interviews (I'll write a separate posting on this at some point). Then in the afternoon there was the panel on the challenges in building ultra-large scale (ULS) systems. The panel wasn't that interesting, because it mainly focused on the social and philosophical aspects. Discussing some of the engineering challenges would have made it more tangible. It was cool to see computer legend Peter G. Neumann. In the evening then there was a session on the GoF which consisted of a memorial of John Vlissides who passed away on 24 November 2005. After that there was a discussion with Erich and Ralph about the future of GoF, specifically the much-rumored 2nd edition. I think it will not appear any time soon, if ever. The day ended with going to the hotel bar with a number of folks. There I met Ward Cunningham who now works for the Eclipse foundation. I tried to convince him of the benefits of MDSD but, I think, didn't really succeed :-)  permalink    0 comments

 

GME and Eclipse

Just wanted to let you know that the GEMS project (more or less the Eclipse/EMF version of Vanderbilt's GME is now part of Eclipse GMT! This is wonderful, since this will result various ways of bridging the GME world and the Eclipse Modeling world. Having the GME folks being part of the Eclipse Modeling community is a huge win, since these folks (Doug Schmidt, Andy Gokhale, Jules White, Jeff Gray and others) are really experienced in that domain. Very cool!

Labels: eclipse

  permalink    0 comments

 

OOPSLA III: Monday

Today I joined a tutorial by Brian Goetz and David Holmes on Java 5 concurrency (I also signed them up for an SE Radio interview :-)). The tutorial was really good and systematically introduced the audience to concurrent programming in Java - although there was a lot of stuff that wasn't Java specific at all. I took one thing from the tutorial: today's programming languages are not sufficient for dealing with concurrency. All but the most trivial idioms have to be implemented through more or less intricate behavioural code. Why is this a problem? It is a problem, because this makes things very hard to analyse by tools. We need languages that factor out most of this stuff into declarations (as opposed to implementation code). There have been languages (such as Occam) that did that to some extend. New languages, such as Fortress, aim at reviving this transition. This also gets back to a comment Eric Meijer made at JAOO: We must design languages and runtime systems so that the programs are much more amenable for analysis by tools. In my view, this is especially true for concurrent programs.

Later that day, after lunch, I did an interview with IBM's steffen schaefer for SE Radio about sensor networks and mobile computing. Very interesting - you'll like it when it's online. After that, I spent a while with Arno and Frederic Jouault discussing an upcoming Eclipse TMF project. Then there was a reception (with the usual food and shop talk :-)). After that, Arno and I recorded another interview: Compiler Construction (exemplified by GCC) with Morgan Deters. Finally, the day ended with another set of discussions of various Eclipse Modeling related issues with Jean Bezivin and Frederic.

So all in all a good day - with not too much sessions attended, but a lot of productive work. Looking forward to tomorrow.

By the way, I am not going to write a daily diary for the rest of my life, but I think conference days at OOPSLA are always packed full with interesting things - interesting not just for me, but also for some of you readers, I hope.  permalink    0 comments

 

OOPSLA II: Sunday

Today in the morning I was in the workshop for domain-specific modeling (DSM), organized by JP Tolvanen and Jeff Gray (I was on the comittee). The morning was paper presentations. Here are some noteworthy things:

• Do you know Jos Warmer? He's a well known UML and OCL guy. He said he doesn't like UML for MDSD :-) Just thought I'd let you know ...
  
• There was also a presentations where the presenter talked about building a DSM infrastructure with MS DSL Tools. Transformations were to be built using C#, References among models were done using name-equivalence, the generators generated code only from one model at a time. This sounds actually quite simplistic. In general, I thought that many of the practitioner report position papers were relatively simple systems. I don't want to badmouth anything of this. However, I think that advanced concepts are not very widely spread. Specifically, many people build their tools from scratch and reimplement (more or less round) wheels over and over again.
  
• After the practitioner papers, the workshop moved on to discuss the "theory and philosophy" papers. There were two quite good papers on metamodel composition and on the relationship between metamodels, ontologies and semantics. Seems like there's a lot of research to do. Other problems of current modeling infrastructures, as it turns out, are scalable repositories as well as model paritioning and cross-references. That's some of the same challenges we'd identified at the Eclipse Summit Modeling Symposium.
  
• Then it became bad. There was a presentation by a guy from a german university (I am not going to mention his name or the university). He talked about some "research results". And I got really frustrated. Why? Because he presented as research results stuff that we had literally written in the MDSD book 1.5 years ago. Don't these people read literature before they do research? For example, they "researched" the roles that developers have to play in an MDSD project: DSL developer, f/w developer, app developer! Who'd have thought that. Also, he talked about "agile DSM" and basically repeated the arguments we made in that section in the book. Now, why do I write this here? It's not that I am angry because we've "invented" these things in the MDSD book. But, shouldn't universities, before resarching something, check whether this stuff had already been described somewhere? Why present something as research results that is already state-of-the-art in industry? I hink research dollars and euros should be spent for really hard and novel issues, and not on reiterating on trivialities!
  

In the afternoon I gave my GPCE tutorial on Eclipse and oAW together with Arno. Went well, I think. We then got stuck talking about stuff with Michael Stal and Krzysztof Czarnecki... went to have dinner in town ... and then got to bed at 2200 ... jetlagged :-)  permalink    0 comments

 

OOPSLA I: Flight and Portland

Yesterday I arrived in Portland, Oregon for OOPSLA 2006. I'll give two tutorials there and I have also been on the comittee for two workshops as well as the poster comittee. Portland is actually a really nice city. Relatively small, nice pubs and - very strange for US cities - a really good public transport system based on a light rail train called MAX (bascially a "Strassenbahn"). Inside the city, it is even free. Very useful. I arrived at Portland on Saturday at 11:30 after a 10 hour, non-stop flight from Frankfurt. No connecting flight hassle. Very nice. Also, on the flight they had free wifi. Thanks, Lufthansa. After walking around Portland yesterday (and meetig Arno in the park, hunting birds with his giant telephoto lens :-)). We then had dinner with Robert Hirschfeld (HPI) and Klaus Ostermann (TU Darmstadt). At about 10 pm I went to bed, and after 9 hours of resting sleep I am now comparatively fit :-). More OOPSLA reports will follow during the week.  permalink    0 comments

 

MDSD/PLE Conference in Leipzig

On Oct 19 and 20, I was at the conference Model-Driven Development and Product Lines: Synergies and Experience organized by Ulrich Eisenecker from the University Leipzig. As you can see from the program, there were a number of interesting presentations. Here are some comments about things that I found especially interesting:

• JP Tolvanen of Metacase showed once again their MetaEdit+ tool. As most of you will probably know, they have a tool for defining and working with DSLs. Once again, it became obvious that they have by far the most advanced tool in this category. I am not necessarily convinced about the way they process models (their code generation language doesn't look that nice, and they don't support model-2-model transformations) but their editor, as well as the facilities to build the graphical language is really cool. If they only were a bit mre standards-conforming. I (hope I) convinced JP to at least build an EMF export for the meta model and the model, so that other tools (such as oAW) can be used to process models. To be honest, I would really like to use MetaEdit+ as the tool to build DSLs and edit models and then use oAW to process them. I think that would be an interesting combination... Well, let's see.... :-)
  
• Roman Roth of innoQ talked about model-driven software modernization. The idea is to extract the structures from existing host applications (assembler!) into models and then to use MDSD to build the new, modernized applications. His conclusion was that this works in principle, but some aspects were much more challenging than expected. Very interesting presentation! Note that the OMG is working on a standard for this kind of thing called ADM (for Architecture Driven Modernization) - a funny coincidence, that it is the reverse of the MDA acronym :-)
  
• Then Danilo Beuche of pure-systems talked about some of the challenges of converting a set of applications into a product line. He mentioned that while there are some technical challenges (such as how to find the variation points in existing applications - he showed some very interesting approaches!) he emphasized that the main challenges are on the management and organizational level. So, if you want to establish PLE in an organization, you WILL NEED management buy-in. So don't forget that!
  
• Later, Axel Uhl, the Chief Development Architect for SAP's MDD tools talked about the challenges of scaling MDD to the enterprise level. Currently, they have roughly 200 (!) different development tools, most of them in some way model-based. All of them shall be integrated into a common new repository-based MDD development environment. It is really interesting what kinds of challenges will show up on this scale. Luckily, most of us are not working on this scale, so many of the problems are not directly relevant, but this was certainly one of the best presentations of the conference.
  
• The last session on Thursday was by Jens Weiland of DaimlerChrysler Research talked about variant management for Matlab/Simulink models in the context of automotive systems. The approach he took was very much based on the approach I once experimented with (see this (german) article). It is cool to see that these things are beginning to be used in practice - well, at least *research* practice :-) However, I find it interesting that these rather advanced concepts are adopted in the technical/embedded dmain. This once more confirms my impression that currently, the embedded domain is much more eager at improving their approaches/methodologies/tools than the enterprise world. I will blog on this aspect some more, later, I guess :-)
  
• The first session I attended on Friday was by Peter Haensgen of intershop. He talked about their approach to MDSD. He had one slide I really liked. He shows a number of metamodels (and models) that they use for building their system. He suggested that each of the models can be characterized along six dimensions: meta level, partition, technical domain, abstraction level, (concrete) syntax and version. Also, the relationships between models can be categorized: instance-of (i.e. crossing a meta level, transformation relationship and dependencies (or references). Nice categtaorization...!
  
• Tom Stahl, my coauthor on the MDSD book, talked about management issues in model-driven projects. You could feel the experience he has in this area ... interesting talk inspired from practice.
  

Note that for most of the talks I mentioned in this blog entry, the slides are available on the program page. I don't know whether it is planned that the conference will be repeated next year - I would certainly suggest to do so!  permalink    0 comments

 

Eclipse Model-2-Text Proposal

The Project Proposal for the Eclipse Model-2-Text EMP subproject is online. As some of you may know, it was put together mainly by IBM's Paul Elder and myself. openArchitectureWare's XPand, as well as the Recipe framework, will be important components of Eclipse M2T. Please visit the proposal page and provide feedback!  permalink    0 comments

 

The little Joys of a Physicist

As some of you may know, I have studied physics at the University of Applied Sciences in Weingarten. So I am always interested in interesting phenomena in nature or the technical world. Today, when I decided I had to wash my dishes, I let the water fill up the kitchen sink and went away. The sink was full of dirty dishes. When I came back into the kitchen, I saw something really funny. Because of the geometry of the dishes in the sink, and the way the water poured in and flowed out of the sink, the foam produced from the dish liquid formed a nice mushroom-like shape, turning in circles and not moving away. A nice stationary state stabilized. I have taken a photograph of this phenomenon :-)  permalink    0 comments

 

Applied Abstractions

Arno Haase, Sven Efftinge, Bernd Kolb and myself have teamed up to be Applied Abstractions. In addition to our freelance work, we now also operate as a team.

Applied Abstractions specializes in model-driven software development technologies. We help customers build domain-specific languages and adopt model-driven development for their projects. Applied Abstractions leverages open source tooling, primarily Eclipse and openArchitectureWare.  permalink    0 comments

 

Modeling News from the Eclipse Summit 2006

Over the last two days, I have been at the Eclipse Summit 2006 in Esslingen, Germany. I went there because I had two papers submitted to the Modeling Symposium and I also gave a talk, together with Richard Gronback, Ed Merks and Bernd Kolb on the new developments in Eclipse Modeling - of course, openArchitectureWare is a part of that :-)

It was really good to meet some of the people in the community, such as Jean Bezivin (and of course Rich and Ed) to talk through some of the new developments in the modeling world. So here's my own personal summary of these discussions.

Upcoming Projects: First of all the proposal for the Model-to-Text Transformation project is slowly coming along. It has been prepared by IBM and the oAW team. It is now through IBM's internal review and will be submitted to Eclipse real soon now. We are also working, together with Borland, on a proposal for a project to generate textual editors - there's no name yet :-)

Other Communities: We talked about the possibility of integrating various other communities better into the Eclipse Modeling world. Among them is the folks at Vanderbilt (the people around Doug Schmidt with the GME and GEMS tool suites) and the TopCased project (the tool they've built actually looks quite nice!). We'd also like to get the group around Krzysztof Czarnecki involved (who mainly work with feature modeling). Finally, there's already an integration layer between Microsoft's DSL tools and EMF.

What should EMP do? We also discussed about the potential responsibilities of the EMP project itself, that is, in addition to being an "umbrella" for the various subprojects. We thought that they should mainly be working on improving usability (more docs, cook books, tool integration), make sure that the proverbial wheel isn't reinvented over and over again, and trigger necessary changes to base technology (such as EMF). Also, from a more technical perspective, they should provide a framework for subprojects to plugin their tools, i.e. a kind of "workflow component model" for the runtime of a generator and a development time" repository that manages models and edit-time references between them.

Challenges and Issues: We also identified a couple of issues that need to be addressed in the future. Here's a subset: better support for creating "large" EMF Models (Browsers, Editors), MVC for models (several views on the same model, all up-to-date) and resource management, model diffs and Merge
usability (complexity, tutorials, accessibility, tool consistency), as well as collaborative Modeling Support.

All in all, I think - as usual - the most important aspect of such an Event is to meet the people and build personal relationships. The "workshop" itself is not that important. This is why I suggested to run the next meeting of the Eclipse Modeling folks in the form of a hiking trip in the alps (or somewhere). You can have many deep discussions while you're out there in nature - maybe more so than in a "workshop" setting. Let's see :-)

Labels: eclipse

  permalink    0 comments

 

I hate travelling

Travelling has always been one of the more annoying aspects of a consultant's life. But recently it has become really awful. It started with me driving to Munich two weeks ago. It took me 4.5 hours instead of 1.5. Reason: A truck fell over on the autobahn, they closed the autobahn. Chas reigned on the alternative routes. So I though ok, maybe use public transport next time. So, the next time I had to go to Munich I took the train from Heidenheim. It was scheduled to leave at 07:24 in the morning. It was 07:24, but no train to be seen ... and no announcement, nothing. At 07:35 the train arrived. Of course, trains never compensate for their delay once they're on the track, so I didn't catch the connecting train. Instead of the ICE, I had to take the regional train (== much slower!). Of course, once we were half-way in Munich, the locomotive broke down and the subsequent ICE overtook us. To make a long story short: It took me 4.5 hours again, this time by train! Next thing: I had to go to Nurnberg. Typically 1.5 hours by car. Of course it was friday afternoon and I learned that it's a bad time to use the A6 direction east, because all the east german and polish folks drive home for the weekend. 3.5 hours.

Next thing, I flew Munich -> Genoa, Genoa -> Aarhus, Aarhus -> Munich for some conference stuff. Plane from Munich to Kopenhagen (stopover on the trip to Aarhus) was late. I had to run over the complete airport to catch the connecting flight. Since my luggage doesn't have legs to run, it didn't make it.... Until I found out about that in Aarhus, and reported it correctly, the bus from Aarhus airport to the city was gone. Since it was already one o'clock in the morning and no further bus was going, I had to take the expensive taxi....

But it get's worse. Today I had to go to London for a short meeting. I fly into Heathrow at 10:15, and planned to leave at 15:35. But some idiot left a suitcase in the terminal, so they shut the terminal down. People outside of the security checks were evacuated, people inside the secure area were trapped.

So now I am sitting here, trying to spend the time, somehow. At least I found an electrical plug. But the frustrating thing is that you're not told anything. Nobody knows what's happened, how long it will take and so on. There has been an announcement that "flights will be delayed". Oh yeah - I guessed that much! Recently the timetable showed my flight as being cancelled. And Lufthansa, my carrier, doesn't know what to do with me: "We cannot promise that you can go with the next plane" - "So, what do I do if they don't take me?" - "You'll have to take the plane tomorrow morning" - "And Lufthansa pays for the hotel, right?" - "I can't guarantee that". So much for Lufthansa service.

Later, the lounge crew told me I should go out of the security area, and go to ticketing in order reticket myself to the next morning. It gets even better from there. At exactly the time I tried to get out of the "airside" part of the airport, they allowed all the planes that arrived over the afternoon to let their passengers to get off. So we had complete chaos at the passport control booth (which I had
to pass for some unknown reason). An hour later, I, and probably 500 other folks were in the queue at Lufthansa ticketing. I spent two hours in the queue, and when I almost was at the front of the queue, some Lufthansa official came by and said they had managed to bring in an old A300, a bigger airplane than planned, and we could fly out of Heathrow to Frankfurt (and not to Munich, where I wanted to go originally). It was planned that the plane leaves at 21:00. After a lot of queueing in various places, I was on board of D-AIAZ and we left - at 23:30. So, to make the rest of the story short, I arrived in Frankfurt at 2am. There, at least, were some folks who knew what to do. After 10 minutes we (i.e. myself and a little group of fellow travellers who flocked together to make the tour more sustainable)
we were in the Intercity Hotel... Lufthansa would pay.

I am writing this last paragraph from within the ICE train that will bring me to Stuttgart. I'll go directly to the Eclipse Forum in Esslingen and I'll pick up my car in Munich on Friday.

All of this crap is really frustrating. I think I will try to do more "remote" work and travel less. I am fed up with this.  permalink    1 comments

 

A categorization of DSLs

At this year's JAOO conference, I was the track host for the track called "DSLs and Beyond". It was planned that Martin Fowler would do the intro session, but he had problems with his back and he couldn't make it. So I had to prepare an alternative intro session. I decided I'd like to talk about categorizations of DSLs. So this blog post is basically what I came up with.

Domain Selection: If you talk about a Domain Specific Language, the first thing you need to do is to define the domain for which you want to build your DSL. In the context of software development it is useful to distinguish (at least) two kinds of domains: Technical Domains adress key technical issues related to software development such as Distribution, Failover and Load-Balancing, Persistence and Transactions, GUI Design or Concurreny and Realtime. Fuctional (or "Business") domains represent the business/professional issues; examples include Banking, Human resource management, Insurance, Engine Controllers or Astronomical Telescope Control. Some times these two kinds of domain are also called Horizontal and Vertical domains. You also have to decide whether you DSL should be rathergeneral to the domain you've selected or specific to your use cases in the domain; in other words, selecting a domain always implies tradeoffs between more general applicability of the DSL and more specificity (and thus, better support for your specific needs).

Expressive Power: The next issue you have to decide upon is whether your DSL should allow creative construction or use a metaphor that is more configuration like. Creative Construction means that the DSL defines a number of "words" from which you can creatively construct "sentences", the models. On the other hand, configuration languages typically allow you to select and unselect features that your system might or might not have - this selection can be as simple as three checkboxes or as sophisticated as a feature model. The two alternatives - creative construction and configuration - are in fact not alternatives, they are the two extremes on a continuum. Your DSL can be located anywhere on that continuum. In any case, you have to decide about the expressive power of the DSL and the freedom you want to give your users (a lot of freedom in case of creative construction, less freedom for configuration DSLs). Note that, of course, this issue is related to the domain. Certain domain lend themselves to configuration, others are better served by creative construction. In general, I think it is fair to say that the more mature a domain is, the more configuration-like the DSL to describe models in the domain will be.

Concrete Syntax:Yet another dimension along which DSLs can be structured is their concrete syntax. Graphical notations is what everybody talks about in MDA. However, textual notations are also very useful. You can even use tabular notations or some kind of custom-made forms (or GUI dialogs). Graphical notations are useful if you want to destribe structures or relationships between things (and also to impress prospective customers :-)). Textual notations are well suited for behavioral or algorithmic aspects (although state machines and petri nets kind of proof the opposite :-)). Typically, graphical, as well as textual modeling is a form of creative construction. For configuration DSLs, often tabular notations or specific GUI forms are well suited. Textual notations are also often useful. The amount of work you need to put into the construction of the editor is vastly different for these various alternatives. Building graphical editors is quite a bit of work (in spite of tools such as GMF!). Tools for building textual editors are starting to emerge (e.g. oAW's xText or INRIA's TCS and TGE). From my perspective, building textual editors (even with syntax hightlighting, constraint checks and code completion) will probably stay less complex than building graphical ones. The effort for builing GUI-based editors (incl. tree views and the like) is probably even lower ... and the editors are usually less pleasing and productive. There's one thing that has to be kept in mind: if you use textual editors, things like diff and merge is much easier. So the integration of the models (i.e. text files) with CVS etc. is much simpler compared to all kinds of other models (ever built a graphical diff for your GMF editor? Or tried to diff on the object structures directly?)

Execution: Another important aspect is the way the "program" is executed. There are two fundamental forms. One is transformation (also known as compilation), the other one is interpretation. Each of these approaches requires tradeoffs in respect to performance, code size, the ability to change stuff at runtime, reflection, etc. We all know about these tradeoffs from programming languages. There are also ways to combine the two: you can, for example, generate some XML document from a graphical representation of a state chart and then interpret this XML document. In general, it is easier to write a code generator (or any kind of transformer, for that matter) since you're dealing with more concrete things. There is another reason that can explain why transformation and code generation is the predominant form of executing DSLs (at least, external ones): if you have to run your system on a predefined infrastructure that requires certain artifacts to be present (such as J2EE, or many embedded OS) you have no choice but to generate these artifacts. Interpretations cannot help you there.

Internal vs. External: There's another aspect, and that is actually considered by many to be the most important distinguishing feature of DSLs: a DSL can either be separate from „normal“ programming languages or it can be embedded (in what is then often called the host language"). The premier language these days for embedding DSLs is Ruby (historically, Lisp was the champion there). To be able to embed a DSL into a language, the syntax of the host language must be flexible in order to "tweak" it a bit to suit the DSL. You'll always be limited by the kind of syntax the host language allows (tweaked or not) - that's the primary disadvantage of this approach: external DSLs are more flexible wrt. to syntax. However, internal DSLs have one big advantage: and that is symbolic integration (a term borrowed from Martin Fowler). this means that a symbol that is defined in the DSL part of the overall program can be used in the host language - and vice versa. Also, you can for example use the expression language of the host language in the DSL - very useful! Often internal DSLs are interpreted (as in Ruby, relying heavily on runtime meta programming). However, you can also use compile time metaprogramming to have a more static approach to embedded DSLs. Larie Tratt's converge language is an example here.

Tooling: So, these are the most important distinguishing characteristics of DSLs. There's another consideration. It's not a language characteristic, but it is important: tool support. Are there decent editors? Debuggers? What about refactoring support? You should also take these aspects into account when selecting a DSL approach.  permalink    0 comments

 

New Material for SE Radio

At JAOO 2006, I had the chance to interview a number of people for SE Radio. Among others, I talked to Guy Steele (about his new Fortress language), Werner Vogels (on Amazon technology), Steve Vinoski (on Middleware), Laurence Tratt (about his Convergence language), Obie Fernandez (on Ruby DSLs), Gregor Hohpe (on Enterprise Integration and Messaging) and Dragos Manolescu (on Architecure Evaluation). So there will be a lot of interesting stuff coming up on SE Radio. Stay tuned :-)  permalink    0 comments

 

JAOO 2006 is almost over..

My favourite conference is (almost) over. The tenth edition of the JAOO conference has passed by. It was once again an unbelievable cool week. There were really interesting talks about topics you'll hardly hear anywhere else: compile-time meta programming, the history of scheme, new abstractions and concepts for dealing with concurrency, and, of course, more "everyday" topics such as SOA or Web Development. However, it wasn't just the topics that were great. There was a whole bunch of speakers that you'll hardly see anywhere else, among them Guy Steele, Dave Thomas, Charles Simonyi or Bertrand Meyer (yes, he did talk about Eiffel :-)). All these things make JAOO already worth going to.

But that's not all. The organization is superb. You might consider this a detail, but throughout the conference, there was an unlimited supply of bottled water. This is essential, I think, if you want to stay awake over the day. And then there was the food. As usual, Chilli John took care of feeding and man, was this food great. Every afternoon there was a lunch with different salads, meat, fish etc. Really gret stuff. But the speakers dinner was even better, I think I never ate this good in my life! I think this really does distinguish JAOO from several other, especially US conferences.

From my personal perspective, the conference was a big success, too. My talks were well attended, and the DSL track as a whole (which I organized) got pretty good feedback. The talks were about compile-time meta programming (Laurence Tratt), Microsoft's DSL tools (which are pretty neat!), Intentional Software (by Charles Simonyi himself!), as well as some thoughts by Eric Evans on how DSLs go together with DDD. There was also a talk by Obie Fernandez on DSLs in Ruby (it was not in my track, technically, but who cares :-)).

So, next year, consider going to JAOO! Most everybody will agree that this is in many respects the best conference they have ever been to.  permalink    0 comments