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 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

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

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

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

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

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

Coding · Grade 11

Abstract Data Types and Invariants

Learners separate abstract data types from their implementations, specifying stacks and queues by their operations and rules, and apply them to bracket matching, browser history and print queues. They then study representation invariants through a circular-buffer queue with wrap-around indexes, and compare implementations of the same ADT to see why clients must depend only on the interface.

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

Coding · Grade 11

Data Structures and Their Tradeoffs

Learners compare dynamic arrays with linked lists, trace a toy hash table with buckets and collisions to see why dictionaries are fast and keys must be immutable, and build binary search trees, observing how insertion order changes their height and performance. They then choose structures for realistic workloads by comparing the costs of the operations that matter most.

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

Coding · Grade 11

Algorithmic Complexity and Measurement

Learners derive Big-O bounds from code by counting operations through sequences, nested loops with dependent bounds and halving loops, distinguish best, worst and average cases, and check their analysis with exact operation counts and doubling experiments rather than noisy timings. They finish with space complexity and judgement about when complexity really matters.

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

Coding · Grade 11

Recursion and Problem Decomposition

Learners build recursive solutions from base cases and smaller subproblems, tracing them with the call stack and indented call logs. They design recursive functions for palindromes, powers by halving, digit sums and lists, test them against hidden buggy versions, analyse costs with call trees (including Fibonacci's exponential blow-up and memoisation), and decide when iteration is the better choice.

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

Coding · Grade 11

Graphs and Network Problems

Learners model networks (bus stops, study partners, prerequisites, roads) as directed, undirected and weighted graphs stored as adjacency lists, trace breadth-first and depth-first search, find shortest paths with BFS and Dijkstra's algorithm, and answer network questions with reachability, connected components and topological ordering.

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

Coding · Grade 11

Software Interfaces and Controlled APIs

Learners design and implement an API from the provider's side using a controlled, network-free club-information service: resources, methods, consistent JSON responses and status codes; a request handler that authenticates, routes, validates and authorises before acting; access control, data minimisation and rate limiting; and safe evolution with versioning, deprecation and contract tests.

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

Coding · Grade 11

Security, Reliability and Automated Testing

Built around one realistic task, testing a search algorithm, this course teaches learners to trace binary search, state its input assumptions, reason about edge cases and efficiency, inspect and repair broken implementations, and design test suites that catch realistic bugs. It closes with reliability and security practices for untrusted input: validating preconditions, bounded execution, toy datasets and safe failure. Learner code is never executed; tests are checked against a reference and registered buggy versions.

  • 5 lessons
  • About 110 min
  • Quiz: 10 questions

Coding · Grade 11

Build and Defend a Computing Solution

In this capstone-style course learners define a computing problem precisely (a lab-booking clash checker), compare candidate algorithms, gather evidence from edge-case tests and operation counts, discover that a fast shortcut is subtly wrong, evaluate solutions honestly against success criteria, and defend a recommendation with claim, evidence and reasoning, including limitations and effects on people.

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

Coding · Grade 12

Select and Scope a Software or Research Project

Learners begin the senior capstone by choosing a worthwhile, feasible project with a weighted decision matrix, writing an evidenced problem statement and an aim or research question with measurable success criteria, scoping an MVP with stretch goals and an out-of-scope list, planning milestones with a buffer, and addressing risks, privacy, consent and licences in a reviewed proposal.

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

Coding · Grade 12

Architecture and Modular Interfaces

Learners give their capstone a sound structure: layered architecture with separation of concerns, modules judged by cohesion and coupling, interfaces expressed as abstract base classes, and dependency injection so storage and clocks can be swapped for fakes in tests. They record significant choices in architecture decision records and weigh flexibility against unnecessary complexity.

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

Coding · Grade 12

Data Models and Persistent State

Learners design the data layer of a capstone: entities, primary and foreign keys, one-to-many and many-to-many relationships with link tables, and normalisation to avoid update, insertion and deletion anomalies. They query real in-memory SQLite databases with SELECT, JOIN, GROUP BY and IS NULL from Python, and persist state safely with serialisation round trips, transactions, parameterised queries and planned migrations.

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

Coding · Grade 12

Implementation with Robust Error Handling

Learners make their capstone robust: they classify failures and choose strategies (validate, retry, fall back, fail fast), design custom exception hierarchies that are raised where problems are detected and handled at the right layer, implement bounded retries with exponential backoff against a simulated unreliable service with attention to idempotence, and write useful, safe logs alongside clear user messages.

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

Coding · Grade 12

Tests, Profiling and Security Review

Before release, learners check their capstone three ways: a test strategy shaped like the test pyramid with an honest view of coverage; stronger tests through mutation thinking, property-based checks against an oracle and testsuite activities against hidden mutants; profiling to find real hot spots before optimising; and a defensive security review built on a simple threat model and a prioritised checklist.

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

Coding · Grade 12

Human-Centered Design and Accessibility

Learners put people at the centre of their capstone: they observe users and write evidence-based personas, prototype and iterate, run neutral usability tests and analyse success, time and errors, apply WCAG accessibility principles (computing real contrast ratios, keyboard access, labels and semantic HTML), and evaluate designs for inclusion, cognitive load, consent and dark patterns.

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

Coding · Grade 12

Documentation, Deployment and Maintenance

Learners prepare their capstone for life after the first release: documentation for each reader (README, docstrings, user guide, runbook, changelog), semantic versioning traced in code, deployment pipelines with test gates, staging, rollback and configuration from environment variables, and maintenance planning (corrective, adaptive, perfective and preventive work, monitoring, technical debt and a secure handover).

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

Coding · Grade 12

Demonstrate, Defend and Reflect on a Capstone

The final Grade 12 course prepares learners to present their capstone professionally: a scripted, rehearsed demonstration built around the success criteria with contingencies and test data; an honest evaluation that reports every criterion with evidence (including those not met); a defence that answers hard questions with claim, evidence, reasoning and trade-offs; and a specific, analytical reflection with complete attribution of sources and AI assistance.

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