The critical topic they don't teach at tech bootcamps

TLDR; navigating layer of abstraction with the least amount of mental overhead is not taught, it should.

The critical topic they don't teach at tech bootcamps
Photo by Lagos Techie / Unsplash

A few weeks ago I had a very nice discussion with someone on reddit that was struggling in an intensive 12 weeks tech bootcamp!

The main issue she had was something I've seen over-and-over with software engineering students (even at university level). She struggled with understanding deeply how everything worked and she always felt like she didn't truly understand what was going on.

This led her to be super stress and feels the impostor syndrome kick in pretty bad. To top all of it of, she was learning the following tech in the boot camp:

  • React
  • Javascript
  • Express
  • Node.js
  • Git
  • Heroku
  • MongoDB
  • JQuery
  • Django
  • Python

(i.e. this is a lot to take in for a beginner)

Bootcamp are mainly about breath and breaking the ice

The main utility of bootcamp in my opinion is to break the ice with the content in whatever software related field you are trying to get in. They will not teach you things at very deep level and they will go through a lot of technology in a very short period of time.

This is very good for some people since the bootcamp are usually fairly structured. This remove the messing around part if you are not too sure where to start. Once this breath of the field has been shown, you are basically good to go to learn more about one of the particular topic in more depth.

This is important for some people and might be worth it. I'm not saying here that bootcamp are worthless or overpriced. They might actually be a good investment if you have problem starting your software engineering journey.

In my case for instance it took me 3 year and 3 attemps to finally learn just enough Ruby/Ruby on Rails to understand what the hell was web development. A 12 weeks bootcamp would have saved me a lot of time here.

(btw for a more well rounded overview of bootcamps check out this video by Zubin Pratap from Google, he actually know what he is talking about!)

Now, this way of teaching the topics is lacking something that is critical in my opinion and I've seen no one in bootcamps teaching the very critical skill of navigating layers of abstraction with the least amount of mental overhead. Let me explain.

You truly don't need to understand how everything work deeply

Coming back to the stressed out bootcamp student, the main takeaway that I told her about with respect to learning software engineering is that you don't have to understand how everything work deeply. It's seems counter intuitive, but it's true.

If you get bogged down from the start with all of the details you will never get anything done. There are layers-upon-layers of abstraction in software engineering, navigating through these layers with the least amount of mental overhead is what a good software engineer does.

Check out this video for an example that ties in machine learning into this theory

This type of layered abstraction is present in everything in life and it's something that is absolutely normal for us to keep into account in the physical space.

For instance, if you are learning how to cook a cake you stick to a certain layer of abstraction. You will rarely start stressing out about not knowing how the oven internal heat induction mechanism is working at the start of your recipe (unless the oven heat induction mechanism is broken).

Yet, in the digital space it's not tangible for student and they won't have this reaction of being okay with the layer of abstraction they are in. For instance, the natural reaction to seeing a snippet of Django should be an unanimous "...okay but how is it doing that?"

Show that to a non-programmer, tell them that is a website and send me what their reaction was at lol

If you are a student new to programming, your mind will start racing towards the internal of the Django urls system. If you are very curious you'll start checking out source code (if you even understand that this is a framework and it is something composed of many bits of code stitched together)

after a few googling and clicking around you will end up on something called Github where a bunch of volunteers seems to be working part-time??? on the Django ???

Now this is where the complexity hit the fan hard and people get overwhelmed. You won't find a nice clear cut dependency of things to learn. It's not a clean linear directed-acyclic-graph with very few branching.

This is not it.

Software engineering learning graph is a massive network of concept that are connected with no clear direction and that feed back into themselve at all node level

The start node for your learning is not defined btw and everybody has it's own opinion of which one is to best to start with (see python vs javascript vs C debate)

People that usually thrive and learn the fastest in software engineering are the one that are okay in whichever layer of abstraction they get parachuted in. It could be assembly language, C++, Django, Kubernetes, Sklearn, Pytorch or Scratch.

rare picture of a good student in an introduction to MIPS programming class

They know it doesn't matter much if they don't understand exactly what is going on. They also understand that it's smart to sometime dig a bit under the hood, but not fret too much if they don't get everything. But the peninsulate understanding of a good software engineering student is that they intuitively know that the key to being productive is to be able to navigate the different layer of abstraction with the least amount of mental overhead.

What the hell do you mean by navigating layer of abstraction

Let's take the very simple problem of learning how to code a machine learning model to do image recognition of handwritten digits.

How would the average beginner student do?

  • They will start by freaking out about the fact that it's been so long they haven't looked at linear algebra concept.
  • they will subscribe to 2 course on Coursera about Linear Algebra and Statistic (they will let them sit there for 1 month and half while they prep themselve by doing some Khan Academy math).
  • they will also buy the Andrew Ng. course about machine learning to get the certificate and install Matlab to follow along with their academic license.
  • After 4 months of tolling around, they will start their foray into the nitty gritty of neural network and try to understand what the hell is backpropagation.
  • Usually at this point most student stop and tell themselves that they need to go back to the Linear algebra class as they have trouble with dot product notation.
  • Finally, they will stress everyday until they drop the project.

How a very good student will do?

  • Figure out how people are actually doing it for real.
  • They will stumble into some weird tensorflow code. Read a bit of it, find it weird and shove that in the back of their mind.
  • They will hit a forum telling them that FastAI is magic and should 100% be used everywhere.
  • They will write 6 line of code and congratulate themself!
for real though, check out the library and the free course!

They will not even scratch the surface of how anything work. However, they will anchor themselve at the beggining (i.e. understanding what the problem to solve is) and the end (i.e. how to get the job done).

From that framework digging deep into different topic is very simple and reassuring because the learning problem is bounded. These are the student that in the same timeframe will exponentially improve their skills with confidence.

That's also exactly what senior people do

This is the kind of untangible behavior that you see very senior software engineer exhibit (or very senior researchers in cryptic fields).

rare picture of a senior software engineer about to navigate their whole team through some Kafka tangled error with no-support (and also no prior background in the tech)

They will just roll with whatever layer of abstraction they get thrown in and figure out where they need to navigate in that mess. Not too much, just enough to get the job done with the least amount of mental energy spent.

After the job is done they are able to anchor themselve into their new found understanding and fill in the holes in their knowledge (if needed). Doing so will allow them to relate the disparate mesh of understanding they have acquired over the years and become a better software engineer.


If you find yourself stressing out because you don't get it it's normal. No one does 100%. Even people writing the package that you use don't understand the full extent of how it work.

Here is Linus Torvalds stating clearly he has no idea how to install some linux distro

So start with these heuristic:

  • go with the highest level of abstraction you can to get the job done
  • understand that you are at a high level of abstraction, take a deep breath and recite the litany against fear.
  • and if/when needed dive just deep enough to learn more or debug!

Once this full loop of value is secured, going back to basic makes a lot of sense because you have a nice mental model that shows the value of the thing you learn!

Also check out my blog post on FreeCodeCamp for some very practical framework on how to learn machine learning! The FastAI course also use this sort of framework for teaching deep learning, highly recommend!

If you have a questions or comment, don't hesitate to shoot me a email at! Also, if you liked the content don't hesitate to subscribe to the newsletter!


Subscribe to Yacine's Machine Learning Help Desk

Don’t miss out on the latest issues. Sign up now to get access to the library of members-only issues.