Teach Yourself Programming in Ten Years (1998)

What It Means to Be “Good” at Programming

• Several comments argue you never truly “arrive”; competence is better judged by others and by whether your work is accountable and reliable over time.
• Others push back on extreme humility: it’s possible to recognize skill without denying room for improvement.
• “Good” is seen as contextual: good enough to help a neighbor’s kid, to mentor a coworker, or to ship and maintain real systems.
• Some tie “good” to earning a living from programming; others note this excludes hobbyists and doesn’t reflect depth of skill.
• Indicators mentioned: repeatedly finding elegant solutions to complex problems, building systems that keep working, and becoming good at learning what you need.
• One commenter notes severe imposter syndrome despite shipping multiple projects, highlighting the psychological side of “goodness.”

Short-Course Books and Learning Timelines

• The thread distinguishes between criticizing the titles (“in 24 hours/21 days”) and the content: many see these books as decent foundations and approachable introductions.
• Main criticism: the titles create unrealistic expectations and work as era-appropriate clickbait.
• Some recall formative experiences with these books, even if they didn’t finish them.
• Older developers note that in the 90s you could more or less “know a language” from one book; modern ecosystems (e.g., post‑C++03, modern web) are far more sprawling.
• Project-based books spanning start-to-finish examples are preferred over chopped-up mini exercises.

Norvig’s Thesis vs Interview Culture

• One commenter jokes that following the “10 years of real learning” advice would hurt chances at Google, since time should instead go to LeetCode-style prep.
• Replies stress that the essay is about mastery, not interview rehearsal, and was a reaction against “learn X fast” marketing.
• There’s disagreement on whether a decade of real-world programming naturally yields strong data-structures/algorithms skills as used in interviews.
• Some Google interview veterans say they mostly relied on years of real programming, with minimal cramming.
• Several note that getting hired by a big tech company is not the proper end-goal of learning to program.

LLMs and the Ten-Year Idea

• A sarcastic take claims modern LLMs make the essay obsolete and let you “learn C++ in 24 hours” by rapid code generation.
• Most responses reject this: generating code is not the same as understanding it, and overreliance leaves novices unable to debug or reason about failures.
• LLMs are framed as accelerators or tools for iteration, not replacements for the deep pattern recognition built through years of solving real problems.
• One commenter argues that much low-level knowledge (memory hierarchy, malloc) is not required for many modern web jobs, regardless of LLMs.

Lifelong Learning and Keeping Up

• Multiple people with decades of experience say they’re still learning constantly.
• There’s a sense that technology now moves fast enough that no one can fully “keep up”; instead, you become good at targeted learning and staying humble.
• Some question whether feeling “good” would even help, worrying it might reduce curiosity.

Usenet and Historical Context

• A younger developer asks what Usenet was; answers compare it to Reddit (threaded, topic groups), mailing lists, and early PHP forums, with IRC as the ancestor of Discord-like chat.
• Several long-time users describe Usenet as decentralized, volunteer-run, with strong threading and filtering, initially high discussion quality, later damaged by spam.
• There’s detailed debate over naming (“Usenet” vs “netnews”), its relation to ARPANET/Internet, and cultural differences between then and now.
• Nostalgic reflections emphasize how old discussions persist unchanged while the world and readers have changed around them.

Pedagogy, Languages, and “Silver Bullets”

• A side thread asks whether certain languages/environments (Objective‑C + NeXT, Swift/SwiftUI) fundamentally reduce the difficulty of learning programming.
• The counterargument: tools that make complex software easier don’t necessarily make learning to program easier; low-level exposure can deepen understanding.
• There is skepticism that object-oriented programming ever delivered the “silver bullet” some promised.

Miscellaneous

• Some readers are confused by the article’s mix of 1990s core and later references (e.g., Go, Ratatouille); the footer copyright range suggests it was updated through 2014.
• A link is shared to a talk where the author is reportedly cautiously optimistic about LLMs, seeing them as useful if prompts are well-phrased.