Tuesday's grey

No prize for who ever can place today's title quote.  I was going to reveal yesterday's reference here, but I'll add a comment on the post instead.  Not much happened today - I didn't make it to the gym but my throat is scratchy, so it kinda... Well I thought I'd pay down some bills today and maybe some debt, but didn't.  The debt didn't increase or decrease so it's an "unlose" situation, double-plus unlose in fact, according to my wife.  Not me though - I think it's pretty good.

The annoying thing related to paying bills were the polite letter I got for my line of credit.  Interest is charged to this line of credit by taking the bank prime rate plus some amount.  In recent months, the Bank of Canada overnight rate, the rate that banks are charged when they borrow money, has been falling.  As of this writing, this rate is at the historic low of 1%, while the bank prime rates are at 3%.  Well, according to this letter, the part that is added to the prime rate to determine the interest charged, is increasing.  I guess the banks really need to get a particular rate of return for their investments, so they can just nudge the rates up in such a way that the total interest that I'm charged remains constant.  So much for falling interest rates.  I probably shouldn't complain - if this was 1989 they'd probably be calling in the entire line instead of bumping the rates up a bit.  But still, it 'tis annoying.

An interesting article that I finally got some time to read was over at Geek In A Suit, the blog by Christian Gruber.  I talked with Christian a few times in his role as Agile consultant at my place of work.  The entry about testability and Object-Oriented development really hit some good points.  Especially how we, as developers, forgot all our O-O design education when we started working.  I remember one of the early classes (early in the morning, early in my university career, etc) on the software life cycle where the prof went out of his way to show that maintenance was by far the largest part of the cycle.  That initial development was small and that testing and what followed would dominate.  And that was the waterfall model.  So, over the past few years, my company has been exploring Agile methods and it's given me time to consider how we develop software and what I should be doing to create the best software.  It has shown me that testing, writing testable code, documentation, automation, KISS design are all very important.  One thing my feature team has discovered is that writing tests should take at least as much time as writing the code, especially given that there are two or three types of testing that have to be done.  Also, we cannot consider test code to be throw-away, second class or ignored.  We have one coding standard, which includes guidelines for design and documentation, and it applies to all code created.  Code reviews are done for all code.  Since tests are code, they are part of this process.

Something else that Christian touches on is the role of design in an agile process.  It's touched on a little bit, but not enough.  The emphasis in Agile is on iterative design, on incremental things, on people over process and I think people follow the buzzwords instead of doing "what's right".  Design is an important consideration, as I think many jump into the work because that seems like the right thing to do.  I believe what Agile is trying to impart is that design should be as simple and minimal as possible - that's the only way to have robust, flexible code.  The design should be map of what to do in a project.  It should be the five lines on a napkin map, not the satellite photo map.