A Roadmap for the Fundamentals

“When action fails you, plan. When planning fails you, Act.”

One of my best and worst qualities is that I hate viewing things as a black box. I have a strong desire to understand the world around me from the small and big things. Everything from how things are made, the science of how they work, I get frustrated when something is a complete mystery to me. While this is a bit of a tangent, it is exactly this desire of mine that has led me to the path I am about to take.

And that path is a roadmap that I’ve made: “Systems & Programming Fundamentals”

If you’ve read my first blog post you’ll know that one of my long-term plans is to take on the MIT Challenge. A few months ago, while preparing for the challenge I discovered that my math skills had deteriorated to 0, not to mention that my math foundations were already weak to begin with. This meant that the challenge would have to be put on hold while I work on building up my knowledge of mathematics from the very bottom. While I would have loved to dedicate all of my time to fixing my math foundations, delaying working on my technical skills is something I can’t afford to do.

So, the question became: “What do I work on in the meantime?

The main thing I wanted to avoid was working on computer programming too early. The reason being is that once you get through the “Intro to CS classes” on MIT’s OCW, the courses start to get very math heavy. I knew that I wouldn’t be caught up with Calculus that quickly, so I needed another option.
That’s when I realized that this was the perfect opportunity to go through two subjects that I’ve been interested in learning about for years: Linux and Computer Networking. These 2 subjects are often covered late in most Computer Science degree plans. However, one can get immense value out of the material without any advanced math, so starting here works perfectly for my situation.

Inspiration & Philosophy

Over the past 2 years, I have been self-studying programming. I’d love to say I was consistent during this period, but that would be a lie. Most of my studying was spread out and infrequent, and I was trying too many things at once. One moment I would be working on Web-Development, then I would be going through python, and I would suddenly find myself trying to dive deep into C++. This was especially true last year: I was attending hackathons, doing a fellowship, and going to work Full-Time. Suffice it to say, this all led to me getting burnt out, having accomplished nothing noteworthy.

Though painful, I don’t fully regret these past 2 years. I ended up meeting all sorts of people and had some truly life-changing experiences, It was a great period of personal development. When I first started programming, I wasn’t sure where I wanted to end up, and I’m certain that’s a big part of the reason why I never fully committed to anything. But that has changed, I now know that I want to dedicate myself to working in AI & Robotics in the future. Taking that into account and the lessons I’ve learned in the past is why I’m sharing this journey that I’ve started on.

The philosophy of this roadmap is about reaching true understanding. Looking back at my past attempts to self-study there were 2 big mistakes that I made. One was that I was trying to learn everything at once and the other was trying to rush through everything too quickly. The blog article “Play the long game when learning to codeby Daniel Chae explains the point perfectly.
To summarize why I believe focusing on true understanding is important: It is only when you truly understand something that you can start thinking about it in new and interesting ways, that you can start applying it to the real world and see unique crossovers in both related and unrelated fields.

The Roadmap

Systems & Programming Fundamentals roadmap on roadmap.sh


The philosophy of this roadmap is to take the long-term approach to studying.

For each major topic, we will go through a set of sub-topics that that involve both books & courses that give us a solid overview of the main subject. Upon finishing the course or book we will then be doing a section project, which could involve a large single project or various smaller tasks. Finally, at the end of the section we arrive at the Capstone Project, the Capstone is intended to be a holistic review of everything we have covered, as well as be a difficult challenge that pushes our understanding of the subject to its limit.

Example snippet of the roadmap

To explain the roadmap layout. The blue button behind every sub-topic will link to the full article in the Lab-Book. Meanwhile the actual sub-topic will cover a brief summary of the course, video or book we will be working through, and it will also include relevant resources. While not pictured here, the alternatives section will provide other courses/books/videos that work as a substitute, but you are free to work on everything.

One of the best ways to really cement your knowledge on a topic is through hands-on learning. So we will be rounding out a section by going through a Section Project indicated by the turquoise colored checkmark ✅. The section project is also intended to be both a decent challenge and a good review of all of the material we have covered.
Lastly at the end of a branch we arrive at the Capstone Project marked by the purple checkmark☑️. The Capstone is intended to put all of the knowledge we have learned in a branch to the absolute test. This will be the portion that brings us one step closer to becoming an actual engineer. While it’s a category that’s still a work in progress, the intent is to focus on both designing and building powerful practical systems. As well as learning good practices and creating write-ups for our work.
While not pictured Lastly while not pictured, there will be a dark-blue checkmark  next to courses/books that are optional but may be worthwhile depending on your use-case.

The Lab-Book

The Lab-Book Home Page
A draft of the Linux Upskills Challenge Page

This brings us to the Lab-Book

The Lab-Book is a bookstack instance hosted at my sub-domain at lab-book.01blu3.com The purpose of the site is to serve as a place to document any personal labs or projects that I am working on. And the book, Systems & Programming Fundamentals is where I plan on posting any labs and write-ups associated with this roadmap. It will include more detailed guides and all the necessary resources to finish a topic.

I also plan on writing a blog-post for each section that I finish, detailing all of the things I’ve learned and the projects I’ve accomplished. In fact it’s the first section on this roadmap: The Linux Upskills Challenge, that gave me what I needed to finally start my blog.

The Roadmap Path

This is the current list of every subject and topic I plan on covering for this roadmap. My long-term goals are far more involved, but this can be considered as my absolute starting point. During all of this I’m also going through “The AoPS” series of math books starting from the introductory level, which I’ll be covering in a separate blog-post sometime in the future which may include its own bookstack roadmap though it will be a simplified roadmap.

This roadmap is a work in progress that will likely span years as I do not plan on stopping at the System & Programming Fundamentals level. I will continue to work on this roadmap as long as I find it interesting and worthwhile. In the future I would love to convert all of the lab-book into a GitHub repo and make it opensource when I feel I’ve progressed enough.

The Roadmap Summarized

In the following list I will be giving a brief reasoning for each main subject up unto the Intro to Programming section as there are many more things I need to learn before I can provide a proper reasoning for the future topics. If you’d like to know more of the specifics look at the Roadmap Overview in the lab-book.

Systems & Networking Fundamentals

A system can be defined as a set of parts working together, and a network as a group or system of interconnected things.

The aim of this path is to familiarize ourselves with Linux & Computer networking. We’ll learn to both configure and administer our very own Linux Servers, write powerful scripts, and come away with a sys-admin’s eye and toolset. We’ll also gain a solid foundation in computer networking, uncovering the Blackbox that the internet often seems to be, learning about various protocols, topologies, and architectures.
At the end of this path, we’ll be able to call ourselves a jr sysadmin and jr network-engineer.

  • Linux Fundamentals
    • Linux Upskill Challenge
    • Learning the Unix OS
    • Linux Journey
    • Learning the bash Shell
    • UNIX and Linux System Administration Handbook (Alternative)
    • The Debian Administrator’s Handbook (Alternative)
    • Linux Fundamentals Capstone
  • Networking Fundamentals
    • Intro to Computer Networks
    • Cisco CCNA
    • Network Warrior
    • Practical Packet Analysis
    • Core 5G and Beyond
    • Networking Fundamentals Capstone

Intro to Programming

This is by no means an introduction to computer science, that will be something to cover later. Instead, this path is all about easing us into computer programming. We’ll be learning about the absolute basics of programming and some automation as well. We’ll also cover Databases learning about CRUD and Data-In/Data-Out, then finally rounding things out with version control.
By the end of this path we’ll have taken our first steps in programming.
There’s still a long way to go before we can call ourselves software developers much less engineers, but bit-by-bit we are getting there.

  • Intro to Programming
    • Python Programming
    • Automate the Boring Stuff with Python (Optional)
    • Intro to MySQL
    • Git
    • Intro to Programming Capstone

Containers & Orchestration

  • Docker
    • Hypervisors
    • Containers
    • DevOps with Docker
    • Docker Capstone
  • Kubernetes
    • Intro to Orchestration
    • Kubernetes
    • Kubernetes Capstone

Intro to Computer Science

  • Programming
    • Harvard’s CS50
    • Programming Capstone Project
  • Hardware Fundamentals
    • Code: The Hidden Language of Computer Hardware and Software
    • Computer Principles
    • From Nand To Tetris
    • C Programming
    • Hardware Fundamentals Capstone

Computer Systems

  • Systems
    • Data Structures in C
    • UC Berkeley – CS61C Great Ideas in Computer Architecture
    • Software Construction
    • Operating Systems
    • Systems Capstone
  • Linux Programming
    • How Linux Works
    • Advanced Programming in Unix
    • Linux Programming Interface
    • Linux Programming Capstone Project


I will admit that the structure of the roadmap is rather strange. Starting with Linux is sensible, but then we go further into System Administration and just as deep into Computer Networking then we dive into Programming afterwards covering Containers & Orchestration finally arriving at Computer Science. This roadmap is definitely not for everyone, and I can only imagine that a handful will follow through each resource from start to finish.

But making a roadmap for others wasn’t my intention when I began working on this project. Instead, my goal was to create something that I could share with others to show my journey starting over from the very beginning. This roadmap is something I made in order to get my studies back on track, using my years of hackathons and the advice of incredibly gifted students, professionals, and passionate hobbyists to create something that covers all of the fundamentals. This roadmap of course still needs much work, I’m very confident in the early sections but I may likely choose different resources for the future topics. Either way I’m satisfied with the overall structure as is.

I’m not sure how many will follow along if any, but I do hope whoever reads through the roadmap and goes over the lab-book, that they are able to find something of value to them.

It’s a strange project but I am looking forward to what will come of it.

Leave a Reply