Learning to code? Here’s why getting stuck is a good thing.
This blog was originally published on Substack. Subscribe to ‘Letters to New Coders’ to receive free weekly posts.
Imagine a game of billiards. An intermediate player teaches a total beginner how the rules work, and they play a round. The beginner wins.
This is a classic case of beginner’s luck: when circumstances grant an inexperienced person success that is disproportionate to their novice skill level.
Beginner’s luck usually gives people a false sense of confidence. As a new coder, imagine you solved your first 10 coding challenges with 100% success rate, or you wrote your first five programs without a single bug. This is all well and great, but it’s circumstantial — and it does run out before too long.
Losing your beginner’s luck can be disheartening. Things don’t come easily anymore, and unfortunately, this is the point when some beginners quit. It may seem counterintuitive, but losing your luck means you’ve entered a more productive part of your learning journey.
Today I’ll talk about the idea of the productive struggle — and explain why losing your luck is actually one of the most important parts of the learning curve:
- Why beginner’s luck ends (and why that’s a good thing)
- Embracing the entire learning curve
- Setting up for long term success
Why beginner’s luck ends
The only way to master any skill is with time and plenty of practice (and failures). This is especially true for coding.
When I first started learning to use pointers in C, it seemed easy. But over the course of a few weeks, I realized pointers were a significant and even mind-bending concept that would take months and years to master.
As soon as beginner’s luck starts running out, you may feel that you don’t know what you’re doing wrong. You can feel stuck and lose momentum. You may even feel your progress is moving backwards.
What you may not realize is that this shift is not a matter of luck at all — you’ve just reached a new phase of the learning curve.
Learning to program is like hiking up a mountain with different paths. All the paths reach the same summit, but you’ll experience steepness in different parts of the journey. Every path has its own challenges. You may not know when you’ll encounter a steep incline, but when you do, it’s going to be an arduous climb (and you’ll have to persist despite it).
The steeper part of the learning curve
Some developers hit dips in their learning and think, “Coding isn’t for me.” But this is far from the truth. Everyone encounters obstacles. It may feel counterintuitive, but struggling in the learning process is actually very effective for your learning.
There’s actually a term educators use for this: productive struggle. By actively engaging in challenging (even uncomfortable) learning activities, our brains even produce myelin, which encourages skill retention and effective signaling in the brain.
There’s a sweet spot between ease and overwhelm, where you need to be challenged by a concept in order to make a breakthrough in your learning. However, to make the most of that sweet spot, it’s essential that you:
- Remain clear on what your goal is
- Get support when you need it
- Have a healthy relationship with failure
A lot of people even give up programming prematurely because they hit an incline and don’t have mentors to tell them they’re a healthy part of the learning process. Imagine someone started to lift weights and gave up because they were sore, and thought this meant they weren’t good. This is when a coach should be there to tell you, “Hey, becoming sore is part of the process. It’s normal and means you’re growing — that’s literally the feeling of your muscles breaking down and growing back stronger. In some cases, the soreness won’t go away for a week, but you’ll still keep getting better.”
Any professional developer gets stuck on countless concepts and bugs throughout their coding journey. The only difference is that successful programmers persisted. And sometimes, persistence just means taking a nap (in other words, taking a break).
It’s not the wrong path. Keep pushing ahead.
When you hit a roadblock and lose momentum, it’s best to stick to that path that you’re already on than to abandon your progress for a different one.
I’ve seen many new developers switch programming languages just because they lost momentum. This can be tempting if you’re self-taught and have an abundance of choices available when it comes to learning your first programming languge.
Switching tracks like this ultimately slows your growth, making you the jack of all trades and master of none. If you take up Python and get stuck, you might think, “Maybe I would’ve been better off with Java,” and switch over. At first, you might find that you’re picking up Java faster, further validating your belief that Python was the wrong choice. In reality, the only reason you’d feel more comfortable with the new language in this situation is because you’re repeating the beginner steps in another language. (After all, the skills you learn in one language do transfer over to the other, which is why it doesn’t really matter which programming language you learn first).
No matter which language, skill, or concept you’re learning, you can expect to hit a steep incline sooner or later (and several times). When you do, your key to success is maintaining resilience and embracing the struggle.
Luck alone won’t make you a pro
When I learned my first programming language, I was confident that I could build complex apps like Microsoft Word quickly. After all, this program would just need a few functionalities, of which I already knew a few (how to get input and save a file).
As soon as I tried building a text editor myself, the reality hit quickly that it wasn’t that easy. In reality, every successful product is a complex software backed by a lot of engineering. And while building basic programs is a good start, it’s only the beginning of building job-ready skills.
It can be easy to believe that if you’ve picked up a language quickly, you can become a professional developer quickly, too. The truth is that successful developers have gone much farther and spent more time not only learning a language. They’ve understood the core of data structures and algorithms that help them solve problems optimally. As a professional developer, your main task is not even using a programming language: it’s problem-solving. In the problem-solving process, you really only use the programming language at the very end, to translate your solution into executable instructions for the computer.
Coding is an amazing career, and it will constantly challenge you. Once you’re in the professional world, you’ll need to learn to leverage more complex computer science skills to apply your current tools to the fullest. You can worry about these more complex skills later down the line, but in the meantime, I hope you enjoy the learning process — even when you have to move uphill.
Braving the summit
You don’t need luck to succeed in your coding journey. The true key to success is persistence.
Inclines in the learning curve can be frustrating and demoralizing, yet we all encounter them — and they’re a good thing. Every professional programmer I’ve talked to can recount days where they were stuck because of an obstacle in their learning, despite endless Googling and nail-biting.
Even if you’re stuck, remember that you’re still on the same path as the greats. Take a break, ask for help, or retrace your steps to find the root that’s tripping you up. When you’re making mistakes or feeling stuck, breakthroughs are just around the corner. You will find the way forward as long as you try.
As a reminder, you can learn everything you need, from your first line of code to your first job with Educative’s Learn to Code courses.
Happy learning!