Friday's finally here, and I am dashing this off before I get out of the office, which of course is not my first choice of locales.
I had fun (if you could call it that) fixing up a sorting routine in some code I wrote a while back. It turns out that the sort routine never actually worked at all, and yet the routine that depended on it still mostly worked. It may not have worked quite as intended, but the results were indistinguishable to the naked eye. In fact, I only found out that the sort was broken because the results did not vary with different inputs like I would have expected.
So I took a day to rework the routine. In a sense, the old routine was fast and cheap (because I implemented it in a hurry and obviously didn't test it much), but not good. The new routine is very well tested, fast in the execution sense, but not particularly cheap (since I had to invest a lot of time in it).
And so it goes. I got a strange satisfaction from revisiting and repairing that routine. There is always the temptation to linger on a piece of code, polishing and polishing it until it shines. A good engineer has to know when to draw the line and stop the refinement.
And now I have to bring this column to an end and get out of here.
You can respond to my ranting here.
Oh what a tangled web we weave, when first we practice to rant.