The Gods of the Copybook Headings – truisms of writing software

Rudyard Kipling has a poem called The Gods of the Copybook Headings which is about how everyone likes to go chasing off after shiny things and sooner or later those shiny things turn out to be mirages and by that time you’re stuck in the desert, up a tree without a canoe and there’s nothing much you can do. The Copybook Headings referred to in the poem are proverbs that used to be printed at the top of school exercise books. Of course our school exercise books are much more boring nowadays. Anyway, the thing is that proverbs and folk wisdom exist precisely because they’re sort of… trivially true things that everyone should know. But as my grandfather used to say “Common sense is not so common”.

I feel that we face a problem in software today where people – especially management type people – ignore the basic truths of how reliable software is built and created, and throw money and the latest frameworks and fresh-out-of-university graduates at a problem with the confident belief that this is how one solves it. But it frequently does not result in fame, fortune or happiness for the person or organization from whom the aforementioned units of financial exchange are being squeezed. So I think that the software industry needs something like copybook heading proverbs. Things like “Beware of fads in software, for not every latest tech is good”.

Here are a few things I’ve learned or otherwise picked up an opinion on, which I think should have the status of universally acknowledged basic truths, but which for some reason people keep having to rediscover for themselves, or maybe it’s because there’s a universal human tendency to think that one can somehow magically not be subject to these laws. These are not all original to me. I’ve tried to attribute where I can remember, but I’m not claiming authorship of any of these.

  • You can have Cheap, Reliable, Quickly-Developed software. Pick any two. This is an absolute rule that nearly every entrepreneur thinks they can violate at will. You cannot.
  • It’s better to delay a release or to cut not-yet-ready features than to release untested or buggy code. avl ivermectin People might get mad about a two week delay and that they didn’t get ice-cream cones in the Sims 4, they won’t forgive a bug that corrupts their save file. Also, you can’t get around this by slave-driving your coding team – they’ll just get demotivated and quality will suffer anyway.
  • All coders make mistakes. We are not gods. We code bugs and send them to production. Thus, between our hapless users and disaster, heroically building up the wall and standing in the gap are… the testers. Not automated tests, not bored executives who sign the document saying we’ve delivered the agreed upon product after wiggling the mouse. Actual testers who try to break the software in ways undreamt of by humankind. You can have all those other tests too if you want, but you absolutely cannot not have human testers.
  • It’s easier to think about a design than to alter existing code, so a little planning goes a long way. This is one of the fundamental ways that people misunderstand agile development. You have to have a roadmap for any software project.
  • Catch-22: No design survives contact with its implementation (not my phrase, I got it from Chris Fox). You always learn new things about the problem you’re attempting to solve once you actually start coding. can you buy ivermectin over the counter in nz
  • Simple designs that solve a single problem well are better. It’s way too easy in software to think “but if I just added this extra feature then my lawnmower could make candy-floss”. With the result that you get a mediocre lawnmower or a mediocre candy-floss maker and none of your users are happy.
  • Nearly every software design eventually turns into a big ball of mud. There’s even a paper about it. There’s a clear reason for this. ivermectina dosis oral para piojos As soon as your software gets anywhere near to being successful deadline pressure becomes a thing and quality takes a knock.
  • There are no guarantees. Software is not ever a sure thing. Today’s tech giant is tomorrow’s cautionary tale. The market changes. Someone else beats you at your own game. Your tech is old and development becomes prohibitively expensive. That’s how it is.
  • You can save a lot of money, time and effort with a little (or a lot of) thought about your potential market, it’s size, how much money your typical end user is gonna be willing to fork over for your product and so forth.
  • Once development starts regular end user contact is an absolute requirement. You can consult domain experts, you can implement agile methodologies, but if your development team are not making regular contact with the actual people who will use their software once it’s released, you are risking pretty much everything.
  • Software project management is hard. Most projects, except very simple ones, go way over budget, time etc. Although this problem is recognized, there is no single agreed upon method of delivering quality software on time and on budget every time (although there has been a lot of careful thought put into it and e.g. agile software development is getting some traction, at least in the form of a buzzword). A lot depends on the individuals who work on the project.

Here’s a recommended reading list 🙂

Actually that’s it. He’s an actual software person who actually knows what he’s talking about.

About the Author