Tom DeMarco and Timothy Lister start their book Peopleware – Productive Projects and Teams, with a thought worth harping on:
Somewhere Today, A Project Is Failing.
Since the days when computers first came into common use, there must have been tens of thousands of accounts receivable programs written. There are probably a dozen or more accounts receivable projects underway as you read these words. And somewhere today, one of them is failing.
Imagine that! A project requiring no real technical innovation is going down the tubes. Accounts receivable is a wheel that's been reinvented so often that many veteran developers could stumble through such projects with their eyes closed. Yet these efforts sometimes still manage to fail.
Software Legend Steve McConnell throws some light on the same mistakes people in our Industry have been making again and again, so many times, for so many years, that he calls them Classical Mistakes.These are the kind of mistakes which can easily cause yet another simple accounts receivable project to fail once again.
Both, the thought of an accounts receivable system failing and classical mistakes are thoughts that have some sarcasm, irony and a lot of bitter truth in them. Both these thoughts are in-fact quite scary if you harp on them for too long. And then you begin to wonder why.
Why do the same kinds of projects keep failing over and over? Why do programmers keep making the same kinds of mistakes again and again? Why can’t programmers of this planet, for once, spend some time and learn how to program?
DeMarco and Lister provide a clue to the alert reader who can read between lines and come to his own conclusions in their book:
The statistics about reading are particularly discouraging: The average software developer, for example, doesn't own a single book on the subject of his or her work, and hasn't ever read one. That fact is horrifying for anyone concerned about the quality of work in the field; for folks like us who write books, it is positively tragic.
Notice the use of the word horrifying? Yes, it is in fact much more than just horrifying.
It is a well known fact that today most folks in the business of crafting software don't give a shit about learning the craft of building good software and the sorry state of our industry allows them the luxury of staying blissfully ignorant.
Software Development as it stands today, is probably the only field where you can afford to be the man responsible for the failure of multiple accounts receivable systems and be rest assured that there will be a body-shop out there willing to hire you at a higher salary and a better designation to give you the job of building another accounts receivable system just because your resume says you worked on multiple accounts receivable systems.
I do not know why or how but an obsolete version of my resume which has not even been touched, updated or posted anywhere in the past five to six years, keeps fetching me job offers, interview calls and emails from Indian body shops which I politely keep turning down and sometimes even ignoring.
Not because someone somewhere out there wants to hire me. That’s the good part. There’s nothing tragic about that. It’s the best professional complement you can receive as a software developer. This year for instance I received a couple of offers from folks who knew me or folks who had read this blog, had read one of my articles, had taken the pains to get my references from folks I had worked in the past and then decided to make me a job offer. Even though I turned them down, the offers did come as professional compliments which ended up making me feel really good.
Having said that however, most other offers I ended up getting this year have been from complete strangers, based out of an obsolete outdated resume that has neither been updated nor posted anywhere for over five to six years! The fact that there are recruiters out there working for so-called-big-body-shops who want to hire me, without knowing anything about me, based on a resume which hasn’t been updated in the last five to six years, speaks at-length about the recruiter, his desperation to find anyone who is ready to call himself a programmer, the shortage of programmers in our business and the desperation of the organization he works for.
And, that is in fact both tragic and scary.
I even have a name for this type of a software-development-eco-system which constantly encourages crappy programmers to enter the industry, make classical mistakes and keep failing project after project. I call this the Infinite Loop of Failure.
The Infinite Loop of Failure explains why another simple accounts receivable system can manage to fail even after the millions of man-hours of computing experience our industry has behind it. Let me illustrate the Infinite Loop of Failure using my artistic skills:
A huge part of the universe in which we live in includes:
- People who build software – we refer to them as programmers; depending on their way of working, sometimes I address them as bodies, so-called-programmers or even Fred.
- People who hire people to build software – we refer to them as companies or employers; depending on their way of working, sometimes I also address them as body-shops.
- The People who ultimately pay, to get software built – we refer to them as clients; these are people who know nothing about building software, have one or more bitter experience with software development from their past where they've been bitten by some body-shop and a bunch of clueless bodies. Now they want to spend as little money as possible. These are people who need help in getting their problems solved by building systems that work.
I write this post with a heavy heart, but the fact is that most of the people who form these three categories are totally lost and looping around at different stages of the Infinite Loop of Failure playing different roles in the loop’s infinite life cycle. They are in-fact helping the loop gain momentum and stay alive.
A huge part of our industry, is doomed to a future where the same kind body-shops will keep recruiting the same kind of programmers, who will keep making the same kind of mistakes on the same kind of projects, using the same crappy processes and methodologies and will keep meeting the same kind of failures. As you read this post, a huge number of so-called-programmers are spending their lives looping in this Infinite Loop of Failure as they hop from one job to another, one designation to another and one project to another, earning peanuts more for every hop.
What makes the problem difficult to solve however, is that this multitude of so-called-programmers is largely un-reachable and cannot be helped by posts like this one. You can’t get them to know about this Infinite Loop of Failure. They are not exactly reaching out for technical blogs, reading posts like this ones, writing their own posts, learning how to become a better developer, participating in user-groups, asking or answering questions in forums or buying copies of Code Complete, Pragmatic Programmer, the Software Project Survival Guide and the like. Long story short, they don't care - because our Industry allows them the luxury of not caring and getting away it.
I’ve had my share of failures as I pushed budding college students to read and write blogs, pushed budding project managers to read Software Project Survival Guide and pushed budding programmers to read Code Complete.
Most of them are usually too busy to read a book, read a blog or start their own blog. They are too busy firefighting their current project which is doomed to fail because they are making the same classical mistakes. Others are busy playing musical chair with their jobs. They are standing right on the edge of the Infinite Loop of Failure preparing to enter it.
I've had my share of failures as I try to nudge them to the brighter side and try to stop them from entering the loop. Some don’t even make an attempt to read a book, blogs or start their own blog. Others start for a couple of weeks - under the gush of enthusiasm, at times even just to impress me - and then stop. I've seen multiple other colleagues at work fight this same battle of motivating the unmotivated programmers and face the same problems.
If you’re trying to convert a programmer who has already entered the Infinite Loop of Failure and is addicted to going around in circles, it’s usually a losing battle, at-least a very difficult one. Having said that, I agree that that we need to continue motivating the masses and keep trying relentlessly to pull the ones walking on the thin line of the loop to the brighter side of the line.
It is a fact that these masses consist of a huge percentage of our industry, and if they don't care about software development, if you think logically, it translates to a very strange fact:
A huge percentage of the people in the craft of building software do not give a shit about the craft of building software.
And that is a scary thought. Don't you think?
But there is a silver lining to the dark cloud. The sorry state of affairs in our world of software development makes it really easy for shameless thick-skinned programmers like us, which includes me who is writing this post, and you dear reader who cares to read it, differentiate ourselves as one man armies or kick ass programmers and shine.
We can distinguish ourselves very easily! Not because we write code that no-one else can write but because we know that most of the times we write shitty code with bugs. Because we know that the Infinite Loop of Failure exists! We also know that this loop can be broken by exchanging thoughts through books, sharing ideas through blogs and learning from not just our own mistakes but from the mistakes of the people we work with and share ideas with.
We know that, to break the Infinite Loop of Failure all we have to do is find a job we love, join a team we love working with, stick to developing deeper roots and in the process have loads and loads of fun doing what we always loved doing – which is building software that is nowhere close to perfect, but that ships, gets the job done and keeps improving and getting better with us!
Of course, we are no different from the ones who do not care and yet so very different. Just like them, we are bound to make mistakes. Some of these may be small, some may be colossal. Some can be fixed; some cannot be fixed for life and will keep us wishing if only we could go back in time and fix them. But every single mistake will at-least teach us a lesson and turn us into better individuals. Mistakes are good, as long as we stop making the same old lame mistakes and make all new ones; As we make all new mistakes we are bound to keep learning something from these fresh new mistakes and that knowledge will eventually keep us out of the Infinite Loop of Failure.
As Jeff Atwood points out in his post:
I say the more failed projects in your portfolio, the better. If you're not failing some of the time, you're not trying hard enough. You need to overreach to find your limits and grow. But do make sure you fail in spectacular new ways on each subsequent project.
So, do you know a couple of folks who could never ship a module on time but who managed change three jobs in the last one year? Do you know folks who never cared to read a book or a blog but were happily failing one accounts receivable system after another? Or do you know a few developers who are basically smart but standing on the edge of Infinite Loop of Failure? Jeff Atwood's suggestion on reducing daily WTF snippets might turn into a beautiful New Year’s gift you can buy them this year:
Let's take a break from our regular programming to consider how we can prevent WTFs from happening in the first place. If you're reading this, you probably don't need our help. But your fellow developers do. Take less capable developers under your wing. Mentor them. Provide them with guidance. Invite them to a user group meeting. Email them blog links. Expose them to essential programming books like Code Complete and Don't Make Me Think. In extreme cases, maybe they legitimately picked the wrong profession and should be gently nudged into some other role.
Go buy them a copy of Code Complete before it’s too late. If they do read it, nudge them to read a couple of blogs and push them into starting their own blog. Show them the path to shamelessness. After all, in the years to come, we don’t need more failed accounts receivable systems, do we? Who needs more Daily-WTF Code Snippets in our project code-bases? I don't. Do you?
As a new year rolls towards us, let’s continue relentlessly trying to help the programmers walking on the thin line of the Infinite Loop of Failure move over to the brighter side.
As for us, you dear reader and me – people who care to reach out for books, blogs, user-groups, web-casts, open-source code-bases, fellow-developers, colleagues or any other source under the sun that can help then become better developers and better individuals, let’s continue to break the break the Infinite Loop of Failure, this year and year after year. Not because we want to change the world, but because we know that it can be broken and because we can have fun breaking it!
Dear reader, this new year, I wish you luck. If you’re going to be making mistakes, I wish that you make all new mistakes. And by the way, this year, as you slog away at becoming a better developer, a better professional and a better individual, day after day, don’t forget to play your part in breaking the Infinite Loop of Failure. You owe it to your profession, you owe it to your fellow programmers and above all, you owe it to yourself!