I beseech you, [gentlemen], consider the possibility that you are mistaken.
-Oliver Cromwell
I'd like to tell you a story.
When I was first hired at my current job, I was given a task: build a search engine for our company intranet. Well, that won't be hard, I thought, I already know how to build a search engine. It'll take no time at all. A database, a crawler, a ranking algorithm, done! With a misplaced confidence in my development skills, I told my boss this would take just about a month, even though I really thought it would only take a couple weeks.
As you might have guessed, Hofstadler's Law immediately went into effect. Several seemingly minor problems popped up. For example, I realized I had to strip out the HTML from the crawled pages. A couple days later, after learning about HTMLAgilityPack, I had this solved. But this and other problems I had to account for gobbled up time, time that was cutting into my estimate, and now I had to catch up.
I started coding faster, with less critical thinking and more shortcuts, as my deadline was bearing down on me. But, despite the road bumps, it was starting to come together! It passed a bunch of test sites and was bringing back results perfectly. My confidence renewed, I set about testing the crawler against our beta intranet sites.
The problem hit me like a bird hits a window. I had totally forgotten about security. Each of the intranet sites had different security rules and different procedures, and my crawler needed to log into each of these sites. Now, instead of building a simple crawler, I had to deal with hundreds of different rule sets, and that was going to take time, time that I was rapidly running out of. I started to think that if this damn code hadn't been so difficult I would have had this done by now.
But, a couple years removed from all this, I now realize that the code was not the problem. I was the problem.. My arrogance had convinced me that the system was simpler than it was.
Eventually I had to return to my boss, hat in hand, to explain to him that what he wanted was probably doable, but was going to take a lot longer than he wanted. After a long and rather embarrassing (for me) discussion, he eventually decided that the entire project was not worth the effort needed. Just like that, a month's work, gone.
That embarrassment, that wasted time, could have been avoided if I'd only remembered to have a little forethought. If I'd told my boss "I'll get back to you," instead of blurting out my overeagar estimate, maybe I would have been able to get more time allotted to solve this problem. I'd shot myself and my boss in our collective feet by putting too much trust in my programming skills.
I believe that programmers, as a whole, are smart, rational people. One of the problems smart people have (really, that people in general have) is that they tend to assume that because they're smart, they're right. This is a dangerous assumption to make, because it precludes the possibility of being wrong. You may be smart, but you are not as smart as you think you are. And we must always be ready to consider the possibility that we are wrong, for it is in that moment that we learn the most.
