University College London

United Kingdom · 2026/27

University College London

51 lab practicals for the UCL syllabus.

UCL BSc and MEng Computer Science, Years 1 to 4: programming principles, OOP, algorithms, compilers and systems. 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 GroutCodeAll syllabuses

Updated

Semester by semester

Programme: BSc / MEng Computer Science. Scheme: 2026/27 module catalogue. Open a course to see its practical units and the lab lesson GroutCode ships for each.

  1. Year 1

    3 courses13 lab lessonsCPythonJava
    • COMP0002CPython

      Principles of Programming

      4

      lessons

      • From algorithms to a tiny compiler — gcd, primes, bases, a tokenizer and an expression evaluator
      • Imperative C from the ground up — control flow, types, scope, pointers, the heap and files
      See all 4 lessons
      1. 1From algorithms to a tiny compiler — gcd, primes, bases, a tokenizer and an expression evaluatorUnit I · Core Programming Concepts
      2. 2Imperative C from the ground up — control flow, types, scope, pointers, the heap and filesUnit II · Introduction to Imperative Programming
      3. 3Functional programming in Python — cons lists, folds, composition, lazy streams and persistent treesUnit III · Introduction to Functional Programming
      4. 4Small programs, designed well — binary search, a stack, a ring-buffer queue and a linked listUnit IV · Program design in the small
    • COMP0004Java

      Object-Oriented Programming

      3

      lessons

      • Object-oriented principles in Java — a small bank built from value objects, interfaces and encapsulation
      • Object-oriented design — a lending library with abstract classes, interfaces and a service layer
      See all 3 lessons
      1. 1Object-oriented principles in Java — a small bank built from value objects, interfaces and encapsulationUnit I · Object-Oriented Principles
      2. 2Object-oriented design — a lending library with abstract classes, interfaces and a service layerUnit II · Object-Oriented Programming
      3. 3Data representation — growable list, linked stack, hash map and a CSV data setUnit III · Data Representation
    • COMP0005Python

      Algorithms

      6

      lessons

      • Analysing algorithms — counting, doubling experiments and growth orders
      • Abstract data types — stacks, queues, deques and a priority queue from scratch
      See all 6 lessons
      1. 1Analysing algorithms — counting, doubling experiments and growth ordersUnit I · Analysis of algorithms
      2. 2Abstract data types — stacks, queues, deques and a priority queue from scratchUnit II · Abstract Data Types
      3. 3Sorting algorithms — from selection sort to 3-way quicksort and heapsortUnit III · Sorting Algorithms
      4. 4Searching — binary search, an ordered BST and two hash tablesUnit IV · Searching Algorithms
      5. 5Graph algorithms — BFS, components, topological sort, SCCs and shortest pathsUnit V · Graphs Algorithms
      6. 6String processing — radix sorts, tries, KMP, Boyer-Moore, Rabin-Karp and HuffmanUnit VI · String-processing Algorithms

  2. Year 2

    1 course5 lab lessonsJava
    • COMP0010Java

      Software Engineering

      5

      lessons

      • Object-oriented design principles — fixing ten broken designs
      • Design patterns — ten Gang of Four patterns, built and tested
      See all 5 lessons
      1. 1Object-oriented design principles — fixing ten broken designsUnit I · Object Oriented Design Principles
      2. 2Design patterns — ten Gang of Four patterns, built and testedUnit II · Design Patterns
      3. 3A ports-and-adapters order system: domain core, adapters, events and a composition rootUnit III · Software Architecture
      4. 4Build a unit-testing framework, then make tests that kill mutantsUnit IV · Testing
      5. 5Refactor a legacy rental statement under a golden masterUnit V · Tools and Processes

  3. Year 3

    3 courses26 lab lessonsJavaCPython
    • COMP0012Java

      Compilers

      6

      lessons

      • A hand-written lexer, then regular expressions to NFA to DFA
      • Recursive-descent parsing to ASTs, then FIRST/FOLLOW and a table-driven LL(1) parser
      See all 6 lessons
      1. 1A hand-written lexer, then regular expressions to NFA to DFAUnit I · Anatomy of a compiler and lexical analysis
      2. 2Recursive-descent parsing to ASTs, then FIRST/FOLLOW and a table-driven LL(1) parserUnit II · Syntax analysis (parsing)
      3. 3Syntax-directed translation — a parser whose actions build the ASTUnit III · Syntax-directed translation
      4. 4Semantic analysis — a scoped symbol table and a Visitor type checkerUnit IV · Semantic analysis
      5. 5Three-address code — generating IR from a tree, and running itUnit V · Intermediate code generation
      6. 6Code generation and optimisation — frames, basic blocks, IR passes and a peephole optimiserUnit VI · Code generation and optimisation
    • COMP0019C

      Computer Systems

      9

      lessons

      • Machine-level data — bits, two's complement, byte order, layout and the stack frame
      • Bug hunting with gdb — ten broken C functions, found with breakpoints, watchpoints and backtraces
      See all 9 lessons
      1. 1Machine-level data — bits, two's complement, byte order, layout and the stack frameUnit I · Machine-level representation of code and data
      2. 2Bug hunting with gdb — ten broken C functions, found with breakpoints, watchpoints and backtracesUnit II · Debugging C with gdb
      3. 3Undefined behaviour in C — overflow-checked arithmetic, safe shifts, type punning and saturating castsUnit III · Undefined behaviour
      4. 4Cache simulator — address splitting, LRU set-associative caches, write-back and the cost of loop orderUnit IV · The memory hierarchy
      5. 5A linker in miniature — symbol resolution, archive order, section layout, relocations and PLT/GOT bindingUnit V · Linking
      6. 6A model kernel — wait statuses, errno, signal sets, fork/exit/waitpid, signal delivery and job controlUnit VI · Processes and exceptional control flow
      7. 7Virtual memory — page tables, a TLB and a heap allocator in CUnit VII · Virtual memory
      8. 8System I/O — robust reads and writes, buffered lines, files and dup2Unit VIII · System I/O
      9. 9Concurrent C — threads, locks, condition variables and deadlock-free transfersUnit IX · Concurrent systems programming
    • COMP0023Python

      Networked Systems

      11

      lessons

      • Information, error-control codes and compression — entropy to Hamming, CRC, Huffman and LZW
      • Sharing the wire — ALOHA, CDMA, Ethernet backoff, learning switches and spanning trees
      See all 11 lessons
      1. 1Information, error-control codes and compression — entropy to Hamming, CRC, Huffman and LZWUnit I · Introduction to Networking
      2. 2Sharing the wire — ALOHA, CDMA, Ethernet backoff, learning switches and spanning treesUnit II · Medium Access Control and the Link Layer
      3. 3Reliable delivery over a lossy channel: checksums, stop-and-wait and Go-Back-NUnit III · Achieving Reliability
      4. 4Selective Repeat, IP prefixes, NAT and a router's forwarding planeUnit IV · Selective Repeat and Internetworking
      5. 5A DNS message codec, an iterative resolver and the end-to-end argument in numbersUnit V · The Domain Name System
      6. 6Inside TCP: headers, the connection state machine, reassembly and retransmission timersUnit VI · Reliable Transport and TCP
      7. 7TCP congestion control: slow start, AIMD, Reno fast recovery and fairnessUnit VII · TCP and Congestion Control
      8. 8Intra-domain routing — Dijkstra link-state and Bellman-Ford distance-vectorUnit VIII · Intra-Domain Routing
      9. 9Inter-domain routing — BGP path selection and Gao-Rexford policyUnit IX · Inter-Domain Routing
      10. 10Wireless networks — link budgets, hidden terminals and the 802.11 DCFUnit X · Wireless Networks
      11. 11Security and content delivery — firewall, IDS, HTTP caching and a CDN hash ringUnit XI · Security and Content Delivery

  4. Year 4

    1 course7 lab lessonsPython
    • COMP0089Python

      Reinforcement Learning

      7

      lessons

      • Markov decision processes — returns, Bellman equations and the Student MDP
      • Planning by dynamic programming — policy evaluation, policy iteration and value iteration on a gridworld
      See all 7 lessons
      1. 1Markov decision processes — returns, Bellman equations and the Student MDPUnit I · Markov decision processes
      2. 2Planning by dynamic programming — policy evaluation, policy iteration and value iteration on a gridworldUnit II · Planning by dynamic programming
      3. 3Model-free prediction and control — Monte Carlo, TD(λ), SARSA and Q-learning from raw episodesUnit III · Model-free prediction and control
      4. 4Value function approximation — linear features, semi-gradient TD, LSTD and a replay-buffer DQNUnit IV · Value function approximation
      5. 5Policy gradients and actor-critic — a softmax policy trained by REINFORCE and by its own criticUnit V · Policy gradient methods, Actor-critic algorithms
      6. 6Integrating learning and planning — learned models, Dyna-Q and Monte Carlo tree searchUnit VI · Integration of Learning and Planning
      7. 7Multi-armed bandits — epsilon-greedy, UCB, gradient and Thompson agentsUnit VII · Exploration vs exploitation trade-offs

The full 34-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 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. 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. 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. 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. 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. 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 UCL 2026/27?

Yes. GroutCode ships the transcribed UCL 2026/27 for BSc / MEng Computer Science — 34 courses — with 51 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 UCL practicals use?

Python (25 lessons), Java (14 lessons), C (12 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

University of Oxford

Oxford

University of Oxford

University of Oxford Computer Science course synopses for 2026-27: databases, database systems implementation and AI.

27

lab lessons

2026-27Java · SQL · C++
University of Cambridge

Cambridge

University of Cambridge

The Cambridge Computer Science Tripos, Parts IA and IB: algorithms, databases, object-oriented programming, C and C++.

36

lab lessons

2026-27Java · C · SQL · C++
Imperial College London

Imperial College

Imperial College London

Imperial College London BEng/MEng Computing: computing practicals, algorithms, databases, operating systems and machine learning.

24

lab lessons

2026-27Python · C · SQL · Java

← All supported syllabuses

Do your UCL lab work with the checks built in

GroutCode is included in every Grout Suite license. Free download for Windows and macOS.

Download GroutCode