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

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

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