Monday, 23 October 2000
Life is confusing and chaotic. Especially the future is hard to predict.

Computer systems are just as unpredictable. Will current software develop towards something disposable, or will it last for decades?

According to Dijkstra, the famous Dutch IT professor, the best thing to do with most software is to trash it. (google.com/...).

Well, nice ideas from such a theoretical scientist, but in reality everybody just has to make the best of it, given

  • the current means,
  • the current deadlines,
  • the software of those that preceded us (yes, including my own software, written in the past without the accumulated progressed insight of the present).

Links on Edsger Wybe Dijkstra

(11 May 1930 - 6 Aug 2002)
the collection of EWD's, full of bold quotes. It is a vast collection of manuscripts, written during four decades.
a classic from 1968, the end of the go-to, and the beginning of structured programming.
A mathematical description of Dijkstra's shortest path algorithm.
How to tell a truth that can hurt?
Dijkstra died 6 August 2002 at the age of 72.
I'm convinced that a some things will stay with us for the years to come. Most good ideas are old, but not worn out yet.

Are you writing something with some kind of SGML, OO or SQL? Be sure that your software will last years or even decades, in one form or the other.

Be aware of Quick fixes. There is nothing as permanent as a temporary solution.

The future remains hard to predict, but it is sure that continuous change will be the only constant thing.

Structured General Markup Language (such as HTML and XML) is here to stay. My first encounter with HTML was a Déjà vu, like meeting an old aquintance. It was like DCF just resurfaced from an ocean of deep dust.
Object Orientation will remain too. Programming languages will continue to change. I hope and expect that the future will liberate us from the compelling compilers.

Things are progressing though. Java is much more like the charming Smalltalk than the antique C++. Soon everybody will use a real object oriented language.

The need for a structured query language on a relational database will remain. Codd's law is based on logic and collection theory. Both of those never age.
So be prepared for the unknown future and keep software utmost flexible:
  1. Keep quality high, the core of 10 Java Maxims. More than 80% of software development effort is in maintenance (cs.unc.edu/...). So keep software maintainable, especially when you have a shortage of manpower.
  2. Apply encapsulation as extreme as possible. Have every object talk to it's immediate neighbours only. A reader talks only to subscription, not with newspaper.
      In the example to the right
    • a reader only talks to subscription.
    • a subscription talks to both newspaper and reader.
    • a reader talks only to subscription.
    Even if an object class changes dramatically you'll be sure that only the object, and it's immediate neighbours need an update. A software "earthquake" remains local in a very nice way.
  3. Keep presentation apart from business logic and data access. A slick three tier architecture is really not a bad idea.
Till next week!