Be a Just in Time Learner, part II

Dear new developer,

I previously wrote about being a JIT learner and talked about it in the context of a Just In Time compiler.

Just in time has another meaning, that relates to manufacturing. Delivering the right parts to the right plant at the right time revolutionized manufacturing. Just in time learning means that you focus on what can give you the greatest bang for your buck, and that you learn it when you need to.

The world of software is immense and as you navigate it more, you’ll begin to see patterns. When I see a new dependency management tool, I know it’ll operate roughly like the three other dependency management tools I’m experienced with. It will have:

  • a dependency tree, likely stored in text
  • a central repository or multiple repositories, where common code resides
  • a way to have a private repository for proprietary code
  • commands to update individual packages or an entire system

So, I don’t really need to master each dependency manager, because I can do the mental mapping between the ones that  I know (like maven and bundler) and the ones I’m less familiar with (composer, npm). I learn just enough to do what I need to do. I do this to avoid being overwhelmed by each new tool.

In a similar manner, you can apply the same thing to software development in general. When you start to get overwhelmed, you can focus on one task at a time, and learn just enough to do that task. Now, I think you should try to understand why you are doing that task and not just copy pasta code, but there’s a balance to be struck. You also may need to have a deep stack to do this (watch out for yak shaving), as you’ll be pulled from one task you don’t fully understand to another.

The way to defeat this is to continue to build the mental model. Try to understand the smaller pieces of a site or application before moving up to the medium size pieces and then to the larger pieces.

An example. When I’m starting a new project the first task I always try to understand is how do I get this running locally. Running a project locally is glorious! Even if the project isn’t under version control, I have absolute control of the local environment and can tweak and break things with abandon. The next task I try to understand is how does this software get deployed to production. Here obviously I can’t break things with abandon, but I learn what the architecture is like. Finally, I’ll try to make a small change and see if I can get through the deployment pipeline. This assures me I know how to connect the two key environments (local and production).

You can do the same thing with the first months of a new job. Map it to other jobs or schooling you’ve had. Think back to what worked in the past for learning new tasks.

In short, be a just in time learner. Focus on what’s in front of you, and learn that. Build models between what you know and what you don’t. Don’t fall into the trap of trying to understand everything.





Be a Just in Time Learner, part I

Dear new developer,

There’s the concept of a JIT compiler. I was first introduced to it with the HotSpot Java compiler. The idea is that a compiler can look at code and find the code that executes often and optimize it, sometimes compiling it down to faster code, sometimes unrolling loops. I’m no compiler expert or even intermediate, but the results speak for themselves. JIT has spread elsewhere (python, ruby, javascript).

As a new developer, you should be a just in time learner. Just like the compiler watches to see what is used often and then optimizes the code that runs fast and often, you should do the same. That’s why I recommended you learn version control and a text editor. These are tools that, as a software developer, you spend a lot of time in. So learning them well will save you time in the long run.

But what about the intricacies of a language or framework. That’s important too. But it depends on how often you predict the issue will come up.

Here’s a great chart from XKCD.

If you spend two hours remembering how to do something but you only do it yearly, and you learn it well enough to do it in one hour, you save five hours over five years. Does this make a lot of sense?

So, basically, I’m saying optimize for the things you do often. Another way you can do that is to make what you learn do double duty:

  • When you learn SQL you learn a way to query across multiple different databases.
  • When you learn javascript, you are learning a language that you can use on the front end (in the browser) and the back end (on the server).
  • When you learn vi keystrokes, you can use them to edit a text file in a terminal on any unix machine, on the command line to navigate your history and directory structures, and in eclipse or visual studio.