Multifaceted software

I read Grady Booch’s article “Through the Looking Glass” today. It’s a follow-up to the article “The Illusion of Simplicity”, in which he concludes, “Modeling helps, components help, well-defined processes help, but none of these alone represent breakthroughs that will yield a state change in the way we build interesting systems.”

In the new article, he lists three signs that there’s something new coming “that’s truly beyond objects”: software design patterns, multiple views of a system’s architecture and aspect-oriented programming (AOP). Booch continues,

Collectively, Gregor Kiczales (formerly with Xerox PARC), John Vlissides (who works for IBM), Charles Simonyi (who works for Microsoft) and I’ve named this [coming change] ‘multifaceted software’ because it represents a means of attaching development’s complexity by approaching it from multiple fronts.

So, Charles Simonyi pops up again. I knew him from Hungarian notation, then found him again through reading writings of Richard Dawkins (see here – and here), which led me to Simonyi’s writing about Intentional Programming (see here – and here). I wonder if he’s abandoned Intentional Programming for someting else; perhaps AOP?

Anyway, AOP is something I’ve meant to read about for a long time. I downloaded a few articles about it four or five years ago, but never got around to reading it. Perhaps I will do it now. In the sidebar of Booch’s article, Roger Smith writes, “[AOP supports] a new unit of software modularity: aspects. Aspects are elements such as security policies and synchronization, optimization, communication or integrity rules that crosscut traditional module boundaries.” I don’t “get” what it’s about from reading the sidebar, but it refers to Xeroc PARC’s AspectJ (an extension to Java) and AspectR (for Ruby!).

I like Boochs’ account of the evolution of programming:

...the task of the software development team is to create an illusion of simplicity. We build abstractions to help us create this illusion; these abstractions are an essential way we mitigate the intellectual complexity that lurks within our systems. Indeed, the entire history of software engineering can be traced by studying the manner in which our programming languages and methods have tried to raise the level of abstraction in our systems.

Then he goes on to mention structured programming and object-oriented programming as important inventions in software engineering, at which times languages got better at managing complexity by creating abstractions. When he first encountered OOP, he writes, “I thought I’d seen the ultimate model on which all kinds of complex systems could be grown”.

So what we can expect in the future are tools to work with abstractions at even higher levels – which was the purpose of Intentional Programming, and probably is what AOP is about, too. I will probably get back to that … in the future.