Skip to content

UNIX simplicity and agility

In the course of a series of comments around my post about Oracle’s ADF, I started to think about “vendors” and their technology stacks.  Of all the big vendors whose technology comes closest to playing nice with Agile development and (especially) agile engineering practise and discipline (e.g. test-driven design, pair programming, fearless refactoring, etc), I have found the most in-tune with this, is Sun. I have absolutely no scientific data for this opinion, mind.

I think that maybe this is because they are a ‘UNIX’ company with an excellent ‘UNIX’ pedigree and a generally ‘UNIX’ mentality through and through. Unlike Oracle, which is pretty agnostic about operating systems, and IBM, which only caught the UNIX fervor in the last decade (although it’s always had a UNIX implementation, i.e. AIX, it’s not like the whole company has been orientated around this operating system, unlike Sun and SunOS/Solaris). But what does UNIX have to do with agility?

I am of the firm view that MS Windows is just not a development platform. The reason is that I think it just doesn’t have the right command-line interface. There’s no find, diff, ps, awk, sed, and the other multitude of small tools that make a developer’s life much easier. It almost embodies the big-tool-does-it-all thinking that I think is terribly inelegant – and unagile.

Now I have been using UNIX since 1989. In those days it was a Amdahl UNIX as well as a version of SunOS. Some point after that – early 1990s I guess – I had a version of Linux installed on a personal computer of mine. In those days you had to boot off floppy with a super-basic kernel and a 25×80 terminal, recompile the kernel to suit the exact hardware setup of your computer. Just to get a serial port and modem functioning to run PPP over. It was pretty dire, hands-on, stuff – but I was young and had time to do it. This doesn’t sound very simple does it?

But there is a simplicity to UNIX, it’s the entire UNIX philosophy. And it is this:

Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface. (wikipedia)

And from the same Wikipedia page as above, here’s an extension of the UNIX philosophy by Mike Gancarz, the “9 Paramount Precepts”:

  1. Small is beautiful.
  2. Make each program do one thing well.
  3. Build a prototype as soon as possible.
  4. Choose portability over efficiency.
  5. Store data in flat text files.
  6. Use software leverage to your advantage.
  7. Use shell scripts to increase leverage and portability.
  8. Avoid captive user interfaces.
  9. Make every program a filter.

I reckon that points 1, 2, 3 and 6 are definitely Agile in nature (point 8, I think, goes to the point I was trying to make about IDE-to-Server integration in the ADF post).

None of this is exactly the Agile Manifesto, of course. However Agile is a similar philosophy that values simplicity in order to manage complexity. And this simplicity takes some considerable effort to achieve, as it does in Unix. But its benefits in the end are enormous.