Programmer Musings

LCDC: Rising Tide

I began this series on Least Common Denominator Code (LCDC) with The Myth of Code Anyone Can Read. In the posts that followed I attempted to show how this kind of code is not actually possible in a real development shop. I've shown how different code should be written for different audiences, and how real business value drives code that cannot be written for the least common denominator.

In this post, I propose to show why, even if it were possible, LCDC would be a bad idea.

Expertise

Different developers have different kinds and levels of expertise. Unless you only have one developer on staff, you have probably seen that some developers are more productive, or faster, or safer than others. You may have one developer that always works on the critical code because she is the most careful or security conscious. A different developer may be tasked with time-critical issues, because he can always get a 90% solution in place in short order, even if other developers are needed to finish the work.

These developers have different skills and expertise, as well as temperament, that determines how the company can best make use of them.

However, you don't want the developers on your team sitting still. The rest of the industry is continually learning new tools and techniques. They are exploring other ways of solving problems. If your competitors are improving and your team is not, your company will fall behind. This could cause the project (or company) to fail.

On a related note, the kind of people who become software developers usually like to learn. They are probably spending some time looking into new technologies and related fields. The good ones will be exploring on their own to improve their skills. If one of your good developers finds an interesting tool or technique, they are going to want to use it.

On the other hand, there are developers who just code as a job. Just like any field, there is a spectrum of skill and motivation. These are the people that may just be doing the same thing year after year. As a manager or mine used to say:

There a big difference between 5 years of experience and 1 year of experience 5 times.

If you want to keep up or surpass your competition, you need more of the former than the latter.

Developer Motivation

Many people have written about what motivates software developers.

In most of these discussions, you will find some variant of interesting problems and opportunity to learn or improve. The best developers seek out positions with with these features. They also like to be recognized by other developers for their expertise. LCDC fights against all three of these motivational factors. If a really good developer has no or few interesting challenges, is not allowed to learn more effective ways to solve problems, and cannot show off new techniques to the other developers, their main motivation is to find a new job.

I have heard managers argue in the past against training for their developers, because they might learn enough to want to leave. One trainer I met answered with What if your developers don't learn anything, and then stay? As I pointed out above, developers outside your company are learning, if your team is not, they are falling behind.

The Rising Tide

The open source community is fond of the phrase:

A rising tide raises all boats.

The idea is that if we share our expertise the whole industry gets smarter and more capable. You can take advantage of this inside your company or team as well.

Instead of aiming to keep your code written to the level of your most junior developer, aim for just above the middle level of expertise on your team. Anyone below that level should be encouraged to learn. The developers with more expertise will be looking for ways to improve the overall team ability, so that they can show off their skills.

The downside of this approach is that new people will have a lot to learn. But, the really good developers like to learn. That's a large portion of why they are in this field. The upside is that the developers who want to learn and improve will stay with the team. The ones who refuse to learn will fall behind (and might leave). The overall result is a more capable, more experienced team.

Summary

The point is that LCDC is quite likely impossible. Every bit of experience in your code, fights against the idea of LCDC. The more you look, the more likely it is to be bad for your project. Not only is this a bad idea from a technical point of view, but it also tends to chase off your best developers.

This whole series of posts is aimed to convince you that LCDC is a really bad idea.