Jonathan Blow on how to learn serious programming

SUMMARY

Jonathan Blow, indie game developer, offers blunt advice for learning serious programming: dive into challenging problems directly, avoid superficial online tutorials like UML, and study real experts to discern quality from pretense.

STATEMENTS

To learn serious programming, one must attempt to build or solve serious projects rather than follow generic guides.
Numerous online resources falsely claim to teach advanced programming but deliver irrelevant concepts like UML diagrams.
Beginners lack the experience to distinguish competent instructors from those offering shallow advice.
The key to progress is tackling difficult, engaging problems that demand genuine skill.
Learning occurs by observing and emulating how skilled programmers approach and resolve complex challenges.

IDEAS

Serious programming skills emerge only from hands-on engagement with substantial, real-world problems rather than theoretical exercises.
The internet is flooded with misleading "experts" who prioritize buzzwords and diagrams over practical coding competence.
Novices are particularly vulnerable to poor teaching because they cannot yet evaluate the depth of the material presented.
UML and similar tools often represent a distraction from actual programming, serving more as academic fluff than useful skills.
Interest in a problem is crucial; motivation drives persistence through the inevitable frustrations of hard work.
Observing expert solutions provides a roadmap for improvement, revealing efficient patterns invisible to beginners.
Self-directed problem-solving builds intuition faster than structured courses, fostering independent thinking.
The illusion of progress from easy tutorials can stall real development by avoiding discomfort.
True expertise requires repeated failure and iteration on ambitious goals, not incremental toy projects.
Discernment in learning sources comes from action; trying and comparing outcomes sharpens judgment over time.

INSIGHTS

Authentic learning in programming demands immersion in complexity to cultivate discernment, bypassing the trap of superficial validation.
Misguided tutorials exploit beginners' ignorance, underscoring the need for self-validation through personal experimentation.
Passionate pursuit of intriguing challenges transforms rote effort into profound skill acquisition.
Expert emulation accelerates growth by bridging the gap between aspiration and competence.
Avoiding distractions like UML focuses energy on core mechanics, enabling deeper systemic understanding.

QUOTES

"You just have to try to do serious things. That's all it is."
"The problem is there are many people on the internet who will claim to be teaching you serious programming and they will teach you some UML."
"You don't want that."
"The problem is because you're trying to learn, you don't know the difference between those people and people who are good."
"You just have to try to solve hard problems that are interesting and then look at how people do that and try to learn from that."

HABITS

Regularly seek out and attempt to solve challenging programming problems that spark personal interest.
Actively study the code and approaches of accomplished programmers to identify effective techniques.
Avoid engaging with online courses or resources that emphasize diagrams or theory over practical implementation.
Persist through failures by iterating on ambitious projects, treating setbacks as learning opportunities.
Periodically evaluate learning progress by comparing personal solutions to expert ones for self-improvement.

FACTS

UML (Unified Modeling Language) is often taught in programming tutorials but rarely used in professional software development.
Many online programming educators lack real-world experience, leading to advice disconnected from industry needs.
Beginners frequently overestimate the value of structured tutorials, delaying exposure to genuine problem-solving.
Interest-driven learning enhances retention and motivation in technical fields like programming.
Expert codebases reveal optimized patterns that simplify complex tasks, often overlooked by novices.

REFERENCES

UML (Unified Modeling Language) as an example of superficial teaching tool.
Twitch stream (https://www.twitch.tv/videos/26375377...) as the original source of the discussion.

HOW TO APPLY

Identify a hard, interesting programming problem that aligns with your curiosity, such as building a small game engine or optimizing an algorithm for a real dataset.
Attempt to solve it independently using basic tools and languages you know, documenting your thought process and roadblocks without external help.
Once stuck, research solutions by examining open-source code from reputable developers on platforms like GitHub, analyzing their structure and decisions step by step.
Rewrite your initial attempt incorporating insights from the experts, then test and refine iteratively to measure improvement.
Repeat the cycle with progressively tougher problems, gradually building a portfolio of serious projects to track long-term growth.

ONE-SENTENCE TAKEAWAY

Master serious programming by tackling intriguing hard problems and learning from expert solutions, shunning superficial tutorials.

RECOMMENDATIONS

Prioritize projects with personal stakes to sustain motivation amid difficulties.
Curate a list of admired programmers' work and dissect one piece weekly for targeted learning.
Test tutorial claims by applying them to a real problem; discard what fails practical scrutiny.
Join communities focused on deep dives, like game dev forums, to encounter authentic challenges.
Set quarterly goals for completing one substantial project, emphasizing depth over breadth.

MEMO

Jonathan Blow, the acclaimed creator behind indie hits like Braid and The Witness, cuts through the noise of programming education with stark simplicity: to learn serious coding, immerse yourself in substantial challenges. In a candid Twitch stream, he warns against the proliferation of online "gurus" peddling Unified Modeling Language (UML) diagrams and other academic distractions that masquerade as expertise. These resources, Blow argues, prey on eager beginners who can't yet spot the difference between fluff and substance, potentially derailing true progress.

Instead, Blow advocates a direct path: seek out hard, captivating problems—perhaps simulating physics in a game or parsing complex data—and grind through them. Failure is inevitable, but it's in this struggle that real skills forge. Supplement by poring over how seasoned coders navigate similar terrain, absorbing their elegant solutions without rote memorization. This hands-on ethos echoes the self-taught ethos of tech pioneers, emphasizing curiosity over credentials.

Ultimately, Blow's wisdom reframes programming not as a checklist of syntax but as a craft honed through audacious trials. For aspiring developers, the message is liberating: no fancy bootcamp required, just the resolve to build something meaningful and learn from those who already have. In an era of endless tutorials, this approach promises not just competence, but mastery.