The beginning of the end?

So. Last week I had an experience which I think was a significant step in my programming life/career/whatever. I realised that I was about to rewrite my first big application. And when I say re-write, I don’t mean v2.0. I mean: I was faced with a problem; I came up with a solution to it that was quite specific; after a few seconds of thought about how to implement it I realised that I had already implemented it years before. As far as I know that system is still in 24×7 operation with the kernel of the code untouched by other developers. So it was clearly good, so why not just re-use it? That is good, right? We want to re-use code. Or even if we can’t re-use the code we want to re-use the pattern (in this case it was using .NET attributes to decorate strongly-typed classes so that they could be turned into loosely-typed data-transfer objects). All good, right? Even if I couldn’t use the code, I knew that the concept would solve the problem and solve it well enough to last years of subsequent tweaks.

Well, in spite of that, it didn’t feel good. It felt like the chill of old age. It felt like this is the beginning of the end. There are no new problems to solve, they have already been done, even by me. All the rest of programming is just repetition, automation and abstraction. Of course, this is probably what it has always been; ever since Turing became complete people have probably been sighing over the fact that they are doing the same thing as they were last year only faster. The shocking thing is that my father used to say the same thing; having worked on minicomputers in the 60s for doing critical path analysis he was forever telling me that “computers haven’t changed”. He was wrong of course; the scope of the problems had changed because there was 100,000 times more processing power, but I suspect that the programming problems were just the same.

The question is, do I still want to keep doing the same thing over and over? Just a little bit faster with less bugs than before. I wrote another application this week. It was, I have to say, well structured using all the tweaks that ReSharper could throw at it. The methods were tiny and readable; the code was flexible enough to cope with change but it wasn’t over-designed; I cranked it out in 4 days but it ran first time (or maybe second..). There are, as I’ve said before, no points for difficulty and the business people who wanted it would probably be happy that it got done in a week with no problems. Next patient, the doctor is IN!

But how long can it go on? The same tired old business problems; more reporting tools; more transaction processing; more stupid little GUIs with one more button to handle special case X. I mean, you can’t avoid that. The world moves on and programs rot. You can’t be writing earth-shattering middleware every week, and as I’ve said before, the stuff that becomes the new backbone of an architecture doesn’t get written, it gets extracted from a running application (e.g., Rails). But seriously, how long can people stand to do the same thing over and over. A little more abstraction isn’t enough; to get from c++ to MFC to c# in, what? 20 years?

All I can say is that I won’t be doing this in 20 years time.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s