The University of Edinburgh

Verenigd Koninkrijk · 2026/27

The University of Edinburgh

43 labpractica voor het Edinburgh-leerplan.

Informatics in Edinburgh, jaar 1 tot en met 4: programmeren, algoritmen en datastructuren, computersystemen, compilers en databases. 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 BSc (Hons) / Informatics MInf. Regeling: DRPS 2026/27. Open een vak om de practicumonderdelen te zien en het labpracticum dat GroutCode bij elk onderdeel meelevert.

  1. Year 1

    1 vak3 lablessenPython
    • INFR07004Python

      Informatics 1 - Introduction to Programming

      3

      lessen

      • Python fundamentals — types, operators, loops, conditionals and functions
      • A tested gradebook — debugging, refactoring and test-driven code
      Bekijk alle 3 lessen
      1. 1Python fundamentals — types, operators, loops, conditionals and functionsOnderdeel I · Fundamental Principles of Programming
      2. 2A tested gradebook — debugging, refactoring and test-driven codeOnderdeel II · Software Engineering Practice in Code
      3. 3Reviewing AI-generated code — find the errors and inefficienciesOnderdeel III · Extended Principles and AI-Assisted Coding

  2. Year 2

    3 vakken13 lablessenPythonCJava
    • INFR08026Python

      Informatics 2 - Introduction to Algorithms and Data Structures

      5

      lessen

      • Measuring algorithms — case analysis, asymptotics and recurrences
      • Stacks, queues, linked lists and sorting from scratch
      Bekijk alle 5 lessen
      1. 1Measuring algorithms — case analysis, asymptotics and recurrencesOnderdeel I · Asymptotic Notation and Algorithmic Analysis
      2. 2Stacks, queues, linked lists and sorting from scratchOnderdeel II · Sequential Data Structures and Sorting
      3. 3Heaps, binary search trees and a chained hash map — built from listsOnderdeel III · Trees, Heaps and Hashing
      4. 4Graph algorithms — traversal, ordering, shortest paths, spanning trees and backtrackingOnderdeel IV · Graphs and Graph Algorithms
      5. 5Dynamic programming, spelling correction and the edge of computabilityOnderdeel V · Dynamic Programming and Complexity Classes
    • INFR08027C

      Informatics 2C - Introduction to Computer Systems

      4

      lessen

      • Bits, fields, two's complement and IEEE floats in C
      • A MIPS simulator in C — decode, execute, and compile a loop by hand
      Bekijk alle 4 lessen
      1. 1Bits, fields, two's complement and IEEE floats in COnderdeel I · Data Representation and the C Language
      2. 2A MIPS simulator in C — decode, execute, and compile a loop by handOnderdeel II · Instruction Set Architecture
      3. 3Caches, page tables, a TLB and a scheduler — the environment a program runs inOnderdeel III · Program Execution Environment
      4. 4From gates to a MIPS processor — adders, an ALU, registers and a multi-cycle CPUOnderdeel IV · Digital Logic and Processor Structure
    • INFR08032Java

      Informatics 2 - Software Engineering and Professional Practice

      4

      lessen

      • Requirements toolkit — parsing, checking, prioritising and tracing a changing specification
      • From UML to Java — an order system built from its class diagram and state machine
      Bekijk alle 4 lessen
      1. 1Requirements toolkit — parsing, checking, prioritising and tracing a changing specificationOnderdeel I · Requirements Analysis
      2. 2From UML to Java — an order system built from its class diagram and state machineOnderdeel II · Software Design with UML
      3. 3A team's toolbench — test runner, diff and patch, issue tracker and review gate in JavaOnderdeel III · Construction and Testing in Java
      4. 4A compliance toolkit for a student-records serviceOnderdeel IV · Professional, Legal and Ethical Issues

  3. Year 3

    3 vakken14 lablessenJavaC++SQL
    • INFR10065Java

      Compiling Techniques

      4

      lessen

      • A compiler front end: lexer, recursive descent and LL(1) tables
      • Semantic analysis: abstract syntax, scoped symbol tables and a type checker
      Bekijk alle 4 lessen
      1. 1A compiler front end: lexer, recursive descent and LL(1) tablesOnderdeel I · Lexical Analysis and Parsing
      2. 2Semantic analysis: abstract syntax, scoped symbol tables and a type checkerOnderdeel II · Abstract Syntax and Semantic Analysis
      3. 3Intermediate code: frames, three-address translation, basic blocks and tracesOnderdeel III · Intermediate Code
      4. 4A compiler back end: liveness, graph-colouring register allocation and RISC-V selectionOnderdeel IV · Code Generation and Register Allocation
    • INFR10079C++

      Operating Systems

      5

      lessen

      • A toy kernel: traps, system calls, interrupts and a preemptive timer
      • CPU schedulers, a bounded pipe, and fork versus threads
      Bekijk alle 5 lessen
      1. 1A toy kernel: traps, system calls, interrupts and a preemptive timerOnderdeel I · The OS Kernel
      2. 2CPU schedulers, a bounded pipe, and fork versus threadsOnderdeel II · Process and Time Management
      3. 3Semaphores, a monitor, races and the Banker's algorithmOnderdeel III · Resource Management
      4. 4Memory management: allocators, page tables, a TLB and page replacementOnderdeel IV · Memory Management
      5. 5Disk scheduling, file-system structures, nested paging and containersOnderdeel V · Storage Management and Virtualization
    • INFR10080SQL

      Introduction to Databases

      5

      lessen

      • Querying a course database: relations, multisets and aggregation in SQL
      • Relational algebra, calculus and Datalog, translated into SQL
      Bekijk alle 5 lessen
      1. 1Querying a course database: relations, multisets and aggregation in SQLOnderdeel I · The Relational Model and SQL
      2. 2Relational algebra, calculus and Datalog, translated into SQLOnderdeel II · Query Languages
      3. 3Constraints that refuse bad data, and a BCNF decompositionOnderdeel III · Database Design
      4. 4Nested queries, NULLs and certain answers, and triggersOnderdeel IV · Advanced SQL and Application Access
      5. 5Schedules, locks, indexes and cost estimates, analysed in SQLOnderdeel V · Transactions, Indexing and Query Evaluation

  4. Year 4

    3 vakken13 lablessenJavaCPython
    • INFR11217Java

      Advanced Database Systems (UG)

      5

      lessen

      • Row stores, column stores and the disk beneath them
      • Index structures: B+-trees, hashing, z-order and a learned index
      Bekijk alle 5 lessen
      1. 1Row stores, column stores and the disk beneath themOnderdeel I · Architectures and Storage
      2. 2Index structures: B+-trees, hashing, z-order and a learned indexOnderdeel II · Indexing
      3. 3Query operators and a dynamic-programming join optimiserOnderdeel III · Query Evaluation and Optimisation
      4. 4Transactions: serialisability, locking, MVCC and recoveryOnderdeel IV · Transaction Management
      5. 5Distributed data: partitioning, 2PC, consistent hashing and vector clocksOnderdeel V · Distributed and Big Data Systems
    • INFR11226C

      Parallel Programming Languages and Systems (Level 11) (UG)

      4

      lessen

      • Models of parallelism in Pthreads: decomposition, reduction, scan and a bag of tasks
      • Shared-variable synchronization: locks, semaphores, barriers and monitors in Pthreads
      Bekijk alle 4 lessen
      1. 1Models of parallelism in Pthreads: decomposition, reduction, scan and a bag of tasksOnderdeel I · Models of Parallelism
      2. 2Shared-variable synchronization: locks, semaphores, barriers and monitors in PthreadsOnderdeel II · Shared Variable Programming
      3. 3Message passing from channels up: an MPI-style communicator with collectivesOnderdeel III · Message Passing Programming
      4. 4Linda tuple spaces and TBB-style parallel_for and parallel_reduceOnderdeel IV · Alternative Approaches
    • INFR11229Python

      Text Technologies for Data Science (UG)

      4

      lessen

      • A search engine's text pipeline: tokenise, normalise, stop, stem, then Zipf and Heaps
      • A search engine from scratch — inverted index, Boolean, phrase and ranked retrieval
      Bekijk alle 4 lessen
      1. 1A search engine's text pipeline: tokenise, normalise, stop, stem, then Zipf and HeapsOnderdeel I · Text Processing Foundations
      2. 2A search engine from scratch — inverted index, Boolean, phrase and ranked retrievalOnderdeel II · Indexing and Search
      3. 3An IR evaluation script — precision, recall, MAP, nDCG and significance testsOnderdeel III · Evaluation
      4. 4Text classification and corpus analysis — features, Naive Bayes, evaluation and RAG retrievalOnderdeel IV · Text Classification and Analysis

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 The University of Edinburgh. 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 Edinburgh 2026/27?

Ja. GroutCode bevat de overgenomen Edinburgh 2026/27 voor Computer Science BSc (Hons) / Informatics MInf — 34 vakken — met 43 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 Edinburgh-practica?

Java (13 lessen), Python (12 lessen), C (8 lessen), C++ (5 lessen), SQL (5 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 Edinburgh-labwerk met de controles ingebouwd

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

Download GroutCode