JB: What's new, Charles?
SIMONYI: I have been working on what we call "intentional programming." It's very exciting. It has to do with professional programming, so it's kind of hard to get into the details. It also relates to the work of evolutionary biologist Richard Dawkins in a fairly direct way. We are trying to create an ecology of abstractions. Abstraction is really the most powerful tool that we have in thinking about problems. An abstraction is a single thing, yet if it is a good one, it can have many applications, even an infinite number of them. So an abstraction may be looked at from one side as a compression of many instances into one generality or from the other side as a special purpose power tool that yields the solution for many problems. If one could attach a dollar sign to this power, the economies would be amazing: rivaling that of chips or application software itself.
Programming languages are really just vehicles to supply abstractions to programmers. People think of programming languages as being good or bad for a given purpose, but they are really criticizing the abstractions that a language embodies. The progress in programming languages has been incredibly slow because new programming languages are difficult to create and even more difficult to get adopted. When you have a new programming language, the users have to rewrite their legacy code and change their skills to accommodate the language. So, basically, new programming languages can come about only when there is an independent revolution that justifies the waste of the legacy, such as Unix which gave rise to C, or the Web which gave rise to Java. Yet it's not the languages that are of value, but only the abstractions that the languages carry.
It's very much like Dawkins' idea that it's the genes, not the individuals, that are important in evolution. And, in fact, what's being reproduced are the genes, not individuals. Otherwise, how would we have worker bees and so on. We are doing the same thing; it's abstractions that matter, not languages. It's just that we don't think of abstractions without languages, because languages used to be the only carriers for abstractions. But if you could create an ecology in which an abstraction could survive independent of everything else, then you would see a much more rapid evolution for abstractions, and you would witness the evolution of much more capable abstractions.
To enable the ecology, all you have to do is make the abstractions completely self-describing, so that an abstraction will carry all of its description, both of how it looks and of what it does. It's called intentional programming because the abstractions really represent the programmers' original computational intent. And that's what the important invariant is, everything else of how something looks or how something is implemented, these are things that should evolve and should be improved so they can change. What you want to maintain invariantly is the computational intent as separated from implementation detail.
JB: It sounds biological in nature.
SIMONYI: Yes, we are using a lot of biological metaphors. We call our transformations, for example, enzymes. It's just that biology, and all the sciences of complexity, are making big forward strides, and it's just a matter of using as many of the metaphors as one can.
JB: But it is still a programming language, isn't it??
SIMONYI: Absolutely not. Intentional Programming relates to a Programming Language as a powerset relates to a set. It is strictly greater, there cannot be any isomorphism between the two. IP programs are encoded in a tree-like data structure where each node also has a graph-like pointer to the definition of the intention the node is an instance of. Every node can have arbitrary nodes underneath it, that is nodes can be parameterized arbitrarily. The semantics of intentions are described by the tree transformations which convert the instances into primitive intentions from which native or interpreted code can be generated by standard means. The looks of intentions are also defined by arbitrary computation which serves no purpose other than to ease interaction with the programmer. So names and looks — what used to be called "syntax" — will have no effect on the computation and may be changed arbitrarily as programming styles and programmers' needs evolve. Knuth's dream of "literate programming" will become practical and I expect a great deal of visual richness to also emerge in the programs.
JB: Isn't this just another meteor that wipes out legacy to make room for evolution?
SIMONYI: Luckily that is not the case. Intentions can be defined for all features of all legacy languages, so legacy code can be imported into IP without loss of information or functionality. Once in IP, the process of incremental, continuous improvement can begin and the lifetime of the legacy code will be limited only by its usefulness, not by the means used to encode it.
JB: Do you foresee structural changes in the industry as a result of this?
SIMONYI: It will be very exciting. The personal computer industry has enabled evolution in the platforms. Out of the Cambrian Explosion of the early eighties there emerged a few dominant architectures, the Windows family being the most popular of them. There is incredible variety in terms of peripherals, applications, networking, form factors, performances all the result of evolution. I foresee a similar progression in the realm of abstractions. Once everybody with a $5K machine and good programming skills is empowered to create and publish abstractions for which any one of the tens of millions of programmers will be potential customers, there will be a tremendous explosion of creativity. Many of the early new abstractions will be addressing the same easily accessible niches, such as collections and maps of course, so a shakeout will be inevitable. Then the creative energies will be channeled to the myriad domains: software sharing, user interfaces, graphics, accounting, animal husbandry, whatever. Each of these areas will benefit from domain-specific abstractions and optimizations which in turn will improve the quantity and quality of application software in those domains. There will be more shareable software artifacts, thanks to IP's ability to parameterize any abstraction further with any kinds of parameters.
The "first law" of intentional programming says: For every abstraction one should be able to define an equal and opposite "concretion". So repeated abstraction or parameterization need no longer create "Turing tarpits" where everything eventually grinds to a halt due to the overhead introduced by the layers. In IP, the enzymes associated by the abstractions can optimize out the overhead, based on the enzymes' domain specific knowledge. The overhead associated with abstraction has always been the bane of the very-high-level languages in the past.
There will be markets for flexible artifacts, abstractions in all domains, and different implementations for those abstractions. These in turn will improve tremendously the quality and availability of application software.
Once one looks at abstraction as a commodity, the standard rules of business can be applied. For example, one should be able to invest in the manufacturing process in order to make the product more competitive. Or in the software arena one should be able to elaborate the definition of an abstraction in order make its application more effective: simpler, faster, more flexible. Conventional programming languages completely ignored this elementary rule: declarations and references were all designed with the same high-falutin principles in mind: orthogonality, cleanliness, what have you. It's as if we used the same standards, materials, and budgets for the factory and the retail store, or for the machine tools and for the product. Nobody in business would behave in such an idiotic fashion. In IP one can associate an arbitrary computation with any definition, so the opportunities for making investments in definitions are limitless.