⏱️ Lectura: 10 min
TeachYourselfCS has held the same thesis since 2016: you can learn computer science without setting foot in a university, as long as you follow the right books in the right order. The idea circulated again this week from an unexpected source: a botany blog that teaches plant taxonomy using the same curated reading list logic.
📑 En este artículo
- TL;DR
- What happened: a botany list reopens the debate on learning without a degree
- Context and history: from plant taxonomy to TeachYourselfCS
- Technical details: the anatomy of a CS reading list
- How to start using TeachYourselfCS (or build your own list)
- Impact and analysis: does this replace college or bootcamp?
- What’s next
- Frequently Asked Questions
- Do I need a college degree if I follow TeachYourselfCS?
- How long does it take to complete the full list?
- Can it get you a job without going through a bootcamp?
- What’s the difference between a GitHub awesome-list and TeachYourselfCS?
- Is it legal to access these books for free?
- How do I stay disciplined without a course with deadlines?
- References
The parallel isn’t a coincidence. Crime Pays But Botany Doesn’t, a blog dedicated to teaching botany to self-learners, published a guide that organizes learning by canonical texts, reading order, and technical vocabulary. It’s exactly the format TeachYourselfCS has used for nearly a decade to teach programming, operating systems, algorithms, and databases.
TL;DR
- TeachYourselfCS.com organizes self-taught computer science study into 9 areas with specific canonical books per area.
- The site was created by Oz Nova and Myles Byrne, co-founders of Bradfield School of Computer Science.
- It recommends texts like SICP, CS:APP, CLRS, OSTEP, and Designing Data-Intensive Applications instead of generic courses.
- OSTEP (Operating Systems: Three Easy Pieces) and the database Red Book are free, legally accessible PDFs.
- The GitHub repo sindresorhus/awesome popularized the same curated-list format applied to hundreds of technical topics.
- Crime Pays But Botany Doesn’t applies the same reading list methodology to plant taxonomy.
- The debate over learning without a college degree resurfaces as the tech industry cuts bootcamps in 2026.
What happened: a botany list reopens the debate on learning without a degree
The botany blog has nothing to do with technology at first glance: it teaches how to identify plants, understand Latin nomenclature, and classify families by shared evolution. But the structure of the article (which book to read first, why technical terminology shouldn’t be intimidating, how each new concept gets looked up and resolved on the spot) is identical to what thousands of self-taught programmers use every year.
The article spends much of its introduction defending Linnaeus’s binomial nomenclature system (genus capitalized, species lowercase, both italicized) as a universal standard necessary for scientists from different cultures to understand each other unambiguously. The analogy to programming is direct: naming standards (semver for versioning libraries, snake_case or camelCase depending on the language, RFCs for protocols) serve the same function and keep every team from reinventing its own vocabulary.
As the core text, the blog recommends Plant Systematics, by Michael Simpson, and as a complement Raven’s Biology of Plants: two books that function as botany’s CLRS and SICP. One teaches identification by shared evolution (synapomorphies), the other covers the underlying biology that supports that classification.
Context and history: from plant taxonomy to TeachYourselfCS
Modern botanical taxonomy organizes species by evolutionary relationships, not superficial appearance. Two plants with similar-looking leaves can belong to completely different families if their common ancestor is far back in the evolutionary tree. Understanding that logic lets a botanist identify a species they’ve never seen, just by recognizing the pattern of the family it belongs to.
TeachYourselfCS was born from a similar problem in programming: bootcamps teach syntax and frameworks, but not always the fundamentals that let you reason about a system you’ve never seen before. Oz Nova and Myles Byrne, co-founders of Bradfield School of Computer Science in San Francisco, published the site to solve that: a computer science curriculum built from the same books top universities use, but self-guided and mostly free.
The logic is the same one the botany blog describes: technical terminology (whether “monophyletic” in botany or “asymptotic notation” in algorithms) isn’t an obstacle, it’s a tool. Learning it isn’t memorizing vocabulary, it’s understanding why it exists.
Technical details: the anatomy of a CS reading list
TeachYourselfCS divides the curriculum into nine areas, each with a book recommendation. The table summarizes the core areas and the reference text the site recommends for each:
| Area | Recommended book | Why it matters |
|---|---|---|
| Programming | Structure and Interpretation of Computer Programs (SICP) | Teaches you to think in abstractions before focusing on a specific language |
| Computer architecture | Computer Systems: A Programmer’s Perspective (CS:APP) | Connects code to what the CPU and memory actually do |
| Algorithms and data structures | Introduction to Algorithms (CLRS) | Standard reference for complexity analysis and algorithm design |
| Operating systems | Operating Systems: Three Easy Pieces (OSTEP) | Free and used in university OS courses |
| Databases | Readings in Database Systems (Red Book) | Collection of foundational papers, also free |
| Distributed systems | Designing Data-Intensive Applications | Translates consistency and partitioning theory into real design decisions |
The format isn’t exclusive to TeachYourselfCS. On GitHub, the repository sindresorhus/awesome popularized “awesome lists”: README.md files that curate links by topic, from machine learning to compilers. Any developer can clone the format to build their own study list with Markdown checkboxes.
flowchart TD
A["Programming: SICP"] --> B["Architecture: CS:APP"]
B --> C["Algorithms: CLRS"]
C --> D["Operating Systems: OSTEP"]
D --> E["Networks: Kurose and Ross"]
E --> F["Databases: Red Book"]
F --> G["Languages and Compilers"]
G --> H["Distributed Systems: DDIA"]The order matters: TeachYourselfCS insists on not jumping to distributed systems without first covering operating systems and databases, because consistency and partial failure concepts depend on first understanding how a single machine works.
How to start using TeachYourselfCS (or build your own list)
The first step is reading the site’s full index before buying or downloading anything: TeachYourselfCS makes clear which book is essential and which is optional depending on available time. After that, it’s worth versioning your own progress in a personal repository, just like an awesome-list.
💡 Tip: keep a Markdown file with checkboxes per chapter, not just per book. Finishing “Algorithms” in a single commit is too coarse to measure real progress.
A minimal template to start your study repository:
## My CS reading list (inspired by TeachYourselfCS)
- [ ] Programming: *SICP* (Abelson and Sussman) - chapters 1-3
- [ ] Architecture: *CS:APP* (Bryant and O'Hallaron) - chapters 1-6
- [ ] Algorithms: *CLRS* - parts I and II
- [ ] Operating Systems: *OSTEP* (free pdf) - virtualization
- [ ] Databases: *Red Book* - papers 1-5For those who prefer to automate tracking, a short script can read an existing awesome-list on GitHub and turn it into a personal checklist:
import fetch from "node-fetch";
async function extractResources(readmeUrl) {
const raw = await fetch(readmeUrl).then((r) => r.text());
const links = [...raw.matchAll(/\[(.+?)\]\((https?:\/\/[^\)]+)\)/g)];
return links.map(([, title, url]) => ({ title, url, read: false }));
}
const README = "https://raw.githubusercontent.com/sindresorhus/awesome/main/readme.md";
extractResources(README).then((list) => {
console.log(`Found ${list.length} resources.`);
console.log(JSON.stringify(list.slice(0, 5), null, 2));
});The script downloads the raw README, extracts each Markdown link with a regular expression, and builds an array of objects with a read flag that can be toggled by hand or from a small frontend. It’s the same idea as a paper checklist, but versionable in Git.
Impact and analysis: does this replace college or bootcamp?
The short answer is that it doesn’t fully replace either: each path solves a different problem. The table compares the three most common routes to learn programming today:
| Path | When it fits | Advantage | Limitation |
|---|---|---|---|
| College | When you have the time and funding for 4 years | Recognized credential, network, direct mentorship | High cost and time, fixed pace |
| Bootcamp | When looking for a frontend or backend job quickly | Fast, focused on an immediate portfolio | Shallow coverage of fundamentals |
| Self-taught reading list | When you already code and need more conceptual depth | Free or nearly free, self-paced, solid fundamentals | Requires discipline, no mentorship or feedback |
⚠️ Heads up: the biggest risk of following a reading list alone is not having anyone to check whether you actually understood a concept. Solving each book’s exercises, not just reading it, is what separates real learning from turning pages.
The botany blog raises the same problem from another angle: it advises not being intimidated by vocabulary, but also insists on verifying every new concept against a reliable source before considering it understood. Active verification, not passive reading, is what makes any reading list work, whether it’s about plants or distributed systems.
What’s next
The use of AI assistants to reinforce self-taught reading lists has been growing: they’re useful for explaining a dense CLRS paragraph or generating extra exercises for an OSTEP chapter, without replacing the book itself. TeachYourselfCS doesn’t mention this practice because the site isn’t updated often, but the community that follows it has already adopted it as an informal complement.
What doesn’t change is the core of the method: choosing the right canonical texts and going through them in order matters more than the tool used to reinforce them.
📖 Summary on Telegram: See summary
Try it yourself: open teachyourselfcs.com right now and compare its nine-area index against what you already know to see where your biggest gap is.
Frequently Asked Questions
Do I need a college degree if I follow TeachYourselfCS?
It isn’t a requirement to learn the concepts, but some companies still ask for the degree as an administrative filter in large hiring processes. A solid GitHub portfolio makes up for part of that barrier at smaller companies or in remote roles.
How long does it take to complete the full list?
The site itself doesn’t give an official figure because it depends on available time and each person’s starting point; programmers with prior experience usually focus only on the areas where they have gaps, not all nine.
Can it get you a job without going through a bootcamp?
It’s useful for deepening fundamentals, but it doesn’t replace practicing technical interview problems or building projects a recruiter can review.
What’s the difference between a GitHub awesome-list and TeachYourselfCS?
An awesome-list is an open collection of links anyone can expand via pull request; TeachYourselfCS is a closed curriculum curated by its two authors, with a specific reading order.
Is it legal to access these books for free?
OSTEP and the database Red Book are legally free because their own authors published them that way. For the rest of the titles, the legal route is buying them or accessing them through university or public libraries.
How do I stay disciplined without a course with deadlines?
Tracking progress in a public repository with regular commits works as an informal substitute for the pressure of a schedule, and also serves as evidence of the work done.
References
- Crime Pays But Botany Doesn’t: Reading List: the original article that inspired this comparison between self-learning methodologies.
- TeachYourselfCS: the self-taught computer science curriculum created by Oz Nova and Myles Byrne.
- sindresorhus/awesome: the GitHub repository that popularized the curated list (“awesome lists”) format.
- Operating Systems: Three Easy Pieces (OSTEP): free operating systems book recommended by TeachYourselfCS.
- Autodidacticism, Wikipedia: general context on self-directed learning.
📱 Like this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day. @programacion
Imagen destacada: Foto de Daniil Komov en Unsplash
0 Comments