University College London

Vereinigtes Königreich · 2026/27

University College London

51 Laborpraktika für den UCL-Lehrplan.

BSc und MEng Computer Science am UCL, Jahr 1 bis 4: Programmiergrundlagen, OOP, Algorithmen, Compiler und Systeme. Jede Lektion ist in Schritte gegliedert, wird kompiliert und von einer echten Toolchain auf Ihrem eigenen Rechner geprüft — das Modell begutachtet Ihren Code im Anschluss, es entscheidet nicht darüber, ob Sie bestanden haben.

GroutCode herunterladenAlle Lehrpläne

Aktualisiert

Semester für Semester

Studiengang: BSc / MEng Computer Science. Prüfungsordnung: 2026/27 module catalogue. Öffnen Sie einen Kurs, um seine praktischen Einheiten und die Laborlektion zu sehen, die GroutCode jeweils mitliefert.

  1. Year 1

    3 Module13 LaborlektionenCPythonJava
    • COMP0002CPython

      Principles of Programming

      4

      Lektionen

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

      Object-Oriented Programming

      3

      Lektionen

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

      Algorithms

      6

      Lektionen

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

  2. Year 2

    1 Modul5 LaborlektionenJava
    • COMP0010Java

      Software Engineering

      5

      Lektionen

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

  3. Year 3

    3 Module26 LaborlektionenJavaCPython
    • COMP0012Java

      Compilers

      6

      Lektionen

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

      Computer Systems

      9

      Lektionen

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

      Networked Systems

      11

      Lektionen

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

  4. Year 4

    1 Modul7 LaborlektionenPython
    • COMP0089Python

      Reinforcement Learning

      7

      Lektionen

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

Der vollständige Lehrplan mit 34 Kursen ist in der App erfasst, einschließlich der Theoriekurse. Lektionen werden zu den Kurscodes erstellt, die praktische Anteile haben, und die Liste wächst mit jeder Version.

GroutCode steht in keiner Verbindung zu University College London und wird von dieser Einrichtung nicht unterstützt. Kurscodes und -titel stammen aus den veröffentlichten Schemadokumenten der Einrichtung.

So läuft ein Praktikum ab

Dieselben fünf Schritte für jede Lektion, in jeder Sprache.

  1. 1

    Lehrplan auswählen

    Wählen Sie Ihre Hochschule oder Ihr Prüfungsamt und das Semester oder die Klasse, in der Sie sind. Die Kursliste ist die erfasste offizielle Prüfungsordnung, keine Annäherung.

  2. 2

    Laborlektion öffnen

    Jede Lektion ist ein schrittweises Praktikum zu einem bestimmten Kurs, mit einer Startdatei, die Sie bearbeiten, und einer Testdatei, die Sie nicht anfassen.

  3. 3

    Den Code selbst schreiben

    Die Startdatei enthält die Signaturen und die TODOs. Sie setzen sie im Editor um, in der Sprache, die Ihr Kurs tatsächlich verwendet.

  4. 4

    Die Prüfungen laufen lassen

    Die Toolchain kompiliert und führt die Tests aus — 8 bis 15 über die Lektion verteilt, einer pro Schritt, damit Sie sehen, welche Änderung was kaputt gemacht hat.

  5. 5

    Das Review erhalten

    Sobald die Tests bestanden sind, liest das Modell Ihre Implementierung und nennt Ihnen die Eingabe, an der sie scheitert. Über Bestehen oder Nichtbestehen entscheidet es nie selbst.

Warum der Compiler bewertet und nicht das Modell

Der naheliegende Weg, ein KI-Laborwerkzeug zu bauen, ist, das Modell den Code der Studierenden lesen und sagen zu lassen, ob er korrekt ist. Es ist zugleich der Weg, der ein Werkzeug hervorbringt, dem niemand vertrauen kann. Ein Modell wird Ihnen sagen, Ihr Code funktioniere, obwohl der Compiler das Gegenteil behauptet — und es wird Sie durchfallen lassen wegen eines Stils, den es zufällig nicht mag.

Deshalb sind die beiden Aufgaben getrennt:

  • Das Modell entwirft die Lektion, schreibt die Startdatei und die Tests und liest — nachdem die Tests bestanden sind — was Sie tatsächlich geschrieben haben, und nennt Ihnen die Eingabe, an der es scheitert.
  • Die Toolchain entscheidet, ob es kompiliert und ob jeder Schritt besteht. Dieses Urteil ist nicht verhandelbar, und das Modell fällt es nie.

Und warum Schritte statt einer großen Aufgabe

Ein Praktikum über 40 bis 60 Minuten mit einem einzigen Durchlauf am Ende gibt einem Anfänger genau eine Rückmeldung pro Stunde — und die kommt, wenn längst alle Entscheidungen gefallen sind. Jede Lektion hier besteht aus 8 bis 15 Schritten, jeder mit eigener Anweisung und eigener Prüfung, damit Sie noch wissen, welche Änderung was kaputt gemacht hat, während Sie sich an sie erinnern.

Häufig gestellte Fragen

Deckt GroutCode UCL 2026/27 ab?

Ja. GroutCode liefert die erfasste Prüfungsordnung UCL 2026/27 für BSc / MEng Computer Science mit — 34 Kurse — samt 51 eigens erstellten Laborlektionen, die bestimmten Kurscodes zugeordnet sind. Der Lehrplan wurde aus den offiziellen Dokumenten übernommen, und Quelle sowie Prüfsumme jedes Dokuments sind in der App vermerkt.

Welche Sprachen verwenden die UCL-Praktika?

Python (25 Lektionen), Java (14 Lektionen), C (12 Lektionen). Die Sprache ist pro Kurscode festgelegt und wird nicht aus dem Titel erraten, denn dasselbe Fach wird an verschiedenen Einrichtungen in verschiedenen Sprachen unterrichtet.

Schreibt die KI das Praktikum einfach für mich?

Nein. Die Startdatei enthält die Signaturen und die TODOs; umsetzen müssen Sie sie. Die Toolchain — nicht das Modell — entscheidet, ob Ihr Code kompiliert und ob jeder Schritt besteht. Die KI kann Ihnen also nicht sagen, Ihr Code funktioniere, wenn der Compiler widerspricht. Was sie im Anschluss tut: Sie liest Ihre Implementierung und zeigt Ihnen die Eingabe, an der sie scheitert.

Funktionieren die Praktika offline?

Die Lektionen, der Lehrplan und der Testrunner sind in der App enthalten und laufen lokal, sodass die Schleife aus Kompilieren und Prüfen ohne Verbindung funktioniert. Der Review-Schritt am Ende nutzt ein Modell — entweder ein lokales oder ein Cloud-Modell mit Ihrem eigenen Schlüssel.

Was muss bei mir installiert sein?

GroutCode erkennt, welche Toolchains auf Ihrem Rechner vorhanden sind, und sagt Ihnen, was fehlt und was es beheben würde. Sie brauchen den Compiler oder Interpreter für die Sprache Ihres Kurses — einen C-Compiler, ein JDK, Python, Node oder SQLite.

Weitere Lehrpläne

University of Oxford

Oxford

University of Oxford

Die Kursbeschreibungen der Informatik an der University of Oxford für 2026-27: Datenbanken, Implementierung von Datenbanksystemen und KI.

27

Laborlektionen

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

Cambridge

University of Cambridge

Der Cambridge Computer Science Tripos, Parts IA und IB: Algorithmen, Datenbanken, objektorientierte Programmierung, C und C++.

36

Laborlektionen

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

Imperial College

Imperial College London

BEng/MEng Computing am Imperial College London: Programmierpraktika, Algorithmen, Datenbanken, Betriebssysteme und maschinelles Lernen.

24

Laborlektionen

2026-27Python · C · SQL · Java

← Alle unterstützten Lehrpläne

Erledigen Sie Ihre UCL-Laborarbeit mit eingebauter Prüfung

GroutCode ist in jeder Grout-Suite-Lizenz enthalten. Kostenloser Download für Windows und macOS.

GroutCode herunterladen