Explore it together.

Choose a useful starting point

Foundations is an option, not a compulsory first course. BASIC and assembly have independent entry points. Choose according to the learner’s interests and the activity you have prepared, rather than requiring another track first.

The curriculum map shows how lessons, shared subjects, the Vault and the Pattern Library connect. Some subjects are still outlines; check the actual lesson pages before planning around them.

A small activity to try together

The Foundations lesson A Program Is Instructions is one place to begin without installing tools. Treat its pseudocode as an instruction to trace, not something to type into a Spectrum.

1. Predict. Read SHOW "Hello". Ask what the instruction asks the computer to show, and write down the expected result.
2. Change one thing. Replace the message with another word. Explain which part changed and which part still gives the instruction.
3. Add a step. Write a second SHOW instruction. Trace the two lines in order, then swap them and compare the results.
4. Explain. Ask the learner to describe the rule in their own words, or give you instructions to follow. Use any disagreement to work through the example again.

For a machine-based lesson, use the same rhythm with a runnable stage: predict, run, compare and explain. A surprising result is a reason to investigate, not a sign that someone is bad at programming.

Help without taking over

Ask “What did you expect?” and “What changed?” before offering a fix. Read error messages together and narrow the problem to a small example. If neither of you knows why it happened, write down the question and what you tried.

In pairs, one person can operate the keyboard while the other predicts or checks the result; swap roles regularly. Drawing a grid, moving counters or tracing values on paper can make a rule easier to discuss.

Use questions to reveal understanding. An answer is more useful when the learner can explain it, and a wrong prediction can expose a helpful misconception. There is no need to turn every activity into a scored quiz or a pass/fail gate.

Keep a manageable stopping point: a working stage, a saved file and a note of what to try next. A small game or experiment can be a worthwhile finished piece.

Prepare the activity and its tools

Read the chosen lesson and follow its steps yourself before a group session. Check that the required pages, files and assets are available. Allow for setup and troubleshooting when deciding how much to cover.

• Identify the host computer and the target machine or emulator. A tool used to build a program is not the machine that runs it.
• Check the language-specific workflow. Typing BASIC on an emulated machine, converting a BASIC listing and assembling source are different activities; they do not all require the same tools.
• Try the exact emulator model, keyboard controls and file-loading steps. Check that learners can save and reopen their work.
• Check installation permissions, downloads and network access on the computers the group will use. Follow setup guidance and the ROM guidance for the chosen target.

Some setup instructions are still being reviewed. If a command or step does not match what you see, report the page and your configuration rather than assuming the difficulty is yours.

Make room for different ways of learning

Check text size, contrast, keyboard access and the readability of diagrams on the devices you will use. Discuss information conveyed by colour or sound in words as well, and allow time to pause and repeat an example.

A timed game is not the only way to explore a rule. Trace a movement on paper, examine a still image or discuss a sound’s role before running the whole example. Adapt the activity to the learner without assuming every emulator or resource meets every access need.

Using Code198x in a class, club or course

Select a bounded set of lessons and identify what you want learners to explain or make. Review their language, prerequisites and tools against your group’s needs. Within a project, preserve the development sequence so essential code does not appear without explanation.

The site is a developing curriculum, not a complete classroom pack. Do not infer teaching readiness from a catalogue entry or expect every machine to have the same projects. Foundations has authored lessons; the current Craft pages outline future Maths for Games and Game Feel material.

Pages are free to read. You may share and adapt original prose, including for worksheets or courses, under CC BY 4.0. Credit the source and named authors, link the licence and indicate changes. The code samples have an MIT licence. For copied or adapted material, retain the applicable notices and check the licence attached to each resource; third-party assets have separate terms. The prose licence does not cover those assets.

You do not need a community account to read lessons. If you use external discussion services with a group, follow your organisation’s arrangements rather than making them a requirement for the activity.

Tell us what helped and what got in the way

A report from a real learning session can improve a lesson: where an explanation lost someone, which instruction was ambiguous or what helped an idea make sense. Include the page, relevant tools and a concrete example; leave out learners’ names and other identifying information.

Use the correction routes, ask in Discord, or choose a task on the contribution page. You can contribute a useful review without writing code or submitting a pull request.