How to Learn New Things
The world of web development is always changing, and it can sometimes be hard to keep up.
How do you learn complex and difficult skills, deeply and quickly?
Learning is a topic I've been focused on for nearly a decade now, and in this article I'm going to share my thoughts on the subject and how I go about learning in my own life.
But this article is a little different than my other ones, as it's also a review of the amazing book Ultralearning by Scott H. Young, which I highly recommend for all software developers who are in this insane and ever changing industry.
We'll cover the two learning principles from the book that I find most useful in my career:
- Directness
- Experimentation
But first I want to touch on why Scott is such an expert on the topic of learning.
Learning MIT's Computer Science program in 12 months
Scott has been dissecting the learning process on his blog for over a decade now.
Most notable was his MIT Challenge, where he learned (and passed!) MIT's 4 year computer science program, in 12 months, all on his own.
In doing this (and other projects), he has uncovered 9 different principles of learning, which are:
- Metalearning: First Draw a Map
- Focus: Sharpen Your Knife
- Directness: Go Straight Ahead
- Drill: Attack Your Weakest Point
- Retrieval: Test to Learn
- Feedback: Don't Dodge the Punches
- Retention: Don't Fill a Leaky Bucket
- Intuition: Dig Deep Before Building Up
- Experimentation: Explore Outside Your Comfort Zone
The ones that I've incorporated the most into my own learning are Directness and Experimentation.
Directness
The easiest way to learn directly is to simply spend a lot of time doing the thing you want to become good at. - Scott H. Young, Ultralearning
When you learn something, you want to make sure that what you're learning and how you're learning is similar to how you'll be using the skill.
This is because learning is highly dependent on the situation you're in.
For example, learning about computer science topics in a classroom is very different from writing actual software, so it's not a very direct way of learning. On the other hand, learning by creating small projects for yourself is about as close as you can get.
Learning to drive a car by watching a video isn't very direct either, but actually getting in the car and taking it for a spin is the most direct you can get.
This is how I do most of my learning.
How I use directness
Reading articles is great for getting ideas, but for me, to really learn new things and internalize them, I always do a small project. I absolutely love using Code Sandbox for this, because it's so easy to just quickly try something out.
If me or a co-worker has a question about something, instead of just talking about it I'll create a new sandbox and test it out. It's usually faster than arguing about whether something will work, and in the process I'm able to test out a bunch of stuff and learn a whole lot in the process.
At one point we were trying to determine how easy it would be to use our Vue component library in a React app that we have. Instead of wasting days or weeks going back and forth on the issue, I spent a few hours integrating them to see how they would work together.
You can check out the sandbox of that here: https://codesandbox.io/s/mjv0vjxm7j
Another time we were discussing a better way of handling the state of our toast notifications, so I quickly sketched out this concept of a reactive data store that can be used by any Javascript function: https://codesandbox.io/s/reactive-data-store-t8l7d
Experimentation
The difference between a novice programmer and a master isn’t usually that the novice cannot solve certain problems. Rather, it’s that the master knows the best way to solve a problem, which will be the most efficient and clean and cause the fewest headaches later on. - Scott H. Young, Ultralearning
The key to mastery is experimentation.
As you learn more and more about a subject, fewer people are able to teach you new things. You also start to branch off into more specialized skills. Beginners are usually learning the same things, but no two experts have the same skill set. Over time their paths diverge and they go in different directions.
So if no one can teach you, the only way to get better is by discovering new insights yourself through experimentation.
Scott also talks about the concept of "overlearning", that if you go even deeper into something you solidify the previous concepts more. Learning algebra is one thing, but if you go beyond to learn calculus, which uses algebra, you'll solidify your understanding of algebra so much more.
I've found that experimentation provides this overlearning as well as allowing me to uncover new insights into how Vue works.
How I use experimentation
For example, by experimenting a lot with renderless components and moving logic into the template, I learned a lot about how to best use templates and scoped slots. These experiments are never something I would do in production code, but were fantastic for learning.
When React announced their new Hooks feature, I did another experiment to see what it could look like in Vue. I managed to create something that worked decently well, but quickly ran into many issues (requiring this makes composition quite difficult).
Thankfully the new Composition API solves those issues (and much more!) very elegantly, and we'll get our own system for composing logic in Vue 3.
Ultralearning
Unlike many books of this genre, this book has no unnecessary filler content, and is packed from cover to cover with highly actionable and useful advice.
I've been an avid reader of Scott for 8 years now, and bought one of his first courses on learning. And although we've never met, Scott and I actually went to the same university — small world, huh!
Several weeks ago I recieved an advance digital copy of the book in order to do this review, but I immediately pre-ordered the hardcover because I knew it was going to be fantastic (and I wasn't wrong either).
I should also note that I am not getting paid for this endorsement. I am a genuine fan of Scott and all of his work.
Conclusion
You've seen a bit about how I learn new things using directness and experimentation, and hopefully this helps you to learn new things too.
If you want to dive deeper into these learning principles and the other seven I didn't even touch on, you should definitely pick up a copy of Ultralearning.
I've spent the last decade searching for how to become a better learner, and there is no better resource than this book.