Vox

Leitura de 11 min

15: Code Kata - A Practice Arena for Becoming a Better Programmer

Summary

This episode introduces the concept of Code Kata, a practice methodology for programmers popularized by Dave Thomas. The host, Jonathan Cottrell, explains that Kata involves solving predetermined coding problems not to find new solutions, but to create a dedicated practice arena for improving programming skills. He draws parallels to musicians practicing scales or athletes training, emphasizing that the goal is to become a better problem solver, not to solve the specific problem at hand.

The discussion explores the value of Kata as a low-stress, exploratory space for learning new programming languages, algorithms, or paradigms. It allows developers to focus on the process of writing code—syntax, algorithmic thinking, and translation of ideas—without the pressure of delivering a production solution. This intentional practice is contrasted with the common tendency to learn and practice exclusively through high-stakes project work.

A critical point is made about the potential pitfall of applying a ‘Kata mindset’ to real project work. The host warns against the common habit of developers rewriting the same solutions (like sliders, carousels, or API calls) for different projects, arguing that this repetitive coding doesn’t constitute learning or improvement. True Kata practice is an intentional, protected activity aimed at skill development, distinct from passively rewriting familiar code.

The episode concludes by reinforcing the core philosophy: Code Kata is about the journey of becoming a better programmer, not the destination of solving a known problem. It’s a tool for deliberate skill enhancement, providing a space to experiment and learn that is separate from the demands of delivering working software.

Recommendations

Concepts

  • Code Kata — A practice concept founded by Dave Thomas, involving solving predetermined coding problems not to find new solutions, but to create a dedicated arena for improving programming skills and becoming a better problem solver.

People

  • Dave Thomas — Cited as the founder of the Code Kata concept. He uses metaphors from music and sports to explain why deliberate practice is essential for programmers, just as it is for other skilled professions.

Topic Timeline

  • 00:00:00 — Introduction to Code Kata and its pronunciation — Jonathan Cottrell introduces the episode’s topic: Code Kata. He mentions the difficulty of pronouncing ‘Kata’ and decides to refer to it as ‘code practice’ for clarity. He attributes the concept’s founding to Dave Thomas.
  • 00:00:40 — The analogy of practice in music and sports — The host explains Dave Thomas’s analogy comparing code practice to a musician practicing theory or young athletes needing experience before facing a professional team. The core idea is that skill development requires dedicated, repetitive practice outside of high-pressure performance situations.
  • 00:01:26 — Defining what Code Kata is — Kata is defined as a set of predetermined coding problems with relatively prescriptive solutions. Different types of Kata exist, some focusing on runtime optimization, others on implementing functions without using certain language constructs, like re-implementing a constructor in JavaScript.
  • 00:02:36 — The programmer’s addiction to problem-solving — Cottrell discusses how programmers get a ‘high’ from solving problems, which is generally positive. However, he expresses being ‘torn’ on Kata, questioning the value of rewriting solutions to problems that already exist, as it doesn’t seem to provide value or better the world.
  • 00:03:26 — The true goal of Kata: creating a better programmer — The host clarifies the fundamental purpose of Kata. It is not about the thrill of solving the problem or the end solution itself. Instead, the goal is to use these practice problems as an arena to turn oneself into a better problem solver and programmer.
  • 00:04:21 — The need for a dedicated, exploratory learning space — The episode argues that learning is exploratory and often stifled when we ‘practice on the job’ due to high stress and constraints. Kata provides a protected space dedicated to learning, where the developer knows both the problem and the solution and can focus on exploring different paths between them.
  • 00:04:54 — Using Kata to learn new languages and paradigms — Kata is presented as a fantastic method for learning a new programming language. Since solving the problem isn’t the point, the learner can focus entirely on the mechanics of writing code—syntax, translating solutions into a new paradigm, or thinking about algorithms—without the pressure of invention.
  • 00:06:04 — The danger of bringing the Kata mindset to project work — A key warning is issued: the ‘Kata mindset’ can be detrimental if brought into real project work. The host gives examples like repeatedly writing the same slider, carousel, WordPress loop, or AJAX call. Rewriting the same code to accomplish real goals is not learning; it’s just repetition that doesn’t make you a better programmer.
  • 00:07:07 — Kata as intentional vs. passive practice — The episode concludes the main discussion by contrasting intentional Kata practice with passive code rewriting. Engaging in Kata is a conscious choice to get better in a protected space, unlike the unconscious, repetitive rewriting of the same solutions in different projects, which offers no developmental value.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2015-02-06T13:20:00Z
  • Duration: 00:08:15

References

Podcast Info

Transcript

[00:00:00] Hello everyone, and welcome to this episode of Developer Team.

[00:00:04] My name is Jonathan Cottrell, and today we’re going to be talking about code Kata.

[00:00:08] You know, Kata is a very difficult word to pronounce.

[00:00:15] I didn’t know how hard it was to pronounce until I tried to re-record the intro to

[00:00:21] this episode like five or six different times.

[00:00:24] So instead of calling it Kata for the sake of not mispronouncing it, I’m going

[00:00:29] to call it code practice, right?

[00:00:34] Because I think that’s the better descriptor for it anyway.

[00:00:40] Dave Thomas is the founder of this concept, code Kata, code practicing, and basically

[00:00:47] what Dave says about practicing code is that it’s kind of like being a musician, right?

[00:00:55] Being good at being a musician requires that you sit down and you practice theory over

[00:01:01] and over and over.

[00:01:03] He makes a sports metaphor and says that you don’t tell a bunch of young athletes

[00:01:08] that they have four quarters to beat the Redskins.

[00:01:12] And obviously that would be insane.

[00:01:17] That would be out of bounds.

[00:01:19] They wouldn’t be able to do that because they don’t have the experience necessary

[00:01:24] in order to do that.

[00:01:26] So if you aren’t familiar with what Kata is, it’s basically a set of predetermined

[00:01:34] problems and you approach these problems in code and you write whatever code is

[00:01:41] necessary in order to solve those problems.

[00:01:44] And usually they have relatively prescriptive solutions that you can look up and determine

[00:01:51] whether or not the code that you wrote is adequate.

[00:01:54] Now there’s a lot of different types of Kata.

[00:01:57] Some of them require a certain run time, for instance.

[00:02:02] Some of them require that you optimize your code so that it runs very quickly.

[00:02:07] Some of them require that you write the code without using particular constructs.

[00:02:13] Like for instance, they’ll require that you re-implement particular functions of a

[00:02:21] given language.

[00:02:21] So in JavaScript you might would re-implement a constructor function or scoping.

[00:02:29] Kata is, I think, I’m a little torn on Kata and here’s why.

[00:02:36] I believe that we as programmers are kind of addicted to problem solving.

[00:02:42] We get a high when we write code that solves a particular problem, which is

[00:02:50] relatively a good thing, right?

[00:02:52] We enjoy writing things that are useful.

[00:02:55] We enjoy writing things that are accurate, that provide a result that we were looking

[00:03:00] for, and we should.

[00:03:01] We should enjoy writing those things.

[00:03:03] However, when we get so addicted to problems that we start looking for problems that

[00:03:09] already have solutions and we rewrite those solutions over and over, we aren’t

[00:03:14] really providing ourselves any value, right?

[00:03:18] The solution already exists, so what are we doing to better the world by rewriting

[00:03:24] the same solution over and over?

[00:03:26] Well, I think Dave Thomas would say that Kata, the goal of Kata is not to solve

[00:03:34] a problem, it is to create a better programmer.

[00:03:39] So let me say that again.

[00:03:41] The goal of Kata is not to give you the high of solving a problem, it’s not

[00:03:47] to accomplish the goal of solving that particular problem.

[00:03:52] Instead, it is specifically intended to give you a practice arena to turn you into a

[00:04:00] better problem solver.

[00:04:03] Now that is a fundamentally important concept for any line of work, but as Dave says,

[00:04:11] it’s difficult to see that at play for programmers.

[00:04:15] We often learn on the job, we often practice on the job, which is very high stress and

[00:04:21] a lot of the time when we practice on the job, we unfortunately, we can’t explore,

[00:04:28] and learning is an exploratory practice.

[00:04:32] And actually having a space that is dedicated to learning, actually having the space

[00:04:38] to say, I know what the solution is, and I know what the starting point of the

[00:04:43] problem is, now let me learn about different ways to go from the beginning of the problem

[00:04:52] to the solution.

[00:04:54] For example, Kata is a fantastic way to learn a new programming language, because

[00:05:01] you don’t have to, you don’t have to really solve the problem, right?

[00:05:07] That’s not the point.

[00:05:08] The point is not how do you solve this problem.

[00:05:10] The point is how do you write the code?

[00:05:13] And that ultimately is the thing that you are practicing.

[00:05:16] You’re practicing sitting down, and whether it’s syntax, or if it’s thinking about

[00:05:24] a particular algorithm, or maybe it’s just simply translating what you have already

[00:05:30] created as the solution in your mind into a new paradigm.

[00:05:36] All of these particular aspects of Kata are valuable, and they do provide value to you.

[00:05:47] They are not intended to solve those problems.

[00:05:50] Now that seems obvious, right?

[00:05:52] It seems like that’s the obvious truth.

[00:05:56] However, I would argue that a lot of us end up bringing over the Kata mindset

[00:06:04] into our project work, and that’s where we go wrong.

[00:06:07] That’s kind of the secret, right?

[00:06:10] That is where we need to pump the brakes and say, wait a second, do we already have

[00:06:15] a solution to this problem?

[00:06:18] For instance, how many times, if you’re a web developer, how many times have you

[00:06:22] caught yourself writing the same slider, the same carousel, if you’re familiar with

[00:06:30] carousels?

[00:06:33] How many times have you written that same code?

[00:06:35] How many times have you written that same WordPress loop, or that same particular chunk

[00:06:41] of HTML, or that same Ajax call?

[00:06:45] How many times do you rewrite the same code to accomplish a real goal?

[00:06:50] Because truthfully, you aren’t learning from that.

[00:06:53] You aren’t becoming a better programmer by rewriting the same things the same ways.

[00:06:59] When you choose to engage in practicing programming through Kata, it is a protected space where

[00:07:07] you’re intentionally trying to get better, not passively rewriting the same code over

[00:07:13] and over and over.

[00:07:16] I hope you’ve enjoyed this discussion on Code Kata.

[00:07:20] If you are enjoying this show, please drop into iTunes and leave a rating and review.

[00:07:27] This is the most important thing to help other people find the show.

[00:07:32] iTunes uses these ratings and reviews to actually sort the shows and to promote them,

[00:07:38] so if you leave a rating and review, it helps us out tremendously.

[00:07:46] If you have any comments, if you have questions, if you just want to talk, or maybe you

[00:07:50] even want to be on the show with me, you can get at me on Twitter at developerT,

[00:07:56] or you can email me at developerT at gmail.com.

[00:07:59] You can also go to developerT.com where you’ll find a contact link in the header.

[00:08:06] Until next time, enjoy your tea.

Visão de gráfico