United Kingdom · 2026-27
Imperial College London
24 lab practicals for the Imperial College syllabus.
Imperial College London BEng/MEng Computing: computing practicals, algorithms, databases, operating systems and machine learning. 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.
Updated
Semester by semester
Programme: BEng/MEng Computing. Scheme: Module descriptions 2026-27. Open a course to see its practical units and the lab lesson GroutCode ships for each.
Year 1
2 courses5 lab lessonsSQLJavaC- COMP40007SQL
Introduction to Databases
3
lessons
- Normalising an enrolment table into 3NF
- Relational algebra as SQL views
- 1Normalising an enrolment table into 3NFUnit 2 · Database Design and Normalisation
- 2Relational algebra as SQL viewsUnit 3 · Relational Languages and SQL
- 3Integrity, views, triggers and serializabilityUnit 4 · Views, Integrity, Security and Transactions
- COMP40009JavaC
Computing Practical 1
2
lessons
- Functional and object-oriented Java: from folds to value classes
- A toy CPU emulator and assembler in C
- 1Functional and object-oriented Java: from folds to value classesUnit 2 · Kotlin and Java Programming
- 2A toy CPU emulator and assembler in CUnit 3 · Assembler and C: Computer Systems Project
Year 2
5 courses17 lab lessonsPythonJavaC- COMP50001Python
Algorithm Design and Analysis
4
lessons
- Counting the work: operation counts, recurrences and growth order
- Divide and conquer to dynamic programming: from Karatsuba to knapsack
- 1Counting the work: operation counts, recurrences and growth orderUnit 1 · Quantitative Analysis of Algorithms
- 2Divide and conquer to dynamic programming: from Karatsuba to knapsackUnit 2 · Divide and Conquer and Dynamic Programming
- 3Greedy choices and random pivots: scheduling, Huffman and Miller-RabinUnit 3 · Greedy and Randomised Algorithms
- 4Shortest paths, flows and pattern matching: a graph and string toolkitUnit 4 · Advanced Graph and String Algorithms
- COMP50002Java
Software Design and Evolution
2
lessons
- Designing for change: an order module behind interfaces, then measured
- Safe change with tests, doubles and a legacy receipt printer
- 1Designing for change: an order module behind interfaces, then measuredUnit 1 · Designing for Change
- 2Safe change with tests, doubles and a legacy receipt printerUnit 2 · Enabling Safe Change
- COMP50004C
Operating Systems
4
lessons
- Processes, pthreads and home-made synchronisation primitives
- CPU schedulers and the banker's algorithm — simulating what the kernel decides
- 1Processes, pthreads and home-made synchronisation primitivesUnit 2 · Processes, Threads and Synchronisation
- 2CPU schedulers and the banker's algorithm — simulating what the kernel decidesUnit 3 · Concurrency Control and Scheduling
- 3Paging, TLBs and page replacement — a virtual memory simulatorUnit 4 · Virtual Memory
- 4Disk scheduling and file-system structures — from seek distance to path lookupUnit 5 · Devices, I/O and File Systems
- COMP50007AC
Computing Practical 2 (Lab)
2
lessons
- Inside a teaching kernel: Pintos scheduling, alarm clock and virtual memory
- PThreads from the ground up: parallel reductions, bounded buffers and barriers
- 1Inside a teaching kernel: Pintos scheduling, alarm clock and virtual memoryUnit 1 · Operating System Implementation (Pintos)
- 2PThreads from the ground up: parallel reductions, bounded buffers and barriersUnit 2 · Concurrent Programming with PThreads
- COMP50013Python
Machine Learning
5
lessons
- Nearest neighbours, locally weighted regression and decision trees from scratch
- Evaluating learners honestly: splits, cross-validation, metrics and significance
- 1Nearest neighbours, locally weighted regression and decision trees from scratchUnit 2 · Instance Based Learning and Inductive Learning
- 2Evaluating learners honestly: splits, cross-validation, metrics and significanceUnit 3 · Model Evaluation and Comparison
- 3Neural networks by hand: perceptron, back-propagation and SGD on plain listsUnit 4 · Neural Networks
- 4Unsupervised learning from scratch: K-means, kernel density and Gaussian mixturesUnit 5 · Unsupervised Learning
- 5Evolutionary search: a genetic algorithm, a (1+1)-ES, novelty search and MAP-ElitesUnit 6 · Evolutionary Algorithms
Year 3
1 course2 lab lessonsC++- COMP60007C++
The Theory and Practice of Concurrent Programming
2
lessons
- Shared-memory concurrency in C++: locks, atomics, primitives and race detectors
- Correct concurrency: deadlock, monitors, linearisability and a lock-free stack
- 1Shared-memory concurrency in C++: locks, atomics, primitives and race detectorsUnit 1 · Practical Concurrent Programming in C++
- 2Correct concurrency: deadlock, monitors, linearisability and a lock-free stackUnit 3 · Correctness and Synchronisation Patterns
The full 38-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 Imperial College London. 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 Imperial College 2026-27?
Yes. GroutCode ships the transcribed Imperial College 2026-27 for BEng/MEng Computing — 38 courses — with 24 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 Imperial College practicals use?
Python (9 lessons), C (7 lessons), SQL (3 lessons), Java (3 lessons), C++ (2 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.
Other syllabuses
Oxford
University of Oxford
University of Oxford Computer Science course synopses for 2026-27: databases, database systems implementation and AI.
27
lab lessons
Cambridge
University of Cambridge
The Cambridge Computer Science Tripos, Parts IA and IB: algorithms, databases, object-oriented programming, C and C++.
36
lab lessons
UCL
University College London
UCL BSc and MEng Computer Science, Years 1 to 4: programming principles, OOP, algorithms, compilers and systems.
51
lab lessons
Do your Imperial College lab work with the checks built in
GroutCode is included in every Grout Suite license. Free download for Windows and macOS.
Download GroutCode