I’ve been learning since before I can remember: first, learning to read, then, reading to learn.
Ironically, what I never focused on until very recently was learning to learn.
In the world of software engineering, learning effectively is one of the most crucial skills one can possess, yet it’s one of the most underdeveloped ones.
As technologies and frameworks evolve and change, the ability for an effective self-education helps keep many doors open, to diversify and regularly invest in one’s knowledge portfolio.
Effective self-education is marked by learning concepts, ideas, thoughts, and truths effectively.
But what does it really mean to learn a concept effectively?
To me, effective learning is a one-time process of deep understanding and remembering important information and concepts, and then connecting them to existing knowledge.
It’s a deliberate and careful investment of one’s time such that is ideally done once and for all.
The issue with the way the most programmers I know are learning - is that they learn just enough to solve a given problem.
While working well short-term, such a strategy is very time-wasting, unless one is able to reuse the newly acquired skill repeatedly in a short period of time.
But even then, such a skill is often superficial and lacks a deeper understanding required to apply it to related problems.
Reading a technical book cover-to-cover, watching a talk or screencast gives a false impression of understanding and remembering and yields half-assed skills, if at all.
Frustrated with forgetting information and skills I was sure I acquired at the time and reading the same books and tutorials over and over, I decided I wanted to improve the way I learn to be more effective and persistent.
The following strategy is the result of personal experiments with techniques that I learned about from different books and online resources on memory, learning and cognition.
This approach consists of five stages: preparation, exploration, practice, immersion and repetition.
The effectiveness of other stages heavily depends on this short yet very important stage.
At this stage, you select the materials to learn from: make sure to get the best available sources of information, based on online reviews, recommendations of experts in the field, or personal experience.
Regardless of the type of the source - be it a book, a tutorial or a video, at this stage you want to familiarize yourself with it as quickly as possible, without going too much into detail.
Try to understand what the main idea is, and what the author is conveying and how he conveys it.
Don’t concentrate too long on the hardest parts and feel free to skim through them.
Make quick notes to summarize each section and write down any questions you have about the material.
One of the longest, most focused stages. This is a continuous stage; it does not end before going to the next one, but lasts until the very end of the learning process.
At this stage, your main goal is to practice what you’ve explored and learned so far and highlight what you do not understand to immerse into it later.
It’s also important that exercises you choose are challenging enough to keep your progressing, but not impossible to demotivate you.
For example, if you’ve just skimmed through a syntax of a new language, FizzBuzz or StringCalculator katas are good choices for such an exercise, but to make a Twitter clone - not yet.
This stage - is what makes makes the difference between the usual approach most software engineers take, and what I call an effective learning.
Your main goal at this stage is to understand all hard concepts you highlighted during the practice.
For this, I recommend the Feynman Technique:
Identify the subject
Collect all the essential information you possibly can on the concept you are immersing into.
If it’s too big - divide it to smaller chunks. Remember: half a skill - is better than half-assed skill.
Write down the concept you want to understand
Get a piece of paper and write down the concept you are immersing into at the very top.
I like paper because it lets me to draw easily and I find visualizations as much effective as text, but you are free to use a tool of your choise.
Now, it’s time to write a simple explanation of the concept as if you were teaching it to someone else, possibly a child.
Use the information you collected earlier and narrow down each piece of it to the point of writing it down in one to two sentences in your own words.
If you still don’t understand something - copy the explanation from the source, but transform it into simpler terminology.
Use analogies of the concepts you already understand and try to connect the new concept with them.
Ideally, you will end up with notes that can be used to present the new concept to your colleagues, or to write a blog post about it.
After you have filled all the gaps and understood a concept or an idea - you are not done yet.
You still need to preserve your fresh knowledge long-term - ideally, forever.
For this, hack the way your brain works and use spaced repetition!
Transform all the notes from previous stages to flashcards: use your favourite flashcards app (I use Anki) and only create flashcards for those hard concepts you nailed.
Review your flashcards every day for 10-15 minutes.
Don’t worry, you will not end up spending a few hours a day on your flashcards - any good flashcards app will gradually reduce the repetition over time, releasing space for new skills, and remind you of your acquired knowledge once a few months.
The described above stages are not independent. In fact, some of them repeat and overlap, as shown on the next diagram.
Learning in groups
You might also find it effective to learn in a group.
Sometimes, it’s very practical to get someone else to explain you a concept or an idea - their way.
In SICP Reading Club meetup, we meet every two weeks to work on the next chapter and exercises from the SICP book.
Some of the hardest ones are actively discussed and examined, which is great both for those who explain and those who listen.
Learning from patterns
The human brain is great at forming patterns from the information it processes.
This can be used to the advantage of a software engineer, too.
The idea is simple: find and examine as many examples of a new concept as you possibly can.
For example: after learning about pattern matching in Scala, you can go to Github, find a few open source repositories with Scala code, search for the
match keyword and read the code it finds.
Another example: if you are learning about scalable cloud architectures, go to http://highscalability.com/blog/category/example and carefully examine each case.
This will not only boost your understanding of the concept, but will also form patterns in your brain and eventually develop intuition for it.