University College London

Verenigd Koninkrijk · 2026/27

University College London

51 labpractica voor het UCL-leerplan.

BSc en MEng Computer Science aan UCL, jaar 1 tot en met 4: programmeerprincipes, OOP, algoritmen, compilers en systemen. Elke les verloopt in stappen en wordt gecompileerd en gecontroleerd door een echte toolchain op je eigen computer — het model beoordeelt je code achteraf, het bepaalt niet of je geslaagd bent.

Download GroutCodeAlle leerplannen

Bijgewerkt

Semester per semester

Opleiding: BSc / MEng Computer Science. Regeling: 2026/27 module catalogue. Open een vak om de practicumonderdelen te zien en het labpracticum dat GroutCode bij elk onderdeel meelevert.

  1. Year 1

    3 vakken13 lablessenCPythonJava
    • COMP0002CPython

      Principles of Programming

      4

      lessen

      • 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
      Bekijk alle 4 lessen
      1. 1From algorithms to a tiny compiler — gcd, primes, bases, a tokenizer and an expression evaluatorOnderdeel I · Core Programming Concepts
      2. 2Imperative C from the ground up — control flow, types, scope, pointers, the heap and filesOnderdeel II · Introduction to Imperative Programming
      3. 3Functional programming in Python — cons lists, folds, composition, lazy streams and persistent treesOnderdeel III · Introduction to Functional Programming
      4. 4Small programs, designed well — binary search, a stack, a ring-buffer queue and a linked listOnderdeel IV · Program design in the small
    • COMP0004Java

      Object-Oriented Programming

      3

      lessen

      • 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
      Bekijk alle 3 lessen
      1. 1Object-oriented principles in Java — a small bank built from value objects, interfaces and encapsulationOnderdeel I · Object-Oriented Principles
      2. 2Object-oriented design — a lending library with abstract classes, interfaces and a service layerOnderdeel II · Object-Oriented Programming
      3. 3Data representation — growable list, linked stack, hash map and a CSV data setOnderdeel III · Data Representation
    • COMP0005Python

      Algorithms

      6

      lessen

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

  2. Year 2

    1 vak5 lablessenJava
    • COMP0010Java

      Software Engineering

      5

      lessen

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

  3. Year 3

    3 vakken26 lablessenJavaCPython
    • COMP0012Java

      Compilers

      6

      lessen

      • 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
      Bekijk alle 6 lessen
      1. 1A hand-written lexer, then regular expressions to NFA to DFAOnderdeel I · Anatomy of a compiler and lexical analysis
      2. 2Recursive-descent parsing to ASTs, then FIRST/FOLLOW and a table-driven LL(1) parserOnderdeel II · Syntax analysis (parsing)
      3. 3Syntax-directed translation — a parser whose actions build the ASTOnderdeel III · Syntax-directed translation
      4. 4Semantic analysis — a scoped symbol table and a Visitor type checkerOnderdeel IV · Semantic analysis
      5. 5Three-address code — generating IR from a tree, and running itOnderdeel V · Intermediate code generation
      6. 6Code generation and optimisation — frames, basic blocks, IR passes and a peephole optimiserOnderdeel VI · Code generation and optimisation
    • COMP0019C

      Computer Systems

      9

      lessen

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

      Networked Systems

      11

      lessen

      • 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
      Bekijk alle 11 lessen
      1. 1Information, error-control codes and compression — entropy to Hamming, CRC, Huffman and LZWOnderdeel I · Introduction to Networking
      2. 2Sharing the wire — ALOHA, CDMA, Ethernet backoff, learning switches and spanning treesOnderdeel II · Medium Access Control and the Link Layer
      3. 3Reliable delivery over a lossy channel: checksums, stop-and-wait and Go-Back-NOnderdeel III · Achieving Reliability
      4. 4Selective Repeat, IP prefixes, NAT and a router's forwarding planeOnderdeel IV · Selective Repeat and Internetworking
      5. 5A DNS message codec, an iterative resolver and the end-to-end argument in numbersOnderdeel V · The Domain Name System
      6. 6Inside TCP: headers, the connection state machine, reassembly and retransmission timersOnderdeel VI · Reliable Transport and TCP
      7. 7TCP congestion control: slow start, AIMD, Reno fast recovery and fairnessOnderdeel VII · TCP and Congestion Control
      8. 8Intra-domain routing — Dijkstra link-state and Bellman-Ford distance-vectorOnderdeel VIII · Intra-Domain Routing
      9. 9Inter-domain routing — BGP path selection and Gao-Rexford policyOnderdeel IX · Inter-Domain Routing
      10. 10Wireless networks — link budgets, hidden terminals and the 802.11 DCFOnderdeel X · Wireless Networks
      11. 11Security and content delivery — firewall, IDS, HTTP caching and a CDN hash ringOnderdeel XI · Security and Content Delivery

  4. Year 4

    1 vak7 lablessenPython
    • COMP0089Python

      Reinforcement Learning

      7

      lessen

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

Het volledige leerplan van 34 vakken is in de app uitgewerkt, inclusief de theorievakken. De lessen zijn geschreven bij de vakcodes met practicumwerk, en de lijst groeit met elke release.

GroutCode is niet verbonden aan of goedgekeurd door University College London. Vakcodes en vaktitels zijn overgenomen uit de gepubliceerde regelingsdocumenten van de instelling.

Zo verloopt een practicum

Dezelfde vijf stappen bij elke les, in elke taal.

  1. 1

    Kies je leerplan

    Kies je universiteit of examenorgaan en het semester of de klas waarin je zit. De vakkenlijst is de officiële regeling zoals die is overgenomen, geen benadering.

  2. 2

    Open een labpracticum

    Elke les is een practicum in stappen bij een specifiek vak, met een startbestand dat je bewerkt en een testbestand dat je met rust laat.

  3. 3

    Schrijf de code zelf

    In het startbestand staan de signatures en de TODO's. Jij werkt ze uit in de editor, in de taal die je vak daadwerkelijk gebruikt.

  4. 4

    Draai de controles

    De toolchain compileert en draait de tests — 8 tot 15 stuks verspreid over de les, één per stap, zodat je ziet welke wijziging wat kapotmaakte.

  5. 5

    Krijg de review

    Zodra de tests slagen, leest het model je uitwerking en vertelt het je welke invoer hem laat vastlopen. Het meldt zelf nooit of je geslaagd of gezakt bent.

Waarom de compiler beoordeelt en niet het model

De voor de hand liggende manier om een AI-labtool te bouwen, is het model de code van de student te laten lezen en te laten zeggen of die klopt. Het is ook de manier die een tool oplevert die niemand kan vertrouwen. Een model vertelt je dat je code werkt terwijl de compiler iets anders zegt, en laat je zakken op een stijl die het toevallig niet aanstaat.

Daarom zijn de twee taken gescheiden:

  • Het model ontwerpt de les, schrijft het startbestand en de tests, en leest — zodra de tests slagen — wat jij daadwerkelijk hebt geschreven, om je te vertellen welke invoer het laat vastlopen.
  • De toolchain bepaalt of het compileert en of elke stap slaagt. Dat oordeel staat vast en het model velt het nooit.

En waarom stappen in plaats van één grote opdracht

Een practicum van 40 tot 60 minuten met één keer Run aan het eind geeft een beginner één stukje feedback per uur, en dat komt pas nadat alle beslissingen al genomen zijn. Elke les hier bestaat uit 8 tot 15 stappen, elk met een eigen instructie en een eigen controle, zodat je ziet welke wijziging wat kapotmaakte terwijl je je die wijziging nog herinnert.

Veelgestelde vragen

Ondersteunt GroutCode de UCL 2026/27?

Ja. GroutCode bevat de overgenomen UCL 2026/27 voor BSc / MEng Computer Science — 34 vakken — met 51 uitgewerkte labpractica die aan specifieke vakcodes zijn gekoppeld. Het leerplan is overgenomen uit de officiële documenten, en van elk document zijn de bron en de checksum in de app vastgelegd.

Welke talen gebruiken de UCL-practica?

Python (25 lessen), Java (14 lessen), C (12 lessen). De taal is per vakcode ingesteld en niet afgeleid uit de titel, omdat hetzelfde vak op verschillende instellingen in verschillende talen wordt gegeven.

Schrijft de AI het practicum gewoon voor me?

Nee. In het startbestand staan de signatures en de TODO's; jij werkt ze uit. De toolchain — niet het model — bepaalt of je code compileert en of elke stap slaagt, zodat de AI je niet kan wijsmaken dat je code werkt terwijl de compiler het er niet mee eens is. Wat het daarna wel doet, is je uitwerking lezen en aanwijzen welke invoer hem laat vastlopen.

Werken de practica offline?

De lessen, het leerplan en de testrunner zitten in de app en draaien lokaal, dus de cyclus van compileren en controleren werkt zonder verbinding. Voor de reviewstap aan het eind wordt een model gebruikt; dat kan een lokaal model zijn of een cloudmodel met je eigen sleutel.

Wat moet ik geïnstalleerd hebben?

GroutCode kijkt welke toolchains er op je computer staan en vertelt je wat er ontbreekt en hoe je dat oplost. Je hebt de compiler of interpreter nodig voor de taal die je vak gebruikt — een C-compiler, een JDK, Python, Node of SQLite.

Andere leerplannen

University of Oxford

Oxford

University of Oxford

De vakbeschrijvingen Computer Science 2026-27 van de University of Oxford: databases, implementatie van databasesystemen en AI.

27

lablessen

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

Cambridge

University of Cambridge

De Cambridge Computer Science Tripos, Parts IA en IB: algoritmen, databases, objectgeoriënteerd programmeren, C en C++.

36

lablessen

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

Imperial College

Imperial College London

BEng/MEng Computing aan Imperial College London: computing practicals, algoritmen, databases, besturingssystemen en machine learning.

24

lablessen

2026-27Python · C · SQL · Java

← Alle ondersteunde leerplannen

Doe je UCL-labwerk met de controles ingebouwd

GroutCode zit bij elke Grout Suite-licentie inbegrepen. Gratis te downloaden voor Windows en macOS.

Download GroutCode