# How This Course Works

How Design Patterns, Demystified works on ask-codey.com: the passes, the same shape every pattern lesson follows and its pattern card, the language tabs, exercises written as tickets with tests that say Keep this working and Not yet, and how chapter checks, module assessments, Covered and Mastered fit together.

Novice · OOP · Software Development · Updated November 17, 2026

By Gregor Dzierzon

## After this lesson you can

- Describe the parts of a pattern lesson in order, from the problem story to the pattern card
- Read an exercise's test results: what a Keep this working failure and a Not yet failure each mean
- Explain how chapter checks, module assessments, Covered and Mastered fit together

## Key takeaways

- After a first module of tools, the course builds five apps in passes, and each pass meets bigger problems than the last.
- Every pattern lesson has the same shape: the problem first, the plain fixes tried, then the fix that holds up, its name, and its pattern card.
- Every code sample comes in five languages, as tabs. Pick yours once, and every lesson opens on it.
- An exercise is a ticket: tests marked Keep this working pass at the start and must stay green, and tests marked Not yet are the work.
- Chapter checks are practice; a module assessment passes at 80%. Covered counts lessons finished, Mastered counts skills shown.

This course is self-study: you go at your own pace, and the course tells you how you're doing. Every chapter and every pattern lesson works the same way, so a few minutes here save a lot of guessing later. By the third pattern, you'll know what's coming next, and that's on purpose: it leaves your attention free for the problem.

## Modules, passes and chapters

The course has seven **modules**. The first, *Before You Build*, hands over the tools: the object-oriented code patterns are made of, how to draw a design, how to tell code has a problem, and the ideas behind every pattern.

Then come the **passes**. Each pass takes one app through its life: plan it, build version 1, take change requests, connect it to other systems, and keep it running. Each pass goes a little deeper than the one before, and a pattern you met in a small form comes back later with a bigger problem.

| Module | What it's about |
|---|---|
| 1. Before You Build | the tools |
| 2. A Small App That Works | Pass 1: Sunrise Bakery's ordering app |
| 3. The App Grows | Pass 2: Lakeside Parcel's package tracker |
| 4. Talking to Other Systems | Pass 3: the HomeBase smart-home hub |
| 5. Going to Work on a Framework | Pass 4: Riverside Community Library's checkout web API |
| 6. More Problems, More Patterns | problems none of the apps has |
| 7. Rescuing a Legacy App | Pass 5: Summit Gym's old class-booking system |

A **chapter** is a stage of an app's life, named for its problem (*The Owner's Wish List*, *When the Other System Is Down*), never for a pattern. A **topic** groups a few lessons inside it. Each lesson has a **level** from 1 to 4: meeting an idea is level 1, working with it level 2, building with it level 3, and the advanced end level 4. A level says how deep a lesson goes, not how far into the course it is.

## The shape of a pattern lesson

Every pattern lesson follows the same steps, in the same order:

![The eleven steps of every pattern lesson, top to bottom. The problem first: the problem story (symptom and cause) and What would you try?. Then the fix: the role diagram, how it got its name, the classic and modern versions, where you've used it, when not to, and the pattern card](https://fsdtrainingmedia.blob.core.windows.net/public/images/2026/11/85035ef4a2854986b992bcd9124ba44b.webp)

1. **Before this** names any lesson the pattern builds on.
2. **The problem story** shows working code that's about to get worse, told the way a doctor would: the **symptom** you can see in the code (a smell, such as the same `if` chain in three places), and the **cause** underneath it.
3. **What would you try?** tries the plain fixes first (one more `if`, a copied class) and shows where each one breaks.
4. **The everyday version** is something outside software that already works this way.
5. **The fix that holds up**, in one sentence, with its **role diagram**: plain-word boxes, numbered arrows in the order things happen, and a dashed orange fence around the part that changes.
6. **How it got its name**: teams kept landing on this fix, so it was written down and named. A lesson may mention the name earlier as a signpost; this is where it's explained.
7. **The classic version** reshapes the problem code into the pattern.
8. **The modern version**, where there is one, does the same with today's language features, often in a few lines.
9. **Where you've already used it**, in code you've probably written.
10. **When not to use it**, and what it costs.
11. **The pattern card**, the lesson's cheat sheet: the same fields every time, from *The problem* and *Smells that point here* to *Use it when*, *Skip it when* and *Look-alikes*. One field, *How often you'll meet it*, is always marked as our estimate: it depends on your language, your framework and the kind of work you do.

Steps 7 and 8 print exactly what the problem code printed. Same output, better shape: that's how you can see that only the design changed. By the end, your cards add up to your own pattern catalog.

## Five languages, one lesson

Every code sample is written in **C#, Java, Python, JavaScript and TypeScript**, in one box with a **tab** for each. If you haven't picked one, Python opens first. Click your language's tab once and the site remembers it: every box opens on your language from then on. Each sample prints the same lines in all five, and when a language does something its own way (Python and JavaScript have no `interface` keyword), a short note under the code says so.

You need only one language for the whole course. You can add another at any time.

## Exercises are tickets

Each chapter ends with an exercise lesson. You get code that **works**, its tests, and a README written like a ticket at work: what the app does, what's wrong, and what's needed now. It never says which pattern to use: choosing the fix is the skill. A folded *Stuck?* hint at the bottom names it, for when you want it.

A **test** is a small program that runs your code and checks one thing it should do. When you run the tests at the start, two kinds of message tell you where you stand:

- **Keep this working:** tests that pass at the start, because they're what the app already does. If one of these fails, your last change broke something that worked. Undo it, or fix it, before going on.
- **Not yet:** tests that fail at the start, on purpose. They're the ticket. When they pass, the work is done.

So you change the code in small steps and run the tests after every step. The exercise is finished when every test is green. *Running the Exercise Tests* shows the command for each language.

## Check yourself, chapter checks and assessments

- Near the end of a lesson, **Check yourself** asks one to three short questions and shows you the answer and why. Getting one wrong is useful news, not a failure.
- A **chapter check** is a short quiz on the chapter's skills, with a few that review the chapter before. Take it as often as you like: it's practice, and it shows you what to review. If you already know a chapter, take its check first.
- A **module assessment** ends each module. **80% passes.** You get three tries a day, and every attempt draws different questions, so a retake is a fair new try. Most questions ask *why*: which fix holds up, what breaks with the next change, which pattern would be too much.

## Covered and Mastered

When you're signed in, the course keeps two separate records:

- **Covered:** the lessons you've finished.
- **Mastered:** the skills and key terms you've shown you know. A skill is mastered when you answer three different questions about it cleanly, right the first time and without a hint, from at least two different angles. A later miss drops it back, so mastery stays honest.

Reading a lesson doesn't mean you know it, which is why the two are kept apart. Everyone can read every lesson and try its Check yourself questions; with Premium, or if you own this course, you also get course progress, the chapter checks, the module assessments and the **Certificate of Completion**.

## Check yourself

2 questions to try on the lesson page.

## So what

Every chapter follows the same rhythm (read, run the code, check yourself, do the exercise, take the check), so you can spend your attention on the problems instead of on finding your way.

## Key terms

- [Unit Test](https://www.ask-codey.com/glossary/unit-test-unit-testing)
- [Code Smell](https://www.ask-codey.com/glossary/code-smell)

Source: https://www.ask-codey.com/lessons/dp-how-this-course-works
