Being a karate freshman can be a little unnerving for some. Many people won’t know anyone, except maybe the person who invited them to attend, and many will be skeptical about the class. Still others will be flattened by the initial cognitive (and physiological) steam-roller. This last part is the most daunting and the one which the instructor has most control over.
For a while now I’ve been part of the debate on how to teach beginners in many fields, not just karate. I teach a computer science course to non-computer science majors and have been a teaching assistant in CS courses at the first year major every level. In this field, there’s been some contention on the topic of how to approach teaching the beginning material. Do you:
- give them a whole bunch of tools and later show how they work “under the hood”, or
- teach the simplest, seemingly indivisible elements first and build up to the more complex elements later
The first of these two is known in the computer science and psychology fields (et al.) as a “Top-Down” approach, while the second is described as a “Bottom-Up” approach. I want to talk about both and how these relate to teaching beginner karate students.
The Top-Down Approach
The best way I think to understand this and the following concept is by visualizing it as an upside-down tree. We teach a karate element, get the students to replicate it a couple hundred times, and then proceed to show them how to improve it by refining the smaller parts that make up the larger part.
In computer science I’ve come across this approach in teaching first year students the principles of programming and of computers. A top-down approach here is done by first showing how to, for example, build an array of data, traverse the array, and make sure you don’t go off the ends. What happens when you go off the ends of an array? Well, to the first year student we’d have to get into how the array is organized into a sequence of consecutive data sectors on disk. This requires a whole bunch more explanation. In short, we say “oh, don’t worry about that now, you’ll learn that next year”. In this way, we can achieve high level goals quickly but students don’t really understand the fundamentals.
In karate, this is likened to teaching heian shodan before the student knows why or how to place the elbow during a rising-block correctly. Sure, the student can make it through the kata, but they don’t understand the underlying parts.
Top-down approach: start with heian shodan motions, then iteratively refine
The Bottom-Up Approach
In computer science, a bottom-up approach starts by teaching the student how voltages and resistors encode the 1’s and 0’s we all know and love, how the 1’s and 0’s make up larger numbers, how these numbers encode letters, words, and colors, and how pixels are colored in a screen and words compiled as a program syntax to write more complicated programs.
Karate can be learned using this approach too. We can teach the student how bends in the leg and alignment of muscles and joints makes for a strong block or punch and we can demonstrate how squaring shoulders fundamentally lends to rigorous body structured needed to execute a great punch. Later, we use these things in combination to build a great technique and use the techniques to form great kata and kumite, winning tournaments and whatnot.
Advantages and Disadvantages
Neither of these approaches is a catch-all solution. This is why its been such a contentious issue in Computer Science education. The reasons against the bottom-up approach are the same in bth CS and karate, I think.
Boredom. From an instructors point-of-view, teaching the minute details of a perfect technique is exciting. This is where the beauty of the art lies. The true secrets and advancements are hidden in the finest underlying principles. The problem is, students without all the knowledge of the instructor cannot see the light at the end of the tunnel. They get bogged down with little details and cannot really master them since they don’t get to see the end result. A goal isn’t set for them. So teaching only the finer points of a perfect age-uke does’t get us far.
With a top down approach, the reasons may differ more; at least from an initial observation. In CS, I’ve been against a strict top-down approach since students do (very often!) get accustomed to having the details hidden from them. They achieve high level goals without needing to know where the memory is being used, the degree of segmentation, input/output access patterns and deadlocks, etc. When a requirement comes their way that forces them to look under the hood, they’re lost and can’t explain what’s going on. Too often I’ve seen people learn Java as their first language and then have a world of difficulty learning Cand managing pointers, data, etc. Those that start with C as a first language more often than not learn Java very quickly.
I’m not sure this problem exists as much in karate. I think that’s because we acutally don’t use a strict top-down approach, but a more complex approach I’m going to call: “An Opportunistic Top-down and Bottom-Up Iterative Approach”. That’s a huge beast on it own which I’ll leave for next time.