What's About to Happen
We know as much about
how learning works
as we do about public health
- Most people in higher education don't even know this knowledge exists
- A few key ideas can make lessons significantly more effective
Having crammed a dozen books into a two-day course,
we will now try to cram that course into half an hour
and others studied how nurses become more proficient
- Work replicated in many other domains
- (Fairly) predictable series of cognitive transitions
- People don't just know more
- They think differently
- We will simplify to three stages:
Characteristics of Novices
- Ask questions that don't make sense
- Do things by rote
- No understanding cause and effect
- Rely on analogies with other domains
- Use incorrect language or use language incorrectly
- Often over-confident (Dunning-Kruger Effect)
- Don't know what or how much they don't know
- Novices don't yet have a usable mental model of the domain
- Models don't have to be complete or accurate to be useful
- Atoms are colored balls connected by springs
- Atoms are little solar systems with electrons orbiting a nucleus
- A computer has a CPU, memory, and a hard drive
What Novices Need
- Your goal when teaching novices is not to give them lots of information
- Because they don't yet have somewhere to put it
- Your goal is to help them build a usable mental model
- Never hesitate to sacrifice truth for clarity
- Software Carpentry's introduction to Unix only teaches 15 commands in 3 hours
- But it also teaches:
- Command-line arguments
- Without that mental model, the manual doesn't make sense
How to Help Novices
- The key to helping novices build mental models is to diagnose misconceptions
|What is 37 + 15?
||Threw away the '1'
||Treated each sub-problem independently
||Carried the '1' back into the same column
- Each misunderstanding needs a different corrective explanation
You Need a Model of Their Model
You can only create effective diagnostic exercises
if you understand your learners' mental models and misconceptions
Once you do,
you will automatically create lessons that forestall and correct misconceptions
You should be able to explain what misconception each of your expected wrong answers is checking for
Interlude: What We Don't Have (Yet)
- All teaching involves:
- Domain knowledge
- General teaching knowledge
Pedagogical content knowledge (PCK):
how best to teach this topic to this audience
- We're just starting to catalog PCK for programming
Meta: What We Just Did
- Started building your mental model of learning
- Motivated you by using an authentic task as an example
- Gave you a short break so you can clear your head for the next section
Characteristics of Experts
- Solve common problems "instantly"
- Able to solve unusual problems as well
- Able to reason backward from effect to cause (diagnosis)
- Sometimes unable to explain their reasoning
- Often mis-use words like "simple" or "obvious"
A Useful Lie
- Knowledge isn't stored as a graph, but it's a useful metaphor
- Expert's graph isn't just larger: it's also much more densely connected
- Experts take one step where the "merely competent" have to search
- A picture of someone's mental model
- Important to emphasize the connections just as much as the concepts
- Knowledge that cannot be retrieved cannot be used
How Memory Works
- Sensory memory: 1-2 seconds
- Short-term memory: 7±2 items for 10-15 seconds
- Long-term memory: permanent storage
- New information goes into short-term memory
- Learning only takes place if it's transferred to long-term memory
How Big Should a Lesson Be?
If we give learners too much too fast,
it spills out of short-term memory and nothing is remembered
So count the nodes and edges in the concept map
- Each learning episode should be half a dozen items
Immediately reinforced to keep them in short-term memory long enough to be transferred
Different parts of problem solving compete for processing time
- Good lessons let learners concentrate on one aspect of a problem at a time
- Example: Parsons Problems
- Rearrange jumbled lines of code to solve a problem
- Allows learner to concentrate on data flow
- A succession of closely-related problems
- Each gives the learner less scaffolding
- Parts that are removed are closely related
- Learners can focus on one aspect of the problem at a time
- And learn the underlying pattern by example
Fully Worked Example
# ["red", "green", "blue"] => 12
total = 0
for word in words:
total += len(word)
- Go through this line by line
# word_lengths(["red", "green", "blue"]) => [3, 5, 4]
list_of_lengths = 
for each ____ in ____:
- Directs attention to control flow
# join_all(["red", "green", "blue"]) => "redgreenblue"
joined_words = ____
for each ____ in ____:
- Directs attention to initialization and update
# ["red", "green", "blue"] => "RGB"
- By now the pattern has been internalized
- And learners have done more work in less time
Items that frequently occur together are stored in chunks
that only take up one slot in short-term memory
- The digits in frequently-used phone numbers
- Common chord progressions
- Chunking lets us work with larger information sets
- At the risk of mis-categorizing items
- Good libraries turn chunks into components
- Good lessons give chunks names
Systematic Lesson Design
Use the ideas we have seen so far as the basis for a repeatable lesson design process
Sequential description is easiest for the next person to understand
Always iterative in practice
1) Who is this lesson for?
- "Beginner" and "expert" mean different things to different people
Use learner personas to define who you are helping
and what they think they will get out of the lesson
- Deliver: brief summaries of who your lesson will help and how
Example Persona: Jorge
- Just moved to Canada from Costa Rica to study agriculture.
- Can read English well, but still struggles sometimes to keep up with spoken conversation.
- Has used Excel and Word, and done a little editing on a WordPress site.
- Is measuring soil properties a nearby farms with a handheld device that dumps CSV files to his computer.
- Currently processes each file in Excel by hand, would like to automate the steps.
- What problems will learners solve?
- What concepts and techniques will they learn?
- What tools and/or data will they use?
- What terms or jargon will you define?
- What analogies or heuristics will you use?
- What mistakes or misconceptions do you expect?
- Don't need to answer every question
- May pose and answer others
- Deliver: rough scope for the lesson
3) What will learners do?
- Best way to specify content is to design exercises
- More concrete than "explain residual calculation"
- Helps uncover dependencies and technical requirements
Each exercise should be:
- One or two bullet points to explain its purpose
- Fully worked out code or solution
- An estimate of how long it will take to introduce, do, and review
The teaching equivalent of
- Deliver: 3-4 exercises per hour of student time
4) How are concepts connected?
- Put exercises in logical order
- Derive lesson outline from them
- Make notes about the gaps you've just noticed…
- …and add exercises for those gaps…
- …and start cutting content
- Deliver: lesson outline (10-12 bullet points per hour)
Problem, Explanation, Theory, Example
- Describe the problem the lesson will solve
- Work through a solution to that problem
- Explain the general theory that underpins that solution
- Work through a second example so that learners will understand which parts generalize
Interlude: And Others
- PRIMM: Predict, Run, Investigate, Modify, Make
- ADEPT: Analogy, Diagram, Example, Plain English, Technical definition
- CRA: Concrete - Representational - Abstract
- Challenge & Response
The twelve-bar blues of teaching
5) How is the lesson described?
- Summarize everything you have created from the learner's point of view
- A one-paragraph description
- Half a dozen learning objectives
- A summary of prerequisites
- Deliver: all of the above
Break any of these rules sooner than say
anything outright barbarous.
– George Orwell