Skip to content
PlayOwl

Find a course

Search every subject world, from Preschool to Grade 12. The first five courses of every subject path are free.

24 courses

Courses found

Coding · Grade 8

Specify and Decompose a Software Project

Using a community-garden booking app, learners write and classify functional and non-functional requirements and constraints, identify stakeholders, and turn vague wishes into testable Given/When/Then acceptance criteria that become code checks. They decompose the system into modules with clear responsibilities and data flow, then plan an MVP, milestones and risks, and write a reviewed mini specification for a project of their own.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 8

Functions, Modules and Structured Data

Learners design functions that are easy for teammates to use (default and keyword arguments, docstrings, returning several values), organise code into modules and use the standard library, represent real data as lists of dictionary records with nested fields, and process records with filter, aggregate, transform and key-based sorting.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 8

Algorithms, Efficiency and Tradeoffs

Learners count the basic operations algorithms perform, classify growth as constant, logarithmic, linear or quadratic from the shape of the code, and predict how running time scales. They explore trading memory for time with sets and caching, and weigh efficiency against input size, frequency, clarity and resources when choosing an approach.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 8

Objects and Program Organization

Learners model the garden app with classes: they create objects from a class blueprint, write and trace __init__ and methods that use self, and build programs where objects contain and work with other objects, including the surprise of two variables referring to the same object. They finish by designing classes with single responsibilities, deciding which data and behaviour each class owns.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 8

User Interfaces, Events and State

Learners design interface behaviour as state machines with named states, events and allowed transitions, and separate the model (state) from the view (a single render function) so the screen never disagrees with the data. They trace longer JavaScript event sequences with guards and counters, and design helpful feedback: clear status messages, disabled controls and an undo stack.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 8

APIs with Controlled Mock Services

Learners discover how programs request data from other programs through APIs, using a local mock weather service so that no real network calls are made. They read requests, responses, status codes and JSON, parse JSON in Python, write code that checks status codes and missing fields with safe fallbacks and caching, and use APIs responsibly by protecting keys, minimising personal data and respecting limits.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions

Coding · Grade 8

Testing, Debugging and Secure Design

Learners make the garden app trustworthy: they design thorough unit tests that cover normal, edge and invalid inputs and every branch, debug systematically with tracebacks, minimal failing examples and assertions, and apply secure design principles (input validation, least privilege, safe defaults, failing securely, careful error messages). They finish by seeing why passwords are stored as hashes and why data must be kept separate from commands.

  • 4 lessons
  • About 90 min
  • Quiz: 8 questions

Coding · Grade 8

Build, Document and Demonstrate a Capstone

The Grade 8 capstone course guides learners from a specification to a finished, documented and demonstrated project. They plan milestones with a checkable definition of done, write documentation for different readers (README, docstrings, comments, user guide), gather honest evidence from tests and checklists without overclaiming, and plan a clear demonstration and a reviewed reflection.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions

Coding · Grade 9

Algorithms and Problem Decomposition

High-school learners define algorithms precisely (finite, definite, effective, with input and output) and test procedures against that definition, including the unsolved Collatz problem as a case where testing is not proof. They represent algorithms as flowcharts and pseudocode, trace classic algorithms such as Euclid's GCD with trace tables, and decompose problems while comparing algorithms for correctness and efficiency.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Design a Fair and Enjoyable Mechanic

Learners start the game-development elective by treating games as systems of mechanics, dynamics and player experience, then judge fairness with exact probabilities and expected values computed by counting dice outcomes, find dominant strategies in payoff tables and rebalance them, and test a mechanic with a paper prototype and observed playtests, ending with a reviewed design document for an original mechanic.

  • 4 lessons
  • About 90 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Programming Foundations with Python

Learners see how the Python interpreter runs a program statement by statement, why indentation is part of the grammar and how comments work. They control output precisely with print's sep and end, classify and locate syntax, runtime and logic errors from messages and behaviour, and use types and built-in functions, including Python's round-half-to-even rule.

  • 4 lessons
  • About 80 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Coordinates, Vectors and Transformations

Using a fictional boating game, learners convert between world coordinates and screen pixels, move objects with vector addition, scaling, length and normalization, transform shapes by translation, scaling and rotation about a pivot, and apply vectors to gameplay: range checks with squared distances, aiming and fixing the diagonal-speed bug.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Game Loops, State and Input

Learners trace the input-update-render game loop frame by frame, make movement fair on every device with delta time and a fixed-timestep accumulator, organise menus, play, pause and game over as a state machine that controls which systems run, and derive pressed, held and released events from raw input, with buffering and remappable controls.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Expressions, Variables and Input

Using a bike-share fare calculator, learners evaluate Python expressions with precedence and associativity (including floor division of negatives and right-to-left powers), use augmented and simultaneous assignment, read and convert input, and format output with f-string specifiers. They discover why floating-point arithmetic is approximate and learn practical rules: compare with a tolerance and keep money in integer cents.

  • 4 lessons
  • About 85 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Collision and Simplified Physics

Learners detect collisions between axis-aligned boxes and circles, simulate motion with velocity, gravity and Euler steps, respond to collisions by resolving overlaps and bouncing with restitution, and examine the limits of simple physics, especially tunnelling at high speed and how substeps or swept tests prevent it.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Selection and Repetition

Built around a school weather station, the course develops selection (elif chains, nested conditions, branch order and boundaries) and Boolean logic (short-circuit evaluation and De Morgan's laws), then repetition patterns with for, while, break, continue, sentinels and nested loops. It closes with reasoning about loop correctness: termination, off-by-one errors and loop invariants.

  • 4 lessons
  • About 90 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Functions and Modular Design

Using a fictional fitness-tracker app, learners trace calls between functions with the call stack, control scope by passing parameters and returning results instead of using globals, write precise contracts with preconditions and postconditions, and separate pure functions from side effects. They then design programs top-down, build them bottom-up and plan a modular program in a reviewed design task.

  • 4 lessons
  • About 90 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Characters, Animation and Behavior

Learners animate sprites from elapsed time with looping and one-shot sequences, give a non-player character a patrol-chase-search-return state machine with hysteresis, find shortest paths on grids with breadth-first search and program routes with blocks, and tune behaviour so it is readable and fair through telegraphing, reaction delays and learnable patterns.

  • 4 lessons
  • About 100 min
  • Quiz: 8 questions
Free starter

Coding · Grade 9

Levels, Difficulty and Accessibility

Learners design levels that teach mechanics step by step and guide players through layout, read playtest data (completion rates and attempts) to find difficulty spikes, trace a bounded dynamic difficulty adjustment rule, and build accessibility into games through remapping, toggles, captions, colour-independent cues, assist options and photosensitivity safety.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions

Coding · Grade 9

Collections and Structured Data

Using a school clubs fair, learners work with Python's four core collections: lists (slicing, comprehensions, enumerate), tuples (immutable records and unpacking), sets (uniqueness and set operations) and dictionaries (lookup, counting, grouping and nested data). They reason about mutability, aliasing and copies, and choose the right collection for each job.

  • 4 lessons
  • About 90 min
  • Quiz: 8 questions

Coding · Grade 9

Testing, Debugging and Edge Cases

Learners design tests with equivalence partitions and boundary value analysis, build edge-case checklists for collections and text, and write test suites that catch hidden buggy versions of real functions. They debug as an investigation (reproduce, hypothesise, predict, fix, regression-test) and use assertions and automated tests to make programs check themselves, while keeping validation for user input.

  • 4 lessons
  • About 90 min
  • Quiz: 8 questions

Coding · Grade 9

Testing, Performance and Responsible Design

Learners test game rules with exact expected values, write reproducible bug reports, analyse performance against the frame budget and see how spatial grids cut collision checks, and evaluate responsible design: avoiding pay-to-win, loot boxes and dark patterns, supporting healthy play, and protecting young players' privacy and safety, ending with a reviewed responsible-design review.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions

Coding · Grade 9

Build and Explain an Interactive Program

The Grade 9 project course: learners design an interactive text program (state, command functions and a main loop), trace it through sequences of valid and invalid commands using the worked example TaskBoard, test it with normal, boundary and invalid interactions, and explain it with clear code walkthroughs. A reviewed task asks each learner to plan and explain an interactive program of their own.

  • 4 lessons
  • About 95 min
  • Quiz: 8 questions

Coding · Grade 9

Publish a Private Original Game Project

Learners plan an original game with prioritised, estimated features and milestones, check every asset's licence and keep a credits list, release the game privately with no personal information, and write an evidence-based postmortem, ending with a reviewed final project.

  • 4 lessons
  • About 110 min
  • Quiz: 8 questions