Real Computing classroom lessons grouped by PICRAT cell, from Passive Replace to Creative Transform.
By Andy Perryer, Global Head of Digital Learning18 lessons
Creative Replace (CR)
Each child programs a Bee-Bot to navigate a course
Year 3
· 30 min
· Shared Bee-Bots between small groups
Each small group programs a Bee-Bot to navigate a simple course on the floor (e.g. forward, turn, forward, stop). Children take turns and refine their sequence.
Each child builds a Scratch quiz with at least three multiple-choice questions where the sprite reacts differently to right and wrong answers. Submit the project.
Each student builds a Scratch story with at least two sprites, two backdrops, and a sequence of dialogue blocks where the sprites take turns speaking. The story has a beginning, a middle and an end. Students submit their finished project to the teacher's class studio.
Year 8
· 50 min
· 1 device per student plus a micro:bit each
Each student programs a micro:bit to display a randomly-chosen rock, paper or scissors symbol when the A button is pressed. They flash their micro:bit, test it, and play a round with a partner using their two micro:bits.
Each student writes a Python program that asks the user a yes-or-no question, picks a random response from a list of eight Magic 8-ball-style answers, and prints it. They test their own program with three sample questions and submit a screenshot of the running code.
The teacher posts three pseudocode snippets on a class Padlet (a sorting algorithm, a search algorithm, a counting loop). Each student picks one and posts a one-paragraph plain-English description of what it does and what kind of input it works on. The class scrolls and the teacher highlights any snippet where students disagreed about behaviour, drawing out the difference.
The teacher shares a screencast of a programmer debugging a real bug (about 10 minutes). Each student annotates a shared Doc with timestamped notes on what the programmer did at each step and what they could have done differently. The class compares notes and pulls out the three most useful strategies.
The teacher presents three different algorithms that solve the same problem (e.g. find the largest number in a list). Each student votes on Mentimeter for the most efficient. The class sees the live spread, then in pairs writes a 30-second defence. The teacher calls pairs from each side to argue. The class re-votes at the end.
Students translate three pseudocode snippets into Python at their own pace, posting each translation to a Replit gallery. Quizizz tracks completion. After each round, the teacher pulls out the two most efficient and two most error-prone translations and asks the contributing students to walk through their reasoning.
The teacher posts a piece of buggy Python code in a class Padlet. Each student posts one bug they spot with a one-line explanation of why it would cause a problem. The class scrolls all bug reports, the teacher draws out the most useful debugging strategies, and the class collaboratively fixes each bug.
The teacher posts a network diagram (small office LAN) on a class Padlet. Each student posts one structural critique (e.g. single point of failure, security weakness, scalability limit) with reasoning. The class scrolls, the teacher draws out the most defensible critiques, and pairs propose one architectural fix.
The teacher posts an unnormalised database schema in a shared class Doc. Each student annotates one normalisation step they would apply (1NF, 2NF, 3NF, BCNF) with reasoning about the tradeoff in performance and complexity. The class plenary draws out where students propose different sequences.
The teacher posts three different algorithms that solve the same problem (e.g. find a value in a list: linear scan, binary search on sorted, hash lookup). Each student votes on Mentimeter for the most efficient at scale, defends in pairs, debates, re-votes.
Each student posts a 50-line excerpt of their A-Level NEA project code to a class Replit gallery. Two named peers per excerpt write a code-review comment focusing on structure, naming, and edge cases. Students revise based on the two reviews.
The teacher introduces a bug into a shared Replit workspace before the lesson (e.g. an off-by-one error in a loop, a confused variable name). All thirty students enter the workspace simultaneously. Each can edit and run the code. The class works together in real time to identify and fix the bug. The first student to find it explains their reasoning to the class.
Students prompt GitHub Copilot to write a Python function that solves a small problem (e.g. count vowels in a string). They evaluate Copilot's output: does it work, is it the cleanest approach, does it handle edge cases, what would they change? They submit a written critique alongside the working version.
Students are paired with a peer from a partner school in a different country. They share a Replit workspace and work on a small Python project together (e.g. a number-guessing game). They use a video call alongside for live discussion. The teacher reviews each pair's commits at the end and asks two pairs to present their reasoning.