The Best Code Katas For Ambitious Software Developers

YouTube Video

Summary

This YouTube transcript, featuring Emily B from the “Modern Software Engineering Channel,” discusses the importance of code katas for improving programming habits and becoming a great programmer. The video is inspired by Kent Beck’s quote about being a “good programmer with great habits,” emphasizing that consistent good practices, especially under stress, are key to true programming skill.

Emily explains that habits are crucial because they are the default behaviors we fall back on when mental energy is limited, such as when stressed or tired. Coding involves numerous small decisions, and habits shape these choices, directly impacting code quality.

Code katas are presented as a tool to cultivate these good habits. They are defined as simple, interesting problems designed to be solved repeatedly. The simplicity is deliberate, allowing programmers to focus on the process and their habits rather than being overwhelmed by complex problem-solving. This meta-level thinking about one’s workflow is the core benefit of katas.

The concept of code katas is attributed to Dave Thomas, one of the “Pragmatic Programmers” and a signatory of the Agile Manifesto. He drew inspiration from karate katas, where repetitive practice of moves builds muscle memory and ingrained technique. Similarly, code katas offer disciplined practice away from the pressures of production code.

Emily shares her personal experience, stating she has used code katas for over 20 years since she was a junior developer learning about unit testing and Test-Driven Development (TDD). She found studying and practicing katas, especially by looking at others’ solutions, significantly accelerated her skill development in code design and testing.

The video then moves into practical advice on choosing and utilizing code katas:

• Starting Point: For beginners, Emily recommends simple katas like “Leap Years” or “FizzBuzz,” available on the “saman Society website” (saman coaching.org). The focus at this stage is not on the complexity of the problem but on practicing TDD.
• Progressing Difficulty: Once comfortable with basic katas, she suggests moving to slightly more complex ones like “Tennis,” “Christmas Song,” or “File Name Range.” These involve more logic, sophisticated output, and require designing multiple functions, further exercising TDD skills. She even references a video on her other YouTube channel demonstrating the “Christmas Song” kata and TDD heuristics.
• More Challenging Katas: For a greater challenge, “Mars Rover,” “Yatzy,” “Fractions,” and “Monty Hall” are recommended. These require more code, structure, and offer fun, self-contained problems to be repeated with different designs and TDD approaches.
• Repetition is Key: The video stresses the importance of repeating katas to train habits. This repetition is likened to musicians practicing scales and etudes – not for performance in themselves, but to make the underlying skills smooth and automatic for actual performances (coding in production).

Beyond development skills, Emily highlights the value of code katas for collaborative skills like pair programming and ensemble programming. Using simple katas in these settings allows teams to focus on improving communication, role rotation, and overall collaboration dynamics, rather than being bogged down by domain complexity. She recommends starting with simpler katas like “Calc Stats” or “Shopping Basket” when focusing on collaborative practice.

Crucially, the video addresses when code katas are not helpful, specifically in the context of AI coding assistants like Copilot or ChatGPT. Using katas to learn AI assistant tools is deemed ineffective because these tools can solve katas instantly and perfectly, bypassing the step-by-step practice that katas are designed for. Furthermore, AI models are trained on publicly available code, including kata solutions, making them unnaturally proficient in these specific scenarios. Emily advises against using katas to evaluate AI tool capabilities or prompt engineering skills in this context. Instead, she recommends turning off AI assistants during kata practice to focus on developing fundamental habits with “old-fashioned deterministic tools.”

The video concludes by suggesting that the habits developed through katas will actually enhance the effectiveness of AI assistants in production code. By working in small steps, using TDD, and breaking down problems, developers will be better positioned to leverage AI tools to solve smaller, well-defined sub-problems, leading to a more efficient and beneficial workflow with AI.

Finally, Emily mentions a free guide to code katas for TDD and encourages viewers to try katas, visit the saman Society website for resources, and consider supporting her channel and the saman Society through Patreon. She reiterates that repeating katas is generally beneficial, freeing up mental capacity to focus on improving the process of coding, unless boredom sets in, in which case there are many other katas to explore.

Accuracy

The information presented in the transcript is largely accurate and aligns with established knowledge and best practices in software development. Let’s break down the key assertions:

• Kent Beck’s quote and the importance of habits: The quote attributed to Kent Beck (“I’m not a great programmer, I’m just a good programmer with great habits”) is widely known and accurately reflects his philosophy and the importance of consistent, well-practiced habits in programming. The video correctly emphasizes that habits are what we default to under pressure, making them crucial for consistent code quality.
• Code Katas as a tool for habit formation: The explanation of code katas as a method for deliberate practice to improve programming habits is accurate and well-established within the software development community. The analogy to karate katas and musical scales is apt and effectively illustrates the purpose of repetitive practice.
• Dave Thomas’s origin of Code Katas: Attributing the idea of code katas to Dave Thomas of the “Pragmatic Programmers” is correct. He is indeed credited with popularizing the concept within software development, drawing inspiration from martial arts.
• Test-Driven Development (TDD) and Code Katas: The strong link between code katas and TDD is accurately presented. Katas are often framed as exercises to specifically practice and improve TDD skills. The examples provided (FizzBuzz, Leap Years, Tennis, etc.) are common katas frequently used for TDD practice.
• Benefits of Repetition and Focus on Process: The emphasis on repeating katas and focusing on the process of problem-solving rather than just the solution is a core principle of using katas effectively. This is consistent with deliberate practice theory.
• Code Katas for Collaborative Skills: The application of code katas to improve pair programming and ensemble programming skills is a valid and beneficial use case. Using simple problems to focus on team dynamics and communication is a recognized strategy.
• Limitations of Code Katas with AI Coding Assistants: The argument against using code katas to train or evaluate AI coding assistants is sound and well-reasoned. AI tools’ inherent capabilities and training data make katas an unsuitable benchmark for their real-world performance. The advice to turn off AI assistants during kata practice to focus on fundamental skill development is a pragmatic recommendation.
• AI Assistants and Habit-Driven Development: The idea that good programming habits (like TDD and small steps) enhance the effectiveness of AI assistants is a valid and forward-thinking perspective. It aligns with the understanding that AI tools are most effective when used within a structured and well-defined workflow.

Minor Nuances and Considerations:

• While the video accurately presents code katas as simple problems, “simple” is relative. Some katas, like “Mars Rover” or “Monty Hall,” can be conceptually simple in their requirements but might require more complex logic and data structures depending on the chosen implementation and TDD approach.
• The video focuses primarily on TDD as the habit to be developed. While TDD is a central and valuable practice, code katas can also be used to improve other habits, such as refactoring, clean coding, or specific design patterns. The video does mention refactoring katas briefly, suggesting future content on this.

Overall Accuracy: The information in the transcript is highly accurate, well-aligned with established software development practices and principles, and provides valuable insights into the effective use of code katas.

Resources

Here are the top 5 most relevant resources to learn more about the subjects presented in the transcript, focusing on code katas, TDD, and improving programming habits:

1. “The Pragmatic Programmer: Your Journey To Mastery, 20th Anniversary Edition” by Andrew Hunt and David Thomas: This book, co-authored by Dave Thomas, who is credited with popularizing code katas in software development, is a foundational text for software engineers. It covers a wide range of practical advice, including the importance of deliberate practice, learning habits, and the philosophy behind code katas. It provides a broader context for the ideas presented in the transcript and offers timeless wisdom for software craftsmanship.

   • Relevance: Directly connected to the origin of code katas and emphasizes the pragmatic approach to software development discussed in the video.
   • Why it’s helpful: Provides a comprehensive philosophy and practical guidance on becoming a better programmer, including the mindset and habits that code katas aim to cultivate.

2. “Test-Driven Development: By Example” by Kent Beck: Written by Kent Beck, whose quote is featured at the start of the video, this book is the definitive guide to Test-Driven Development. It uses practical examples in Java and Python to demonstrate the TDD cycle and its benefits. Understanding TDD is crucial for effectively utilizing code katas as discussed in the transcript.

   • Relevance: Focuses on Test-Driven Development, the primary practice that code katas are used to train according to the video.
   • Why it’s helpful: Provides a deep understanding of TDD principles and techniques, enabling readers to practice katas with a solid foundation in TDD methodology.

3. Saman Society Website (saman coaching.org): This website, mentioned directly in the transcript, is a valuable resource for code katas. It likely contains descriptions of katas like “Leap Years” and “FizzBuzz” mentioned in the video, and potentially more resources and articles related to code katas and TDD.

   • Relevance: Directly referenced in the video as a source for code kata descriptions and resources.
   • Why it’s helpful: Provides practical starting points for trying code katas, likely including kata descriptions, potential solutions, and community resources.

4. Coding Dojo Website (codingdojo.org): While not explicitly mentioned, Coding Dojo is a well-known platform that provides resources and practice for code katas, often framed within the context of TDD and agile practices. Their website likely contains kata descriptions, articles, and potentially online platforms for practicing katas.

   • Relevance: A popular platform dedicated to coding practice, including code katas and related software development skills.
   • Why it’s helpful: Offers a wide range of kata resources, potentially with varying difficulty levels and focuses, and may provide a community aspect for learning and sharing solutions.

5. Katacoda (now O’Reilly Interactive Learning - oreilly.com): Katacoda, now integrated into O’Reilly learning platform, provides interactive, browser-based coding environments for learning various technologies and practices, including code katas. They often have pre-configured environments for specific katas, making it easy to jump in and start practicing.

   • Relevance: Offers an interactive and hands-on approach to learning and practicing code katas.
   • Why it’s helpful: Provides a convenient and engaging way to practice katas directly in the browser, reducing setup time and allowing for immediate experimentation and learning.

These resources, in combination, offer a comprehensive pathway to learn more about code katas, understand the principles of TDD, and develop better programming habits, aligning perfectly with the themes and recommendations presented in the YouTube transcript.