Why I believe in Learn-by-Doing

Over the years, I've arrived at the conclusion that recreating is a very powerful tool to learn a new concept or dive deeper into one you already know as a programmer.

In fact, in this article, I will hopefully convince you that it's the most effective way to learn as a developer.

I was drawn into this field because I wanted to know how my computer works, and what makes it so powerful. For about a year, I got addicted to watching Fireship (don't lie, we all did at some point). I now knew all these fancy terms: Metaframework, Document Database, ACID transaction, and so many more. I also thought I knew what they meant.

In reality, those concepts had never clicked for me. I never really understood HTTP until I wrote my first web server. I never really understood interpreters until I implemented an abstract syntax tree. I realized I was learning everything twice.

Refining the philosophy

For me, code speaks in a way that books and video tutorials simply don't. However, if you wanted to understand how operating systems work, you wouldn't jump straight into remaking the Linux kernel, right? We therefore need to refine this concept.

I've come up with a set of four principles to encapsulate my philosophy of learn-by-doing.

To truly learn how something works, you must recreate it

When you write it all yourself, from scratch, you are faced with all the same design decisions that the original developers had to go through.

Curiosity and learning go hand-in-hand

A good course is written in a way that makes you want to explore, to ask new questions, and to come up with new ideas.

Learning never stops, no matter the level

When you're starting your coding journey, there is an abundance of resources aiming to teach you the very basics of programming. But the more you progress, the harder and harder it is to find resources matching your skill level and ambition.

Being a seasoned developer should not be a punishment.

Motivation fades without results

When was the last time you abandoned a coding project, and, more specifically, why did you abandon it?

Whether it's because of a bug you couldn't solve or because you moved onto a different project, in the end, you just lost motivation.

What options are there?

Alright, let's build something! So, what options are there?

1. Just try to recreate an app or tool you use as closely as possible. Easy enough. Except what constitutes a finished project? What features should you focus on? What libraries do you choose? Decision fatigue becomes a nightmare. Plus, it's hard to stay motivated without a north star to look towards.
2. Follow a step-by-step guide or YouTube tutorial. Definitely much more fun than the previous option, plus you never feel lost. However, how much of the code did you end up writing yourself, and how much did you rewrite line-by-line from the tutorial?
3. Ask ChatGPT to generate a project idea. Seems like a no-brainer these days, and while it might be helpful for small-scale web projects and such, it struggles considerably once you step deep in the weeds and begin dreaming about tinkering with low-level systems.
4. Purchase a course or a platform subscription. You might end up with a slightly more polished version of option 2, or, in the best case, a platform that does have exactly what you're looking after but is unreasonably expensive.

While some of these options are better than others, none of them met all of my four principles at the same time.

My vision with Project Club

So I began, maybe a bit foolishly, to sketch out my idea for a platform that would have all the features I wanted:

• Structured lessons: To eliminate decision fatigue, the content would be separated into clear stages and chapters, so you would always know how close or far you were to completion.
• No ready-made implementation: Unlike video tutorials, I wanted to capture the learn-by-doing feeling fully. That meant you would only see the theory and context necessary to advance. The implementation decisions would be left entirely up to you.
• All the details: The lessons would not hide the lesser-known intricacies and facts about the systems you were building. If you needed to know linear algebra before moving on, you would learn linear algebra right there. You would also receive language-specific advice so you're not stuck in the depths of Google or some ancient docs.
• Informed decisions: Before you started a project, you would know what journey you'd embark on, and whether it was right for you.
• Replayability: If you wanted to remake a project using a different language or framework, there would be first-class support.

For me, this already sounds a lot better than the alternatives.

As of writing this, I'm still hard at work making my vision a reality, but I'm already starting to tease bits of it to the world. If you want to hear more about the process, consider joining the waitlist!

What lies ahead

I've thought about it and I truly believe we can make this the best learn-by-doing coding platform ever.

Here's a list of ideas I have, in no particular order:

• Gamification: Streaks, achievements, and whatnot. All in order to make the learning process more enjoyable and boost your motivation.
• Certificates: Earn recognised diplomas and awards by finishing projects.
• Project Club for creators: Did you recently finish a project you are proud of? Want a platform to share it on? And... get paid for it?
• Going past programming: We could make this a hub for all engineers by integrating DIY projects from fields such as aerospace and electrical engineering.

I'm excited for what's to come, and, if you're like me, I might have brainwashed you enough to be excited as well.

Till next time.