The University of Edinburgh

United Kingdom · 2026/27

The University of Edinburgh

43 lab practicals for the Edinburgh syllabus.

Edinburgh Informatics, Years 1 to 4: programming, algorithms and data structures, computer systems, compilers and databases. Every lesson is stepped, compiled and checked by a real toolchain on your own machine — the model reviews your code afterwards, it does not decide whether you passed.

Download GroutCodeAll syllabuses

Updated

Semester by semester

Programme: Computer Science BSc (Hons) / Informatics MInf. Scheme: DRPS 2026/27. Open a course to see its practical units and the lab lesson GroutCode ships for each.

  1. Year 1

    1 course3 lab lessonsPython
    • INFR07004Python

      Informatics 1 - Introduction to Programming

      3

      lessons

      • Python fundamentals — types, operators, loops, conditionals and functions
      • A tested gradebook — debugging, refactoring and test-driven code
      See all 3 lessons
      1. 1Python fundamentals — types, operators, loops, conditionals and functionsUnit I · Fundamental Principles of Programming
      2. 2A tested gradebook — debugging, refactoring and test-driven codeUnit II · Software Engineering Practice in Code
      3. 3Reviewing AI-generated code — find the errors and inefficienciesUnit III · Extended Principles and AI-Assisted Coding

  2. Year 2

    3 courses13 lab lessonsPythonCJava
    • INFR08026Python

      Informatics 2 - Introduction to Algorithms and Data Structures

      5

      lessons

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

      Informatics 2C - Introduction to Computer Systems

      4

      lessons

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

      Informatics 2 - Software Engineering and Professional Practice

      4

      lessons

      • 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
      See all 4 lessons
      1. 1Requirements toolkit — parsing, checking, prioritising and tracing a changing specificationUnit I · Requirements Analysis
      2. 2From UML to Java — an order system built from its class diagram and state machineUnit II · Software Design with UML
      3. 3A team's toolbench — test runner, diff and patch, issue tracker and review gate in JavaUnit III · Construction and Testing in Java
      4. 4A compliance toolkit for a student-records serviceUnit IV · Professional, Legal and Ethical Issues

  3. Year 3

    3 courses14 lab lessonsJavaC++SQL
    • INFR10065Java

      Compiling Techniques

      4

      lessons

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

      Operating Systems

      5

      lessons

      • A toy kernel: traps, system calls, interrupts and a preemptive timer
      • CPU schedulers, a bounded pipe, and fork versus threads
      See all 5 lessons
      1. 1A toy kernel: traps, system calls, interrupts and a preemptive timerUnit I · The OS Kernel
      2. 2CPU schedulers, a bounded pipe, and fork versus threadsUnit II · Process and Time Management
      3. 3Semaphores, a monitor, races and the Banker's algorithmUnit III · Resource Management
      4. 4Memory management: allocators, page tables, a TLB and page replacementUnit IV · Memory Management
      5. 5Disk scheduling, file-system structures, nested paging and containersUnit V · Storage Management and Virtualization
    • INFR10080SQL

      Introduction to Databases

      5

      lessons

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

  4. Year 4

    3 courses13 lab lessonsJavaCPython
    • INFR11217Java

      Advanced Database Systems (UG)

      5

      lessons

      • Row stores, column stores and the disk beneath them
      • Index structures: B+-trees, hashing, z-order and a learned index
      See all 5 lessons
      1. 1Row stores, column stores and the disk beneath themUnit I · Architectures and Storage
      2. 2Index structures: B+-trees, hashing, z-order and a learned indexUnit II · Indexing
      3. 3Query operators and a dynamic-programming join optimiserUnit III · Query Evaluation and Optimisation
      4. 4Transactions: serialisability, locking, MVCC and recoveryUnit IV · Transaction Management
      5. 5Distributed data: partitioning, 2PC, consistent hashing and vector clocksUnit V · Distributed and Big Data Systems
    • INFR11226C

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

      4

      lessons

      • Models of parallelism in Pthreads: decomposition, reduction, scan and a bag of tasks
      • Shared-variable synchronization: locks, semaphores, barriers and monitors in Pthreads
      See all 4 lessons
      1. 1Models of parallelism in Pthreads: decomposition, reduction, scan and a bag of tasksUnit I · Models of Parallelism
      2. 2Shared-variable synchronization: locks, semaphores, barriers and monitors in PthreadsUnit II · Shared Variable Programming
      3. 3Message passing from channels up: an MPI-style communicator with collectivesUnit III · Message Passing Programming
      4. 4Linda tuple spaces and TBB-style parallel_for and parallel_reduceUnit IV · Alternative Approaches
    • INFR11229Python

      Text Technologies for Data Science (UG)

      4

      lessons

      • 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
      See all 4 lessons
      1. 1A search engine's text pipeline: tokenise, normalise, stop, stem, then Zipf and HeapsUnit I · Text Processing Foundations
      2. 2A search engine from scratch — inverted index, Boolean, phrase and ranked retrievalUnit II · Indexing and Search
      3. 3An IR evaluation script — precision, recall, MAP, nDCG and significance testsUnit III · Evaluation
      4. 4Text classification and corpus analysis — features, Naive Bayes, evaluation and RAG retrievalUnit IV · Text Classification and Analysis

The full 34-course syllabus is transcribed in the app, including the theory courses. Lessons are authored against the course codes that have practical work, and the list grows with each release.

GroutCode is not affiliated with or endorsed by The University of Edinburgh. Course codes and titles are transcribed from the institution’s published scheme documents.

How a practical runs

The same five steps for every lesson, in every language.

  1. 1

    Pick your syllabus

    Choose your university or board and the semester or class you are in. The course list is the transcribed official scheme, not an approximation.

  2. 2

    Open a lab lesson

    Each lesson is a stepped practical for a specific course, with a starter file you edit and a test file you do not.

  3. 3

    Write the code yourself

    The starter has the signatures and the TODOs. You implement them in the editor, in the language your course actually uses.

  4. 4

    Run the checks

    The toolchain compiles and runs the tests — 8 to 15 of them across the lesson, one per step, so you find out which change broke what.

  5. 5

    Get the review

    Once the tests pass, the model reads your implementation and tells you the input that breaks it. It never reports the pass or fail itself.

Why the compiler grades, not the model

The obvious way to build an AI lab tool is to let the model read the student’s code and say whether it is correct. It is also the way that produces a tool nobody can trust. A model will tell you your code works when the compiler says otherwise, and it will fail you for a style it happens to dislike.

So the two jobs are split:

  • The model designs the lesson, writes the starter and the tests, and — after the tests pass — reads what you actually wrote and tells you the input that breaks it.
  • The toolchain decides whether it compiles and whether each step passes. That verdict is not negotiable and the model never issues it.

And why steps instead of one big task

A 40-to-60 minute practical with a single Run at the end gives a beginner one bit of feedback an hour, and it arrives after every decision has already been made. Each lesson here is 8 to 15 steps, each with its own instruction and its own check, so you find out which change broke what while you still remember making it.

Frequently asked questions

Does GroutCode cover the Edinburgh 2026/27?

Yes. GroutCode ships the transcribed Edinburgh 2026/27 for Computer Science BSc (Hons) / Informatics MInf — 34 courses — with 43 authored lab lessons mapped to specific course codes. The syllabus was transcribed from the official documents, and the source and checksum of each one is recorded in the app.

Which languages do the Edinburgh practicals use?

Java (13 lessons), Python (12 lessons), C (8 lessons), C++ (5 lessons), SQL (5 lessons). The language is set per course code rather than guessed from the title, because the same subject is taught in different languages at different institutions.

Does the AI just write the practical for me?

No. The starter file has the signatures and the TODOs; you implement them. The toolchain — not the model — decides whether your code compiles and whether each step passes, so the AI cannot tell you your code works when the compiler disagrees. What it does afterwards is read your implementation and point out the input that breaks it.

Do the practicals work offline?

The lessons, the syllabus and the test runner are bundled in the app and run locally, so the compile-and-check loop works with no connection. The review step at the end uses a model, which can be a local one or a cloud one with your own key.

What do I need installed?

GroutCode detects which toolchains are present on your machine and tells you what is missing and what would fix it. You need the compiler or interpreter for the language your course uses — a C compiler, a JDK, Python, Node or SQLite.

Other syllabuses

University of Oxford

Oxford

University of Oxford

University of Oxford Computer Science course synopses for 2026-27: databases, database systems implementation and AI.

27

lab lessons

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

Cambridge

University of Cambridge

The Cambridge Computer Science Tripos, Parts IA and IB: algorithms, databases, object-oriented programming, C and C++.

36

lab lessons

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

Imperial College

Imperial College London

Imperial College London BEng/MEng Computing: computing practicals, algorithms, databases, operating systems and machine learning.

24

lab lessons

2026-27Python · C · SQL · Java

← All supported syllabuses

Do your Edinburgh lab work with the checks built in

GroutCode is included in every Grout Suite license. Free download for Windows and macOS.

Download GroutCode