On Teaching, Learning, and Being Honest With Ourselves

Preamble: I’m not an expert teacher or mentor. I practice all the time to get better. Much of what you are about to read comes from personal failings in this arena, as recently as a week ago. This is an open letter to all who would teach.

I’ve been seeing this sentiment going around in various forms, and it’s troubling me. Somehow we’ve gotten it in our heads that it’s not okay to accept the fact that people are not all at the same level of knowledge and ability. Somewhere along the way it became taboo to talk about people being elite, and people being beginners, and that it was imperative to teach and mentor and task people in a manner appropriate to their level. Somewhere along the way it became not only acceptable but encouraged for anyone to go forth, call himself an expert, and attempt to teach a crowd.

Let me disabuse you of some notions you may have gathered from blogs and mailing lists: people *are* at different levels. There are people that are smarter than you, and me, and everyone else. There are people that are more adept with a particular technical skill. There are beginners. There *is* such a thing as a junior developer, and he does a different job than a senior developer. All of these statements reflect the natural order of things. We are not all the same. That’s a good thing, and if you think it’s not, you are naïve.

Treating and tasking a junior developer the same as a senior is detrimental to productivity and detrimental to the growth of that developer. A novice is a novice no matter how you choose to describe it, and what a novice can do is vastly different than what an expert can do.

Teaching and the Dreyfus Model

If you are unfamiliar with the Dreyfus Model of Skills Acquisition, take a second to go read up on it real quick and then come back.

Ok, now we have a model (and programmers love models) for what each stage of learning looks like. Keep in mind the Dreyfus Model applies atomically to a given skill. You can be an expert in C# and a novice in Ruby. This resonates with everyone right? Ok so stop trying to put everyone in the proficient stage of every skill. It’s not reality. We all fall into different buckets of the Dreyfus Model for every single skill that we practice and we only advance from one to the next linearly. You can’t make a beginner skip steps by pairing him with an expert, and you certainly can’t make him skip steps by forcing expert-level work on him. Beginners need rules and boundaries. They need clearly defined tasks and clear context (in such case as they even care about context, which they typically don’t). Think of Iron Chef vs the line cook at your local chain eatery. The latter needs explicit recipes to make standardized food. The former needs only a table full of random ingredients to create something amazing.

This leads into three discussions: first – not everything can be taught to “beginners” and targeting the “beginner” is a farce. Second – when you attempt to teach, you must properly identify your target audience on the Dreyfus Model and set expectations accordingly. Finally – not everyone is cut out to teach.

Let’s deal with the last one first because it’s the one that will make the most people stop reading, so I want to save you some time. The old saying “those who can, do. Those who can’t, teach” is ingrained with a kernel of truth (no offense to teachers, for whom I have the utmost respect). Remember that the Dreyfus Model is atomic per skill. Teaching a given skill is a skill. If you rank as proficient or better with say, C#, you can talk about it with authority sure, but you do not automatically gain the skill of being able to teach your fellow man. Teaching is not telling. Teaching is a vast array of skills related to communications, psychology, sociology, and technical proficiency with the subject matter. Some would say that at certain levels you can teach a subject without “expert” skill in said subject, as long as you have high skill levels in the other aspects of teaching. I can buy into that, because it’s a bleak world indeed where only experts in a subject can teach it.

Bottom lining it for you – not everyone is cut out to teach. Sorry. If you have a strong desire to be a teacher then don’t worry, because you can practice and gain the skills required (I believe Malcolm Gladwell talks a lot about gaining expertise through practice rather than innate ability in his new book Outliers, which I have not yet read but it is in my near future based on friends’ recommendations). But if you go about teaching with the outlook that simply being proficient in a subject makes you qualified to be a teacher, then you are doing a disservice to those you wish to teach. (And replace “teach” with “mentor” or any other such verb at your leisure, dear reader)

Secondly – Define your audience appropriately and set the appropriate expectations. If you wish to teach something to “beginners”, first define “beginner” in what skill. Most tech books do a pretty decent job of this, particularly the O’Reilly Head-First Series, which explicitly lists in the beginning of each book what you will and won’t get from this if you are at a given level. This is called managing expectations, and it’s important both for the teacher and the student. I recently did a full day workshop on TDD aimed at “beginners” and learned this lesson the hard way. Beginner casts a very wide net when both parties’ expectations aren’t managed appropriately, and you spend much of your time either derailing the subject with questions you assumed were already known, or alienating people because you aren’t answering questions that they came to the table with. We came to the table with a set of stories around website registration, just registration, what we thought was a very small problem domain. In the course of the day we implemented the code for 1 story. The rest of the time was spent explaining concepts that we wrongly assumed were in play, like SOLID principles (among other things). And the vastly different levels of each of the 80 or so attendees meant that we felt the need to get to the lowest common denominator with everything. This means that the smallest subset of the audience was served well, and the rest, while they probably got some value from the event, left having not had their expectations met.

Thirdly – “Beginner” may not be a good audience for some concepts that you intend to teach. Again, look to the Dreyfus Model and ask yourself: “Am I able to sum this up into essentially recipes and step-by-step instructions with defined rules?” If the answer is “no”, then “beginner” is not your audience, and you will leave them confused. Looking back to some of the feedback we got from the TDD Firestarter event, this was the case for a lot of people. Presenting TDD/BDD with a lot of “it depends on context” type guidance is not appropriate for beginners. We did those people a disservice and probably confused them to the point where they aren’t going to be testing as a rule any time soon. This is obviously counterproductive in terms of the goal of the event. We even had reports of people being disappointed that our samples were in nUnit rather than MSTest because it didn’t occur to us that an actual beginner may not be able to convert one type of sample to another just based on attribute names. These are the kinds of things that you run into when targeting “beginners” for teaching, and you need to be both aware of them and willing to overcome them if you intend to teach to this group.

Accepting Some Realities

If I had one point to drive home to aspiring teachers of technology it’s: “don’t mismanage your own expectations”. You must understand your audience and the level at which you really intend to teach in order to be successful. And you must understand whether or not you have the requisite skill level to teach that subject matter at that level. I don’t mean at all to discourage budding mentors and teachers, I just want to give you the straight story so that you can more effectively put yourself in that role and not come away disappointed and not leave your students bewildered.

On to the labeling issue. Some people are beginners. Some are experts. It’s okay to call them that. Because it’s honest. I heard recently in a mailing list discussion that some people may take umbrage to being labeled as a beginner. That’s unfortunate but true. However, my experience has been that those people haven’t set their expectations and egos to the level appropriate for being a student. In other words, some people don’t want to be taught, so don’t bother until they are ready, and you will save yourself a lot of stress.

Finally, teaching is a huge burden to bear, and you need to understand this before you take on the responsibility. I know the draw of doing a codecamp talk every other month is a big one, maybe you’ll get some micro-celebrity, maybe you’ll get an MVP award, but you can’t be a hit-and-run guy and be a teacher. I’m not saying don’t do codecamps, because you should, but I’m saying accept the responsibility of the role and tailor your message to the format and the audience. Don’t go to a 1 hour codecamp talk with the intention of teaching TDD+SOLID+IOC+MVC+whatever else. It’s not reality and you won’t be giving your audience anything they can build on. Anyone that can glean a ton of value from a talk that big and that short can get that same value from a blog post. Don’t try to be a hero, don’t try to be sexy, just be honest, teach within your capabilities, and manage expectations appropriately on both sides. Teaching is a rewarding practice, but it takes effort, and you should strive to improve in the teaching skill as relentlessly as you strive to improve your technical skills if you truly want to be a teacher.

One final thought – I know *truly* beginner-level 101 courses and talks aren’t sexy and won’t get you the notoriety, but there is a need for them. Do them. All boats rise with the tide but the water level is lower than we think sometimes. Let’s work together to bring up the baseline.