Simple Ideas, Well Executed
The simplest ideas, when implemented with precision and attention to detail, can be the most powerful
Sushi. It’s a simple idea. Just take a few basic ingredients — raw fish, vegetables, rice — and roll them in a nori (seaweed) wrapper. Anyone can make sushi; just buy sushi rolling mat, get a bunch of ingredients, and follow a recipe.
With really great sushi though, the kind that people pay hundreds of dollars for in high-end Tokyo restaurants, this apparent simplicity hides a lot of complexity: the selection and preparation of the ingredients, the precision in the cutting of the fish, the balance of flavors in the vegetables and pickles, the almost art-like presentation. There’s a level of skill and knowledge involved that leads to a quality of end-product a world away from the sushi you’d make at home or the factory-prepared offerings you’d find at a grocery store.
The interesting thing about the complexity behind this simplicity is how it is achieved. The key is in the training of Japanese sushi chefs, or itamae. As an educator, it’s this aspect that really interests me. The process behind the process. The system that produces these highly-skilled chefs.
Sushi chefs can train for 10 years or more before becoming fully-fledged itamae. Apprentices can spend several years just perfecting the preparation of the rice before they’re allowed anywhere near the cutting board. Prove your competence with the rice and the next stage of development is as a wakiita, which literally translates to ‘near the board’. At this stage you learn a vast array of skills and processes, including mastery of the hocho (blade). After several years as a wakiita, the apprentice might finally make it to the level of itamae and earn the right to stand in front of the cutting board on their own.
There are two main things that strike me about the journey to become an itamae:
- The dedication to mastery of the craft at each stage of the journey.
- Just how high the bar for achievement is set.
These two things are not unrelated. In fact they are intrinsically linked. Of course, not everyone wants to be a master itamae. If you just want to be able to prepare some sushi at home, or for your friends, then simply being able to follow a recipe is probably about as high as you need to go in terms of skill-level. If you do want to scale the heights though, you have to follow that journey; there are no short-cuts.
Just like making sushi, learning to code is essentially a simple idea. Anyone can do it. Just follow a tutorial, and within a few hours you can have a website up and running, or can create a simple application. There is however a massive gulf between following a set of instructions to code a basic calculator app and the itamae level of knowledge and skill required to be a professional software engineer.
If you believe the marketing from most coding bootcamps though, this gulf can be bridged in matter of weeks. Think about that for a minute. These bootcamps are basically telling you that you can thoroughly learn everything you need to know to work competently and productively as a developer or software engineer in just 12 or 14 weeks. If you were training to be an itamae, you’d still be preparing the rice.
A typical curriculum from a coding bootcamp might look something like this:
- Weeks 1–3: Programming Basics
- Week 4: Object Oriented Programming
- Week 5: Databases
- Weeks 6: HTML & CSS
- Weeks 7–8: Web development
- Weeks 9–10: Project
- Weeks 11–12: Job search
These kinds of curricula seem to me like the educational equivalent of just running rails new or create-react-app. There’s an outline structure there, but it’s lacking any kind of depth. If you look at how little time is spent on each topic area, do you really think that it’s going to provide you with a sufficient depth of knowledge on which to build a career?
This approach makes a lot more sense when you understand that the aim of most bootcamps is to quickly teach you ‘just enough’ to get a job. Not necessarily a good job, and certainly not a long-lasting career, just any job. One dirty secret of our industry is that most programming jobs are bad — low paying, menial, and mundane. Added to that, the danger in learning just enough, is that it’s very quickly becoming not enough.
At Launch School, we approach things differently. First of all we’re not a bootcamp. We have a very different goal: to enable our students to target the best jobs and prepare for a long-lasting career. We use this goal as an end-point and engineer our curriculum to meet it.
So how do we do that? We spend time to really understand what top tech employers want from new hires:
- To be productive in a very short space of time.
- To be able to ramp up quickly on the company’s tech stack and codebase
- To solve problems at scale and at a high level of complexity
- To work well as part of a team
With that understanding in place, the question then becomes how can you produce the quality of candidate that meets those criteria?
This is the purpose of our Capstone program. It solves the ‘last mile’ problem and drives towards these high-level jobs. Capstone is about honing and demonstrating the level of engineering competence that top employers demand. It’s about ensuring that you’re ready to stand in-front of the cutting board.
Again this is a simple idea, but getting to that level is far from simple. For their Capstone projects, our teams are required to solve complex software engineering problems. These projects aren’t about mashing together a couple of public APIs in a nice looking front-end, or building another CRUD app. They require the research, planning, and engineering of a solution from the ground up. Our Capstone teams have built decentralized P2P cloud storage systems, real-time collaborative REPLs and text editors, serverless application frameworks, and much more.
In order to do that they had to be able to:
- Use Just In Time learning to quickly level up on advanced concepts
- Problem-solve at a high level
- Work effectively as part of a remote team
Understanding what’s required in Capstone raises another question: how can students develop the skills and knowledge they need to perform at that level? The answer to that question is our Core Curriculum. The Core Curriculum is the ‘study’ phase of our overall pedagogy. This is where students build the strong foundations of knowledge and skill that they can then leverage in more advanced contexts. Again, the basic premise is simple:
- To properly understand advanced software engineering advanced concepts, you first need a solid grasp of programming fundamentals.
- To be able to ramp up on those concepts in a relatively short space of time requires effective learning techniques.
- Deconstructing and solving complex software-engineering problems requires a well-practiced and structured problem-solving approach.
- Working effectively as part of a software-engineering team requires the excellent technical communication and efficient organization.
Building that foundational knowledge and skill is the objective of the Core Curriculum. The implementation of the learning structure for this phase of our pedagogy is built around Mastery Based Learning (MBL). At its core, MBL is yet another simple idea: you learn a topic until you master it, and then you move on to the next topic. Although the underlying idea is simple, the software-engineering curriculum we built around that concept requires the complex interaction of a number of different elements:
- Ensuring students have reached a sufficient level of mastery required to move forward is assessed via live interviews and other tests which mirror real-world job selection processes.
- Helping students to build the skills and knowledge to pass the assessments is achieved through code reviews, circular learning, focused practice, and an emphasis on building strong mental models and explaining technical concepts with clarity and precision.
- Making sure that the system we’ve built is working optimally by iterating over our content constantly. We use a feedback-analysis-improvement loop, which is essentially a form of continuous deployment for our educational program.
The idea behind Launch School is simple: provide studious students a structure within which they can develop the skills and knowledge necessary to target the best software engineering jobs and launch a long-lasting career. Just like the journey from novice to itamae, the simplicity of that idea hides a lot of complexity in terms of the level of educational engineering that goes into planning, implementing, maintaining, and continually iterating and improving that structure. The reason behind all of the work that goes into this structure is so that when Launch School graduates finally stand in front of the cutting board, they know that they belong there.