I have worked in the field of custom software development for almost twenty years now but I have not entered what some people affectionately call the post-technical stage; the stage where the newest IDE on your computer was released several years ago and your “recent documents” list is full of PowerPoint presentations and architecture diagrams. I see this as as a good thing and, actually, made a conscious decision to remain near delivery rather than becoming an ivory-tower architect or a line manager. Luckily, working for ThoughtWorks this hasn't stopped me from doing architectural and strategic work at the same time.
Beyond helping clients in my day-to-day work, I am interested in improving our industry as a whole. At ThoughtWorks this is called out as the second pillar of the business: to champion software excellence and revolutionise the IT industry. Writing articles and presenting at conferences are ways to work towards this goal. With my open source projects I hope to make further contributions, and, last but not least, I am fortunate to be a member of the programme committee for the GOTO Conferences and a member of the advisory council of the JavaSPEKTRUM magazine.
Over the years I've seen a fair number of IT projects and it has become more and more apparent to me that the success of a software project rarely depends on choosing a certain development platform or specific technology. In my opinion, there are two main causes for problems: first, approaches that emphasise upfront design at the expense of reacting to change and new insights and, second, technical implementations that are high on accidental complexity. The latter is still quite common more than twenty years after Fred Brooks wrote his No Silver Bullet paper.
Developers are turning to iterative development and evolutionary design, as Brooks suggested, and a lot of accidental complexity that was caused by low-level programming languages has disappeared. Unfortunately, though, the industry overshot the target and now accidental complexity is caused by ever more elaborate frameworks and products that over-abstract problems, causing development teams again to wrangle with complexity that has nothing to do with the actual business problem. As a consequence I have become interested in simple architectures and in software visualisation as a way of exposing accidental complexity.
How did it all begin?
The very first piece of software I created was a little game that I wrote in Basic on the Commodore VIC-20. That was in 1983. I got the first taste of real software development in 1987 on an Atari ST when I stopped hacking assembly code directly into memory, using SMON, and instead began to work with an IDE, a C compiler and a debugger. This was also my first exposure to windowing systems. Have a look at a the screenshot of the Turbo C IDE on the Atari.
In 1990 I started Uni where we learned the Scheme programming language using the legendary SICP book. It was a bit different at first but in retrospect I think it was a great way to understand fundamental concepts, and to realise that programming should be enjoyable, which is something that is often forgotten. Of course, we also got accounts on Unix machines, the lunchbox Sun IPX for example, and we were connected to the Internet! Not that we could surf, the Web hadn't been invented yet.
A year later I got a student job at a company that wrote software for NeXT computers running NeXTSTEP and at that point I knew I didn't want a beige lunchbox but a black pizza-box! It was UNIX, it was fast, had a great user interface and futuristic applications. Check out the screenshot of NeXTSTEP in 1994 and note the emulator window in the background running the then current version of Windows. However, the best of it all was the development environment: It was all object-oriented and late binding with a great UI toolkit, which in my opinion was so much better than most of what came later; and this decidedly includes Win32 and Swing. Interestingly, the architecture of the NeXTSTEP UI kit has not really changed in almost 30 years and now forms the basis for all new Mac applications.
In 1995, while still writing my thesis, I joined another small IT consultancy that was also devoted to the NeXTSTEP environment. Happiness did not last all too long, though, as we had to abandon our two-tier applications with their beautiful and rich user interfaces and moved back into the future with request/response web-based 3-tier applications. Another piece of roadkill during this time, at least as far as my commercial career is concerned, was Objective-C, the programming language at the heart of the NeXTSTEP platform. We all moved to Java and, given the state of the platform and the tools at the time, were sorely disappointed. Then again, it was probably a bit ambitious at the time to have a Java Applet do RPC with some middleware. On the positive side, the NeXT heritage provided us with WebObjects, probably the best application server at the time.
Late in 1999 I gave up all resistance and fully joined the internet hype. And I guess, a few months of TCL development for the Vignette CMS give you a sense of appreciation for Java and J2EE. It was a great time and we delivered many beautiful websites; even arts projects [PDF]. In any case, we were in the new economy, the dot com bubble. Soon, I realised that this was not meant to last and I found myself having to decide between small web shops with cool but technically boring projects and IT departments of large corporations. A decision I could not make as I love technology and the drive and excitement of small companies.
After a break in 2002 a good friend of mine introduced me to the solution of my dilemma: A boutique consultancy specialised in the “heavy stuff”, a company that runs a Geek Night. And this pretty much brings you to what I'm up to now.