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 10

Structured Programming and Design Contracts

Using a school print-credit system, learners write structured code with guard clauses instead of deep nesting, specify functions with preconditions, postconditions and clear exceptions, protect data invariants in a class, and practise defensive programming by testing both sides of each contract and checking that refusals leave state unchanged.

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

Coding · Grade 10

Objects, Classes and Encapsulation

Using a makerspace tool library, learners design classes that start valid, act through well-named methods and print readably with __str__. They protect data with encapsulation (underscore conventions and validating properties), distinguish class and instance attributes and identity from equality, and build classes from others with composition (has-a) and inheritance (is-a), including overriding and polymorphism.

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

Coding · Grade 10

Collections and Algorithmic Patterns

Using real-world-style air-quality, loan and sales data, learners recognise and apply the core collection patterns (accumulate, count, filter, map, any/all, find-first and best-by-key), group and index data with dictionaries and zip, and use sliding windows and two pointers to avoid repeated work. They finish by testing each pattern's characteristic edge cases, including testsuite activities against hidden buggy versions.

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

Coding · Grade 10

Searching, Sorting and Efficiency

Learners describe algorithm costs with Big-O notation, trace binary search with an interactive tracer, and trace selection sort and insertion sort pass by pass. They study merge sort as divide and conquer, explaining why it is O(n log n) and stable, and use growth rates to choose between sorting once and searching many times, dictionaries and Python's built-in sort.

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

Coding · Grade 10

Files, Data Validation and Errors

Using athletics results files, learners read and write text files safely with with and in-memory file objects, validate every record for field count, type and range while logging rejects with line numbers, handle exceptions precisely with try, except, else and finally, and assemble a robust read-validate-process-report pipeline whose summary never hides rejected data.

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

Coding · Grade 10

Events and User Interface State

Learners discover how JavaScript's event loop runs handlers and timers one at a time, use event objects and event delegation, and manage interface state with a single state object, actions and pure update (reducer) functions. They finish by designing responsive and accessible interactions: throttling rapid clicks, preventing double submissions, keyboard support, focus management and announced status messages.

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

Coding · Grade 10

Version Control, Tests and Collaboration

Learners work like a software team on a club-booking app: they use feature branches, pull requests and merges and resolve merge conflicts deliberately; write independent Arrange-Act-Assert unit tests and require tests before approving changes; give and respond to specific, kind and actionable code reviews; and use continuous integration to stop regressions reaching the main branch.

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

Coding · Grade 10

Build an Original Object-Oriented Project

In this project course learners design an object-oriented solution with nouns, verbs and CRC cards, trace a worked board-game library with collaborating Game, Member and Library classes, test classes and scenarios including side effects of refusals, and plan iterative development with a design log. A reviewed task asks each learner to plan an original object-oriented project of their own.

  • 4 lessons
  • About 100 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