Intentional Software - Democratizing Software CreationThis stuff (the paradigm is called Intentional Programming) borders between The Next Big Thing and vaporware!
Traditional software creation
The traditional way to come up with a software system to solve problems for a specific problem domain (e.g. planning pension funds) is to let the software engineers interview the domain experts (e.g. pension experts) until they understand the problem enough and then let them code their software in the hope that the resulting software will solve the problem and is usable by the domain experts in the end.
This needs one or more development cycles and might result in systems which the software engineers are more comfortable with than the domain experts are. Another drawback is that changes in the problem almost always require changes in the code of the software.
Intentional Software Creation: Editors and Generators
An intentional software system is supposed to work differently:
It should be fed with requirements from the domain experts and then should allow to generate a software system from that data, which will finally solve the problem (see image above).
For the definition of the requirements, the domain experts should use their favourite notations. It should be no problem to model the requirements with different notations, covering each part with the description which fits best.
Here the software engineer is responsible to provide the generators, which will churn out the solution software system.
The big advantage is that changes or variations of the problem are likely to be covered by changes in the requirements from the domain experts. The big disadvantage is, that this intentional software system is a complex beast, with complex editors and generators.
Waiting for Intentional Programming
I follow Intentional Programming since the year 2000, when I first saw it described in the "Tangram book" on Generative Programming by Czarnecki and Eisenecker.
While I still wait for Simonyi's intentional software system to materialize on my computer to sink my teeths in (that is why I use the term vaporware), the ideas behind it already had an impact on me. They led to one software system for certain domain experts and resulted in a CS seminar talk a fellow student and I held some years ago.
This is the image from the Tangram book, which pretty much impressed me:
The same idea (using domain specific notation in the solving of a problem) is illustrated here:
Not bad, or? One can imagine the mathematicans or electrical engineers to provide their requirements in their favourite notation.
While this looks like Visual Studio on steroids (which seemed to have been considered seriously for a short time at Microsoft), it is a glimpse on the intentional software system which Simonyi's company Intentional Software seems to develop since nearly a decade.
It is not dead, Jim!
What I missed until now was this announcement last year:
The funny bit is that the domain specific notation those pension fund experts prefer is "Excel sheets". If I think about it, I have seen the one or other funny use of Excel myself in various departments where economists or marketing people worked.
Excel and Word on Steroids?
Simonyi is famous for having head the Microsoft teams who (based on ideas pioneered at Xerox) created Word, thus an editor for preparation of text documents and Excel, thus a clone of Visicalc, which was a software for modelling and solving various economic problems in a twodimensional tabular scheme.
You all know it.
Both are powerful graphical editors, which allowed domain experts from document writing and economics who have no programming skills to define and solve their problems. So coming from there the idea of intentional software seems like a logical next step.
And the other parts of the Intentional Programming System?
While I am able to see how those special notation editors (with knowledge of the notation to allow stuff like code completion) might be implemented, I always wondered about the mythical database where all requirements are fed in and how the powerful generators would look like.
The editors were supposed to work on a data structure similar to abstract syntax trees (the data structures that carry the information won by parsing). I am still not sure, if this is the intentional tree that was mentioned in the video of the talk.
So I am still waiting for more clues on the database and generators.