30 lab practicals for the Manchester syllabus.

Manchester BSc Computer Science, Years 1 and 2: programming, databases, AI, algorithms, data structures and data science. 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 GroutCode All syllabuses

Updated 6 October 2026

Semester by semester

Programme: BSc Computer Science. Scheme: 2026 entry. Open a course to see its practical units and the lab lesson GroutCode ships for each.

1
Year 1
3 courses20 lab lessonsPythonJava
- COMP13212Python
  Data Science
  4
  lessons
  - A CSV cleaning pipeline — from messy text to a model-ready table
  - Descriptive statistics and text charts, written from the formulas
  See all 4 lessonsHide
  1. 1A CSV cleaning pipeline — from messy text to a model-ready tableUnit II · Data handling and cleaning
  2. 2Descriptive statistics and text charts, written from the formulasUnit III · Exploring and visualising data
  3. 3Measuring uncertainty: intervals, Bayes and tests on a difference in meansUnit IV · Uncertainty and statistical thinking
  4. 4Machine learning from scratch: regression, cross-validation and a naive Bayes spam filterUnit V · Introduction to machine learning
- COMP16321Python
  Introduction to Programming 1
  10
  lessons
  - A tiny assignment interpreter that shows variables, types and program state
  - Selection and iteration — classifiers, loops and early exits
  See all 10 lessonsHide
  1. 1A tiny assignment interpreter that shows variables, types and program stateUnit I · Variables, States & Types
  2. 2Selection and iteration — classifiers, loops and early exitsUnit II · Selection & Iteration
  3. 3File handling — reading, writing, appending and parsing text and CSV filesUnit III · File Handling
  4. 4Functions — parameters, closures, recursion and reusable building blocksUnit IV · Functions
  5. 5Packages and libraries — choosing the right standard-library moduleUnit V · Packages & Libraries
  6. 6Graphics and user interfaces — a pixel canvas, drawing primitives and an event loopUnit VI · Graphics & User Interfaces
  7. 7A character framebuffer: lines, sprites and a bouncing-ball animationUnit VII · Graphics & Animation
  8. 8Hardening a login service: validation, injection, password hashing and rate limitsUnit VIII · Secure Coding
  9. 9Object-oriented banking: accounts, subclasses, polymorphic fees and a bankUnit IX · General Intro to OOP
  10. 10A text plotting library: bar charts, histograms, sparklines and scatter plotsUnit X · Data Visualisation in Python
- COMP16412Java
  Introduction to Programming 2
  6
  lessons
  - Java fundamentals: decisions, loops, primitive limits and reference types
  - A bank in objects: encapsulation, inheritance, polymorphism and interfaces
  See all 6 lessonsHide
  1. 1Java fundamentals: decisions, loops, primitive limits and reference typesUnit I · Programming fundamentals in Java
  2. 2A bank in objects: encapsulation, inheritance, polymorphism and interfacesUnit II · Object-oriented programming
  3. 3Collections, generics and hand-written sorting, searching and recursionUnit III · Collections, data structures and algorithms
  4. 4Processing a sales CSV with records, streams, Optional, exceptions and filesUnit IV · Modern Java and data processing
  5. 5Concurrency and event-driven UIs: threads, pools, queues, futures and listenersUnit V · Graphical applications and concurrency
  6. 6Responsible Java: secure input, accessible output, efficient code, UML, docs and testsUnit VI · Responsible and sustainable software development
2
Year 2
4 courses10 lab lessonsSQLPythonCC++Java
- COMP23111SQL
  Database Systems
  2
  lessons
  - SQL on a university records database: joins, aggregation, subqueries, views and triggers
  - Transaction processing in SQL: atomic transfers, serialisability, 2PL, deadlock and recovery
  See the unitsHide
  1. 1SQL on a university records database: joins, aggregation, subqueries, views and triggersUnit IV · Basic SQL + Stored Procedures & Triggers
  2. 2Transaction processing in SQL: atomic transfers, serialisability, 2PL, deadlock and recoveryUnit VI · Transaction Processing
- COMP24011Python
  Introduction to AI
  1
  lesson
  - Search and planning: BFS, IDDFS, UCS, A*, minimax, alpha-beta and a STRIPS planner
  See the unitsHide
  1. 1Search and planning: BFS, IDDFS, UCS, A*, minimax, alpha-beta and a STRIPS plannerUnit I · Search and planning
- COMP26020CC++
  Programming Languages & Paradigms
  2
  lessons
  - Imperative C by hand: pointers, safe strings, a growable array, linked lists and function pointers
  - C++ classes and polymorphism: a Matrix value type and a symbolic expression tree
  See the unitsHide
  1. 1Imperative C by hand: pointers, safe strings, a growable array, linked lists and function pointersUnit I · Imperative programming in C
  2. 2C++ classes and polymorphism: a Matrix value type and a symbolic expression treeUnit II · Object-oriented programming in C++
- COMP26120Java
  Algorithms and Data Structures
  5
  lessons
  - Loop invariants in practice: ten classic algorithms written and argued correct
  - Basic data structures from scratch: dynamic array, stack, ring queue, BST, heap and graph
  See all 5 lessonsHide
  1. 1Loop invariants in practice: ten classic algorithms written and argued correctUnit I · Algorithms and their expression
  2. 2Basic data structures from scratch: dynamic array, stack, ring queue, BST, heap and graphUnit II · Basic data structures
  3. 3Basic algorithms: three sorts, four traversals, three graph searches and modular arithmeticUnit III · Basic algorithms
  4. 4Measuring algorithms: counting operations, best/worst/average case and growth ratesUnit IV · Algorithmic performance
  5. 5Algorithmic techniques: divide and conquer, dynamic programming, greedy and a 2-D linear programUnit V · Algorithmic techniques

The full 36-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 Manchester. 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
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
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
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
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
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 Manchester 2026 entry?

Yes. GroutCode ships the transcribed Manchester 2026 entry for BSc Computer Science — 36 courses — with 30 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 Manchester practicals use?

Python (15 lessons), Java (11 lessons), SQL (2 lessons), C (1 lessons), C++ (1 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.