Building Your Coding Vocabulary
Recently, a new programmer asked a question on a coding forum that struck me. The question wasn’t about a specific technique or language or framework, but more of a meta-question.
How do you approach a programming question? Whether a simple Javascript task or something more complicated using backend tech like PHP and MySQL. I find myself struggling to dive into a challenge/task because I’m unable to decipher the steps to achieve the result.
This question made me realize that I’d lost touch with one of the most frustrating parts of my development as a programmer — the struggle of not knowing what question to ask.
It’s one thing to not know the answer to a question. Google can usually solve that problem. If not then a colleague, a Stack Overflow commenter, a book, or some other resource can almost certainly give you the answer.
It’s another thing entirely not to know the question that you want an answer to. This happens when the set of skills you need to accomplish your goal is too far beyond the techniques that you’re already familiar with to bridge the gap with intuition alone. This doesn’t just make it hard to accomplish your goal, it makes it hard to even ask how to accomplish it, because you lack the technical vocabulary to express what you’re trying to do in terms that people familiar with that high level goal would recognize.
Unfortunately, there’s no easy way around this problem. The answer to this beginner’s question isn’t long, but it takes a lifetime to implement. You just have to keep learning.
Compilers for Teenagers
Perhaps the most egregious skill gap I stumbled on in my own life came around the time I was 14. I’d acquired a passable knowledge of x86 assembly language (don’t ask, it was a weird phase), and I got it into my head that if I knew assembly language, and I could translate higher level code to it myself by hand, there was no reason I shouldn’t be able to make a programming language of my own. How hard could it be?
Spirits high, I set about Googling how to build a compiler, and this is where things began to go downhill. I found a tutorial, but I couldn’t make heads or tails of its instructions. What were Lex and Yacc, anyways? Did I really have to use C? Eventually I was lucky enough to come across Compiler Construction Using Flex and Bison, which to this day remains my favorite introductory guide to compilers.
At age 14, however, it made no sense to me on almost any level. I could grasp just enough of it to figure out that it seemed to have the answers I needed, but what did the answers mean? What was the point of a lexer? What was a stack machine? How did this parsing code work the way it did?
This is the part where I wish the story turned inspirational, but it doesn’t. I didn’t stick it out and discover a secret trick to mastering compiler construction. I didn’t find a better guide with more detailed instructions. I just put that abortive project down, moved onto something different, and didn’t think about compilers again until my sophomore year of college.
But when I did finally come back to it, I picked that same guide up again. This time, lo and behold, it made sense! What changed between point A and point B? Another four years of aimlessly wandering through self-directed projects, and a year and a half of computer science course-work. This may not be as encouraging a message as I’d like, but I hope it’s at least a little bit encouraging — stick it out, keep working, and eventually you’ll get there. Even if you think you know what you’re doing now (and boy oh boy, did 14 year old me ever think he knew what he was doing) and find yourself utterly shocked at the sheer depth of knowledge you’re missing, it’s only a matter of time until you work your way up to that peak.
How Do I Get There From Here?
So let’s say you’re just getting started now and you find yourself faced with one of these yawning knowledge chasms. Maybe you just finished your first tutorial series, or went through a coding bootcamp. Maybe there’s a CS degree in your future. Maybe there isn’t. What can you do now?
Start Simple
At the very beginning of your journey as a programmer, you don’t know a whole lot. We all start with a basic knowledge of the mechanics of a programming language, but not much of an idea of what we can actually do with those mechanics. It’s like knowing the syntax and grammar of a spoken language, but not having a vocabulary to express yourself with.
As a beginner you’ll find there are a lot of things you just can’t do yet. And in the midst of the disappointment that comes with that realization, it’s all too easy to lose sight of the fact that there are still a whole lot of things you can do. You’re a programmer now! Computers have to do whatever you tell them to. Don’t ever forget how exciting that is!
We live in an age ripe with sophisticated libraries that can accomplish some pretty impressive things with relatively little effort. On the whole this is great, but it’s also had an unfortunate side-effect: the bar for beginner projects keeps creeping higher and higher. I spent years when I was younger happily hacking away in BASIC on dubious terminal applications that saved data to flat text files and occasionally spit out godawful console graphics. Reading Hacker News headlines nowadays, however, you’d think yourself a failure if you couldn’t cobble a real-time location service together in Javascript after a six week coding bootcamp.
Please believe me when I say this: it doesn’t matter what your first project is. However important it seems now and whatever hopes you have for it, you’re going to look back ten years from now and laugh about it. If you find the code, you’ll cringe. And that’s completely okay. What you need to focus on at this point is building your skill-set, and first and foremost that means keeping yourself interested and engaged. If you get bored and stop coding altogether, you’ll never get anywhere.
So before you worry too much about learning that cool new thing, make sure that you’ve taken some time to exercise the things you already know. See what you can get just by combining what you’ve already learned with your own ingenuity. Try to think of slightly more complicated things to do than you’ve done before, and then afterwards look up the right way to do it and see how your first try compares. Then try doing it the right way. Just keep writing code. And be proud of whatever you come up with, because it’s yours and you made it and that’s something to feel good about, whatever it is.
Borrow Expertise
Of course, at some point you’re going to want to expand the scope of your projects. For some people the time comes sooner, for others it comes later. It’s up to you when you want to really push yourself, but eventually you’re bound to come up with a project you want to build that you have no earthly idea how to finish.
Now, it’s entirely possible that, like me with my compiler, you’ve simply found something too complicated for your current skill level. It happens, and it’s not the end of the world if it happens to you. Just make a note to come back to that idea later and move on to something else.
Oftentimes, however, you can still build the thing you have in mind even if you lack the expertise to build it from scratch. The trick is to borrow the knowledge that other people have already learned. I’m talking, of course, about libraries and frameworks.
Learning a complicated framework is harder than learning a programming language, but it’s not that much harder, and it can drastically expand your capabilities. So if you find yourself at a loss for how to accomplish a somewhat common task, take a look around the Internet and see if you can find a library or framework to make it easier on you.
Do you want to build a desktop app? Learn Qt, or GTK, or WinForms. A video game? Picking up Unity will equip you with a wealth of capabilities that would take you years to learn on your own. Complicated web interface? React or Angular can make that a breeze.
Learning these kinds of frameworks takes serious time and effort, so reward yourself by building some serious projects once you get the hang of one. Revel in your new capabilities. Maybe score a Hacker News headline if you’re lucky.
I do recommend, however, that you try to avoid getting stuck in a rut with any given framework or library. Learning to use library code to accomplish higher-level objectives is an important step to take, but if you let it be the end of the journey you’ll miss out on a huge wealth of knowledge under the surface.
What happens when you want to do something new? Something there isn’t a framework for? What if you want to be the one to build the first framework for that thing?
Structured Learning
Ultimately, I believe every programmer should aspire to learn computer science. How much and in what way is up to you, but gaining an understanding of the algorithms and data structures underneath the libraries and frameworks you use every day will help to dispel the magic in them. Over time, you’ll come to see a complicated framework not as an opaque box that does things you don’t understand, but rather as a time-saving technique for accomplishing something that you could do yourself if you really wanted to.
With that understanding comes power. The power to optimize your usage of libraries, to modify them and fix bugs in them, and ultimately to architect and write your own. That understanding takes time to build, and you can easily spend your entire life branching further out into different areas of computer science, but at least a cursory understanding of the basics is worth learning.
The problem with learning computer science, and the reason that I fell down hard every time I tried venturing too far into it on my own, is that the field forms a sort of massive dependency tree. To understand A, you first need to understand B and C. But before you can understand B, you need to understand D and E, and before you can understand C, you need to understand F and G. And before you can understand D, you need to understand…
The relationships between different sub-fields of computer science get complicated, and as an independent learner it can be very, very difficult to figure out which things to start with and where you can go once you’ve mastered those basics. Which is why it’s vital to have a coherent program put together by people who came before you to guide your progress. Without such a program you’ll waste time trying to tackle subjects you’re not ready for, and the resulting frustration will only discourage you from going further.
The classic way to get such a program, of course, is to go to a university and complete a computer science degree. If you’re in a position where you can feasibly do that, I highly recommend it. Barely a day goes by without someone penning an op-ed telling you that a computer science degree is worthless and hopelessly outdated, but I maintain that those sentiments are deeply misguided. Are there downsides and difficulties to a traditional college education? Absolutely. But it’s still hard to beat the instruction and guidance you can get from a good degree program. If one is available to you, seize the opportunity.
Still, college is expensive and time-consuming, to the point that it’s simply not feasible or sufficiently attractive for a large number of people. Just because you can’t or don’t want to attend college, however, doesn’t mean you can’t receive a quality computer science education. The Internet already has quality learning material for just about any CS topic you could ask for, the only problem is organizing it into a coherent program.
Thankfully, in recent years some people on the Internet have also organized several such programs. One that seems promising is the Open Source Society University, which has assembled a reasonably complete list of topics worth learning with links to freely available resources. Another option is MIT’s Open Courseware, which gives you access to lectures and other course material’s from MIT’s own electrical engineering and computer science degree program. And these are far from your only options; you can find myriad computer science course lists and guides online, just try googling for “free computer science degree.”
The important thing is to pick a program that suits you and stick to it. Learning CS fundamentals and moving on to advanced topics takes a lot of time and effort, but if you keep making steady progress it’s entirely possible to teach yourself the equivalent of a four-year degree (or more) for free. Just keep learning, and make sure you take some time to apply the things you learn to projects that interest you. It’s a marathon, not a sprint, and doing interesting work is crucial to keeping yourself engaged at every stage of your programming journey. If it becomes a chore, you’ll inevitably fall by the wayside.
It Never Ends
I want to close with one last reflection on the question that got me started on this topic.
How do you approach a programming question? Whether a simple Javascript task or something more complicated using backend tech like PHP and MySQL. I find myself struggling to dive into a challenge/task because I’m unable to decipher the steps to achieve the result.
I can’t remember exactly what I told the person who asked me that question, but it was mostly a very, very short summary of the things I outlined up above. I told them that I let my past experience guide me, and that over the years I gradually built up the knowledge I needed to construct more and more complicated solutions out of the bits and pieces I’d already added to my vocabulary. Which is usually true.
There is, however, one thing that I forgot to add to my answer at the time. It’s not always true. The whole truth is that however much you learn, the skill gaps never really go away. If I rarely run into them nowadays, it’s mostly because I stretch beyond my boundaries less often than I should.
While I have a pretty good understanding of a decent range of interesting and useful topics, there’s also a huge breadth of specialties within computer science that I remain almost entirely ignorant of. If you asked me to build you, say, a web service for buying and selling event tickets right now, I’d have a pretty good idea of what things I needed to do, and how to look up whichever necessary components I didn’t already know how to build. If, however, you asked me to build a system that used computer vision to recognize and adapt to a robot’s environment, I’d draw just as much of a blank today as I did staring at that compiler manual 13 years ago. I’d have to start from first fundamentals in computer vision, and probably some other fields I don’t even know about yet, and spend possibly years working my way up to that higher level goal.
And that’s okay. Maybe someday I’ll get there. Probably I won’t. There’s a lot of things to learn out there, and life is short. I don’t know how much of this field I’ll eventually master, but I do know that each year I’ll master at least a little bit more of it than I had before. And that’s enough for me.
