There are two challenges in building software: building the right thing and building the thing right (yes, I love alliteration).

Build the Right Thing

Building software that users want is hard because most people don’t know what they want.

You may be surprised to find that people don’t know what they want, but it’s true. And it usually has nothing to do with how smart or thoughtful they are. I once wrote a program for my own use. The first version was barely usable and I had to practically rewrite it before it met my needs. In other words, even though I was the customer, the BA, the architect, the engineer, the QA, and the “every other role conceivable on a project”, the project failed.

How could this be? Well, it could be that I am not a very good BA / Arch / Dev / etc. (this is probably true). Or it could be that I just didn’t know what I needed. The picture in my head of The Thing I Wanted was just too blurry at first pass. It took something tangible to refine it.

There are two ways to deal with this reality. One way is to make people think really really hard about it upfront just to make sure that they thought through it thoroughly (I told you I love alliteration). On top of that, create a really unpleasant process for asking for changes later. Another way is to do a little, show them, allow them to make changes, and do that over and over again until they have what they want.

To recap, your choices are to either fight reality or to accept it and work with it. Interestingly, for the first few decades of software development, we insisted on using the first option. Many processes with fancy sounding titles and impressive sets of document templates sprung up to help us manage requirements. We spent weeks and months writing down, in excruciating detail, all of the things that the system needs to do. Then we created forms and processes to manage changes. This is known as waterfall.

As fun as this sounds, it didn’t work. Projects failed regularly and spectacularly all over the place (I was on a project once that was cancelled after a 2 year / 8-digit investment). Finally, a few smart guys had an insight that fighting reality is hard and so they decided to go with Plan B. They proposed building the product incrementally. Do a little, stop, check, adjust, and so on. This crazy idea took off in a big way and quite a few people now develop software this way. It’s called agile.

Build the Thing Right

Imagine if you ask someone to build you a 3-story, 4-bedroom house, with a 2-car garage, a dog house,  and a bird feeder. Then imagine that they did just that and that it looks great. Are you happy? Of course you are! You just got a huge house with happy pets and wild animals. But what if the plumbing leaks? Or the electrical keeps shorting? Or they left a hole in the attic? Still happy?

Building software right is about building it to be maintainable. It takes effort and knowledge to keep it clean, testable, understandable, and easily changeable. It’s a hard problem but many engineering practices exist to help: Continuous Integration, Test Driven Development, Automated Testing, Pairing, Design Patterns, and so forth. It takes a real commitment to keep it up, but you end up with software that doesn’t require an act of God to modify.

It Takes Two..

OK, so at this point you’re probably thinking one of two things: Either “Wow, this type of fresh thinking coupled with top-notch writing is the reason I read your blog” or “Thank you Captain Obvious and congratulations on becoming the 1 millionth geek to write about this. Can’t wait for your next post on the blueness of the sky. Jackass.” Or, putting it another way, “I know all this already, what’s your point?

Well, my point is this: If your team seems to be incapable of meeting a deadline or delivering a good product to the customer, understand why that is before trying to fix it. This may sound obvious, but it’s not. It’s just too tempting to introduce an agile process (“we’re doing Scrum now“) and think that everything will be great. It may be, but then again, it may not. If you’re building manually and have no code coverage, Scrum will not fix it. And, if it takes 6 months of development before your users see anything, no amount of Pairing or TDD will help deliver what users actually want.

You may also like:

tagged with:

Did you love / hate / were unmoved by this post?
Then show your support / disgust / indifference by following me on Twitter!

This post got 3 comments so far. Care to add yours?

  1. Steve says:

    Alex,
    I think an important part of what you’re saying is the idea that you don’t have the knowledge before you start. Many times the assumption that follows is to get better knowledge up front. A key point, borrowed from economics, is that the knowledge often does not exist ahead of time. Say the Corner Bakery in Westwood decides 6 months ahead of time that it’ll start making ten chocolate chip muffins a week. At some point during that six months, a company in Westwood hires a team of festively plump consultants. Ten muffins per week are no longer nearly enough. Also, the consultants demand chocolate chip cookies rather than muffins. There is no reasonable way that the manager of the Corner Bakery (we’ll call him Rocky) could have anticipated this change in demand ahead of time.
    Steve

Leave a Reply