
India · CUFYUGP 2024
University of Calicut
128 lab practicals for the Calicut syllabus.
The CUFYUGP 2024 four-year honours programmes in Computer Science and BCA, from the first semester. 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: BSc Computer Science (Hons) / BCA (Hons). Scheme: CUFYUGP 2024. Open a course to see its practical units and the lab lesson GroutCode ships for each.
Semester 2
5 courses25 lab lessonsCNode.jsPython- BCA2CJ101C
Fundamentals of Programming (C Language)
5
lessons
- C Operators and Expressions
- Decision Making with If-Else Statements
- 1C Operators and ExpressionsUnit I · Introduction to C Language
- 2Decision Making with If-Else StatementsUnit II · Decision Making Branching and Looping
- 3Passing Arrays to FunctionsUnit III · Arrays and Functions
- 4Pointer Arithmetic and Array AccessUnit IV · Storage Classes, Structure and Union, Pointers
- 5Sorting an Array Using Bubble SortUnit V · Hands-on Problem-Solving Using C
- CSC2CJ101C
Fundamentals Of Programming (C Language)
5
lessons
- C Language Basics: Understanding Variables and Data Types
- Decision Making with If-Else Statements
- 1C Language Basics: Understanding Variables and Data TypesUnit I · Introduction to C Language
- 2Decision Making with If-Else StatementsUnit II · Decision Making Branching and Looping
- 3Passing Arrays to FunctionsUnit III · Arrays and Functions
- 4Pointer Arithmetic and Array AccessUnit IV · Storage Classes, Structure and Union, Pointers
- 5Matrix Addition and SubtractionUnit V · Hands-on Problem Solving Using C
- CSC2MN101C
Foundations of C Programming
5
lessons
- Flowchart to C Program Conversion
- C from the character set up — tokens, types, operators and formatted I/O
- 1Flowchart to C Program ConversionUnit I · Problem-solving and logical Thinking
- 2C from the character set up — tokens, types, operators and formatted I/OUnit II · Introduction to C
- 3Array Sorting with Selection SortUnit III · Control Statements, Arrays & Strings
- 4Understanding Function Parameters and RecursionUnit IV · User-defined Functions
- 5Library Book Search with Linear SearchUnit V · Hands-on C: Practical Applications, Case Study and Course Project
- CSC2MN104Node.js
Web Design Trends and Techniques
5
lessons
- Web Design Evolution Timeline
- Building Semantic HTML Documents
- 1Web Design Evolution TimelineUnit I · Introduction to Web Design
- 2Building Semantic HTML DocumentsUnit II · HTML - Building the Foundation
- 3CSS Box Model & Layout FoundationsUnit III · CSS - Styling Your Web Pages
- 4Writing the DOM — elements, selectors, styles, event propagation and a jQuery-style wrapperUnit IV · JavaScript Essentials
- 5HTML and CSS Tag ImplementationUnit V · Hands-on Programming in Java(Using VSCode, Atom, Aptana Studio): Practical Applications, Case Study and Course Project
- CSC2VN101Python
Introduction to Data Science
5
lessons
- Introduction to Data Science Concepts
- Data Cleaning: Remove Duplicates from Lists
- 1Introduction to Data Science ConceptsUnit I · Introduction to Data Science
- 2Data Cleaning: Remove Duplicates from ListsUnit II · Data Collection and Data Pre-Processing
- 3Descriptive Statistics CalculatorUnit III · Data Analytics
- 4Simple Linear Regression ImplementationUnit IV · Data Model Devolopment and Evaluation
- 5A data-analysis toolkit in plain Python — tables, frequencies, correlation and regressionUnit V · Practical: Introduction to data analysis tools in Python
Semester 3
4 courses20 lab lessonsCPython- BCA3CJ201C
Data Structures using C
5
lessons
- Singly Linked List Insertion
- Stack Implementation Using Array
- 1Singly Linked List InsertionUnit I · Introduction to Data Structures and Basic Algorithms
- 2Stack Implementation Using ArrayUnit II · Stack and Queue
- 3Binary Tree Node CreationUnit III · Non- Linear Data Structures
- 4Implementing Linear and Binary Search in CUnit IV · Sorting and Searching
- 5Singly Linked List: Insert, Delete, and SearchUnit V · Hands-on Programming in Data Structures: Practical
- CSC3CJ202C
Data Structures and Algorithm
5
lessons
- Singly Linked List Implementation
- Stack Implementation Using Array
- 1Singly Linked List ImplementationUnit I · Introduction to Data Structures and Basic Algorithms
- 2Stack Implementation Using ArrayUnit II · Stack and Queue
- 3Binary Tree Traversal ImplementationUnit III · Non- Linear Data Structures
- 4Binary Search ImplementationUnit IV · Sorting and Searching
- 5Stack Implementation Using ArrayUnit V · Hands-on Programming in Data Structures: Practical
- CSC3MN202Python
Introduction to AI and Machine Learning
5
lessons
- Implementing a Simple Search Algorithm
- Implement a Single-Layer Perceptron
- 1Implementing a Simple Search AlgorithmUnit I · Introduction to Artificial Intelligence & Problem Solving
- 2Implement a Single-Layer PerceptronUnit II · Introduction to Neural Networks
- 3Data Wrangling with Pandas: Load, Inspect, and Clean a DatasetUnit III · Python Packages for AI
- 4Supervised Learning: Implement a Simple ClassifierUnit IV · Machine Learning Fundamentals
- 5Machine learning from scratch — perceptrons, regression, trees, k-means and PCAUnit V · Hands-on Artificial Intelligence & Machine Learning using Python: Practical Applications, Case Study and Course Project
- CSC3MN204C
Programming fundamentals using C
5
lessons
- Flowchart to C Implementation: Simple Sorting
- First C functions — types, operators, identifiers and formatted I/O
- 1Flowchart to C Implementation: Simple SortingUnit I · Problem solving and logical Thinking
- 2First C functions — types, operators, identifiers and formatted I/OUnit II · Introduction to C
- 3Implementing Selection Sort AlgorithmUnit III · Control Statements,Arrays & Strings
- 4Function Parameters and Recursion in CUnit IV · User defined Functions
- 5Library Book Management with Arrays and FunctionsUnit V · Hands-on C: Practical Applications, Case Study and Course Project
Semester 4
4 courses20 lab lessonsSQLPython- BCA4CJ205SQL
Database Management System
5
lessons
- Understanding NULLs, Duplicates, and Data Models in SQLite
- Relational Database Design with SQLite
- 1Understanding NULLs, Duplicates, and Data Models in SQLiteUnit I · Database System- Concept
- 2Relational Database Design with SQLiteUnit II · Database Design
- 3Basic SQL SELECT QueriesUnit III · Query Languages
- 4Transaction Schedules and Serializability AnalysisUnit IV · Transaction Processing, Concurrency Control
- 5SQLite Query Practice with Basic SELECT and FilteringUnit V · DBMS LAB
- BCA4CJ206Python
Python Programming
5
lessons
- Implementing a Simple Sorting Algorithm
- Function Arguments and Scope in Python
- 1Implementing a Simple Sorting AlgorithmUnit I · Introduction to Python and Control Flow Statements
- 2Function Arguments and Scope in PythonUnit II · Introduction to Functions & Modules
- 3String Manipulation with ListsUnit III ·
- 4NumPy Array Sorting with Custom LogicUnit IV · Introduction to Scientific Computing in Python
- 5Binary Search ImplementationUnit V · Hands-on Data Structures: Practical Applications, Case
- CSC3CJ204Python
Python Programming
5
lessons
- Implementing a Simple Sorting Algorithm
- Function Arguments and Scope
- 1Implementing a Simple Sorting AlgorithmUnit I · Fundamentals of Python
- 2Function Arguments and ScopeUnit II · Functions & Modules
- 3String Reversal with SlicingUnit III · Data Structures in Python
- 4NumPy Array Creation and Basic OperationsUnit IV · Introduction to Scientific Computing in Python
- 5Implementing a Binary Search FunctionUnit V · Hands-on Data Structures: Practical Applications, Case Study and Course Project
- CSC4CJ203SQL
Database Management System
5
lessons
- Database Schema Design and Querying
- Relational Database Design and Normalization
- 1Database Schema Design and QueryingUnit I · Database System- Concept
- 2Relational Database Design and NormalizationUnit II · Database Design
- 3Basic SQL Query ConstructionUnit III · Query Languages
- 4Transaction Isolation and Serializable SchedulesUnit IV · Transaction Processing,Concurrency Control
- 5SQL Query Building with Aggregates and GroupingUnit V · DBMS LAB
Semester 5
3 courses14 lab lessonsJavaNode.js- BCA5CJ301Java
Object Oriented Programming (Java)
4
lessons
- Implementing a Simple Bank Account System
- Exception Handling with Custom Exceptions
- 1Implementing a Simple Bank Account SystemUnit I · Review of OOPs and Introduction to Java
- 2Exception Handling with Custom ExceptionsUnit II · Exception and I/O Operations
- 3Java threads — Thread and Runnable, thread states, priorities, synchronisation and wait/notifyUnit III · Multithreading and Database Connectivity
- 4GUI Programming
- 5String Operations in JavaUnit V · Hands-on Programming in Java(Using IDE NetBeans Eclipse, VSCode): Practical Applications, Case Study and Course Project
- CSC5CJ302Java
Object Oriented Programming (Java)
5
lessons
- Implementing a Simple Bank Account System
- Exception Handling with Custom Exceptions
- 1Implementing a Simple Bank Account SystemUnit I · Review of OOPs and Introduction to Java
- 2Exception Handling with Custom ExceptionsUnit II · Exception and I/O Operations
- 3Java threads from Thread to wait/notify, and the PreparedStatement side of JDBCUnit III · Multithreading and Database Connectivity
- 4Swing GUIs with MVC — controls, layout managers and event handlingUnit IV · GUI Programming
- 5Complex Number Operations with Method OverloadingUnit V · Hands-on Programming in Java(Using IDE NetBeans, Eclipse VSCode): Practical Applications, Case Study and Course Project
- CSC5CJ303Node.js
Full Stack Web Development
5
lessons
- HTML Tag Validator
- Implementing a Basic Sorting Algorithm in JavaScript
- 1HTML Tag ValidatorUnit I · HTML & CSS
- 2Implementing a Basic Sorting Algorithm in JavaScriptUnit II · JavaScript & Node.JS
- 3React Component State ManagementUnit III · React.JS
- 4A MongoDB-style document store in Node — queries, updates, indexes and aggregationUnit IV · MongoDB
- 5Building a Simple Web Server with Node.jsUnit V · Practical Implementations of Full Stack Web Development
Semester 6
4 courses19 lab lessonsPython- BCA6CJ304Python
Introduction to AI and ML
5
lessons
- Implementing Breadth-First Search (BFS) for Graph Traversal
- Propositional Logic Reasoner
- 1Implementing Breadth-First Search (BFS) for Graph TraversalUnit I · Introduction to Artificial Intelligence & Problem Solving and Searching
- 2Propositional Logic ReasonerUnit II · Knowledge Representation & Reasoning
- 3Implement a Single-Layer Perceptron from ScratchUnit III · Introduction to Neural Networks
- 4Implementing a Basic Decision Tree ClassifierUnit IV · Machine Learning Fundamentals
- 5Implementing BFS and DFS Search AlgorithmsUnit V · Hands-on Artificial Intelligence & Machine Learning using Python: Practical Applications, Case Study and Course Project
- BCA6EJ303(4)Python
Advanced Python for Data Science
4
lessons
- NumPy Array Sorting and Manipulation
- Data Analysis with NumPy Arrays
- 1NumPy Array Sorting and ManipulationUnit I · Arrays, Matrix manipulation using NumPy
- 2Data Analysis and Manipulation using Pandas
- 3Data Analysis with NumPy ArraysUnit III · Other Python packages for data science
- 4Tensor Creation and Basic OperationsUnit IV · TensorFlow Fundamentals
- 5Data Loading and Basic Inspection with PandasUnit V · Open Ended Module
- CSC6CJ306Python
Introduction to Artificial Intelligence & Machine Learning
5
lessons
- Implementing Breadth-First Search (BFS) for Graph Traversal
- A small reasoning engine — logic, semantic networks, frames and rule-based inference
- 1Implementing Breadth-First Search (BFS) for Graph TraversalUnit I · Introduction to Artificial Intelligence & Problem Solving and Searching
- 2A small reasoning engine — logic, semantic networks, frames and rule-based inferenceUnit II · Knowledge Representation & Reasoning
- 3Implement a Single-Layer Perceptron from ScratchUnit III · Introduction to Neural Networks
- 4Implementing a Simple K-Means Clustering AlgorithmUnit IV · Machine Learning Fundamentals
- 5Breadth-First Search ImplementationUnit V · Hands-on Artificial Intelligence & Machine Learning using Python: Practical Applications, Case Study and Course Project
- CSC6EJ312aPython
Advanced Python for Data Science
5
lessons
- NumPy Array Sorting with Custom Logic
- Building a mini pandas — Series, DataFrame, alignment, broadcasting, melt and pivot
- 1NumPy Array Sorting with Custom LogicUnit I · Arrays, Matrix manipulation using NumPy
- 2Building a mini pandas — Series, DataFrame, alignment, broadcasting, melt and pivotUnit II · Data Analysis and Manipulation using Pandas
- 3Central Tendency & Variance CalculatorUnit III · Other Python packages for data science
- 4Tensor Creation and Basic OperationsUnit IV · TensorFlow Fundamentals
- 5A data-analysis pipeline from CSV and JSON to charts and a trained modelUnit V · Hands-on Data Structures: Practical Applications, Case Study and Course Project
Semester 7
2 courses10 lab lessonsC- BCA7CJ401C
Advanced Data Structures and algorithms
5
lessons
- Algorithm Complexity Analysis
- Merge Sort Implementation
- 1Algorithm Complexity AnalysisUnit I · Introduction to Data Structures and Analysis of Quality of an Algorithm
- 2Merge Sort ImplementationUnit II · Basic Technique for Design of Efficient Algorithm
- 3Singly Linked List ImplementationUnit III · Linked lists - operations and implementations
- 4Binary Search Tree InsertionUnit IV · Non-linear Data Structures
- 5Heap Sort ImplementationUnit V · Practical Implementations of Data Structures and its Operations
- CSC7CJ403C
Advanced Data Structures and algorithms
5
lessons
- Algorithm Complexity Analysis
- Merge Sort Implementation
- 1Algorithm Complexity AnalysisUnit I · Introduction to data structures and analysis of Quality of an algorithm
- 2Merge Sort ImplementationUnit II · Basic Technique for Design of Efficient Algorithm
- 3Singly Linked List ImplementationUnit III · Linked lists - operations and implementations
- 4Binary Search Tree InsertionUnit IV · Non-linear Data Structures
- 5Implementation of Max Heap and Delete OperationUnit V · Practical Implementations of Data structures and its operations in Java or C programming Language
Semester 8
4 courses20 lab lessonsCJavaPython- BCA8EJ404(1)C
Compiler Design
5
lessons
- Lexical Analyzer Token Recognition
- Building parsers — recursive descent, left recursion, FIRST/FOLLOW, LL(1) tables and operator precedence
- 1Lexical Analyzer Token RecognitionUnit I · COMPILERS AND LEXICAL ANALYSIS
- 2Building parsers — recursive descent, left recursion, FIRST/FOLLOW, LL(1) tables and operator precedenceUnit II · SYNTAX ANALYSIS
- 3Three-Address Code GenerationUnit III · SEMANTIC ANALYSIS AND INTERMEDIATE CODE GENERATION
- 4Simple Code Generator for Arithmetic ExpressionsUnit IV · CODE OPTIMIZATION AND CODE GENERATION
- 5Lexical Analyzer with Token RecognitionUnit V · Open Ended Module - Application Level
- BCA8EJ405(1)Java
Mastering Java Web Development
5
lessons
- Building a User Profile Service with Logging
- Understanding JSP Page Lifecycle
- 1Building a User Profile Service with LoggingUnit I · Over View of Core Java
- 2Understanding JSP Page LifecycleUnit II · Introduction to JSP
- 3Building a Spring MVC ControllerUnit III · Introduction to Spring MVC
- 4Building a RESTful API with Spring MVC and AJAXUnit IV · Integrated Spring and AJAX
- 5Library Management System with Spring MVCUnit V · Practical Applications, Case Study and Course Project
- CSC8CJ406C
Compiler Design
5
lessons
- Lexical Analyzer Token Recognition
- Recursive Descent Parser for Simple Expressions
- 1Lexical Analyzer Token RecognitionUnit I · COMPILERS AND LEXICAL ANALYSIS
- 2Recursive Descent Parser for Simple ExpressionsUnit II · SYNTAX ANALYSIS
- 3Syntax-directed translation to three-address code, quadruples and triplesUnit III · SEMANTIC ANALYSIS AND INTERMEDIATE CODE GENERATION
- 4Local Optimization: Dead Code EliminationUnit IV · CODE OPTIMIZATION AND CODE GENERATION
- 5Lexical Analyzer for Simple ExpressionsUnit V · Open Ended Module - Application Level
- CSC8VN401Python
Predictive Modelling
5
lessons
- Covariance, correlation matrices, and partial and multiple correlation from first principles
- Simple Linear Regression Implementation
- 1Covariance, correlation matrices, and partial and multiple correlation from first principlesUnit I · Correlation & Covariance
- 2Simple Linear Regression ImplementationUnit II · Regression Techniques
- 3Logistic Regression ImplementationUnit III · Logistics Regression
- 4Decomposing and forecasting a time series — moving averages, seasonal indices, AR, ARMA and ARIMAUnit IV · Time Series analysis and forecasting
- 5Health-care case study — encoding variables, multiple linear regression and logistic regression from scratchUnit V · Open Ended Module: Assignments, Case study
The full 112-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 University of Calicut. 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 Calicut CUFYUGP 2024?
Yes. GroutCode ships the transcribed Calicut CUFYUGP 2024 for BSc Computer Science (Hons) / BCA (Hons) — 112 courses — with 128 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 Calicut practicals use?
C (50 lessons), Python (44 lessons), Java (14 lessons), Node.js (10 lessons), SQL (10 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

KTU
APJ Abdul Kalam Technological University
The 2024 scheme for Kerala’s technological university, covering CSE, IT, AI & DS and ECE from semester three onwards.
85
lab lessons

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
Do your Calicut lab work with the checks built in
GroutCode is included in every Grout Suite license. Free download for Windows and macOS.
Download GroutCode