University of Cambridge

Verenigd Koninkrijk · 2026-27

University of Cambridge

36 labpractica voor het Cambridge-leerplan.

De Cambridge Computer Science Tripos, Parts IA en IB: algoritmen, databases, objectgeoriënteerd programmeren, C en C++. 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: Computer Science Tripos. Regeling: Course pages 2026–27. Open een vak om de practicumonderdelen te zien en het labpracticum dat GroutCode bij elk onderdeel meelevert.

  1. Part IA

    4 vakken24 lablessenJavaSQL
    • ALGORITHM1Java

      Algorithms 1

      3

      lessen

      • Sorting from quadratic to linear time — and finding the median without sorting
      • Divide and conquer, dynamic programming and greedy — one problem set, three strategies
      Bekijk alle 3 lessen
      1. 1Sorting from quadratic to linear time — and finding the median without sortingOnderdeel 1 · Sorting
      2. 2Divide and conquer, dynamic programming and greedy — one problem set, three strategiesOnderdeel 2 · Strategies for algorithm design
      3. 3Stacks to red-black trees — building Unit 3's data structures by handOnderdeel 3 · Data structures
    • ALGORITHM2Java

      Algorithms 2

      3

      lessen

      • Graph search and shortest paths — BFS, DFS, Bellman-Ford, Dijkstra, Floyd-Warshall and Johnson
      • Spanning trees, topological order, max flow and bipartite matching
      Bekijk alle 3 lessen
      1. 1Graph search and shortest paths — BFS, DFS, Bellman-Ford, Dijkstra, Floyd-Warshall and JohnsonOnderdeel 1 · Graphs and path-finding algorithms
      2. 2Spanning trees, topological order, max flow and bipartite matchingOnderdeel 2 · Graphs and subgraphs
      3. 3Amortized analysis, binomial heaps, Fibonacci heaps and disjoint setsOnderdeel 3 · Advanced data structures
    • DATABASESSQL

      Databases

      8

      lessen

      • From a key-value store and a flat file to a relational table
      • Designing a college database: keys, relationships and integrity
      Bekijk alle 8 lessen
      1. 1From a key-value store and a flat file to a relational tableOnderdeel 1 · Introduction
      2. 2Designing a college database: keys, relationships and integrityOnderdeel 2 · Relational databases
      3. 3Relational algebra in SQL: from selection to set differenceOnderdeel 3 · Relational queries
      4. 4NULLs, aggregation, transactions and normalising a sales tableOnderdeel 4 · Further SQL
      5. 5Storing and querying JSON documents in SQLOnderdeel 5 · Document-oriented data
      6. 6A property graph in SQL — vertices, edges and Cypher-style pattern matchingOnderdeel 6 · Graph-oriented data
      7. 7Recursive CTEs — walking an org chart and searching a flight networkOnderdeel 7 · Recursive queries
      8. 8Row stores vs column stores — OLTP and analytics on the same dataOnderdeel 8 · Database system trade-offs
    • OOPROGJava

      Object-Oriented Programming

      10

      lessen

      • From functions to classes — static methods and an exact Fraction type
      • Designing classes — an encapsulated Account, immutable values and generic containers
      Bekijk alle 10 lessen
      1. 1From functions to classes — static methods and an exact Fraction typeOnderdeel 1 · Types, Objects and Classes
      2. 2Designing classes — an encapsulated Account, immutable values and generic containersOnderdeel 2 · Designing Classes
      3. 3References, the call stack and the heap — pass-by-value made visibleOnderdeel 3 · Pointers, References and Memory
      4. 4A shape hierarchy — inheritance, overriding, overloading, casting and shadowingOnderdeel 4 · Inheritance
      5. 5Polymorphism three ways — generic functions, interfaces and the diamondOnderdeel 5 · Polymorphism and Multiple Inheritance
      6. 6An object's life — constructor chains, clean-up and two garbage collectorsOnderdeel 6 · Lifecycle of an Object
      7. 7Comparing objects and working the Collections framework — Money, rankings and a RangeOnderdeel 7 · Java Collections and Object Comparison
      8. 8A bank account and a config loader — from return codes to exceptions and assertionsOnderdeel 8 · Error Handling
      9. 9Generics, type erasure, lambdas and streams — modern Java one feature at a timeOnderdeel 9 · Language evolution
      10. 10Six design patterns, built and tested — Singleton to ObserverOnderdeel 10 · Design Patterns

  2. Part IB

    1 vak12 lablessenCC++
    • PROGCCC++

      Programming in C and C++

      12

      lessen

      • C from the ground up — integers, bits and hand-written string functions
      • Functions, linkage and the preprocessor across two compilation units
      Bekijk alle 12 lessen
      1. 1C from the ground up — integers, bits and hand-written string functionsOnderdeel 1 · Introduction to the C language
      2. 2Functions, linkage and the preprocessor across two compilation unitsOnderdeel 2 · Introduction to the C language (continued)
      3. 3Pointer ranges, callbacks, structs and a tagged unionOnderdeel 3 · Introduction to the C language (continued)
      4. 4Heap-backed strings, a growable vector and formatted I/OOnderdeel 4 · Introduction to the C language (continued)
      5. 5Overflow-proof arithmetic and bounded buffers without undefined behaviourOnderdeel 5 · C semantics and tools
      6. 6A bump-pointer arena, a malloc'd BST and shared expression DAGsOnderdeel 6 · Memory allocation, data structures and aliasing
      7. 7A reference-counted heap with a mark-and-sweep collector in COnderdeel 7 · Further memory management
      8. 8Cache-aware C: struct layout, intrusive lists, SoA and loop blockingOnderdeel 8 · Memory hierarchy and cache optimization
      9. 9A debugging toolkit in C: test runner, invariants, trace buffer, bisect and shrinkOnderdeel 9 · Debugging
      10. 10From C to C++: references, overloading, default arguments and std::stringOnderdeel 10 · Introduction to C++
      11. 11C++ objects: a Fraction type, an RAII buffer, virtual shapes and a diamond of devicesOnderdeel 11 · Objects in C++
      12. 12C++ templates and meta-programming — from max_of to compile-time type listsOnderdeel 12 · Other C++ concepts

Het volledige leerplan van 77 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 of Cambridge. 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 Cambridge 2026-27?

Ja. GroutCode bevat de overgenomen Cambridge 2026-27 voor Computer Science Tripos — 77 vakken — met 36 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 Cambridge-practica?

Java (16 lessen), C (9 lessen), SQL (8 lessen), C++ (3 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++
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
University College London

UCL

University College London

BSc en MEng Computer Science aan UCL, jaar 1 tot en met 4: programmeerprincipes, OOP, algoritmen, compilers en systemen.

51

lablessen

2026/27Python · Java · C

← Alle ondersteunde leerplannen

Doe je Cambridge-labwerk met de controles ingebouwd

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

Download GroutCode