The Long Road to Programming Expertise: A Deliberate Practice System for C++, Vulkan, and Game Development

EscPoint

Introduction to Expertise in Programming [0:00:00]

• The challenging path to expertise [0:00:03]
  • Becoming an expert at something takes a very long time, and most people never achieve it.
  • Many online resources and AI tools promise shortcuts, but the speaker asserts there is no real secret to success.
• Addressing common questions and misconceptions [0:00:30]
  • The speaker frequently receives questions about learning specific technologies like C++ and Vulkan.
  • He believes the deeper question is often about how to become truly skilled and an expert, which is the focus of this video.
  • This content is primarily aimed at newer programmers not yet highly skilled in any area.

The Pitfalls of AI in Learning Programming [0:01:30]

• Why beginners need to struggle and learn basics deeply [0:01:37]
  • Learning requires allowing oneself to be a beginner, struggling, failing, and deeply understanding the basics.
  • AI bypasses this crucial learning phase, which is essential for mastery, by providing immediate answers without requiring understanding of "how and why."
• AI's negative impact on cognitive function [0:02:41]
  • A study on "Your Brain on ChatGPT" indicates that Large Language Models (LLMs) reduce cognitive function during tasks.

    

  • Cognitive offloading and reduced retention (essay study example) [0:02:51]
    • Participants using ChatGPT for essay writing were unable to recall what they had written when later asked to do so without AI.
    • This suggests AI allows users to stop thinking effectively and remember less.
  • Homogeneous solutions and forgetting code (Quick Sort example) [0:03:38]
    • For programmers, relying on AI can lead to more uniform solutions and makes it easier to forget code.
    • ChatGPT's quick sort implementation, for example, used a suboptimal pivot selection (highest array value), resulting in the worst-case time complexity.

      

    • For performance-critical areas like game engine or graphics development, "good enough" code is insufficient, and reliance on AI reduces a programmer's ability to identify and fix such issues.
• The importance of self-reliance for complex programming [0:05:08]
  • The goal is to write code independently, without AI assistance, which is a benefit of building genuine expertise.
  • To achieve this, programmers must allow themselves to be beginners and avoid heavy AI reliance.

The Time Commitment to True Programming Mastery [0:05:40]

• Insights from an experienced programmer [0:05:40]
  • The speaker consulted an experienced programmer, his friend, on learning C++.
  • Learning C++ from the ground up (C, assembly, manuals) [0:05:59]
    • His friend learned C++ in 1997 after mastering BBC Basic, 32-bit ARM assembly, and C, primarily from the Visual C++ 5 manual and library books.
    • This "bits and bytes upwards" approach provided a valuable low-level understanding.

      

  • Recommendation: Learn C first, focusing on low-level concepts [0:06:34]
    • To learn C++ well, it's advised to take time, learn C first, and focus on low-level aspects like memory, addresses, bits, bytes, and I/O.
    • Afterwards, explore the features C++ builds on top of C.
  • Warning against learning C++ quickly [0:06:47]
    • "If you wanted to learn C++ quickly, I'd say don't bother." The friend suggests learning higher-level languages like C# or Java first if speed is a priority, but cautions about the transition.
• The "Teach Yourself Programming in Ten Years" philosophy [0:07:46]
  • The article "Teach Yourself Programming in Ten Years" highlights that true expertise requires about 10 years of dedicated effort, citing studies.

    

  • This philosophy directly counters the prevalent idea of quick learning and shortcuts.
• Speaker's personal learning journey and challenges [0:08:14]
  • The speaker emphasizes that he has invested in many books and revisits them repeatedly to improve.

    

  • Developing 3D game engines and graphics programming is as difficult as writing an operating system, where doing it well is extremely challenging.
  • He has developed multiple renderers, game engines, and games, but continuously strives for improvement.

A Gamified System for Deliberate Practice [0:09:00]

• Inspiration from Rocket League's ranking system [0:09:21]
  • The speaker uses the competitive video game Rocket League's ranking system as a metaphor for programming skill progression.
  • Rocket League's unique nature means all beginners start at the same rank, regardless of prior gaming skill, making it a fair model for skill development.
• Estimating hours for "expert" level (8,274 hours) [0:10:16]
  • Based on a Rocket League video, reaching the highest rank (Supersonic Legend) takes an average of 4,450 hours.
  • The speaker extrapolated this to 8,274 hours to be able to compete in RLCS major tournaments, setting this as his target for programming expertise.

    

• The speaker's goal and current progress [0:10:39]
  • On November 11, 2024, he began counting his coding hours, aiming to reach 8,274 hours from scratch to become an expert.
  • He acknowledges that even after reaching this goal, there will still be room for further growth.
  • He currently tracks his progress using a Google Sheet.

    

• Establishing programming ranks and milestones [0:10:55]
  • He created a system with milestones mirroring Rocket League ranks, with additional lower ranks (Mud, Wood, Stone, etc.) to account for initial programming stages.
  • Higher ranks (B, B+, A, X, S) were added, inspired by semi-professional Rocket League leagues (six mans), with S-rank representing major tournament players.
• Motivation behind the system: controlling effort, not outcome [0:12:07]
  • Since there's no objective measure of programming skill like in competitive games, the speaker focuses on what he can control: deliberate practice time.
  • Cheating the system is self-defeating, as the system is for personal improvement.

Rules and Tools for Tracking Deliberate Practice [0:12:42]

• What counts as deliberate practice (strict rules) [0:12:44]
  • Only deliberate studying or actual programming counts.
  • Activities like having the IDE open, turning on the PC, passive discussions, breaks, random thoughts, meetings not directly problem-solving, waiting for compilation, or making this video do not count.

    

• Exceptions to the rules (educational content) [0:13:17]
  • Up to 30 minutes of educational entertainment about programming.
  • Audiobooks of programming material already studied, if actively coding for 4 hours the previous day.
  • Minor distractions are allowed to avoid constantly stopping and starting the timer.
  • Using AI for code assistance never counts.
• Tracking tools: ToggleTrack and Google Spreadsheet [0:13:45]
  • He uses ToggleTrack, a free online timer and phone app, to log daily programming hours.
  • Daily totals are then transferred to a Google Excel spreadsheet to track progress over time.
  • A template of his spreadsheet is provided in the video description for others to use.

Daily Practice Methodology [0:14:45]

• Two main goals: better programmer, making a game [0:14:47]
  • These goals guide his daily activities and decision-making.
• Morning routine: revision using Obsidian [0:14:58]
  • He starts his day with revision, especially for concepts studied the day prior, using the note-taking app Obsidian.
  • He uses a Git-synced setup for Obsidian, as described by "Odysseus" on YouTube.
  • Revision is done by navigating index pages or using Obsidian's node network.

    

• Active learning: reading, watching, note-taking in own words [0:15:36]
  • When studying (books, articles, videos), he takes notes in Obsidian.
  • The key is to rephrase information in his own words to facilitate deep learning through active thinking and translation.
• The value of slow, deep learning over speed [0:16:01]
  • This note-taking method is slower than passive consumption but ensures better retention, making it faster in the long run as he rarely needs to revisit the original resource.
• Average daily practice and consistency [0:16:17]
  • He averages 4 hours and 25 minutes of deliberate practice daily.
  • Consistency is vital; he strives to avoid missing days and has maintained a perfect record this year, even if only for a few minutes on some days.

Conclusion and Encouragement [0:16:36]

• Programming is all about practice [0:16:40]
  • The core message is that becoming an expert programmer boils down to consistent, deliberate practice.
• Roadmap and resources for C++, Vulkan, graphics, game development [0:16:45]
  • A basic roadmap and resources for learning C++, Vulkan, graphics programming, and game development are provided in the video description and his Discord.
• Belief in everyone's potential to become an expert [0:17:04]
  • The speaker expresses strong belief that anyone can become an expert; the primary barrier is a lack of sustained effort.