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.
Developer Learning Curve
In this image is 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 guide 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 itself out again and again. And in this guide 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:
- Twilight Zone
- The Zone
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 of 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.
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 StackOverflow, 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 industy standards.
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 lookup the documentation for.
In this stage when you visit StackOverflow 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 guide 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 this image. 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 by 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.
I hope that this has been a helpful guide to understanding the developer learning curve, and good luck with the coding.