Université Paris-Saclay

France · 2026-27

Université Paris-Saclay

26 lab practicals for the Paris-Saclay syllabus.

Université Paris-Saclay’s Licence Informatique: programming, algorithmics, modular and object programming in C++ and Java. 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: Licence Informatique. Scheme: Offre de formation 2026-2027. Open a course to see its practical units and the lab lesson GroutCode ships for each.

  1. L1·S1

    2 courses6 lab lessonsPythonC++
    • EN00010106Python

      Introduction à l'informatique

      1

      lesson

      • Python basics — a marks and text toolkit
      See the units
      1. 1Python basics — a marks and text toolkitUnit III · Bases de programmation en Python
    • EN00010107C++

      Introduction à la programmation

      5

      lessons

      • First C++ functions — dates, arithmetic and loops
      • Arrays, matrices, strings and text files in C++
      See all 5 lessons
      1. 1First C++ functions — dates, arithmetic and loopsUnit I · Introduction à la programmation (en C++)
      2. 2Arrays, matrices, strings and text files in C++Unit II · Tableaux, chaînes de caractères et fichiers
      3. 3Separate compilation — a rational-number library in three translation unitsUnit III · Compilation et compilation séparée
      4. 4Good practices — a typed, tested, debugged gradebookUnit IV · Bonnes pratiques de programmation
      5. 5Programming project in C++ — image filters on PGM files and open-data statisticsUnit V · Projet de programmation

  2. L1·S2

    2 courses8 lab lessonsC++
    • EN00010109C++

      Programmation modulaire

      4

      lessons

      • A marks report built top-down: from raw text to a ranked list, one module at a time
      • An encapsulated Rational class: private state, a guaranteed invariant, a clean interface
      See all 4 lessons
      1. 1A marks report built top-down: from raw text to a ranked list, one module at a timeUnit I · Modélisation informatique et modularisation
      2. 2An encapsulated Rational class: private state, a guaranteed invariant, a clean interfaceUnit II · Structures, classes et encapsulation
      3. 3A separately compiled string library and the unit-test library that checks itUnit III · Bibliothèques et tests
      4. 4A grid-world agent simulation: movement, energy, food and reproduction by fixed rulesUnit IV · Projet: simulation
    • EN00010110C++

      Algorithmique 1

      4

      lessons

      • Linear data structures in C++ — dynamic arrays, linked lists, stacks and queues
      • The memory model in C++ — pointers, addresses, values and references
      See all 4 lessons
      1. 1Linear data structures in C++ — dynamic arrays, linked lists, stacks and queuesUnit I · Structures de données linéaires
      2. 2The memory model in C++ — pointers, addresses, values and referencesUnit II · Modèle mémoire
      3. 3Search, insertion and deletion on arrays and linked lists in C++Unit III · Opérations sur les structures de données linéaires
      4. 4Sorting in C++ — insertion, selection and quicksort, measuredUnit IV · Algorithmes de tri

  3. L2·S3

    1 course3 lab lessonsJava
    • EN00010112Java

      Introduction Programmation Objet

      3

      lessons

      • First steps in Java: syntax, strings and the standard library API
      • Points, fractions and accounts — classes, references and encapsulation in Java
      See all 3 lessons
      1. 1First steps in Java: syntax, strings and the standard library APIUnit I · Introduction à la syntaxe java
      2. 2Points, fractions and accounts — classes, references and encapsulation in JavaUnit II · Classes et objets
      3. 3Shapes and a payroll — interfaces, inheritance and polymorphism in JavaUnit III · Interfaces et héritage

  4. L2·S4

    3 courses7 lab lessonsJavaSQL
    • EN00010118Java

      Programmation Objet et Génie Logiciel

      1

      lesson

      • A small bank in Java — classes, inheritance, generics, iterators, lambdas and exceptions
      See the units
      1. 1A small bank in Java — classes, inheritance, generics, iterators, lambdas and exceptionsUnit I · Programmation Java
    • EN00010119Java

      Algorithmique 2

      4

      lessons

      • Binary search, linked lists and binary trees in Java
      • Three dictionaries in Java — a chained hash table, a binary search tree and a trie
      See all 4 lessons
      1. 1Binary search, linked lists and binary trees in JavaUnit I · Structures chaînées et arbres
      2. 2Three dictionaries in Java — a chained hash table, a binary search tree and a trieUnit II · Dictionnaires
      3. 3Divide and conquer in Java — merge sort, inversions and the n log n lower boundUnit III · Diviser pour régner
      4. 4Union-find and backtracking — disjoint sets, Kruskal, N-queens and a sudoku solverUnit IV · Backtrack et union-find
    • EN00010121SQL

      Bases de données 1

      2

      lessons

      • Defining a course-registration schema in SQL — tables, constraints, ALTER and DROP
      • Querying a registration database — relational algebra written as SQL
      See the units
      1. 1Defining a course-registration schema in SQL — tables, constraints, ALTER and DROPUnit IV · Langage SQL – Définition de schéma (LDD)
      2. 2Querying a registration database — relational algebra written as SQLUnit V · Interrogation d'une base de données

  5. L3·S6

    1 course2 lab lessonsJava
    • EN00010138Java

      IA Symbolique

      2

      lessons

      • Minimax and alpha-beta — from explicit game trees to a perfect tic-tac-toe player
      • A small constraint solver: CSP modelling, AC-3, heuristic search and DPLL
      See the units
      1. 1Minimax and alpha-beta — from explicit game trees to a perfect tic-tac-toe playerUnit II · Algorithmes de recherche pour les jeux à deux joueurs
      2. 2A small constraint solver: CSP modelling, AC-3, heuristic search and DPLLUnit IV · Résolution de problèmes par contraintes (CSP/SAT)

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 Université Paris-Saclay. 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 Paris-Saclay 2026-27?

Yes. GroutCode ships the transcribed Paris-Saclay 2026-27 for Licence Informatique — 36 courses — with 26 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 Paris-Saclay practicals use?

C++ (13 lessons), Java (10 lessons), SQL (2 lessons), Python (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.

Other syllabuses

Sorbonne Université

Sorbonne

Sorbonne Université

Sorbonne Université’s Licence d’Informatique, L1 to L3: programming, C, object-oriented Java, data structures and databases.

27

lab lessons

2025-26C · SQL · Java · Python
Université Grenoble Alpes

Grenoble Alpes

Université Grenoble Alpes

Université Grenoble Alpes’s Licence Informatique (UFR IM2AG): imperative programming in C, software projects and databases.

41

lab lessons

2026-27C · SQL · Java · Python
Université Claude Bernard Lyon 1

Lyon 1

Université Claude Bernard Lyon 1

Université Claude Bernard Lyon 1’s Licence Informatique: algorithmics, data structures, databases, systems and object-oriented C++.

24

lab lessons

2026-27C++ · C · SQL · Java

← All supported syllabuses

Do your Paris-Saclay lab work with the checks built in

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

Download GroutCode