Maze in the Dark
When I was learning to code, it was before learning to code was a popular thing to do. Back then, learning to code meant dealing with a crawling dial-up connection, sifting through borrowed programming books at the library, or just copying some code from an article and hoping the compiler didn’t blow up.
It was a lot of fun - and I did it because it was fun - but it was often incredibly frustrating as well. Becoming a self-taught developer is the gym rat’s approach to learning to code. You have to like the pain at least a little bit to really get through the thing. People learning to code now aren’t getting it much easier.
Learning to code feels hard. For a really long time, I’ve been trying to sort out how to describe this feeling accurately. On the surface, it really doesn’t make sense: with all of the new tutorials, videos, and countless other resources now available, it really should be easier, but it isn't. Why? It's a question I've tried to solve with my work on Bento and with Stack Overflow for years now. For anyone who wants to be a developer, whether you decide to go through a bootcamp, get a degree, or teach yourself, this is what I want you know:
Being a programmer feels like walking into a maze in the dark every day.
A lot of people have this idea that learning to code is just about accumulating knowledge and applying it until it becomes really, really solid in your mind. That perhaps if you just read enough books, burn through enough online tutorials, and watch enough walkthrough videos, the knowledge will pour into your head like coffee into a very large, but eventually fillable, mug. The painful truth is: it just doesn’t work that way.
Whenever you’re coding, you’re walking into a maze in the dark. Your job is not to get a map of the maze beforehand, figure out the path from the entrance to the exit, memorize the solution, and then walk in confidently knowing exactly what to do. No, your job is to walk right into darkness, armed with little more than your wits, and feel your way through it.
As it is with all mazes, you will inevitably run into a wall. As a developer, your job is not to collapse on the floor and give up in a puddle of your own tears. Your job is to encounter the obstacle before you, rub your bruised nose, and begin to look for clues. You need to stretch out your arms, groping for the dark edges of the walls around you, and slowly feel your way out. You’ll eventually find a path forward, test it, and keep going deeper into the maze. Sometimes, you will run into dead ends. Sometimes, you will find yourself looping in elaborate circles. But your job is to persist, to keep looking for hints, and eventually find your way to the light.
One of the very first questions people will usually ask me when they begin to learn to code is: how do you know all this stuff? There seem to be hundreds of languages, frameworks, tools, and technologies to learn. To beginners, experienced developers must seem like superhuman repositories of technical knowledge that mere mortals couldn’t begin to compare themselves to. As much as we’d like to think of ourselves that way (on special occasions), the not-so-secret secret is that most experienced developers really don’t know everything off the top of their heads, but we are confident we can learn what we don’t know.
You see, experienced developers don’t magically have the solution to the maze pre-seared into their minds when we get out of developer school. Experienced developers are just more comfortable walking into the maze. The shape of the walls feels familiar to them. The tricky paths don’t fool them so easily. After years of running through the maze, the pace of their steps in the darkness is a little more brisk. Some of them even like being in the maze.
The thing to take away from this story is: persist. Know that coding is about learning your way out of problems you will inevitably run into. You’re not supposed to know everything. More than picking up some syntax, getting better at tooling, riding the wave of the newest language fad, getting good at learning and persevering in the face of the unknown is the core skill you must nurture as a developer. How good are you at finding answers to your programming questions? How precise are you when debugging your own and other people’s code? How thorough are you sifting through documentation about something you don’t know? How do you endure fixing the same error after hours and hours sitting staring at your screen?
Your ability and willingness to learn something you don’t know is precisely what makes you a developer. You’ll learn dozens, if not hundreds of times each time you open up your editor. Encountering and facing the unknown is what makes programming so hard (and fun), but your ability and courage in the face of the unknown is also what makes you so incredibly valuable as a developer.
So, the next time that you run into a compiler error, know that it’s just part of the journey out of the maze. The next time you walk away from a tutorial feeling incomplete, it means you need to take the other path at the fork and find another solution. The next time you want to give it all up because learning to code is just too hard, take a deep breath in the darkness, and maybe you’ll find some unexpected light shining from a path you haven’t yet explored.
When all else fails, just know that there are others here in the maze with you. One of the things that makes being a developer a joy is just how generous the learning community can be. When you find yourself despairing, and when you need the help, reach out. Ask a friend, a colleague, a professor, a stranger on the Internet. Someone may brush by you in the darkness, and gladly take you by the hand a little closer towards the light.
Thanks to Alexa, Kasra, Hoon, and Tiffany for reading early drafts of this post.