In the past couple years I've realized that I've become a new kind of beast in my career. Today I learned the name: Grumpy Old Programmer. Doubtless those heralding this title have far less, and much grayer, hair than me -- but spiritually I'm so there. It boils down to seeing that basic wisdom is more-often-than-not spurned by working programmers in favor of impractical ridiculousness. Unfortunately, I see examples of ridiculousness so often that it's easy to roll out a list:

  • using patterns where not needed
  • using black boxes where not needed
  • using XML or web services where not needed
  • over-engineering; over-architecting
  • not using simple UML to document stuff
  • not using use cases to document requirements
  • not making code extremely readable
  • making all code "object-oriented" (scare quotes intentional)
  • wanting to rewrite from scratch the project that has 20 man-years of debugging invested
  • not valuing automated builds
  • not valuing automated testing
  • overcommenting
  • undercommenting
  • not ambitiously refactoring
  • not ambitiously keeping the name of types as cognitively efficacious as possible
  • valuing "automated document creation" (e.g. ndoc)
  • breaking the build
  • spurning all open source tools
  • failing to effectively communicate requirements
  • failing to effectively communicate architecture
  • failing to document processes with the detail required
  • failing to thoroughly educate the team about our own tools
I continue to be amazed at how guys with 10 years experience just don't get it. I could write a lot more about this, but it's not good to stew in Grumpiness. So I'll close by quoting the GrumpyOldProgrammer web site manifesto, which is limited in scope, but does give the right flavor of a wise outlook on the profession of creating software:


  • MooreIsLess’s Law. Which, given Moore’s Law, holds that the time taken to boot a Microsoft Operating System is constant.
  • LessIsMore’s Law. Which states that the value of any given Design Pattern is inversely proportional to the total number of Design Patterns currently in circulation.
  • That the Law of Misplaced Inference (which states that if a technology is good for one thing it must by inference be universally applicable) is both malevolent and endemic.
  • That Object Orientation is a blight on the software industry (yes, of course we know what it is – we were bored sick of it by 1990). That OO is responsible for programmers losing sight of the principles of Structured Design: low coupling and high cohesion. For this reason we are slightly in favour of Service Oriented Architecture (which is a re-hash of Structured Design).
  • That XML has already outlived its usefulness (Face it: it’s already so complex as to be unreadable by humans. So let’s agree on a simple binary standard and stop pointlessly wasting hardware).
  • That Web Services are a social evil. For this reason, we think that Service Oriented Architecture is probably the devil’s work after all.
  • That the word ‘cool’ has no place in the programming business (we blame Miles Davis for its birth). It epitomises the dumbing down of programming into a fashion statement and makes us cross.
  • That it is ridiculous to believe that programming is a Single Discipline. No-one would think of targeting bricklayers, civil engineers and town planners with the same tools, training and trade literature and yet the distinct groups of workers that are labelled ‘programmers’ are treated as one. This results in confusion, misplaced snobbery and failed projects.