
India · 2024 scheme
APJ Abdul Kalam Technological University
85 lab practicals for the KTU Kerala syllabus.
The 2024 scheme for Kerala’s technological university, covering CSE, IT, AI & DS and ECE from semester three onwards. 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.
Updated
Semester by semester
Programme: B.Tech CSE / IT / AI & DS / ECE. Scheme: 2024 scheme. Open a course to see its practical units and the lab lesson GroutCode ships for each.
Semester 3
8 courses20 lab lessonsJavaSQLPythonC- PBCST304Java
Object Oriented Programming
4
lessons
- A job ticket toolkit — bits, boxes, arrays and the first class
- A build pipeline that dispatches on the object
- 1A job ticket toolkit — bits, boxes, arrays and the first classUnit I · Introduction to Java
- 2A build pipeline that dispatches on the objectUnit II · Polymorphism
- 3A configuration service — singleton, adapter, and exceptions that mean somethingUnit III · Packages and Interfaces
- 4SOLID and the delegation event model, with no window in sightUnit IV · SOLID Principles in Java Swings fundamentals
- PBITT304SQL
Database Management System
4
lessons
- A library database, from ER diagram to enforced schema
- SQL CRUD Operations with Student Database
- 1A library database, from ER diagram to enforced schemaUnit I · Introduction
- 2SQL CRUD Operations with Student DatabaseUnit II · Normalization
- 3Database Constraints and Transaction ManagementUnit III · Constraints
- 4Database Schema Validation with SQLiteUnit IV · Testing and Validation
- PCCDL308Python
Python and Statistical Modeling Lab
1
lesson
- Find Largest of Three Numbers
- 1Find Largest of Three NumbersUnit LAB · List of Experiments
- PCCSL307C
Data Structures Lab
1
lesson
- Sparse Matrix Addition
- 1Sparse Matrix AdditionUnit LAB · List of Experiments
- PCCST303C
Data Structures and Algorithms
4
lessons
- Measuring what an algorithm costs, then building the array containers
- Linked lists, the containers they carry, and a memory manager that fits, coalesces and compacts
- 1Measuring what an algorithm costs, then building the array containersUnit I · Basic Concepts of Data Structures
- 2Linked lists, the containers they carry, and a memory manager that fits, coalesces and compactsUnit II · Linked List and Memory Management
- 3Trees, expression trees, heaps and graphs — the non-linear half of the courseUnit III · Trees and Graphs
- 4Six sorts, two searches and four hash functions — with the operations countedUnit IV · Sorting and Searching
- PCITL307Python
Programming in Python Lab
1
lesson
- List Sorting with Bubble Sort
- 1List Sorting with Bubble SortUnit LAB · List of Experiments
- PCITL308C
Data Structures Lab
1
lesson
- Stack Implementation and Postfix Evaluation
- 1Stack Implementation and Postfix EvaluationUnit LAB · List of Experiments
- PCITT303C
Data Structures
4
lessons
- From an address calculation to the containers a record index runs on
- Binary Search Implementation
- 1From an address calculation to the containers a record index runs onUnit I · Introduction to Data Structures
- 2Binary Search ImplementationUnit II · Searching
- 3Singly Linked List ImplementationUnit III · Linked List
- 4Binary Tree TraversalsUnit IV · Trees
Semester 4
8 courses20 lab lessonsPythonCSQLJava- PBITT404Python
Data Science
4
lessons
- Loading and cleaning a dataset by hand — read_csv, fillna and groupby without pandas
- Building a Data Pipeline for EDA
- 1Loading and cleaning a dataset by hand — read_csv, fillna and groupby without pandasUnit I · Introducing data science and Python
- 2Building a Data Pipeline for EDAUnit II · Data Pipeline, Exploratory data analysis (EDA)
- 3K-Nearest Neighbors Classifier ImplementationUnit III · Machine Learning
- 4Confusion Matrix and Metrics from ScratchUnit IV · Evaluation
- PCADL407Python
Foundations of AI and Data Science Lab
1
lesson
- Implementing Breadth-First Search (BFS) for AI Applications
- 1Implementing Breadth-First Search (BFS) for AI ApplicationsUnit LAB · List of Experiments
- PCCSL407C
Operating Systems Lab
1
lesson
- The kernel side of the syscalls — a process table, a pipe, IPC, scheduling, deadlock and paging in C
- 1The kernel side of the syscalls — a process table, a pipe, IPC, scheduling, deadlock and paging in CUnit LAB · List of Experiments
- PCCSL408SQL
DBMS Lab
1
lesson
- SQLite Database Schema Design
- 1SQLite Database Schema DesignUnit LAB · List of Experiments
- PCCST402SQL
Database Management Systems
4
lessons
- ER Model Entity and Relationship Querying
- Relational Algebra: Selection and Projection Operations
- 1ER Model Entity and Relationship QueryingUnit I · Introduction to Databases
- 2Relational Algebra: Selection and Projection OperationsUnit II · The Relational Data Model and SQL
- 3Functional Dependencies and Normalization in SQLiteUnit III · Database Design Theory & Normalization
- 4NoSQL Database Types AnalysisUnit IV · Introduction To NoSQL Concepts
- PCITL408C
Operating Systems Lab
1
lesson
- Process and thread lifecycle, semaphores, memory and files — an operating system modelled in C
- 1Process and thread lifecycle, semaphores, memory and files — an operating system modelled in CUnit LAB · List of Experiments
- PEECT414Java
Object Oriented Programming
4
lessons
- Java Program Structure and Basic Syntax
- Java Primitive Types and Operators
- 1Java Program Structure and Basic SyntaxUnit I · Introduction
- 2Java Primitive Types and OperatorsUnit II · Core Java Fundamentals
- 3Exception Handling with Arithmetic OperationsUnit III · More features of Java
- 4Swing's MVC, events and layout managers, and the SQL behind JDBC — without a windowUnit IV · Advanced features of Java
- PEITT411Java
Object Oriented Design using Java
4
lessons
- UML that runs — a design model you can execute and check
- Requirements you can check — traceability, gaps and impact
- 1UML that runs — a design model you can execute and checkUnit I · Introduction to Software Engineering
- 2Requirements you can check — traceability, gaps and impactUnit II · Requirements Elicitation
- 3System Design: Managing Book InventoryUnit III · System Design
- 4Designing an Interface for a Simple Bank Account SystemUnit IV · Object Design
Semester 5
5 courses11 lab lessonsNode.jsCPython- PBITT504Node.js
Web Application Development
4
lessons
- Basic JavaScript Functions and Variables
- ECMAScript Features: Let, Const, and Arrow Functions
- 1Basic JavaScript Functions and VariablesUnit I · Javascript
- 2ECMAScript Features: Let, Const, and Arrow FunctionsUnit II · ECMA Script
- 3Building a Minimal Node.js HTTP ServerUnit III · Node.js
- 4Express-style middleware, validation and session login, built from scratchUnit IV · Refactoring to MVC
- PCCSL507C
Networks Lab
1
lesson
- TCP Matrix Type Identifier
- 1TCP Matrix Type IdentifierUnit LAB · List of Experiments
- PCCSL508Python
Machine Learning Lab
1
lesson
- Linear Regression Implementation
- 1Linear Regression ImplementationUnit LAB · List of Experiments
- PCITL507Python
Machine Learning Lab
1
lesson
- Implementing Decision Tree ID3 Algorithm
- 1Implementing Decision Tree ID3 AlgorithmUnit LAB · List of Experiments
- PEECT522C
Data Structures
4
lessons
- Stack Implementation with Array
- Singly Linked List Implementation
- 1Stack Implementation with ArrayUnit I · Basic Concepts of Data Structures
- 2Singly Linked List ImplementationUnit II · Linked List
- 3Binary Tree Traversal ImplementationUnit III · Trees and Graphs
- 4Selection Sort ImplementationUnit IV · Sorting and Hashing
Semester 6
7 courses22 lab lessonsCJavaC++Python- OECST611C
Data Structures
4
lessons
- Stack Implementation with Array
- Singly Linked List Implementation
- 1Stack Implementation with ArrayUnit I · Basic Concepts of Data Structures
- 2Singly Linked List ImplementationUnit II · Linked List and Memory Management
- 3Binary Search Tree InsertionUnit III · Trees and Graphs
- 4Selection Sort ImplementationUnit IV · Sorting and Searching
- OECST615Java
Object Oriented Programming
4
lessons
- Java Primitive Types and Operations
- Understanding Method Overloading in Java
- 1Java Primitive Types and OperationsUnit I · Introduction to Java
- 2Understanding Method Overloading in JavaUnit II · Polymorphism
- 3Implementing and Extending Java InterfacesUnit III · Packages and Interfaces
- 4The delegation event model and JDBC connection steps, built without a windowUnit IV · Swings fundamentals
- OEITT611Java
Object-Oriented Programming in Java
4
lessons
- Reading expense lines from a console you do not have
- An Expense class, and a Wallet that guards it
- 1Reading expense lines from a console you do not haveUnit I · Introduction to Java and OOP
- 2An Expense class, and a Wallet that guards itUnit II · Classes and Objects
- 3Kinds of expense, each answering for itselfUnit III · Inheritance
- 4A ledger that keeps its shape when things go wrongUnit IV · Exception Handling
- OEITT612C++
Data Structures using C++
4
lessons
- An array ADT you own the memory of
- Linked structures, and the two ends of a queue
- 1An array ADT you own the memory ofUnit I · Module 1
- 2Linked structures, and the two ends of a queueUnit II · Module 2
- 3Binary Search Tree ImplementationUnit III · Module 3
- 4Binary Search ImplementationUnit IV · Advanced Data Structures and Algorithms
- OEITT613Python
AI with Python
4
lessons
- AI Agent Types Classification
- Water Jug Problem: State Representation and Valid Moves
- 1AI Agent Types ClassificationUnit I · Introduction to Artificial Intelligence (AI) and Python
- 2Water Jug Problem: State Representation and Valid MovesUnit II · AI Problems
- 3Breadth-First Search ImplementationUnit III · AI Search Algorithms
- 4Minimax Algorithm for Tic-Tac-ToeUnit IV · Game Playing and Constraint Satisfaction Problem (CSP)
- PCADL607Python
Deep Learning Lab
1
lesson
- Implement Logistic Regression from Scratch
- 1Implement Logistic Regression from ScratchUnit LAB · List of Experiments
- PCCSL607C
Systems Lab
1
lesson
- Lexical Analyzer Token Counter
- 1Lexical Analyzer Token CounterUnit LAB · List of Experiments
Semester 7
1 course4 lab lessonsNode.js- PECST742Node.js
Web Programming
4
lessons
- HTML5 Page Generator
- JavaScript Array Sorting with Custom Comparison
- 1HTML5 Page GeneratorUnit I · Creating Web Page using HTML5
- 2JavaScript Array Sorting with Custom ComparisonUnit II · Scripting language
- 3Building a Simple HTTP Server with Node.jsUnit III · JavaScript runtime environment
- 4A layered book catalogue service — SQL placeholders to REST, XML and SOAPUnit IV · SPA – Basics, Angular JS; Working with databases
Semester 8
2 courses8 lab lessonsNode.js- OECST832Node.js
Web Programming
4
lessons
- Building HTML5 Pages with Semantic Structure
- JavaScript Array Sorting with Custom Comparison
- 1Building HTML5 Pages with Semantic StructureUnit I · Creating Web Page using HTML5
- 2JavaScript Array Sorting with Custom ComparisonUnit II · Scripting language
- 3Building a Simple HTTP Server with Node.jsUnit III · JavaScript runtime environment
- 4A layered book catalogue service — SQL placeholders to REST, XML and SOAPUnit IV · SPA – Basics, Angular JS; Working with databases
- OEITT833Node.js
Web Designing
4
lessons
- HTML Page Builder
- CSS Rule Builder
- 1HTML Page BuilderUnit I · Website creation roles, Gearing up for web design, Web Page Addresses
- 2CSS Rule BuilderUnit II · Concept of CSS, Creating Style Sheet, CSS Properties, CSS Styling
- 3Basic DOM Manipulation with JavaScriptUnit III · Introduction to JavaScript
- 4SVG Path ParserUnit IV · Introduction to XML
The full 264-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 APJ Abdul Kalam Technological University. 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 KTU 2024 scheme?
Yes. GroutCode ships the transcribed KTU 2024 scheme for B.Tech CSE / IT / AI & DS / ECE — 264 courses — with 85 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 KTU practicals use?
C (22 lessons), Java (20 lessons), Node.js (16 lessons), Python (14 lessons), SQL (9 lessons), C++ (4 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

VTU
Visvesvaraya Technological University
Karnataka’s 2022 scheme across CSE, ISE, AI-ML, AI-DS and ECE, including the dedicated lab courses.
123
lab lessons

Anna University
Anna University, Chennai
Anna University’s Regulations 2021 B.E. CSE, from Python and C programming to the data structures and OOP laboratories.
31
lab lessons

AKTU
Dr. A.P.J. Abdul Kalam Technical University, Lucknow
AKTU Lucknow’s B.Tech CSE for the 2026-27 session: C programming, data structures, Java OOP and the operating system lab.
28
lab lessons
Do your KTU lab work with the checks built in
GroutCode is included in every Grout Suite license. Free download for Windows and macOS.
Download GroutCode