Memo on O-Ring and Software Erosion

One of the most fascinating documents I’ve read to date is the memo from Roger Boisjoly on O-Ring Erosion. The original target audience for this memo he’d written were the management folks of Morton Thiokol back in 1985, about six months before the Challenger disaster.

What I find so striking about this whole story is its resemblance to the field of software engineering. We software developers can relate to this story all too well. I’ve personally been in this situation more than once. Heck, some of us are in similar kinds of situations all the time.

Roger Boisjoly attempted to halt the launch of the Space Shuttle, unfortunately to no avail. In his particular case, a failure of the Space Shuttle would cost the lives of the astronauts on board. But what about the software that we are crafting? In most cases, a failure of the software would not result in the loss of human life. It would cost the company a particular amount of money. Worst case scenario, its reputation would be flushed down the drain alongside the money.

But what should we do when we encounter reliability issues in the software that we’re working on? Well, first of all, we make an assessment about the severity and the impact of these problems and fix them accordingly. But what if it takes us a couple of days, a week, two weeks or even a few months to fix things? Well, then we usually turn to the management staff, explaining in our best non-technical terms what’s going on and ask them for the time (aka budget) we need. But here comes the tricky part. What if they don’t want to listen? What if they don’t take us serious? What if they don’t trust us that our findings are correct? What if they simply ignore us, wondering why we still have the energy to even come talk to them after or during this dead march that we’re in? What if they do listen to our plea, wholeheartedly agree with everything we say, walk us back to the hallway and then simply don’t give us anything except more business requirements and feature requests?

But now on to the million-dollar question. What do we software developers do when we don’t get the time to do the right thing? Well, we could try to fix things in our spare time, sacrificing the precious time we have with our family and friends or perhaps even our sleep for the next couple of days, weeks, months, perhaps even years? I don’t think that this is very sustainable. Or we could simply ignore management, stop adding new features and business capabilities and start fixing things on our own behalf, like some kind of software development team mutiny? I guess this will end up with one or more developers getting fired. Or we could start a campaign on social media about how software developers are being wronged at this or that particular company. Would anyone even care? And this will probably end up in some layoffs as well.

So what should we as professional software developers do to make things right in these kinds of scenarios? Maybe the people of the software craftsmanship movement could draft a script with concrete actions that guide software developers when they find themselves in the same situation as Roger Boisjoly?

I can only wonder what would happen to our industry if only 10% of all software developers would follow the actions described in such a manifesto. Wouldn’t that be useful advice?

Why Software Development Will Never be Engineering

I always find it rather interesting when academics try to quantify generalized metrics about software development.

Things like: per lines of code, there will be X number of bugs.

Statements like: it has been empirically proven that “blah” affects the development of software in some way “blah.”

These are all interesting thoughts, but software development will never conform to rigid engineering principles like many other engineering practices.  The longer I work in the field, the more and more I realize that software development has nothing to do with engineering.  We just happen to attend some of the same math classes in school.

Building bridges

One of the main arguments I hear people make about the current state of software development as an engineering practice is based around its relative maturity to other engineering fields.

There is a huge problem with this line of thinking.

The argument goes something like this:  “Engineering has been around for hundreds of years and has matured to the point where it is a measurable science, but software development has only been around in earnest for the last few decades or so, therefore it is relatively immature as an engineering discipline.”

On the surface this argument seems sounds.  And certainly in 50 years software development will be different than it is now.  Heck, it is much more different than it was just 10 years ago.

But, here is the problem.  We build much more software than we do bridges.


Let me give you an example that came to light in another area of my interest… poker.

The poker quickening

An interesting thing happened in the poker community in the last 10 years; poker pros with decades of experience started getting beat time and time again by 19 year old poker prodigies.

From an outside perspective it looks like the poker world opening up just widened the search for talent and there it was.  But, a closer examination of the evidence leads to the truth.

Before the online poker industry was born, poker was played in card rooms and casinos in states where it was legal and occasionally at small home games throughout the US.

A poker pro might play poker tournaments perhaps 100 times to 150 times a year.  The sum knowledge of the poker community and the meta game around it was based on this base of professional poker players playing tournaments and gaining experience at this mediocre rate.

Once the internet poker rooms started opening up, things changed, and they changed rapidly.  Now anyone could play poker from their home PC.  Not only could they play poker, they could play poker tournaments at all hours of the day.

Here is a list of some of the major changes that took place:

  • Hands are dealt at 60-80 hands per hour instead of 10-30
  • Players can play in many tournaments at one time, 10 tournaments at once is not unheard of
  • Players can analyze hand histories and historical data about their play and opponents play through the use of software
  • Age requirements are out the window, technically any one of any age could be playing online
  • Players can play 24 hours a day
  • The professional online tournament player could easily play over 3000 tournaments in a year, while a brick and mortar pro would be lucky to reach 100 in a year.


So where am I going with all this?

The point is that as a whole more hands were dealt and more poker knowledge and experience was obtained in 1 year of online poker than probably the entire history of poker before that.  We reached such an accelerated pace of play that all previous knowledge of poker became obsolete. 

The strategy of tournament poker completely changed.  The game evolved perhaps 500 years into the future in a matter of 5 years time.

The same has happened with software development.

Back to the bridge building

So let’s take that poker example and look at it through the lens of software development.

Let us compare the engineering maturity to software development to the engineering maturity of the engineering discipline of building bridges.

I think most people would agree that bridge building is a very mature engineering discipline but many people would argue that software development is not.

How many bridges do you think have been built in the world?

Well there are about 600,000 bridges in the United States alone, so the world figure must be at least somewhere around 10 times that number perhaps 20.

How many software programs have been written?

This is a very hard number to estimate, but lets take a rough guess based on how many software developers there are in the world

If we say there are about 12 million software developers and each software developer has written approximately 3 programs, we can estimate that a large amount more programs have been written than bridges built.

My point is not to knock bridge building, we are pretty good at it as a whole, but rather to show that collectively, even though we have been building bridges for hundreds of years, we have probably devoted an equivalent amount of time to building software.

This line of thinking may lead you to argue back that software development and bridge building are very different.  Bridge building has a fixed set of requirements that are pretty close to the the same for each bridge you build, but software development is a big open void of whims and ambiguously contradictory statements.

I agree with you 100%!  And in essence that is my point.

Software development is different

And we have had enough time to realize that.  Waiting for software development to gel into some kind of engineering discipline like other engineering disciplines is like waiting for water without gelatin mix to turn into Jello. 

It’s just not going to happen!

In my mind it is clear that the argument that we haven’t given it enough time is just wishful thinking.  The nature of software development, just like online poker, leads itself to rapid evolution.

Consider what direction software development is evolving.  Is it even evolving in the direction of rigid engineering practices or is it evolving in the exact OPPOSITE direction?

Ten years ago, we tried to use UML diagrams and CASE tools to develop software.  Ten years ago waterfall was all the rage.  Ten years ago, we thought that ten years in the future we would have programs that would allow us to build software in the same way that CAD tools allow for building machine parts.

Not only did it not happen.  It went completely the other way.  Now we are all talking about Agile.  Now people don’t even remember what CASE tools are.  Now we are building software without trying to define the whole system in UML diagrams.

The fact of the matter is software systems are unruly beasts!

In my mind it comes down to one simple distinction.  Software is living, bridges aren’t.  When you are done building a bridge, you are done building the bridge. 

Sure someone, probably not you, will have to come along and do some routine maintenance on it.  Sure, some small things might change about it, but for all intents and purposes the work is done.

In most software development scenarios, this is not the case.  In most software development scenarios, releasing V1 is not even close to the end.  Sometimes V1 and V2 don’t even look that same at all.  Software development is about operating on a living breathing thing and all the while keeping it alive.

The truth is, we software developers have more in common with surgeons than with other engineers.

As always, you can subscribe to this RSS feed to follow my posts on elegant code.  Feel free to check out my main personal blog at, which has a wider range of posts, updated 2-3 times a week.  Also, you can follow me on twitter here.

Why Rules Rule

I have to admit, I love rules.

They go against my nature to the core, but they are some of the most valuable institutions I put into my life, both personally and professionally.

Rules are all around us.  We follow so many of them each day and don’t even recognize how valuable they are, because when rules are doing their job, you don’t even notice them.

The first rule of your day is likely your alarm clock.  This is a self imposed rule that you have created for yourself to get up at a certain time in the morning.  Try to function in any meaningful way by completely removing that rule and see what happens.

Almost all games we play have rules.  Without rules those games wouldn’t be much fun.

We drive on the correct side of the road in our lane, following rules of traffic, which if not obeyed put us in mortal danger and make the road quite a scary place.

It is a gross understatement to say rules are important to our daily life.

Yet, I am constantly amazed how many people seem to oppose any notion of rules when it comes to our craft of software development.

There is this notion that rules somehow preclude judgment

Somehow the idea has crept into many of our brains that rules and good judgment, (what we might call craftsmanship), are diametrically opposed to each other.

There seems to be a pervasive thought that rules suck all the fun out of things and take away creativity, skill and experience, reducing the follower of such rules to a mindless robot, replaceable by any other robot.

Not only do I think this viewpoint is completely wrong, but I think it is downright destructive to the craft of software development.

Let us first dispel the notion that rules destroy creativity and its kin.

Think about a game like Scrabble.  Scrabble is a game that is based on a very restrictive set of rules.  You basically have only two moves you can do.

  1. Make a word using only letters in your rack and letters on the board.
  2. Discard some letters to get some new ones.

Rules dictate how many letters you can have and what ways you can arrange them.  Yet, how much creativity is actually created by these constraints?

Music is often seen as a cousin to coding, and is another great example of constraints which breed creativity.  Music has a huge amount of constraint.  There are many natural rules about sounds and chords.  We only have a small amount of notes to even work with, yet people have been elaborating on those 12 notes for hundreds of years and new creative sounds are produced every single day!

If you really take the time to think about it, I think you will find that constraints actually breed creativity not destroy it.

The truth is rules come from good judgment at the right time

Let me posit you this question.

When is a better time to make a judgment decision of what to do when a bear attacks you?

  • When the bear is actually attacking you
  • Sitting at your computer with a huge amount of reference material available to you about bear attacks and a calm peaceful environment

If you chose when the bear is actually attacking you turn to page 32.

Page 32:


Having no rules in which to operate, in the heat of the moment, you decide to “tickle” the bear.  The bear slays you and munches on your bones.  Your adventure has come to an end.

You are DEAD!

The point is that your judgment is much more likely to be sound when you are removed from the situation which you are making the judgment call about.  Unless you are a close relative of Spock, you’ll probably find that human emotions tends to interfere with sound judgment.

This is why I instead firmly believe that we should use our good judgment to formulate rules that we will use in the situations which they apply to rather than to try and execute good judgment when we are engrossed in the situation.

If you still disagree with me here, let’s ponder the example of the alarm clock one more time.  Better yet, I challenge you to make a judgment call each morning of when you should wake up.  You can’t use an alarm clock or any rules.  (Before you do this, you might want to make sure you get your resume polished up.)

alarm clock

How does this all apply to software development?

I’m not going to attempt to address every way in this blog post, perhaps we’ll revisit this subject in the future, because it is so important.  Instead my goal here is to convince you to embrace rules and to not fear setting them for yourself, for your team or for your code.

Some of the biggest failings of teams that I see is the fear of setting rules.  Teams seem to be so afraid of restricting someone or impairing their ability to make judgment calls that they go the direction of never setting any concrete rules, just guidelines or best practices.

There is a huge difference between guidelines and rules.  Guidelines help you make a decision, rules make it for you.  Don’t be fooled into thinking they are the same thing, and don’t fear rules.  I always prefer rules over guidelines, because they are much more valuable.

You can actually measure the effect of a rule, but you can’t easily measure the effect of a guideline.

Let me give you some examples of areas in software development that I think are great places to enforce some rules:

  • Naming conventions
  • Unit testing
  • Process of starting work
  • Who works on work
  • When work is considered done
  • How defects are handled
  • What changes can be made to work in progress
  • What should be in a backlog
  • Language and library choices
  • Data access strategies
  • Dealing with build failures

Every time you are having a conversation which ends up identifying something to improve upon, you should be thinking about how you can codify it into a rule.  Don’t be afraid to step out here.  It’s ok to make the wrong rule and change it later.  If you do this you learn something.

Having rules in place prevents you from making in-the-moment decisions which you later come to regret.

When I go to a buffet, I set rules for how much food I can eat.  When I decide to start a workout routine, I set rules for how often and what duration I will workout.  When I write code, I set rules for how I will write that code.

In any of those areas, when I fail to set rules, I end up failing.  It is human nature.

But rules impede me and end up making me do silly things

Good.  That is called feedback.

Remember back when you were just making judgment calls all the time instead of following rules you or your team preset ahead of time, you weren’t getting any feedback, now you are.  Be happy about it, celebrate!

You can always change the rules.  You can always tweak the parameters, but if you want to have any success in process improvement, it is much like cooking on the stove.  You are much better off with burner dials that have numbers on them or at least some kind of label, then ones with just a blank dial.  If you don’t know where the dial is, how will you know which way to turn it?

Sometimes rules are going to make you do something silly or seemingly extraneous.  Sometimes rules are going to cause you to possibly even do the wrong thing.

But, if you want to have any chance of learning from your mistakes, if you want to truly improve your process, you must resist the urge to break the rules and instead wait for a time to reflect upon the rules and make appropriate changes at that time.

Learn to embrace rules and you’ll suddenly see an improvement in all areas of life where you apply them, especially your software development!

As always, you can subscribe to this RSS feed to follow my posts on elegant code.  Feel free to check out my main personal blog at, which has a wider range of posts, updated 2-3 times a week.  Also, you can follow me on twitter here.

Programming is not a Craft: My Take

Dan North has provided tremendous benefit to our profession and in the brief conversations I have had with him has proven to be an affable guy. I was a bit taken aback when I read his recent post: Programming is not a Craft. Dan’s sentiments are not unique. I have heard similar opinions from other prominent developers I respect.

I read in Dan’s post (and in some of the comments) a visceral reaction to gold plating things not determined "important" by the customer. I get that. I also see a need to temper this with the simple fact that the client doesn’t always know what is best for them. Let’s just get that out in the open. My doctor knows what is better for my physical body than I do and I am willing to pay for that. Will I always take the advice I am paying for? Well, probably not. And I’m sure that leaves my doctor shaking her head in dismay.

I learned that integrity is "doing the right thing even when no one is looking", and I see the Software Craftsmanship discussion as striving for integrity in the systems we create.

One mark of a true professional might be a willingness to balance client need with implementaion elegance resulting in software that meets the need of the client AND is something worthy of pride when shown to another developer. If the only reason we are writing code is to provide the minimum a client wants to pay for, then how compelling is my work, really? Can I be proud of my professional body of work if I am simply marching to orders? I say no.

Where I part ways with Dan is in his analogy of the plumber. Granted, I simply want my pipes to work, but I am willing to pay for a plumber that takes pride in his work. I trust that plumber will simply do a better job as he strives to make his work appreciated by the next plumber that sees it. Can I quantify this into dollars? Not really. Perhaps in the extra time required to lay in a perfectly soldered joint as opposed to a sloppy one. Am I willing to pay more for this type of person to do the work? No question: Yes.

The bottom line for me is that we would all like to take pride in our work. No one I’ve ever met gets up in the morning thinking, “Today I will make a piece of crap”, and keeps at the job with any pleasure. We want to enjoy our work and be proud of it. Is that so bad? The very real software craftsmanship discussion simply gives us a vehicle for discussion in the pride we may take in our work for its own sake.

The risk to the craftsmanship community is to avoid getting carried away with dogma. Every time I hear Bob Martin assert to a 500 person room that if they aren’t writing unit tests they are "not professionals" or somehow unworthy of being in the room with him, I cringe. That’s a perfect way to draw fire and alienate people who might otherwise join you in your cause. It also happens to be a perfect way to stand out as a charismatic speaker who gets lots of attention, but I digress…

Do I write tests? Yes.

Always? No.

Am I ashamed when I don’t? Not really. Some jobs still call for duct tape.

Professionalism is knowing the appropriateness of a tool for a job and in always striving for integrity in our work.

My .02.

And, Dan, I admire and appreciate your contribution to our craft Smile .

A Burden Called Meetings

I’ve been working for an enterprise corporation for 5+ years, which I’m going to be leaving soon. This organization is suffering from a wide-spread malady called “meetingitis”. This phenomenon bothers me from time to time, especially when I’m being pulled in those pointless meetings, wandering about the same thing over and over again without coming to a conclusion or a solution. Then there are also those kinds of meetings where you don’t have anything to say or contribute; these are just a complete waste of time.

Yesterday, Yves pointed me out on Twitter that it is perfectly fine to leave a meeting if you feel that you’re not able to gain or contribute anything. Today, I walked out of a meeting where one of the participants started making insults against me. I just stood up, walked to the door and left. And I must say that it felt liberating doing so. I went back to my desk, calmed down and got some actual work done. Without a basic form of respect, one simply can’t achieve anything, let alone come to win-win agreements. From now on, I’ll be evaluating all meetings that require my presence before I accept them and also keep evaluating my presence while being there.

Let me close of this mini-rant by sharing a must-see recording of a talk called “Why work doesn’t happen at work” by Jason Fried. I recommend you watch this short video, and if you like it, I also recommend picking up a copy of Rework.

I hereby rest my case.

Laborers versus Professionals

A while ago, my good friend Michel Grootjans tweeted the following:

Are developers (a) laborers or (b) professionals? If (a) don’t expect them to think. If (b) don’t expect them to execute without question.

Personally, these few sentences struck a nerve or two. Read it a couple of times and think about this statement for a while. Try to picture your own work environment and how this relates. Go ahead! I can wait.

OK then, let’s move on.

I’ve been working for an enterprise corporation for 5+ years now. One of the things I’ve seen and learned there over this period of time is that laborers are more valued by management than professionals. Let me elaborate on this.

One of the biggest issues in a typical enterprise corporation is trust, specifically the lack thereof. The direct consequence of this lack of trust are massive amounts of constraints, regulatory processes and fear-driven development. This is the natural habitat of laborer developers, a nice and cozy place where they can spend their hibernation until retirement. This is where the term ‘code monkey’ originates from. Nine to five, no thinking, narrow focus, like soldiers in the military obeying orders to make a big mess. But sometimes, amongst these massive cohorts of laborers, there are small islands that exist of one or more professional developers. These are the kind of people that are very passionate about their craft, that want drive innovation and also want to continuously learn and improve. If you’re a developer and you’re reading this blog post, you probably fall into this category of developers.

But professional developers always have one part of the establishment going against them. It’s not the laborers. They don’t care. It’s an instrument better known as management. A large part of the IT industry, especially corporate IT shops, are being run by giant flocks of managers. Some of these managers started out as software developers and some of them are just born that way. But there’s something that they all have in common: they don’t write code as part of their day job. Although they don’t get their hands dirty with writing software, most managers do feel compelled to impose all kinds of political decisions regarding business requirements, software architecture/design, tools and technologies to the development teams they are ‘managing’. I for one want to make it clear that this has to stop. In order to lift this industry to the next level, we as software professionals need to free ourselves from the leash that is currently being held by management.  

Professional developers working in these kinds of corporate environments are generally considered as troublemakers, if not by their direct bosses then certainly by other parts of management. The general attitude towards professionals is slamming them with more  procedures, so called ‘company standards’ and ‘default architectures’. This ends up with a lot of frustration, a feeling of burn-out or even worse, suffocation as it may seem that the walls are closing in. Professional developers generally have a hard time placing this attitude towards them. They just want to do the right thing and provide the best possible solution they’re able to come up with. If managers don’t trust their development teams to make the right decisions, then why did they got hired in the first place?

I for one am pleading to get past this all this. Any business that wants to survive in this hard world economy and even wants to get ahead of its competition has to free its professional developers from management. It’s that simple. Management is great for enforcing compliance, but if engagement is what you want (and is definitely needed for bringing innovation), self-direction is essential. I already wrote a blog post about self-organizing teams a couple of years ago. Today, I’m even more convinced that self-direction is one of the major key enablers for innovation in the IT industry of the 21th century. Anyway, someone who isn’t coding at least 50% of his day job shouldn’t be allowed to interfere with any kind technical decision making. Period!

I’m not saying that development teams should get a signed blank check. On the contrary. Financial and business constraints should still be taken into account. But when it comes to creativity, methodologies, technologies and tools, management shouldn’t get in the way. Development teams should be able to take responsibility for their own actions. Managers should know their place by making sure that their development teams can operate as optimal and efficient as possible by removing as many impediments as possible.

Let me show you a couple of examples where this principle of autonomy has immensely paid of so that you’re able to judge for yourself.

I personally find health care a fascinating craft. I find it fascinating simply because there are so many parallels than can be drawn between software engineering and the state of health care roughly 200 years ago :-). Lets take about modern hospitals for example. Medical facilities are generally being run by senior medical staff and not by managers! Senior medical staff are people that have a high degree of mastery in what they do and still perform their craft every single day. Maybe they’re not doing it full time so that they’re able to fulfill their ‘path-finding’ responsibilities, but still, they are still fixing their patients. Hospitals do have managers however, but they are there simply for enabling the medical staff to not worry about anything else besides saving lives. Can you picture lying in an operating room when a manager in a suit bursts through the door, yelling at the surgeon that he’s not allowed to use technique xyz to save your live? Preposterous you say? Not so with the current state of affairs in IT departments of the enterprise corporations.

There are a couple of concrete examples in the IT industry as well. Remember when Google announced that their engineers get to spend 20 percent of their time to work on something of their own interest? This resulted in massive improvements for products like GMail, Google Maps, Google Docs, etc … and directly contributed to Google’s success and current market share. Other companies like Atlassian and Facebook are enabling innovation in basically the same way.

Yet another example is Pixar. If you haven’t seen or listened to this interview with Ed Catmull, the president of Pixar, stop reading this blog post and let it inspire you now! Somewhere along this awesome interview he mentions the following:

Part of the behavior is I don’t know the answers. And at first that seems a little bit glib. But after awhile people get that I really don’t know the answer to a lot of these things. So we set it up so that the management really doesn’t tell people what to do. 

Think about how amazing it would be like to work in an environment like that. It’s inevitable that great things are bound to happen.

There are plenty of other examples out there, like open-source software, Wikipedia, etc. … . They all prove that self-management results in engagement and that this is going to be a major differentiator in tomorrow’s economy. 

Make sure to check out the following resources as well:

Till next time.

Keep Pressing on my Friend (When programming seems bleak)

Do you ever get the feeling that you just want to get a cabin in the woods and never see a computer again?

Do you ever feel like someone stole your motivation and sapped your energy like a mosquito in a bug zapper?

I used to think it just happened to me.  The first time it happened to me, I almost switched my major from CS to CIS.  But, the more and more I work in this field and talk to other programmers, the more and more I see the same exact thing happening.  And guess what?  It is happening to everyone.

Not just you.  You are not alone.


I’m not talking about burnout here

This is more than burnout.  This lack of motivation energy-sapping-plague can hit a programmer at any time whether you just finished a week of all nighters or you just came back from a peaceful vacation.

I actually find that it is the time when I am furthest from what should be burn out that this phenomenon is most likely to occur.

So, if it’s not burnout, what is it?

I’ll call it programming lethargy.  It actually happens to two other groups of professionals: athletes and craftsmen.

The truth is it is a perfectly normal cycle.  This “barrier” is actually the reason why there are many apprentices, few journeymen and even fewer masters.

When you hit this phase be glad, it means you are about to be tested and if you come out on the other side, you will end up with a renewed interest and passion and leave behind the others that can’t cut it.

Oh, and it will happen again, probably several more times.

Press on my friend

What can you do about this problem?

Don’t despair, just press on.  Stay the course and all will be well.

I am not sure why this happens, but I do know that it is a true test of your desire for the goal, whether to be a better programmer or a better athlete, or a better singer or musician.

The test is whether or not you can still press on when the motivation and passion is not there.

The reward waiting for you on the other side?

  • A renewed passion and energy. 
  • A new kind of appreciation for what you do. 
  • Experience and true appreciation for your craft.

The question you have to ask yourself, is what do you ultimately want to become?  If what you do is more than just a job to you, then you’ll find the strength to press on.

How to press on when the motivation is gone

If you agree with me, or even think that perhaps what I am saying is worth considering, then you will probably wonder how you can get through this phase or test to see the other side.

We can look at athletics again as a comparison to provide some insight.

Think about a professional track runner, training for competition.  Consider what would happen if that athlete decided to not have a formal training schedule, but instead only train when he felt like it.

What would happen when he didn’t feel like training for a week?

Now let’s say he had a training schedule and he followed it, even on the mornings when he didn’t feel like getting up to train.

What would happen if his training was not planned out?  If he didn’t know what kind of drills to do or have a long term plan for the training sessions?

If you want to make it through the times when you don’t feel the motivation and passion for writing code and solving problems, then you have to have a plan.  A solid plan that will ensure that you will be able to press on.

Here are some tips to make sure that when you get struck by programming lethargy, you do make it through to the other side.

  • I’ve talked about this several times in my blog.  Make sure you are always reading a technical book.  Create a schedule and stick to it.  Even 15-30 minutes a day of reading will let you read around 1-2 books a month.  That is a huge amount of knowledge.
  • When you don’t feel like working, break up your work into small tasks and start accomplishing those tasks.  Figure out exactly what you have to do to move forward and do it.  Don’t give in and waste time.  The time you feel the most like killing time, is the time when you must throw yourself into your work all the more.
  • Set some goals for yourself.  Short term and long term.  The short terms goals should clearly lead to the long term goals.  Review those goals frequently and always try to make progress towards the goals.  Even a little bit of progress adds up over time.
  • Don’t start thinking about changing careers or looking for an easier job.  Don’t start thinking you will feel this way forever.  Realize that what you are experiencing now is a feeling and feelings are not trustworthy.
  • Clean up.  Clean up your workspace.  Clean up your computer.  Get yourself some new equipment if it will help.  Feeling like you have a new and fresh environment can do wonders for motivation.
  • Challenge yourself.  Your gut is going to tell you to slow down and relax, but that road leads to laziness.  When laziness comes your way, the best way to fight it is to push right into it!

Well, that is all the tips I have for you for today.  Just remember that you are not alone and what you are experiencing is normal. 

If you’re in a period now where you are motivated and feel great about your work and what you are doing, you might want to bookmark this post and come back to it when it can benefit you more. 

Remember though, setting up good habits and routines now can help you cruise through the hard times later.

As always, you can subscribe to this RSS feed to follow my posts on elegant code.  Feel free to check out my main personal blog at, which has a wider range of posts, updated 2-3 times a week.  Also, you can follow me on twitter here.

    Microsoft doesn’t create bad developers, developers do

    Have you ever stopped to think about the industry you have choose to work in (I’m bluntly assuming that if you are reading this you are working in the software industry in some way)? I would call it one of the most complex industries in the world. Think about it. We are working in an industry that is evolving at an incredible pace, contains an incalculable number of technologies, frameworks, best practices and constantly redefines the definition of how things should be done in the best possibly way. It’s the industry that makes the rest of the world tick. Daunting really, if you think about it.

    A while back I read a couple of posts by Gil Zilberfeld (here and here) where Gil talks about the responsibility that vendors such as Microsoft plays in the role of securing the quality of the work that is produced in our industry. While I think I see the points  Gil is trying to make, I think he misses the beat a bit and I have a hard time agreeing with the conclusions he draws.

    The way I see it there are two types of developers; those that are just in it to pay the bills and those that consider themselves as craftsmen. If you consider yourself a craftsman then you should already be aware that you are responsible for your own faith and actions in this industry. But, if you are just in it to pay the bills then you are probably also looking to do so by doing the least amount of work and that includes looking for information on how to solve a particular problem or how to apply a technology onto your stack.

    So if you are one of the developers that are only looking towards Microsoft (or the relevant company for the technology stack you are working on) is it their fault if you implement something in a way that could be considered bad? Of course not! Sure there are a lot of outdated and down right poor samples at the Microsoft (or relevant company) website and their idea on how certain things should be solved are bound to differ from others (and that’s definitely not to say that there isn’t good contents, there are a ton of it). However, if you rely on a single source of information, you are always going to get an opinionated view. Take my word on it (right?).

    Doctors reads medical journals, publishes research papers, attend conferences, network with colleagues and make sure they stay up to date with the latest in their field. I’m pretty sure you are happy that they spend all of this time to make sure they can provide the best possible care and treatment when someone are in need of their services. I know I am.

    Just as with any other profession, developers are responsible for their own education, for honing their skills in the craft that they have chosen to practice. In order to keep up in an industry that evolves at the speed of light you need to invest in yourself. The code you write today should be some of the best you have ever written, while a year later you should be considerably less excited about its quality. It’s a sign of growth. That you’ve continued to move forward as a craftsman, that you skills have been honed and broadened during the past year.

    So what about the tools? Do we really rely on them too much to get the work done? I would say, definitely not! But again you have to specify just exactly what you are talking about when talking about tooling. If you rely on visual designers, drag and drop, wizards and the likes to to the majority of your work, then yes you are probably relying too much on your tools. Odds are that you will have a hard time to get anything outside of standard behavior to run and there will be pain points when you need to debug.

    However you would do yourself (and your employer) a huge disservice if you did not make it your goal to know the tools in your toolbox as good as possible. What’s wrong with knowing how to use the debugger, the IDE and tools like ReSharper as good as possible? Used correctly they will have a huge impact on productivity. Make sure you know the finer details of the tools and make them work for your and not the other way around. Yes, sometimes tools do get in the way of the goal, even slow you down, and when that is the case, don’t use the tools! Tools are there to help you when you need them, not to act as a crutch you always have to lean on so you don’t fall on your ass.

    Well there you have my thoughts on the subject. It’s always up to the developer, not the companies. Always.

    I am also around on twitter @thecodejunkie in case you need one more person to follow