Chapter 12. Developer Learning Curve – Why Learning How to Code Takes So Long

When it comes to becoming a developer, one of the questions I get asked the most is: why does it take so long to learn how to code? I've discovered the answer can be found in research related to learning curves.

What is the learning curve?

The concept of learning curves has been around since 1885. Typically, the research has been performed in the psychological and cognitive sciences. However, the concept can be clearly utilized when it comes to learning development.

The developer learning curve

The following graph shows the standard learning curve. This was generated by a big data analysis algorithm that analyzed the learning patterns of individuals in a number of industries. The curve is smooth because it takes the average learning process and averages the process.

Later in this chapter, we'll take a look at what a learning curve looks like for a single person. Over the years I've had the privilege of teaching students how to become developers. I've witnessed this learning curve play out again and again. And in this chapter, I want to examine the three stages that all developers go through. Additionally, I'll discuss about how long it takes to traverse from one stage to another. The three stages that I'll discuss are:

• Liftoff
• The twilight zone
• The zone

Liftoff

Let's start off by taking a look at the liftoff stage. This is an exciting time for new students. During this time students are immersed in learning skills that they've never seen before:

Because all the topics that students learn during this stage are new, their expertise skyrockets. I like to call this the liftoff stage because it's easy to visualize a new student's expertise like a rocket ship soaring into the sky into places it has never been before. During this time, a student will learn how to:

• Configure a development machine
• Learn a programming language
• Work with various frameworks
• Build functional applications

This stage usually lasts for the first 250-300 hours that a developer is learning how to code. This estimate is based on what I've seen with the DevCamp bootcamp students and equals around 6-8 weeks of intensive learning.

As fun as this stage is, it has drawbacks. One of the key problems is that it can give students false confidence. When they see themselves building applications that actually work, it's natural to believe that they can dive right into building production apps for clients. However, they don't realize that they're about to enter… the twilight zone of learning how to code.

The twilight zone

After the exciting liftoff stage of the developer learning curve, aspiring developers will enter the twilight zone:

This is a challenging time for students and many students decide to quit programming entirely during this stage.

So why is this time so challenging? After seeing countless students go through it, I've discovered that there are a number of contributing factors:

• While in this stage, many of the core concepts and commands haven't cemented themselves in a student's long-term memory. This results in them having to constantly look up documentation, query Stack Overflow, and things like that.
• During this time, the novelty of simply having an application work has worn off. Now students are asked to perform advanced tasks such as:
  • Working with legacy applications
  • Debugging defects
  • Improving performance
  • Building features that they don't have a step-by-step tutorial for
• Additionally, while working through the twilight zone, students are expected to start implementing best practices. In the launch stage, the primary goal was to get applications functional.

During this next phase, students start learning how to build applications that can be used in real-world scenarios. This means that a student may spend five times longer to build an application with the identical feature of something they created during the launch stage.

This can be frustrating; however, the increased time spent implementing best practices allow the applications to be scalable and flexible enough to be used in production. This is in stark contrast to the apps created during the launch phase that don't adhere to industry standards.

The zone

There is good news though; if a student persists through the twilight zone of learning they will enter The Zone of the developer learning curve:

This zone is entered usually after around 1,000 hours of study and work. During this stage, developers have a wide range of features they can build without having to look up the documentation.

In this stage, when you visit Stack Overflow you'll be answering as many questions as you ask. And thankfully, learning new concepts will come easier. The reason why learning is easier at this stage is because you will have developed a mental model of development.

For example, I recently started working with the Scala programming language. I've been able to pick up on how to build applications in Scala dramatically faster than when I started learning C or PHP a decade ago. This is because I have a decade of knowledge in the development space that allows me to frame the new concepts. When I read the documentation and see what it says about data types, I don't have to wonder what a data type is. Instead I can skip ahead to learning the syntax.

As you'll notice in the developer learning curve, the growth pattern in this phase is less than the other two stages. As you've heard me say countless times, learning never ends for developers. However, learning does change. During this phase, a developer focuses on learning topics such as:

• Incremental performance improvements
• Building helper code libraries
• Refining how application code flows

A unique journey

Throughout this chapter you may have noticed that the developer learning curve was smooth. However, that's not reality. The reason why the curve was smooth was because it averaged out the learning path of a large number of individuals. When it comes to a single student, the learning curve looks more like the following graph:

There are ups and downs throughout the learning cycle. As a student, you may decide to switch programming languages after a few years (like I did when I switched from PHP to Ruby around 5 years ago).

Even though you don't have to start back from scratch, it will still take time to learn a new language or framework. And throughout your development journey you'll discover plenty of ups and downs. So, don't get discouraged if you aren't satisfied with your skill level, because I have a secret to tell you: good developers never feel like they've arrived and are done learning.

Summary

I hope that this has been a helpful guide to understanding the developer learning curve, and good luck with the coding.