The latest issue of IEEE Software has an interesting article by Simon Helsen (of ArcStyler MDA fame, now with SAP), Arthur Ryman (IBM, Rational Application Developer), and Diomidis Spinellis (Athens University). They look at the history of software development tools over the last 40 years, and bemoan the lack of major progress since the move up from assemblers. Tools have improved, but slowly, and "silver bullets" have often turned out to be filled with hot air.

"Software factory tooling, computer-aided software engineering, and model-driven development tools, to name just a few buzzwords, clearly haven’t lived up to their proponents’ sometimes-inflated promises."

Looks like we're going to get bashed here, doesn't it? But no: while the authors agree with us that some companies have hyped their tools and approaches beyond what they could deliver, they say MetaCase isn't one of them. Here's the first figure from the article, a 40-year history of "exemplary well-known development tools" and their level of abstraction:

Levels of abstraction of well-known software development tools over 40 years -- look who's top!

Even the original version of MetaEdit, from 1993, is ranked higher than Microsoft's Visual Studio 2003 (with their DSL Tools) or Eclipse (with EMF+GMF). Hopefully we've moved on a little since 1993, keeping MetaEdit+ ahead of XMF Mosaic. The graph doesn't show which tools are still around, or how long things lasted: Xactium, the company behind XMF Mosaic, sadly stopped development of it this year. Last I heard they intended to release the source code into the GMT project in Eclipse, to join the several existing prototype modeling tools there. At least so far it's not appeared, although the source code can be found from the web. It would be a shame if the GMT project became the open source equivalent of Computer Associates (who bought up many dead and dying modeling tool companies, but seemed more interested in collecting maintenance fees, leaving the tools to languish with no further development).

The article is not without its faults: it mistakes "text" and "XML" as universally readable formats, as if by having your software described in one of those formats means it will be readable by other tools or later versions. For the record, opening the proprietary, binary format of a Word 97 document in Word 2007 works fine, and the document will be upgraded if desired when saving. Contrast that with opening a Java program from 1997 in a Java IDE today: the program almost certainly won't compile, or will give many errors. The underlying storage format, text or binary, hasn't changed in either case; what changes is the actual syntax, structure or in XML terms the schema. Whether the content can be read and updated to match schema updates depends on the tool, not the underlying storage format.

In many ways, text is worse than binary or XML as the underlying storage format: the latter imply that the storage format is already close to the structure of the program -- its abstract syntax tree. Or to take a more pragmatic view, the work needed to turn the storage format into whatever the development tool natively works with in memory is fastest for binary, somewhat slow for XML, and slowest for text. Of course text has its advantages: you can open it in any editor (at the cost of losing the IDE's power), and the diff algorithms and displays are more mature (but show changes at the character level, not the language concept level -- rename a function in a refactoring IDE and your diff shows hundreds of changes).

I can't resist one last comment on the chart above: look at the development tools that are ahead of the curve, i.e. furthest above the diagonal. Written in Smalltalk, all three of them. If you think Smalltalk = old, go take a look at MetaEdit+, Seaside, or DabbleDB -- or jump straight to the source, Cincom's VisualWorks Smalltalk.