Yusuf Birader

How I learned to learn as a developer

The New Shiny Thing

As developers, we know first hand how fast the software world moves. New frameworks, languages, and tools seem to appear every day.

When I first entered this industry, I found it overwhelming.

Many say that this is simply how the industry is. That developers need to always be learning. And failure to do so means our skills becoming outdated.

But following this approach seemed like a recipe for burnout.

Overwork has been cited in many studies as a significant factor in developer productivity loss.

There has to be A Better Way.

Focus on the Fundamentals

One solution is to stop learning the latest framework du jour and cut through to what really matters. The things that don’t change. The fundamentals.

As Martin Fowler says:

Topics like algorithms, data structures, networking, computer, programming language theory and compiler theory are going to to stay constant relative to the latest and greatest JavaScript framework.

And having a strong grasp of these foundational topics is going to make you into a developer who can learn every language.

But learning just the fundamentals is not enough. Despite their reputation of a short life, knowledge of the latest frameworks is essential when working in modern software teams.

The key insight is that learning the fundamentals requires a different learning approach to learning the latest technologies.

The need for two learning approaches

When learning the fundamentals, we need to optimize for depth of understanding and retention.

We need a mastery-based approach.

In an MBL approach, the time to learn a concept is variable; the mastery of the material is fixed. Mastery-based learning is perfect for learning the fundamentals. It allows us to build foundational mental models of fundamental concepts.

Since the fundamentals don’t go through the same boom and bust as the latest and greatest frameworks, spending the time to master them early on pays dividends throughout one’s career.

It’s knowledge which never goes stale.

exponential knowledge growth

Knowledge of fundamental concepts never goes stale. Mastering these concepts allows us to learn new concepts much faster. This results in a compounding benefit throughout our careers. But MBL does have a cost.

It’s a slow process.

Using this approach for learning the latest tools required on the job is overkill. What’s in today may be out tomorrow.

We need to use a different learning approach that recognises this.

Just-In-Time Learning (JIT)

The solution to deeply understanding a vast number of the latest tools and languages is simple.

You don’t have to.

Instead, we use JIT learning.

In JIT learning, we use the fundamental mental models developed in our mastery-based phase to quickly develop a mental model of the tool we’re interested in.

Most importantly, JIT learning allows us to learn only the tools we need at the time we need them.

When learning a new tool via JIT, I find it useful to first ask:

What fundamental problem is this tool solving?

Once i’ve understood this, I can quickly get to grips with the basic syntax and dive into coding.

Whenever I come across something i don’t know how to do, I simply ask:

What is the minimum amount of information I need to solve my immediate problem?

Nothing more. Nothing less. Only that which allows me to solve my immediate problem and move on [1].

Continually asking this question over a project or three means that i quickly understand the core of the framework/language and makes me productive as soon as possible.

I don’t spend any significant time trying to memorise and master.

Remember, this is not foundational knowledge but simply a tool that I need to quickly gain proficiency in to solve my immediate problem.

The Outcome

The results speak for themselves.

Using this approach, I’ve managed to become proficient in Go and React in no more than a week.


Because I merely saw them as new tools which fit into existing fundamental models, which I’ve long-ago developed whilst learning for mastery.

In this way, I don’t see Go as a completely new language. I see it as a compiled statically typed language with garbage collection and CSP style concurrency.

I see React as a library which allows me to declaratively interact with the DOM API, and which solves the problem of maintaining synchronisation between the true, application state and its representation in the view.

I’ve framed what seems like new and challenging technologies in the context of well understood, fundamental concepts.

In Summary

Keeping up with the latest technologies can feel overwhelming.

But the good news is that you don’t have to.

Here are three simple steps to remember:

  1. Focus on the fundamentals. The things that don’t change. This knowledge never goes stale.
  2. Use a mastery-based approach to learn the fundamentals. It’s knowledge which never goes stale. Going slowly now so you can go fast later.
  3. Use Just-In-Time (JIT) learning to rapidly gain proficiency in new technologies when needed. We can do this as new tools simply fit into fundamental models, which we’ve learn to mastery.


[1] This is harder than it sounds. Many of us enjoy learning something deeply and having full control over our tools. We feel deeply uncomfortable when there are areas of something we don’t fully understand. Accepting this is key to becoming a better JIT learner.