The Calm Before the Software Development Storm

Back on topic...

I have been lurking on the Pragmatic Programmer Yahoo! group for a couple of years now (http://tech.groups.yahoo.com/group/pragprog/) and enjoy reading many of the discussions. It's not a particularly high-traffic group which suits me fine.

The group follows up on the themes of The Pragmatic Programmer (Andy Hunt and Dave Thomas) - one of my favourite books that I regularly dip into and re-learn what I thought I knew. If you a programmer I would strongly suggest you pick yourself up a copy and read it thoroughly.

Anywho, I was reading one of the messages from the group and a paragraph in a message from Paul struck a chord with me:

Maybe I'm being overly romantic, but I sense that we have reached one
of those "calm before the storm" periods for software development.
Development is still excessively prone to failure. Improvements in
quality have been minimal, but our dependence on software has
increased. There are lots of great ideas floating about, but only
limited adoption. To me, I think we are still at the infancy of the
science, and I can't help imaging how they will look back on us and
our work hundreds of years from now. I image that the Computer Science
of the future will be radically different than what we have today.

And I agree. I sense a lot of 'treading water' in the industry currently. Don't get me wrong, many people are making great efforts to improve what we do and how we do it. For example, all the current Agile development work (XP, Scrum, Lean, etc) are trying to bring about massive changes in how we approach software development. However, I believe that most development is still currently done using a variant of the the Waterfall methodology or with no formal or informal process or guidelines at all. This and many other things all lead, as Paul mentions, to development which is 'prone to failure' and software that has 'minimal' quality.

A storm has to be on it's way! Something radical has to happen to prevent us from coding ourselves into a very dark, complex and scary dead end. There is so much software in the world these days, and the original authors have moved on and possibly forgotten they even wrote it. There is so much unique complexity in the majority of the software too. Most idealistic coders would like to see transparent, simple (not simplistic), elegant code, which with a little intellectual investment can be comprehended and maintained as required. Most coders know it just isn't going to be that easy. I would suggest that the majority of code is far more complicated that the problem it was intended to solve. I think there is often an essential complexity that is hard to avoid, but many coders compound this problem 100 fold (including myself though I certainly try not to). Something has to radically change what we do if we are to continue to do what we do.

Like Paul, I often think about the future of software development and wonder what it might be like in 100 or 200 years and, for the life of me, I simply can't visualise it. Will people still be using CVS (or a descendent)? Will C/C++ still be driving the majority of the operating systems in the world? Will LISP finally have finally become mainstream? Will computers finally become what I envisioned them to be when I was 7 - some strange machine that somehow or other (details ain't important when you're a sprog) knew everything that could possibly be known? The last option sounds radical, maybe it'll work - now how do suppose you program a computer to know everything.....hmmm.

Modern Day One (Wo)Man Band

Well, then last post was off topic and so is this one, but it is worth it.

A long while back my girlfriend mentioned having seen a performance of KT Tunstall's where she gradually builds up the accompaniment to her own song as she sings it. It's all done with some fancy footwork and is very interesting to watch.

The song is 'Black Horse and the Cherry Tree' and here is the link (youtube).

Pasta and Sauce

On holiday here in Tuscany, visiting our friends Ang and Andy, Saff and I have been shown how to make tasty fresh pasta. So I don't forget how, here is the *very* simple recipe.

3 eggs
300g flour
pinch of salt
a little olive oil
*Basically you have 100g for each egg.

Put everything in a bowl and mix it and kneed it. When thoroughly mixed and kneeded, cover the mixture in cling film and pop it in the fridge for half and hour.

After half and hour, roll the mixture flat [adding flour as required if the mixture is still sticky]. Now feed the mixture through a pasta roller, each time reducing the thickness setting [we ended on a setting of 5], and hang the piece of pasta up to dry.

Once dry, feed the pasta strip through the pasta machine again [this time the cutter], and hang the strips up again to dry.

When ready to cook, drop the pasta in boiling water for half a minute, then drag it out and drop it into your waiting hot source [recipesto follow soon, if I'm allowed to write it down].

And the end result is very, very tasty.

Google Docs 'Edit HTML'

I've been editing my CV on Google Docs for a while and now I'm trying to get it in to a format (PDF/RDF/ODF) to send it on and I seem to be having a lot of problems with white space. I get very large gaps between paragraphs that I'm just not expecting.

To find out what was going on I have tried the 'Edit HTML' function and can see the problem...lots empty paragraphs, spans and H3 tags. So let the hacking commence.

I'm surprised with the way Google are representing documents, lots of font tags and style attributes on elements. I was expecting greater use of CSS. Surely this would allow greater control over the available styles and make them much more powerful whilst making it easier to convert to all the output formats?

Design-dead code

I found an interesting video by Ken Schwaber - Agile Quality: A Canary in a Coal Mine.

Here's the video (about 69 minutes long)

In it he mentions design-dead code (or quality-dead code), a very interesting notion that highlights something that I think I have always known.

The notion basically goes that the more you ignore refactoring and adapting your core (or legacy system) functionality to better suit your new features then the slower you go because you reduce the quality of the core. Whatever you don't spend on the improving the core this time will slow your velocity down by some relative amount next time (and every time afterwards). The worst thing is that it cumulates, as more features are added (and iterations continue) you will eventually get no new features because it's simply too hard to add them and your company will slowly, but fairly surely, die.

It's all gone a bit .... functional

As my last post explained I am currently looking at a bit of Haskell - which isn't reminding me too much of the ML I did back during Uni, just yet.  This has all come about as I assess where I am in my career and where I might go.  

My last two jobs have been very general - not simply designing and coding, but doing lots of varied tasks: db schema design, db administration, network admin, systems admin, R&D, systems testing, business analysis, etc.  This has all left me feeling a little wide-and-shallow.

Fortunately, I recently read "My Job Went To India" by Chad Fowler.  It describes many things that you can do to make sure you stay employable.  One technique is to be a genrealist - which set my mind at rest slightly, but I do still have to communicate that on my CV.

As part of this generalist thing it makes sense to try out different languages.  I have been interested in computing (hardware and software) for almost as long as I can remember.  My professional career has been heavily Java based.  In my free time I have always played with new languages and techniques but without the professional need to use these skills I have never managed to internalise them too deeply.

That said, most of my 'playing' has affected my thinking and my Java programming.  Amongst other things Smalltalk made me question Java's access modifiers, and LISP made me think about so many diferent ways of composing my code.

I recently met with my friend Oli who I worked with a few years ago.  We played book swapsies - I lent him 'Micro ISV' and he lent me a functional programming book based around the Scheme language.

As I currently have a little time off as Saff and I try to move to Cananda I thought I'd stretch my brain a little look into Scheme and Haskell and try a internalise a little.

Haskell Hacking

I found the first of a set of Haskell introductions just before Christmas but have only now got around to giving it a go.  Here's a link to the first one:
http://cgi.cse.unsw.edu.au/~dons/blog/2006/12/16#programming-haskell-intro

I had a few problems installing ghc on the Mac OS X side so I installed Ubuntu (Edgy) in a Q (qemu) virtual machine and after learning about enabling the 'universe' respository in sources.list installed 'ghc6' and 'haskell-mode' (the emacs editing mode for haskell). 

I read all three articles and have started hacking with number three - the 'cat' clone.  Things are going reasonably at the moment except ghc doesn't like the 'set' in concatMap.  I don't have a clue at the moment what might be wrong, but I suppose that comes from learning new stuff...

Blogger Dashboard Widget

I've not been a mac owner for very long and it's taking a little time to get used to the mac way of doing things after years with various GNU/Linux distro and of course various incarnations of Windows.

The latest thing I've found is the google blogger dashboard plugin which makes it quick to blog.

Initial impressions are very good - simply logged in and started typing and if this post pops up on the web then publishing will be equally easy.

Currently I don't know how to make hyperlinks, but I'm sure someone has thought about it...

[Edit: now Blogger.com has come out of beta this widget doesn't currently work, damn]