I vividly remember my first 6 months trying to learn to program. I was following along with a tutorial of some sort, not understanding anything of what I was doing.
I was basically a copy cat.
The video in front of me would often go too fast for my typing. And too many times I had to stop the video, rewind and rewatch or pause at a specific location, just so I could copy the exact same code as the instructor.
And even then I often got it wrong.
I remember the frustration of trying to debug a specific tutorial for two straight days, just because the instructor had forgotten to show something he took for granted that I knew.
It wasn’t their fault per se, but it sure was frustrating. It’s easy to forget that attained knowledge for us is black magic to someone else.
I’m guilty of that too.
Many years have passed since those early days, and my journey of learning and hard work has paid off. But I still wonder, could I have learned more effectively?
How to learn effectively
In this article there are three points I’d like to address that I think slowed down my learning: lack of focus, the tutorial trap, and abstractions.
Lack of focus
My early days of programming were plagued by a severe lack of focus. I was like a lost lamb. Searching for knowledge, but not in the right places, and never enough. The lack of focus was not entirely my fault, but was a product of why I was learning.
I started learning how to program as the result of working in a startup where we needed a web developer. Our outsourcing strategy was failing, and we needed someone to learn in order to help bring the product to market.
I was going to help out our overseas developers, so I began learning the programming language they were writing our platform in: PHP.
As time went by we changed developers three times. And programming languages. This resulted learning a little PHP, a little Python and a little Ruby.
That was a mistake.
Learning a little of this and a little of that means you’re not really giving yourself time to grasp the concepts fully. Programming is difficult, there’s no getting around that. So we need to give ourselves time to fully grasp these concepts.
Do not flap around. Master one programming language. Master it to the core. Master it fully.
This does not mean that you are marrying one language. You can branch out later. It means you are using one programming language as your vehicle for understanding programming.
The tutorial trap
Tutorials are great. Honestly, I’ve lost count of how many tutorials I’ve done. It’s a great feeling to create something that works. Besides, watching videos of someone who knows what they are doing makes you feel like you know it too.
But it’s all too easy to fall into the trap of only watching tutorials. Putting on a video is simple. Doing the hard work isn’t. And doing the hard work is what is going to make you a developer.
The problem I often had with tutorials was that all of the thinking was already done in advance, by the instructor. And the instructor doing that work meant that I didn’t have to.
That wasn’t good, because it meant that I was fooling myself and thinking I was learning at the same time.
I’m not saying you shouldn’t do tutorials. Especially if you are self learning, sometimes you just have to get a grasp of what exactly you need to do to move forward. Or you need to try to pick up pieces here and there to fill in the big picture.
But every time you are done watching a tutorial, you must practice.
I know. It’s hard. I’m being deliberately hard on you now. Even today I’m guilty of just putting on a video tutorial when my energy is spent. I keep thinking it’s better than nothing. And sure, it is.
But if you don’t practice, you are wasting valuable time and effort.
One of the best things that ever happened for my learning was the decision I made to do the freeCodeCamp projects. They are defined projects that don’t hold your hand. I needed to figure out how to implement everything.
And guess what? Doing that is exactly the job of a developer. That’s how we feel every single day. We are given a task that we often initially have no clue on how to solve, and then we apply a toolbox of learned skills to that problem.
Being a developer is not about having an answer to everything. It’s s about finding the answer to everything.
And you don’t get there by only watching tutorials.
Practice. Practice. Practice.
Don’t rely on abstractions
Being a developer in 2020 is hard. Technology is moving rapidly, and advances are being made all the time. One of concepts that allows us to move quickly is abstractions.
Abstractions are a great thing. Someone has taken something hard, and made it easier by abstracting away the hard part.
You can think of it like a stove. You don’t need to know how the stove works, you only need to know that when you press a button, the stove turns on and puts heat on the plate. That’s all you need to make dinner.
In code, this is a great thing too. We don’t need to write machine code, because it’s abstracted away. We don’t need to write HTTP servers, because they’ve been made and are available for us to use, and we can build new and amazing things on top of these.
Unfortunately, this is also a double edged sword.
While abstractions allow us to do amazing things, we also miss important things that allow us to grow as developers. Things that allow us to understand on a deeper level what is going on. Things that could be important for creating great solutions.
We miss these things because we don’t have to learn them, even though when learning them, we often become better developers on the other side.
These things are often bothersome, difficult, and boring to learn. Which makes them easier to skip in our learning process.
But I’d like to challenge you to be curious.
Don’t be satisfied just using Express. Try to build your own web server using Nodejs and TCP. Learn HTTP.
Learn the difficult, boring, and trite things that make you a better developer. Or at least try. In my opinion you’ll be better off.
In this article we’ve explored three areas that I think slowed down my path to becoming a developer: lack of focus, the tutorial trap, and abstractions.
I’ve given some concrete advice based on my own experience on how you can avoid these mistakes and hopefully learn more effectively.
Thanks for reading this article, and please share it with anyone you think might find it useful. Good luck on your journey.