36 lab practicals for the Cambridge syllabus.

The Cambridge Computer Science Tripos, Parts IA and IB: algorithms, databases, object-oriented programming, C and C++. Every lesson is stepped, compiled and checked by a real toolchain on your own machine — the model reviews your code afterwards, it does not decide whether you passed.

Download GroutCode All syllabuses

Updated 6 October 2026

Semester by semester

Programme: Computer Science Tripos. Scheme: Course pages 2026–27. Open a course to see its practical units and the lab lesson GroutCode ships for each.

1
Part IA
4 courses24 lab lessonsJavaSQL
- ALGORITHM1Java
  Algorithms 1
  3
  lessons
  - Sorting from quadratic to linear time — and finding the median without sorting
  - Divide and conquer, dynamic programming and greedy — one problem set, three strategies
  See all 3 lessonsHide
  1. 1Sorting from quadratic to linear time — and finding the median without sortingUnit 1 · Sorting
  2. 2Divide and conquer, dynamic programming and greedy — one problem set, three strategiesUnit 2 · Strategies for algorithm design
  3. 3Stacks to red-black trees — building Unit 3's data structures by handUnit 3 · Data structures
- ALGORITHM2Java
  Algorithms 2
  3
  lessons
  - Graph search and shortest paths — BFS, DFS, Bellman-Ford, Dijkstra, Floyd-Warshall and Johnson
  - Spanning trees, topological order, max flow and bipartite matching
  See all 3 lessonsHide
  1. 1Graph search and shortest paths — BFS, DFS, Bellman-Ford, Dijkstra, Floyd-Warshall and JohnsonUnit 1 · Graphs and path-finding algorithms
  2. 2Spanning trees, topological order, max flow and bipartite matchingUnit 2 · Graphs and subgraphs
  3. 3Amortized analysis, binomial heaps, Fibonacci heaps and disjoint setsUnit 3 · Advanced data structures
- DATABASESSQL
  Databases
  8
  lessons
  - From a key-value store and a flat file to a relational table
  - Designing a college database: keys, relationships and integrity
  See all 8 lessonsHide
  1. 1From a key-value store and a flat file to a relational tableUnit 1 · Introduction
  2. 2Designing a college database: keys, relationships and integrityUnit 2 · Relational databases
  3. 3Relational algebra in SQL: from selection to set differenceUnit 3 · Relational queries
  4. 4NULLs, aggregation, transactions and normalising a sales tableUnit 4 · Further SQL
  5. 5Storing and querying JSON documents in SQLUnit 5 · Document-oriented data
  6. 6A property graph in SQL — vertices, edges and Cypher-style pattern matchingUnit 6 · Graph-oriented data
  7. 7Recursive CTEs — walking an org chart and searching a flight networkUnit 7 · Recursive queries
  8. 8Row stores vs column stores — OLTP and analytics on the same dataUnit 8 · Database system trade-offs
- OOPROGJava
  Object-Oriented Programming
  10
  lessons
  - From functions to classes — static methods and an exact Fraction type
  - Designing classes — an encapsulated Account, immutable values and generic containers
  See all 10 lessonsHide
  1. 1From functions to classes — static methods and an exact Fraction typeUnit 1 · Types, Objects and Classes
  2. 2Designing classes — an encapsulated Account, immutable values and generic containersUnit 2 · Designing Classes
  3. 3References, the call stack and the heap — pass-by-value made visibleUnit 3 · Pointers, References and Memory
  4. 4A shape hierarchy — inheritance, overriding, overloading, casting and shadowingUnit 4 · Inheritance
  5. 5Polymorphism three ways — generic functions, interfaces and the diamondUnit 5 · Polymorphism and Multiple Inheritance
  6. 6An object's life — constructor chains, clean-up and two garbage collectorsUnit 6 · Lifecycle of an Object
  7. 7Comparing objects and working the Collections framework — Money, rankings and a RangeUnit 7 · Java Collections and Object Comparison
  8. 8A bank account and a config loader — from return codes to exceptions and assertionsUnit 8 · Error Handling
  9. 9Generics, type erasure, lambdas and streams — modern Java one feature at a timeUnit 9 · Language evolution
  10. 10Six design patterns, built and tested — Singleton to ObserverUnit 10 · Design Patterns
2
Part IB
1 course12 lab lessonsCC++
- PROGCCC++
  Programming in C and C++
  12
  lessons
  - C from the ground up — integers, bits and hand-written string functions
  - Functions, linkage and the preprocessor across two compilation units
  See all 12 lessonsHide
  1. 1C from the ground up — integers, bits and hand-written string functionsUnit 1 · Introduction to the C language
  2. 2Functions, linkage and the preprocessor across two compilation unitsUnit 2 · Introduction to the C language (continued)
  3. 3Pointer ranges, callbacks, structs and a tagged unionUnit 3 · Introduction to the C language (continued)
  4. 4Heap-backed strings, a growable vector and formatted I/OUnit 4 · Introduction to the C language (continued)
  5. 5Overflow-proof arithmetic and bounded buffers without undefined behaviourUnit 5 · C semantics and tools
  6. 6A bump-pointer arena, a malloc'd BST and shared expression DAGsUnit 6 · Memory allocation, data structures and aliasing
  7. 7A reference-counted heap with a mark-and-sweep collector in CUnit 7 · Further memory management
  8. 8Cache-aware C: struct layout, intrusive lists, SoA and loop blockingUnit 8 · Memory hierarchy and cache optimization
  9. 9A debugging toolkit in C: test runner, invariants, trace buffer, bisect and shrinkUnit 9 · Debugging
  10. 10From C to C++: references, overloading, default arguments and std::stringUnit 10 · Introduction to C++
  11. 11C++ objects: a Fraction type, an RAII buffer, virtual shapes and a diamond of devicesUnit 11 · Objects in C++
  12. 12C++ templates and meta-programming — from max_of to compile-time type listsUnit 12 · Other C++ concepts

The full 77-course syllabus is transcribed in the app, including the theory courses. Lessons are authored against the course codes that have practical work, and the list grows with each release.

GroutCode is not affiliated with or endorsed by University of Cambridge. Course codes and titles are transcribed from the institution’s published scheme documents.

How a practical runs

The same five steps for every lesson, in every language.

1
Pick your syllabus
Choose your university or board and the semester or class you are in. The course list is the transcribed official scheme, not an approximation.
2
Open a lab lesson
Each lesson is a stepped practical for a specific course, with a starter file you edit and a test file you do not.
3
Write the code yourself
The starter has the signatures and the TODOs. You implement them in the editor, in the language your course actually uses.
4
Run the checks
The toolchain compiles and runs the tests — 8 to 15 of them across the lesson, one per step, so you find out which change broke what.
5
Get the review
Once the tests pass, the model reads your implementation and tells you the input that breaks it. It never reports the pass or fail itself.

Why the compiler grades, not the model

The obvious way to build an AI lab tool is to let the model read the student’s code and say whether it is correct. It is also the way that produces a tool nobody can trust. A model will tell you your code works when the compiler says otherwise, and it will fail you for a style it happens to dislike.

So the two jobs are split:

The model designs the lesson, writes the starter and the tests, and — after the tests pass — reads what you actually wrote and tells you the input that breaks it.
The toolchain decides whether it compiles and whether each step passes. That verdict is not negotiable and the model never issues it.

And why steps instead of one big task

A 40-to-60 minute practical with a single Run at the end gives a beginner one bit of feedback an hour, and it arrives after every decision has already been made. Each lesson here is 8 to 15 steps, each with its own instruction and its own check, so you find out which change broke what while you still remember making it.

Frequently asked questions

Does GroutCode cover the Cambridge 2026-27?

Yes. GroutCode ships the transcribed Cambridge 2026-27 for Computer Science Tripos — 77 courses — with 36 authored lab lessons mapped to specific course codes. The syllabus was transcribed from the official documents, and the source and checksum of each one is recorded in the app.

Which languages do the Cambridge practicals use?

Java (16 lessons), C (9 lessons), SQL (8 lessons), C++ (3 lessons). The language is set per course code rather than guessed from the title, because the same subject is taught in different languages at different institutions.

Does the AI just write the practical for me?

No. The starter file has the signatures and the TODOs; you implement them. The toolchain — not the model — decides whether your code compiles and whether each step passes, so the AI cannot tell you your code works when the compiler disagrees. What it does afterwards is read your implementation and point out the input that breaks it.

Do the practicals work offline?

The lessons, the syllabus and the test runner are bundled in the app and run locally, so the compile-and-check loop works with no connection. The review step at the end uses a model, which can be a local one or a cloud one with your own key.

What do I need installed?

GroutCode detects which toolchains are present on your machine and tells you what is missing and what would fix it. You need the compiler or interpreter for the language your course uses — a C compiler, a JDK, Python, Node or SQLite.