Lesson design

This is a checklist and hints when designing and writing a new lesson. It is more actionable than Lesson philosophy. CodeRefinery can’t claim to reproduce all the other good material out there, but this short crash course for what we have seen.

This page doesn’t replace your own knowledge in doing the actual teaching part. Instead, the first half gives pointers on making sure your audience can connect to the material, and the last half gives hints to help you come up with good exercises and examples.

Backwards lesson design

Think test-driven development: decide what you want students to be able to do, design exercises to measure it, then fill in the gaps with teaching. You can see their summary. The steps are:

Brainstorm what you want to cover.
Create or reuse learner personas - understand who you want to teach. What do they care about? Perhaps as important is what they don’t care about: make sure that you don’t go too in depth too early and turn people off.
- We generally know we teach to early-career researchers, but at what level do they want to interact with the tools? How much time do they have? What do they not need to know?
Create some summative assessments, that show what learners should learn by the end. Try to connect these to the learner personas.
- In our case, we don’t give a final test, or even a final exercise to test knowledge.
- Instead, this is more like “something that learners can do themselves, in their work, shortly after the course”.
- Don’t be over-ambitious! When I (rkdarst) plan a lesson, I try to think of ~three points someone might remember, one or two might be an action and one or two might be knowledge of something they can learn later.
Create formative assessments (exercises) that let the learners practice what you want them to learn. See below for hints on coming up with good exercises. These should also connect to things the learners will actually do, but can also be more of checkpoints.
- Basically, interesting exercises at the end of or during each exercise. Think interactive but simple.
- I (rkdarst) once heard instructors can do exams ten times faster than students. Think on that level.
Put exercises in a logical order, and fill in any gaps. Ideally there should be a cycle of ~30-50 minutes of teaching+exercise (not including 10 min break every hour). Perhaps most are short (a few longer examples as needed), to identify a certain learning goal and misconception.
- I (rkdarst) these days think that it is best to have exercises as long as possible (group many small into one large), since more time than you expect is lost with context switching.
- Also, if you can make it work, it’s best to minimze talking to introduction and discussion, if you can make the exercise material self-explanatory. In other words, tell the students what and why, let the exercise text explain “how”.
Write just enough material to get from one exercise to the other.

The most important point here is to start from learner’s needs and how they can feel connected, not from the tech details. It is very easy for us to start with what we would do, and over time every one of these lessons migrates towards a learner-centric design. Make a shortcut and start learner-centric.

When advertising the course, connect it to your learner personas so that you get the right audience and they know why they should come.

Emotional and intrinsic appeal, other basics

You can think of why people should feel emotionally connected to your material - maybe it’s too much to expect people to get emotionally invested, but if you try for that, you’ll end somewhere better. Most people don’t attend our courses to learn a skill. They attend because they think it will help their other work.

Try to design around tasks and exercises which your audience will care about. For example, don’t say “here are some shell commands”, but “aren’t you tired of copying all of these files one by one… check out the shell… once you know it, you will really feel at home. Here are some typical things you might do.”. Intrinsic motivators include sense of agency (being able to do things themselves), competence (usefulness of what they are doing, feeling they know something), and relatedness (doing things that others are doing).

A manual is reference, a tutorial builds a cognitive model. If you can build the cognitive model and tell them the “why”, students may be able to refer to the manuals themselves and become self-sufficient. Thus, our teaching is usually more of a tutorial, with good links to manuals (it can also explicitly teach how to use the manuals).

Perhaps a related point is inclusiveness: make sure there’s not some “in” crowd. Perhaps the best description I have seen: don’t assume that some people are missing something, but that others have had the fortune of learning it earlier. This may not matter in a purely factual lesson design, but if you are trying to make things intrinsically or emotionally appealing, it is essential. (Example: git lessons use to have Star Wars references about “force pushing”. They are mostly gone now, since it’s not clear why force pushing is interesting nor does everyone like Star Wars).

Who is the audience?

Making the learner personas are essential to making a good lesson, even if you think you know who you are teaching to. This is because it grounds you into what your audience already knows (or doesn’t know) and what they are interested in. Think:

Different types of work they do
Different ways they do their work (and thus future needs)
Different levels of background (shell proficiency, etc.)

You also have different ways people can refer to the material:

In a class, with an instructor guiding them
Reading along by themselves
In a class, being much more advanced than others, so that they skip ahead and do advanced material themselves.
In a class and lacking some prerequisites, so may struggle with some parts.

Planning

Do some planning, and document it - the design process helps others to teach and modify. At least put it in the instructor guide (guide.md). (this is the designer/maintainer’s guide)
- Put the main points from the “backwards lesson design process” in here, enough that it is easier for someone to improve your lesson than to redo it.
Make learner personas: what is your target audience?
Decide learning objectives based on the personas: high-level end goals. What students get out, not what they do.
Also make a guide for teaching (instructor’s guide), “if you want to present this, do this”.
- How much preparation is needed? Is it enough to know the topic and have read the material?
- Things to prepare before the presentation. Does anything need to be set up?
- Practical notes on presenting.
- Are there solutions to exercises somewhere? Are they needed?
- Include some pre-assessment questions which can be asked at the beginning.
- Perhaps you should do this at the end, but at least starting the instructor’s guide at the beginning will frame your writing.

Writing

There is not much here yet, mostly just follow the “backwards lesson design” above. The hardest part is coming up with good exercises, so our practical advice is to leave plenty of time for this and talk with others. There is inspiration at the bottom of this page. Try to think of diverse types of exercises.

Exercise design is the time it is most useful to be with others to do brainstorming, so we highly recommend discussing with others at this point. Because exercises are used to set the overall outline of the lesson, this also gives people a say in the overall outline - in a very concrete way.

Make sure you include the emotional starting point at the beginning - why should you care and why is this cool?
This should also be at the start and end of each section: not just what or how, but why?
Part of this is also having a student’s guide, so that people independently studying can know how to follow the material.
It’s OK to have more material than can be presented or than people should know, but label things well, including labeling the difficulty.
- In the beginning, what sections are expected to be taught in short/long versions? What’s advanced/optional?
- Label advanced and optional sections as such. Perhaps also really basic sections that can be skipped for that reason.

Plan for mixed abilities. It’s OK to have optional (basic) and advanced sections, as long as they are clearly labeled. Mainly, don’t have people think that you are uncoordinated because you are skipping advanced sections.

Once you are done, update maintainer’s and instructor’s guides.

Introduction (and conclusion)

The introduction is the first thing people hear, and needs special thought. Don’t start with a cold open, just going straight to the topic (“what” or “how”). Instead, have some careful motivation (“why”). It could be especially good to talk about what is wrong with the current state of affairs (give a good, simple example) and why it should be improved. Then start talking about what the improvements are.

Ideally, the introduction should serve as an self-contained abstract of your material. If you need to teach your lesson in only 10% of the time you have, can you use just the introduction to do it?

Conclusion should remind people about why this is cool and discuss what comes next.

Thinking of exercises

Not every exercise has to be an amazing hand-on example. It’s mixing with smaller, more conceptual things to reduce the cognitive load and be able to have more frequent exercises.

One of your other primary goals should be to make your exercises relevant. Abstract will lead to disconnection. Most lesson designers work at a higher level of abstraction than their students. Connect the exercises to the real world. Also, can you tell a complete story with exercises? (Remember, in backwards lesson design, the exercises form the story of the lesson.)

There are three types of “action”:

Exercise: Learners do these themselves during a quite time. They can focus, read, and figure things out. These are good but make them long. These should be in as long sessions as possible, so learners have time to focus. A five or even ten minute exercise is almost zero time to think.
- Subtype: Questions which you ask the learner and they answer via the Notes. These can be short and during your talking.
Demos: The instructor do something and explain it why doing. These can be good, but you need to remember to go slow enough for learners to follow, and they aren’t very interactive.
Type-along is where instructors do something and learners are expected to follow along at the same time. This sounds like a good idea, but there are just so many things that can go wrong, and if someone gets behind, the lose it all. They can work if you give an exercise doing the same things right after, and make it clear “what I am typing is the next exercise, so you don’t need to follow along”.

Good exercises are the most important factor in a good lesson. Even if you are preparing the rest of the lesson mostly alone, consider a good long brainstorming session to go from “list of topics to cover” to “sequence of exercises”.

When you are stuck thinking “how can I make an exercise that covers X”, think of the lists below inspiration. Not every exercise has to be an sophisticated hands-on thing, so don’t be afraid to use different types:

Exercise inspiration

Basic types:

Multiple choice (easy to get feedback via a classroom tool - try to design each wrong answer so that it identifies a specific misconception).
Code yourself (traditional programming)
Code yourself + multiple choice to see what the answer is (allows you to get feedback)
Inverted coding (given code, have to debug)
Parsons problems (working solution but lines in random order, learner must only put in proper order)
Fill in the blank

More advanced:

Tracing execution
Tracing values through code flow (e.g. what is the sequence of values that x takes on?)
Reverse execution (find input that gives an output)
Minimal fix (given broken code, make it work)
Theme and variations (working code, adapt to other type of situation/problem)
Refactoring

More conceptual:

Draw a diagram
Label diagram
Matching problem: two sets of Q/A, match them.

Thinking through the learning taxonomies also helps to come up with diverse types of exercises:

Bloom’s taxonomy: hierarchical skill levels (can you help students to “grow a level”?):
- Remembering
- Understanding
- Applying
- Analyzing
- Evaluating
- Creating
Fink’s taxonomy: complementary types instead of hierarchical:
- Foundational knowledge
- Applications
- Integration
- Human dimension
- Caring
- Learning how to learn