“Just in Time” Learning
New developers entering the job market for the first time seem to face a classic catch-22 — job postings want you to have experience, but you can’t get that experience without first having a job. Going by what we read in job listings, it seems like employers only want to hire fully-formed developers.
But on second thought, this can’t be quite right. How did today’s experienced developers initially get hired? How come companies recruit graduates fresh out of college? And what if the employer is at the bleeding edge, working with a technology so new it’s not possible for anyone to have experience with it? Employers always talk about how they’re looking for “fast learners” or “smart people” or “intellectual athletes”, but what skills are employers actually looking for?
Based on my observation and experience, what employers are really after is something called “just in time” learning, or JIT learning. This isn’t just another skill for budding programmers to learn — in fact, I think it’s the single most important skill for any developer to possess. It means being able to learn quickly and effectively — being given a new tool, language or even codebase and learning to work with it productively in a short period of time.
Employers are really looking to hire developers who are effective JIT learners.
From talking to top employers and our recent Capstone program graduates, I hear every day just how much JIT learning is expected from developers. For example, one of this year’s Capstone program graduates told me recently:
I was thinking about it this morning, in the last 3 weeks I’ve learned and used in code:
- Go
- gRPC
- GraphQL
- k8s (with Helm)
- NATS
Yet not one of these topics is covered in our curriculum here at Launch School. So nearly all of his work over these three weeks relied on JIT learning.
The catch is that JIT learning ability is not easy to develop. Below I’ll break down why that is and how to unlock JIT learning, but first let’s examine why there’s this disconnect between what job postings say employers want and what employers actually want.
The Crux Of The Problem
When employers ask for experience, credentials or evidence of previous excellence, they’re indirectly inquiring about a candidate’s ability to apply JIT learning. However, not every developer is capable of it, so employers often resort to questions around experience instead.
Let’s step back and look at this from the employer’s perspective. Every day they hear interviewees tell them “I’m not familiar with language X and framework Y, but I’ll pick them up on the job.” Candidates are sincere when they say this, thinking “I just need a chance.” They all have the desire, but most do not have the prerequisite skills to actually deliver on this promise.
So if JIT learning is so critical, how can people attain this skill? Developers need to focus intently on building up the two key components of JIT learning:
- a rock-solid grasp of programming fundamentals and
- knowledge of how to learn
These two things unlock JIT learning. Not by coincidence, these two things form the pillar of the Launch School curriculum — our goal is to help students hone the JIT learning skill that’s so sought after by employers.
‘Experience Required’ — Reading Between The Lines
Ultimately, no employer wants to hire a new developer whose hand they’ll need to hold for many months, waiting for their new hire to become properly productive. Instead they’re looking for a developer who will be able to join her team, ramp up quickly on the company’s tech stack and start making meaningful contributions to the codebase in a reasonable amount of time. While our hypothetical developer is adjusting to her new job, her employer is perfectly fine with the fact that she’s learning on the job — provided it’s effective JIT learning.
The 2 Key Components of JIT Learning:
1) A rock-solid grasp of programming fundamentals
2) Knowledge of how to learn
But all too often this isn’t what happens. In recent years, waves of recent coding bootcamp graduates have hit the job market lacking fundamental programming skills. Often, bootcamps gloss over their graduates’ poor skillsets with a flawed, catch-all argument: “you’ll learn everything on the job.” So to avoid these types of newly stamped bootcamp graduates with shaky skillsets, employers de-risk hiring decisions by asking for experience.
What employers should actually be asking for is JIT learning ability. That’s the much more important metric, but unfortunately it’s also one that’s more difficult to measure. The industry has instead settled on asking for experience.
So where does this leave the inexperienced developer? Your job is to prove that you have the core components of JIT learning: 1) a strong technical skillset rooted in mastery of fundamental programming concepts and 2) the ability to learn quickly and effectively.
JIT Learning And Hiring Practices
Different types of companies hire for different mixes of knowledge vs. skill. Let’s contrast the hiring practices at boutique software consultancies with hiring practices we see at growth oriented engineering companies.
A lot of small boutique consultancies value repeatability. They bill out their programmers to repeatedly build out applications with similar functionality for different clients. Their tech stack is well-defined, and they hire for knowledge of that particular tech stack. In a consultancy context, JIT learning isn’t as essential because the work is standardized and developers come on board already having experience with the technologies they’ll use day to day.
The situation at growth oriented engineering-centric companies is different. These types of companies are much more dynamic, so there’s less emphasis on repeatability. Here, a company may not even know what problem they’ll be working on in six months, so they can’t hire developers with specific language or framework knowledge — they themselves don’t know what those languages and frameworks will be. In this context, skill and JIT learning are absolutely critical.
JIT Learning And The Launch School Curriculum
At Launch School, our primary goal is to help our students build this JIT learning ability that’s essential for landing a job at a top engineering-centric company. If we do our job correctly, by the time they finish our program, our students have done two things: 1) mastered the fundamentals of programming and 2) learned how to learn. Combine these two components and you have true JIT learning ability. This is the single most important skill we want our students to walk away with when they’ve completed Launch School.
Mastering the Fundamentals
Mastering the fundamentals of programming means studying foundational topics in software engineering from first principles and studying them to depth. It means taking a bottom-up approach to learning topics that are on the “critical path”, studying these in the right order and deferring exploration of topics that aren’t on this critical path. Some examples of fundamental topics may include:
- How to learn a programming language well
- Programming paradigms, like object-oriented programming
- Problem solving with code, with a particular emphasis on solving coding challenges in an interview-like setting
- Testing
- Networking
- Databases
Notice that this list doesn’t include the frameworks-du-jour or productivity libraries or how to build features — these are fundamental “atomic” concepts.
“To depth” means carefully deconstructing a topic to its core components. Once you understand each atomic concept, only then do you integrate them to see the more complex whole. Repeatedly following this process leads to the slow accumulation of sound mental models about things that don’t change. This is the end goal for studying fundamentals.
To ensure our students have the mastery of fundamentals that facilitates JIT learning, we’ve built our curriculum around mastery-based learning. If you’d like to learn more about this approach, I’ve written extensively about it elsewhere.
Learning How to Learn
As you’re building mental models of fundamental programming concepts, you’re simultaneously building mental models about learning how to learn, the second component of JIT learning.
Knowing how to learn is the ultimate meta-skill for a software engineer. This boils down to being a studious learner, even if you weren’t one in the past. It’s about developing effective habits around how you learn technical concepts: this means studying consistently and studying effectively. These habits aren’t glamorous, but they’re essential and they can be developed.
One of the benefits of the mastery-based learning approach mentioned above is that it lets students figure out how to learn. MBL doesn’t automatically give students these skills, but because MBL courses are self-paced, it gives learners the room and time to finally learn how to learn. Many people’s entire educational experience has been based on the factory model of education, so they’ve never had a chance to learn at a pace that’s truly comfortable for them. MBL is that opportunity.
Aside from the benefits of MBL, you’ll also want to invest in understanding a bit about the mechanics of how to learn. For this, I recommend Barbara Oakley’s Learning How to Learn course on Coursera, as well as the book that accompanies the course. If you worn out by videos, you can just read the book.
At Launch School, our motto is that we’re the “slow path.” But given what we know about JIT learning, we can make this more specific: we’re the “slow path through fundamentals.” And in the long run, slowly mastering fundamentals is what unleashes fast JIT learning. When employers say they want the “smartest people”, they’re really saying they want the fastest JIT learners. So take the slow path, because in the long run, slow is fast.
Chris Lee is an instructor at Launch School, an online school for software engineers. He has over 16 years of software engineering experience ranging from large enterprise to startups. He enjoys programming, teaching and talking about Mastery Based Learning.
