Programmers tend to focus on specializing specific skills, and the average person needs months or years to master a single skill.

Acquiring basic knowledge in a specific area is the easy part, but once you get to the intermediate and advanced levels, you need more and more hours even to make a 1% gain in skill, since advanced skills are harder to master.

The actual improvement graph could look like this for a single skill (e.g. a single programming language like C# or JavaScript):

Skill Improvement Over The Years

Note: The time axis could represent hours, days, months or years depending on the skill, cognitive abilites and other factors, so the time axis is relative, but the principle stays the same.

So if you are working hard to become a better programmer, focusing on one skill might be the wrong strategy, because (except in the initial period) you will have a very small return of investment for the invested time and effort. So if your reading/tutorial list is limited to a single programming language, you might not be getting the improvement you expect.

Even if you focus your efforts on 3-4 skills you might get a relatively small improvement of your overall software development skills per year, which is OK, as long as you are making progress.

If i told you there was an alternative technique that could make a 100% improvement of your overall software development skills in a single year (or less) would you believe it? Read on.

The technique

The technique is called improvement by marginal gains and i first heard about it in the book Faster, Higher, Stronger: How Sports Science Is Creating a New Generation of Superathletes--and What We Can Learn from Them written by Mark McClusky.

The concept of improvement by marginal gains is extensively used in sports and it's pretty simple. The idea is to improve performance by aggregating small marginal gains. The belief is that getting small improvements in many areas at the same time is a more efficient approach than focusing on improving a single skill over the same period.

Dave Brailsford, the performance director of the Olympic British cycling team summarized it nicely in an interview with BBC Sports:

"The whole principle came from the idea that if you broke down everything you could think of that goes into riding a bike, and then improved it by 1%, you will get a significant increase when you put them all together." - Dave Brailsford

The British Cycling team achieved great success by using this approach at the Olympic games, and by 2012, the British had become the most successful cycling nation on earth. Mark McClusky explained the concept in his words in the book Faster, Higher, Stronger from the link above:

"Instead of looking for one earth-shattering change, British cycling takes a different approach. It looks at every aspect of performance, and tries to improve each a little bit— even just a tenth of a percent. If you find a training technique that makes an athlete that tiny bit stronger, it alone might not have a huge effect on a race. But if you can stack those very small improvements on one another, finding a bit in tires and a bit in the wheels and a bit on the track surface and a bit in nutrition supplements— well, soon those marginal gains begin to add up to big gaps between you and your competition." - Mark McClusky.

So if this approach worked for the Olympic team, could it also work for programmers? Why not.

Implementation

The whole idea is to distribute your efforts over a wider range of skills instead of focusing on a skill or two, so you first need to break down all the skills that are required to make a 2.0 version of your professional self.

The skills should be specific to our craft. This could be a possible list for a web-developer:

  • JavaScript
  • JSON
  • XML
  • Ruby
  • Rails
  • NoSQL
  • Patterns
  • Algorithms
    ...

The more you put in the list it will be easier to define the marginal gains.

Once you have the list, you need to define specific, measurable marginal gains required in each area (e.g. C# - Async Programming, JavaScript - Prototype Inheritance etc.). Every item should be as detailed as possible.

Next step is of course execution. Once you achieve the small improvements in each area, the total of those should be a significant leap forward in your overall programming skills.

How to measure the exact improvement? Well, it's not that simple since you need figure out how to calculate the percentage marginal improvement in each area, and then add to the total improvement, but even without the calculation you can do an approximation of your overall improvement.

More Ideas

If you want to borrow more improvement techniques from athletes, and get an insight into the fascinating world of sports and the technology used inside of it, i would recommend the book by McClusky mentioned earlier in this post. Here is a link for your convenience: