University College London

Royaume-Uni · 2026/27

University College London

51 travaux pratiques pour le programme UCL.

Le BSc et le MEng Computer Science d'UCL, Years 1 à 4 : principes de programmation, POO, algorithmique, compilation et systèmes. Chaque séance est progressive, compilée et vérifiée par une véritable chaîne d'outils sur votre propre machine — le modèle relit votre code ensuite, il ne décide pas si vous avez réussi.

Télécharger GroutCodeTous les programmes

Mis à jour

Semestre par semestre

Formation : BSc / MEng Computer Science. Régime : 2026/27 module catalogue. Ouvrez un cours pour voir ses unités pratiques et la séance de TP que GroutCode propose pour chacune.

  1. Year 1

    3 UE13 leçons de TPCPythonJava
    • COMP0002CPython

      Principles of Programming

      4

      leçons

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

      Object-Oriented Programming

      3

      leçons

      • 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
      Voir les 3 leçons
      1. 1Object-oriented principles in Java — a small bank built from value objects, interfaces and encapsulationChapitre I · Object-Oriented Principles
      2. 2Object-oriented design — a lending library with abstract classes, interfaces and a service layerChapitre II · Object-Oriented Programming
      3. 3Data representation — growable list, linked stack, hash map and a CSV data setChapitre III · Data Representation
    • COMP0005Python

      Algorithms

      6

      leçons

      • Analysing algorithms — counting, doubling experiments and growth orders
      • Abstract data types — stacks, queues, deques and a priority queue from scratch
      Voir les 6 leçons
      1. 1Analysing algorithms — counting, doubling experiments and growth ordersChapitre I · Analysis of algorithms
      2. 2Abstract data types — stacks, queues, deques and a priority queue from scratchChapitre II · Abstract Data Types
      3. 3Sorting algorithms — from selection sort to 3-way quicksort and heapsortChapitre III · Sorting Algorithms
      4. 4Searching — binary search, an ordered BST and two hash tablesChapitre IV · Searching Algorithms
      5. 5Graph algorithms — BFS, components, topological sort, SCCs and shortest pathsChapitre V · Graphs Algorithms
      6. 6String processing — radix sorts, tries, KMP, Boyer-Moore, Rabin-Karp and HuffmanChapitre VI · String-processing Algorithms

  2. Year 2

    1 UE5 leçons de TPJava
    • COMP0010Java

      Software Engineering

      5

      leçons

      • Object-oriented design principles — fixing ten broken designs
      • Design patterns — ten Gang of Four patterns, built and tested
      Voir les 5 leçons
      1. 1Object-oriented design principles — fixing ten broken designsChapitre I · Object Oriented Design Principles
      2. 2Design patterns — ten Gang of Four patterns, built and testedChapitre II · Design Patterns
      3. 3A ports-and-adapters order system: domain core, adapters, events and a composition rootChapitre III · Software Architecture
      4. 4Build a unit-testing framework, then make tests that kill mutantsChapitre IV · Testing
      5. 5Refactor a legacy rental statement under a golden masterChapitre V · Tools and Processes

  3. Year 3

    3 UE26 leçons de TPJavaCPython
    • COMP0012Java

      Compilers

      6

      leçons

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

      Computer Systems

      9

      leçons

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

      Networked Systems

      11

      leçons

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

  4. Year 4

    1 UE7 leçons de TPPython
    • COMP0089Python

      Reinforcement Learning

      7

      leçons

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

Le programme complet, soit 34 cours, est transcrit dans l'application, cours théoriques compris. Les séances sont rédigées à partir des codes de cours comportant des travaux pratiques, et la liste s'étoffe à chaque version.

GroutCode n'est ni affilié à University College London, ni approuvé par cet établissement. Les codes et intitulés de cours sont transcrits à partir des documents de programme publiés par l'établissement.

Comment se déroule un TP

Les mêmes cinq étapes pour chaque séance, dans chaque langage.

  1. 1

    Choisissez votre programme

    Sélectionnez votre université ou votre académie, puis le semestre ou la classe où vous êtes. La liste des cours reprend le référentiel officiel transcrit, pas une approximation.

  2. 2

    Ouvrez une séance de TP

    Chaque séance est un TP progressif rattaché à un cours précis, avec un fichier de départ que vous modifiez et un fichier de tests auquel vous ne touchez pas.

  3. 3

    Écrivez le code vous-même

    Le fichier de départ contient les signatures et les TODO. C'est à vous de les implémenter dans l'éditeur, dans le langage réellement utilisé par votre cours.

  4. 4

    Lancez les vérifications

    La chaîne d'outils compile et exécute les tests — de 8 à 15 sur l'ensemble de la séance, un par étape, pour que vous sachiez quelle modification a cassé quoi.

  5. 5

    Recevez la relecture

    Une fois les tests passés, le modèle lit votre implémentation et vous indique l'entrée qui la met en défaut. Il n'annonce jamais lui-même la réussite ou l'échec.

Pourquoi c'est le compilateur qui évalue, pas le modèle

La manière évidente de construire un outil de TP piloté par l'IA consiste à laisser le modèle lire le code de l'élève et dire s'il est correct. C'est aussi la manière de produire un outil auquel personne ne peut se fier. Un modèle vous dira que votre code fonctionne alors que le compilateur affirme le contraire, et vous recalera pour un style qui, ce jour-là, ne lui plaît pas.

Les deux rôles sont donc séparés :

  • Le modèle conçoit la séance, écrit le fichier de départ et les tests, puis — une fois les tests passés — lit ce que vous avez réellement écrit et vous indique l'entrée qui le met en défaut.
  • La chaîne d'outils décide si le code compile et si chaque étape passe. Ce verdict n'est pas négociable et le modèle ne le prononce jamais.

Et pourquoi des étapes plutôt qu'une seule grande tâche

Un TP de 40 à 60 minutes avec une unique exécution à la fin ne donne au débutant qu'un seul retour par heure, et ce retour arrive une fois toutes les décisions déjà prises. Chaque séance compte ici 8 à 15 étapes, chacune avec sa consigne et sa vérification, pour que vous découvriez quelle modification a cassé quoi pendant que vous vous en souvenez encore.

Questions fréquentes

GroutCode couvre-t-il le programme UCL 2026/27 ?

Oui. GroutCode intègre le programme UCL 2026/27 transcrit pour BSc / MEng Computer Science — soit 34 cours — avec 51 séances de TP rédigées et rattachées à des codes de cours précis. Le programme a été transcrit à partir des documents officiels, et la source ainsi que la somme de contrôle de chacun sont consignées dans l'application.

Quels langages utilisent les TP UCL ?

Python (25 séances), Java (14 séances), C (12 séances). Le langage est défini par code de cours plutôt que deviné d'après l'intitulé, car une même matière est enseignée dans des langages différents selon les établissements.

L'IA fait-elle le TP à ma place ?

Non. Le fichier de départ contient les signatures et les TODO ; c'est à vous de les implémenter. C'est la chaîne d'outils — et non le modèle — qui décide si votre code compile et si chaque étape passe : l'IA ne peut donc pas vous annoncer que votre code fonctionne alors que le compilateur dit l'inverse. Ce qu'elle fait ensuite, c'est lire votre implémentation et pointer l'entrée qui la met en défaut.

Les TP fonctionnent-ils hors ligne ?

Les séances, le programme et l'exécuteur de tests sont embarqués dans l'application et s'exécutent en local : la boucle compilation-vérification fonctionne donc sans aucune connexion. L'étape de relecture finale fait appel à un modèle, qui peut être local ou bien dans le cloud avec votre propre clé.

Que dois-je avoir installé ?

GroutCode détecte les chaînes d'outils présentes sur votre machine et vous indique ce qui manque et comment y remédier. Il vous faut le compilateur ou l'interpréteur du langage utilisé par votre cours — un compilateur C, un JDK, Python, Node ou SQLite.

Autres programmes

University of Oxford

Oxford

University of Oxford

Les course synopses Computer Science 2026-27 de l'université d'Oxford : bases de données, implémentation de systèmes de bases de données et IA.

27

leçons de TP

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

Cambridge

University of Cambridge

Le Computer Science Tripos de Cambridge, Parts IA et IB : algorithmique, bases de données, programmation orientée objet, C et C++.

36

leçons de TP

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

Imperial College

Imperial College London

Le BEng/MEng Computing d'Imperial College London : TP de programmation, algorithmique, bases de données, systèmes d'exploitation et apprentissage automatique.

24

leçons de TP

2026-27Python · C · SQL · Java

← Tous les programmes pris en charge

Faites vos TP UCL avec les vérifications intégrées

GroutCode est inclus dans chaque licence Grout Suite. Téléchargement gratuit pour Windows et macOS.

Télécharger GroutCode