Slides from Keith Ray's talk on "How do we teach TDD? Considering the Dreyfus Model of Learning" Presented at SFPSD Monthly Meetup, 2011-03-29

1. How Do We Teach TDD?
Considering the Dreyfus
Model of Learning
C. Keith Ray
Coach, Trainer, Developer at Industrial Logic, Inc.
keith@industriallogic.com twitter: @ckeithray
http://industriallogic.com

2. What's TDD?
TDD is Test-Driven Development. The simple
description of TDD is:
Red-Green-Refactor-Repeat: write a test that
fails (red), write just enough code to make it pass
(green), then refactor to a good design (aka
"simple code"), and repeat.

3. Dreyfus Model
Dreyfus came up with a model of learning. He
named five levels:
Novice
Advanced Beginner
Competent
Proficient
Expert
See http://en.wikipedia.org/wiki/Dreyfus_model_of_skill_acquisition

4. Novice
Completely new to the thing to be learned.
Wants recipes, rules, constraints
They don't know what "good" look likes yet, so
they want fast feedback.
Craves rules.

5. Advanced beginner
Knows the rules, but not all the contexts for
them, knows just enough to be "dangerous."
As a software developer, probably writing "big
balls of mud".
Better to have them learning in a safe
environment to learn from their mistakes.
5

6. Competent
Can do a task without needing instructions.
Identifies patterns and uses them, mostly in
appropriate contexts.
May be offended if you treat them like a Novice
or Advanced Beginner.

7. Proficient
Good, but now trying to become expert.
Lots of experience / practice.
Knows how to do stuff, but can't tell people how
to do it.
(Teaching has its own Novice to Expert levels)

8. Expert
Beyond rules.
Working on instinct.
Needs to compare notes with other experts.
Arguing about their subject refines their
understanding of it.

9. TDD seems so simple, so why
is it hard to teach?
Teacher: it's red, green, refactor, repeat.
<long time later>
Student: ok, here's all my tests!
Teacher: where's the code?
Student: I haven't written it yet.
Teacher:
Photo by striatic

10. TDD seems so simple, so why
is it hard to teach?
Teacher: it's red, green, refactor, repeat.
<long time later>
Student: here's my first test. [400 lines of code
in a single test.]
Photo by Marcin Wichary

11. TDD seems so simple, so why
is it hard to teach?
Teacher: it's red, green, refactor, repeat.
Student: <Doesn't understand why the test
should fail before it is made to pass, so writes
code and tests so that the tests usually pass the
first time they are run.>
oops

12. TDD seems so simple, so why
is it hard to teach?
Teacher: it's red, green, refactor, repeat.
Student: here's my tests and code.
Teacher: nice, but you've got a very large class, with a
very large method, and all
your tests are repeating lots
of code. Did you refactor?
Student: I thought we'd
refactor next month!

13. TDD seems so simple, so why
is it hard to teach?
Because each of the steps of TDD require skills
in three main areas:
Writing tests.
Writing simple code.
Refactoring.

14. There's more,
Refactoring Requires:
Recognizing symptoms of bad
design (code smells).
Making small transformations to
improve the design. (The actual
Refactorings.)
Recognizing good design (aka
"Simple Code")

15. "Simple Design"
Kent Beck's rules for simple design were:
1. Runs all the tests.
2.No duplication.
3. Expresses the developer's
intentions.
4.Minimizes the number of classes
and methods.
Photo by GN

16. Getting back to Dreyfus...
We teach using web-base materials in live
training and via coaching.
Our web-based materials assume the student is
in the Novice stage of learning about TDD.
We also assume the student is at least in the
Competent stage as a programmer.
We encourage pairing of students — it makes a
large improvement in learning.

17. What Novices Want
A "novice" is completely new to a
subject.
They want rules, recipes,
formulas, step-by-step
how-to-do-it.
They don't know enough to
judge their own results, so
they need fast, frequent
feedback by coach or trainer.
Photo by Steve Snodgrass

18. Breaking TDD
Skill-Sets into
Novice-sized
Pieces

19. Demo Video
Videos are usually short (around 5 minutes) and
demonstrate a technique or make a point.

20. Demo Quizzes
We have a variety of quiz types. Students can
comment on quiz answers or post questions and get a
prompt response from Industrial Logic staff.

21. Demo: Exercises
TDDing Big Bill's
Billing System
Task 1: Calculate A Simple Phone Bill
Task 2: Calculate Excess Minutes
Task 3: etc.
Student writes the code, compares it with
solution(s).
Almost all solutions are demonstrated in
video form and downloadable code.

22. Demo: Critiques
Your score was 62% based on
our Automated Critique.
This ranks you as Intermediate.
A Graph of Your TDD Activity
See several
examples here.

23. Conclusion
Our web-based training with critiques provides
feedback that Novices and Advanced Beginners
need, and which would otherwise require one-to-one
coaching. This works for our live training as well as
purely web-based training.
Try it out: http://elearning.industriallogic.com
(PS: Competent, Proficient, and TDD Experts should try Sessions.)
See also Dan North appling the Dreyfus model to a more general level of
"best practices": http://www.infoq.com/articles/better-best-practices