cs-speedrun.md

CS Bachelor's Speedrun (wip)

This is a project inspired by Scott Young's MIT Challenge and Forrest Knight's Open Source CS Degree. The overall goal is the same; teach yourself as much CS as a graduate from an elite school would learn in 4 years, but do it at 4x speed. This essentially comes down to completing a class every week.

There are a couple of differences with my take on the challenge over Scott's:

• I will not be following some preset curriculum (e.g. MIT's), instead focusing on the topics I personally want, from the sources I choose.
• This project will be structured into a core curriculum and several tracks. The goal is to complete the core and one track in the first year, and then two tracks every year after. Each track+core combo should be equivalent to a degree specializing in that field.
• I'm skipping math. Not because I don't want to learn it, but traditional methods just don't click for me. I'll be doing so until I feel it starts holding me back in real-world programming tasks or I find an intuitive way to learn it. This should technically not be a problem for the AI track. Technically.
• Unlike Scott, I want to get hired, so I'll be picking up credentials wherever possible, free ones where I can. This will be noted in the following "transcript".
• Exams are useless, will be avoiding them unless I need them for a credential. Projects speak louder than scantrons. PROJECTS ARE NOT EXAMS! (some courses will list them as such)
• Where credentials aren't possible, I will at least try to find a course that leads to some tangible output in the form of projects.
• I'll be using teachyourselfcs.com as a rough guideline, but will be making a lot of changes to it.

🎓 = College Course 📚 = Book F = Free U = Accredited college credits/units(!) C = Certificate P = Project-focused

Core

Intro (5 segments)

Classes to get you coding and thinking about code.

1. 🎓FPC CS50x - "Harvard University’s introduction to the intellectual enterprises of computer science and the art of programming." This is the class that anyone should start with. If it's too hard, do CS50P first, but give this a solid shot before that. Free certificate from Harvard! Don't worry about the final project too much, just make sure you complete it before the time listed in the syllabus so you can get your certificate.
2. 📚F = The Rust Programming Language - Speedrun the book. Don't take notes. Don't get something? Keep going. Don't look back. Rust is the language I'll focus on the most here, for three main reasons; it's really easy to set up, it's really easy to debug, and you'll get a taste of functional and OOP code. Just read the book. Don't stress about trying everything in there or anything. If something confuses you, keep going. Only do the big projects (hello world, guessing game, I/O project, and web server), just read everything else and move on.
3. F rustlings - Get some interactive practice in Rust.
4. F Frontend Masters: The Last Algorithms Course You'll Need - Very inaccurate title, but seems like a solid intro.
5. 📚F = The Rust Programming Language - Yes, again. This time, use the interactive version from Brown University. Do the quizzes, and when curious run the code samples. Learn the language inside and out. You'll be using it a lot from now on.
6. F rustlings - Yes, again.

Practicum (4 segments)

Write some code! These are all either Rust projects or don't specify what language you should use. Feel free try other languages for any of these challenges.

1. FP PNGme: An Intermediate Rust Project - You might not have noticed, but you're an intermediate programmer now. You've been one for a while, actually, but now it's time to act like one. This "class" will have you build a program that hides messages in PNG images. No more training wheels. You get a specification and some tests, and implementation is completely up to you.
2. FP Let's build a browser engine! - Does what it says on the tin; you implement a "tiny" program that parses HTML and CSS and displays it to the user.
3. FP cryptopals - Learn cryptography by solving coding challenges.
4. FP Rust Cookbook - Feel free to move on as you slowly walk through this. You can also start this earlier, but probably complete PNGme first.

Dig deeper (6 segments)

These classes give you more insight into the systems you're building on top of. If you haven't built a computer, start to finish, you haven't done CS.

1. 🎓C [nand2tetris Part I: Hardware] - Building a Modern Computer from First Principles. You start with logic gates and work your way up to a CPU. Certificate included with Coursera+. Not a fan of the video lectures, though, much prefer reading the book.
2. 🎓PC [nand2tetris Part II: Software] - Continuation of previous, this time you build a compiler, dynamic language, operating system, and emulator, for the machine built in part I. Start Practicum II after this.
3. 📚FP Learning Rust With Entirely Too Many Linked Lists - Learn how to make linked lists, why you shouldn't, and ease into unsafe Rust.
4. 📚F The Rustonomicon - Unsafe Rust. Feel free to keep moving on while working through this. This will be frustrating, but you should rip the band-aid off pretty early on. You will rarely use this stuff, but when you do need it, you really will need it. You'll also understand Rust and programming languages in general better.
5. 📚FP Crafting Interpreters - A gentle introduction to the art of implementing programming languages.
6. 📚FP Writing Interpreters in Rust: a Guide - Follow-up on previous.

Practicum II (3 segments)

Write more code!

1. FP Writing NES Emulator in Rust - Like nand2tetris Part II, but with a real-world platform.
2. FP CHIP-8 - You might notice that this is an extremely intimidating spec document, and not a course. Read it. Implement an emulator for it. Do this before, during, or after nand2tetris but, DON'T refer to your nand2tetris code while doing this. If you get really stuck, refer here as a last resort.
3. FP Writing an OS in Rust - What it says on the tin. x86-64.

Intro II

You thought we were done, didn't you? We've only scratched the surface! These are the intro classes that you can do at any point after Intro I, or maybe even skip entirely.

1. 📚F Learn You A Haskell for Great Good - Learn the basics of functional programming; you'll see code in a way most programmers can't, or so they say... Intended to be used in parallel with the Haskell course below.
2. 🎓FU Haskell MOOC (University of Helsinki) - This course gets you more exposure in functional code, which is lacking in most CS paths. 5+5 ECTS credits. Seek classes like this out.
3. 📚F Rust by Example - Use this as a reference book for the most part, but slowly work through it as well. If you don't know what to do but you want to do something, do the next chapter of this.
4. 🎓C Programming Languages, Part A - This set of courses is intended to give you a wider understanding of programming languages. Uses ML, Racket, and Ruby.
5. 🎓C Programming Languages, Part B - Ditto.
6. 🎓C Programming Languages, Part B - Ditto.

Practicum III

Just like Intro II, these are resources you can work through in your downtime. Not strictly necessary, but useful nonetheless.

1. F Programming Projects for Advanced Beginners - List of small projects you can probably do in an afternoon. Too small to be listed as experience, in my opinion, but big enough to be a non-trivial exercise.
2. F MacroKata - Like rustlings, but for macros.
3. FP Nifty Assignments - Experimental assignments.

Weaknesses

This is more robust than 99% of university CS core curriculi. It's, to my understanding, an extremely solid introduction, one where you have to hit the ground running. CS50x might be too hard for a beginner, but try it first! If it is too hard, do CS50P, then come back to CS50x.

This core does not stop being daunting. Just when you think you got over the hardest hurdle, a bigger one pops up in front of you. This is by design. If you're comfortable, you're not learning. You should always feel confused.

My goal is breadth here, and then I'll make a track for whatever I want to go in-depth in, i.e. computer architecture.

I focus on Rust here, though the skills are transferrable, of course, and the language you actually start with will be C. Rust is really nice, and there are amazing free resources built around it, but they don't have credentials for the most part. That's fine, I think, because a lot of them are project-based. It's also the easiest language to set up via rustup's magic, and the compiler is really helpful. The Rust path here is ripped from this excellent video: https://www.youtube.com/watch?v=2hXNd6x9sZs

There's no math. I don't see that as an issue, but some people will.

Not a lot of DSA or computational thinking; I will be adding them.

Artificial Intelligence

1. 🎓FCU Elements of AI - Very introductory theoretical course. 2 ECTS credits in exchange for 6 hours of time.
2. 🎓FCP CS50AI - CS50 extension focusing on AI. Another free Harvard cert. Kind of outdated, but will hopefully be a good warm-up.
3. FP fastai Practical Deep Learning - The canonical deep learning course for self-teachers that are actually self-teaching instead of having years of college math as a foundation. No certificates or anything, but I believe that this course is worthwhile regardless.
4. FP fastai Practical Deep Learning Part 2 - Follow-up to the previous course. This one centers around cloning Stable Diffusion. Insanity.
5. F TinyML and Efficient Deep Learning Computing - Resources aren't infinite (yet), so learning to use them well is a solid idea.
6. Building AI - Continuation of the first class, looks a lot less intense, but ECTS credit. Might do it.

Weaknesses

Lack of math severely limits the amount of AI resources available to me (the big one being those juicy Andrew Ng courses that are included in my Coursera subscription, but oh well) and makes reading papers a slog. However, it also means I'm coming in from a different perspective, so I'm curious to see how this turns out.

Ethics isn't in here, because I've already researched and thought long and hard about it. If you haven't, you should!

Web

1. F Shuttle Launchpad
2. Zero to Production in Rust
3. 📚F Beej's Guide to Network Programming - The canonical low-level network programming reference, using C.

Weaknesses

Literally just do Full Stack Open. Tons of ECTS credits. (very iffy on this since I have already learned most of the frontend web stuff I'd like to learn, and the route is centered around React.)

I have instead decided to focus on high-performance backend development and distributed systems, because it's the only thing I don't know in the field.

Embedded

1. nand2tetris, as mentioned in the Core.
2. Embedded Discovery Book - You'll need a BBC micro:bit to follow along. Getting a starter kit with components you can mess around with is a good idea.
3. Operating System development tutorials in Rust on the Raspberry Pi - The title says it all, really. You'll need a Raspberry Pi 4, and a few components.
4. The Embedonomicon

Weaknesses

I'm sure there are many, mostly relating to core electronics knowledge. Programming alone won't get you too far in embedded.

Computer Architecture

1. nand2tetris, as mentioned in the Core.
2. 📚FP Operating System development tutorials in Rust on the Raspberry Pi - The title says it all, really. You'll need a Raspberry Pi 4, and a few components.

Extension

Most people wouldn't dare to touch this stuff, with good reason. I'd like to.

1. P Tiny Tapeout - This is where it starts to get really expensive. We're making the leap from code to actual silicon.
2. P zero2asic - This was unthinkable a few years ago.