Programming logic, data structures, SQL databases, computing concepts, testing and an application project.
What you will cover
Programming logic
data structures
SQL databases
computing concepts
testing
an application project
Topic list from the institute's programme record.
Certification
Certificate terms for this programme are confirmed by the institute at admission. Any ADIVAS course-completion certificate is an institute certificate; it is not a university degree, an externally accredited qualification or a vendor certification (such as AWS or Microsoft) unless the institute states so in writing.
The programme title is as supplied in the institute's list. Please confirm the awarding body and recognition with the institute before enrolling.
Curriculum 0.1 · Draft: written for ADIVAS and awaiting academic review and approval. Topics and weeks may change before your batch starts.
Your skill trail
You move through 8 stations. Each week builds one skill you can show, not just a topic you have heard.
1
Computing foundations
Understand how computers represent data, think in algorithms and write the first Python programs.
Week 1 How a computer works
Week 2 Algorithms and problem decomposition
Week 3 Python setup, variables and input
Week 4 Decisions and loops
2
Programming fundamentals
Write structured, tested Python with functions, collections, files, exceptions, Git and objects.
Week 5 Functions
Week 6 Strings and text processing
Week 7 Lists and tuples
Week 8 Dictionaries and sets
Week 9 Files and exceptions
Week 10 Command line, Git and debugging
Week 11 Object-oriented programming I
Week 12 Object-oriented programming II and mini project
3
Data structures
Implement and compare the core data structures and understand their costs.
Week 13 Complexity and measuring performance
Week 14 Arrays and dynamic arrays
Week 15 Linked lists
Week 16 Stacks
Week 17 Queues and deques
Week 18 Recursion
Week 19 Hash tables
Week 20 Binary trees and binary search trees
Week 21 Heaps and priority queues
Week 22 Graphs and traversals
4
Algorithms
Apply searching, sorting, greedy and dynamic programming techniques to practical problems.
Week 23 Searching techniques
Week 24 Elementary sorting
Week 25 Merge sort and quick sort
Week 26 Greedy algorithms
Week 27 Dynamic programming introduction
Week 28 Problem-solving workshop and mid-course assessment
5
Databases and SQL
Design relational schemas and use SQL from the command line and from Python.
Week 29 Data, databases and the relational model
Week 30 SQL basics: creating and changing data
Week 31 Querying: filtering, sorting and aggregates
Week 32 Joins and subqueries
Week 33 Database design and normalisation
Week 34 Indexes and transactions
Week 35 Databases from Python and SQL safety
6
Computing concepts
Understand operating systems, networks, the web and security at concept level.
Week 36 Operating systems: processes and scheduling
Week 37 Memory and file systems
Week 38 Computer networks
Week 39 The web: HTTP, clients and servers
Week 40 Security fundamentals
7
Software engineering and testing
Test, design and review software and build a small web service with reviewed AI assistance.
Week 41 Software testing
Week 42 Requirements and design
Week 43 Building a small web service
Week 44 Code review and responsible AI-assisted development
8
Application project
Plan, build, test and present a complete database-backed application.
Week 45 Project: proposal and design
Week 46 Project: build core features
Week 47 Project: testing and hardening
Week 48 Project: presentation and review
★
Neighbourhood Library or Shop Management System
Your project, reviewed by a trainer.
The ADIVAS mastery ladder: how each skill is recognised
Explored You have seen the idea and tried a first example.
Practising You can do it with hints and keep improving.
Proficient You complete the weekly practical task correctly on your own.
Proven You apply it in a project reviewed by your trainer.
Skill-level tracking is being added to the learner workspace. Your trainer already reviews weekly practical work.
What you will be able to do
Explain how a computer represents and processes data, and express solutions as algorithms before coding.
Write Python programs using conditions, loops, functions and structured problem decomposition.
Process text, lists, dictionaries and files, and handle errors with exceptions.
Design classes and objects with encapsulation, inheritance and polymorphism.
Use the command line and Git, and debug programs systematically.
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Explain at concept level how operating systems, networks, the web and basic security work.
Write unit tests, derive test cases, review code, and use AI assistants with careful verification.
Plan, build, test and present a database-backed application as a project.
Who it suits
School Class 11-12 students who want a thorough, practical computer science foundation beyond the school syllabus.
College Diploma and degree students who want strong programming, data structure and database skills and clear concepts behind them.
Professional Working adults and career changers who want a systematic computer science grounding over one year.
Prerequisites: Comfort with basic computer use and school mathematics. No prior programming is required; the course starts from the beginning. Tools: Python 3 with pip and venv, VS Code or PyCharm Community Edition, SQLite and MySQL Community Server with a SQL client, Git and a free code hosting account, A Linux or macOS terminal, or WSL on Windows, pytest, Flask (for the web application weeks), An AI coding assistant (with review rules taught in the course).
Weekly plan
Computing foundations Weeks 1–4
Week 1: How a computer works
Theory
Hardware, software and the fetch-execute idea
Binary numbers and text encoding (ASCII and Unicode, including Tamil)
Memory, storage and units from bit to gigabyte
Lab
Convert numbers between decimal and binary by hand and with a calculator, and inspect a text file in a hex viewer to see how a Tamil letter and an English letter are stored.
Homework
Convert ten decimal numbers to binary and back, and explain why 8 GB of RAM is not the same as 8 GB of storage.
Deliverable
A one-page worksheet of conversions with a short note on Unicode.
Weekly checkpoint
Convert binary values, identify hardware roles and explain why text needs an encoding.
You will be able to
Explain how a computer represents and processes data, and express solutions as algorithms before coding.
Week 2: Algorithms and problem decomposition
Theory
What an algorithm is and how to write pseudocode
Flowcharts and tracing with sample data
Breaking a big problem into smaller steps
Lab
Write pseudocode and a flowchart for three problems (largest of three, bill with discount, ATM withdrawal limits) and trace each with two sample inputs.
Homework
Write pseudocode for sorting five numbers by hand, and trace it.
Deliverable
Pseudocode and flowcharts for three problems with trace tables.
Weekly checkpoint
Trace a given algorithm; arrange the steps of an algorithm in order.
You will be able to
Explain how a computer represents and processes data, and express solutions as algorithms before coding.
Week 3: Python setup, variables and input
Theory
Installing Python, running scripts and the REPL
Variables, int, float, str and bool
input(), print(), f-strings and type conversion
Lab
Write a GST bill calculator, a simple interest calculator and a temperature converter; read inputs, convert types and format output to two decimals.
Homework
Write a program that splits a bill equally among friends and prints each share.
Deliverable
Three Python scripts with sample runs.
Weekly checkpoint
Predict outputs involving integer and float division and string concatenation.
You will be able to
Write Python programs using conditions, loops, functions and structured problem decomposition.
Week 4: Decisions and loops
Theory
if, elif, else and Boolean logic
for and while loops, range, break and continue
Nested loops and pattern problems
Lab
Write programs for grade assignment, leap year, a multiplication table, digit sum and a pyramid pattern.
Homework
Write a guess-the-number game with a limit of five attempts.
Deliverable
A set of five loop and decision programs with test inputs.
Weekly checkpoint
Trace a nested loop; fix an off-by-one error in a loop.
You will be able to
Write Python programs using conditions, loops, functions and structured problem decomposition.
Programming fundamentals Weeks 5–12
Week 5: Functions
Theory
Defining functions, parameters and return values
Scope, default and keyword arguments
Writing small reusable functions and docstrings
Lab
Refactor the earlier bill and loop programs into functions and write functions for prime check, gcd and factorial.
Homework
Write a function library file and import it from another script.
Deliverable
A utilities module with at least eight documented functions.
Weekly checkpoint
Predict outputs of function calls with default arguments and variable scope.
You will be able to
Write Python programs using conditions, loops, functions and structured problem decomposition.
Week 6: Strings and text processing
Theory
Indexing, slicing and immutability
Common string methods: split, join, strip, replace, find
Simple validation and text cleaning
Lab
Write a palindrome checker, word counter, vowel counter and a validator for Indian mobile numbers and PIN codes.
Homework
Write a function that converts a name to initials and another that masks the middle digits of a phone number.
Deliverable
A text toolkit with tests for each function.
Weekly checkpoint
Predict outputs of slices and split/join; find a bug in a validator.
You will be able to
Process text, lists, dictionaries and files, and handle errors with exceptions.
Week 7: Lists and tuples
Theory
List creation, indexing, append, insert, remove
Iteration, sorting and list comprehensions
Tuples, unpacking and list aliasing versus copying
Lab
Analyse a list of 20 exam marks: total, average, highest, rank list and count above average.
Homework
Rotate a list by k positions and remove duplicates while keeping order.
Deliverable
A marks-analysis script using list operations.
Weekly checkpoint
Predict list outputs, including aliasing with b = a.
You will be able to
Process text, lists, dictionaries and files, and handle errors with exceptions.
Week 8: Dictionaries and sets
Theory
Key-value pairs and dictionary methods
Sets for uniqueness and membership
Counting and grouping patterns
Lab
Count word frequency in a paragraph, group transactions by category and find common and unique items between two class lists using sets.
Homework
Build a phone-book program with add, search, update and delete.
Deliverable
A phone-book program and a word-frequency report.
Weekly checkpoint
Choose a list, dictionary or set for scenarios; predict a counting loop's output.
You will be able to
Process text, lists, dictionaries and files, and handle errors with exceptions.
Week 9: Files and exceptions
Theory
Reading and writing text and CSV files with with-blocks
try, except, finally and raising errors
JSON for saving structured data
Lab
Make the phone book persistent with JSON, and read a CSV of sales while handling missing or malformed rows gracefully.
Homework
Add a log file that records each error with a timestamp.
Deliverable
A persistent application with error handling and a log.
Weekly checkpoint
Order try/except/finally output; fix code that crashes on a missing file.
You will be able to
Process text, lists, dictionaries and files, and handle errors with exceptions.
Week 10: Command line, Git and debugging
Theory
Terminal navigation, files and pipes
Git: init, add, commit, branch, merge and remote
Debugging method: reproduce, isolate, fix, verify; IDE debugger and print tracing
Lab
Create a repository for the course, commit weekly work on branches, resolve a deliberate merge conflict and debug a provided program with three seeded bugs.
Homework
Write a bug report for each bug found: symptom, cause, fix and evidence.
Deliverable
A repository with a clean history and a bug log.
Weekly checkpoint
Sequence a branch and merge workflow; locate a bug from a traceback.
You will be able to
Use the command line and Git, and debug programs systematically.
Week 11: Object-oriented programming I
Theory
Classes, objects, attributes and methods
__init__, __str__ and encapsulation by convention
Modelling real things: students, accounts, products
Lab
Model a BankAccount and a Student class with validation, and write a small program that manages a list of objects.
Homework
Add a class for Library Book with issue and return and a fine rule.
Deliverable
Two modelled classes with a demo script.
Weekly checkpoint
Read a class and predict output; identify attributes and methods in a design.
You will be able to
Design classes and objects with encapsulation, inheritance and polymorphism.
Week 12: Object-oriented programming II and mini project
Theory
Inheritance, overriding and super()
Polymorphism and composition
Structuring a small multi-file project
Lab
Build an inventory manager with Product, PerishableProduct and Inventory classes, file persistence and a menu.
Homework
Write a README and a short design note with a class diagram.
Deliverable
Mini project 1: a menu-driven inventory manager.
Weekly checkpoint
Practical: extend the inventory manager with one new feature in 45 minutes.
You will be able to
Design classes and objects with encapsulation, inheritance and polymorphism. Use the command line and Git, and debug programs systematically.
Data structures Weeks 13–22
Week 13: Complexity and measuring performance
Theory
Counting operations and growth of functions
Big-O intuition: constant, log, linear, n log n, quadratic
Measuring with the time module and why measurements vary
Lab
Time three ways to check for duplicates in lists of 1000 to 20000 items and fit the results to O(n) or O(n^2).
Homework
State the complexity of ten short code fragments with a reason for each.
Deliverable
A timing table and a short analysis.
Weekly checkpoint
Classify code fragments by complexity.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs. Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 14: Arrays and dynamic arrays
Theory
Contiguous memory and indexing cost
Dynamic arrays and amortised append
Two-pointer and prefix-sum techniques
Lab
Implement a dynamic array class with resize and use two pointers and prefix sums to solve pair-sum and range-sum problems.
Homework
Solve five array problems and state each solution's complexity.
Deliverable
A dynamic array class with tests plus solved problems.
Weekly checkpoint
Explain why append is usually cheap but sometimes expensive.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 15: Linked lists
Theory
Nodes and references
Singly linked list insert, delete and traversal
Array versus linked list trade-offs
Lab
Implement a linked list with append, prepend, delete and reverse, and write tests for empty, one-element and many-element lists.
Homework
Detect a cycle in a linked list and find its middle node.
Deliverable
A tested linked list implementation.
Weekly checkpoint
Trace deletion of a middle node; choose array or list for a scenario.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 16: Stacks
Theory
Last-in first-out and its operations
Implementing with list and with a linked list
Applications: bracket matching, undo and expression evaluation
Lab
Build a stack, write a balanced bracket checker and evaluate postfix expressions.
Homework
Convert an infix expression to postfix by hand and by program.
Deliverable
A stack module with a bracket checker and a postfix evaluator.
Weekly checkpoint
Trace stack contents during postfix evaluation.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 17: Queues and deques
Theory
First-in first-out and circular buffers
collections.deque and why list.pop(0) is slow
Applications: scheduling, ticket queues and buffers
Lab
Implement a queue and simulate a ticket counter with arrival and service times, reporting average waiting time.
Homework
Implement a queue using two stacks.
Deliverable
A queue module and a counter simulation.
Weekly checkpoint
Choose stack or queue for scenarios; trace queue operations.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 18: Recursion
Theory
Base case and recursive case
The call stack and stack overflow
Recursion versus iteration; memoisation idea
Lab
Write recursive factorial, Fibonacci, power, binary search and a directory-size calculator, and trace the call stack for two of them.
Homework
Fix three recursive functions with a missing or wrong base case.
Deliverable
A recursion workbook with call-stack drawings.
Weekly checkpoint
Trace a recursive call; find the bug in a recursive function.
You will be able to
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 19: Hash tables
Theory
Hash functions, buckets and collisions
Chaining and load factor
How Python dict and set use hashing; mutable keys
Lab
Implement a hash table with chaining and compare lookup times against a list for 100000 student IDs.
Homework
Solve two-sum and first non-repeating character using a dictionary.
Deliverable
A hash table implementation and a timing comparison.
Weekly checkpoint
Explain a collision; predict where keys land in a small table.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 20: Binary trees and binary search trees
Theory
Tree terms: root, leaf, height
Traversals: in-order, pre-order, post-order
BST insert, search and delete; balance problem
Lab
Build a BST for student IDs with insert, search and in-order listing, and measure height after sorted versus random insertion.
Homework
Compute tree height and count leaves recursively.
Deliverable
A BST class with tests and a height experiment.
Weekly checkpoint
Insert values by hand and list traversals; explain why sorted input hurts a plain BST.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 21: Heaps and priority queues
Theory
Heap property and array representation
Insert and extract with heapify
heapq and priority queue use cases such as emergency triage
Lab
Implement a min-heap, then use heapq to run a hospital-style triage queue and to find the k largest items in a list.
Homework
Explain why heap sort is O(n log n).
Deliverable
A heap implementation and a triage simulation.
Weekly checkpoint
Show heap contents after insertions; choose a heap for a scenario.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs.
Week 22: Graphs and traversals
Theory
Vertices, edges and adjacency lists
Breadth-first and depth-first search
Shortest path in an unweighted graph and connected components
Lab
Model a bus-route map of Madurai as a graph and find the route with the fewest stops with BFS, then count connected areas with DFS.
Homework
Detect whether a graph has a cycle.
Deliverable
A route finder with a drawn graph.
Weekly checkpoint
Trace BFS on a given graph; choose BFS or DFS for a task.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs. Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Algorithms Weeks 23–28
Week 23: Searching techniques
Theory
Linear search and binary search with preconditions
Search on answers and boundary conditions
Counting comparisons
Lab
Implement binary search iteratively and recursively, test on edge cases and count comparisons for 1000000 items.
Homework
Find the first and last position of a value in a sorted list with duplicates.
Deliverable
Search functions with a boundary test table.
Weekly checkpoint
Find the bug in a binary search with an incorrect loop condition.
You will be able to
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 24: Elementary sorting
Theory
Bubble, selection and insertion sort
Stability and in-place sorting
When simple sorts are acceptable
Lab
Implement three sorts, count comparisons and swaps on random, sorted and reverse-sorted data, and tabulate the results.
Homework
Sort a list of students by marks and then by name stably.
Deliverable
A comparison report of three sorts.
Weekly checkpoint
Trace one pass of each sort; identify which sorts are stable.
You will be able to
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 25: Merge sort and quick sort
Theory
Divide and conquer
Merge sort and its n log n bound
Quick sort, pivot choice and worst case
Lab
Implement merge sort and quick sort and compare them with Python's built-in sort for sizes up to 200000.
Homework
Explain in writing why quick sort can degrade to quadratic time.
Deliverable
Sorting implementations with a benchmark chart.
Weekly checkpoint
Trace a merge on two sorted lists; explain pivot effect.
You will be able to
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 26: Greedy algorithms
Theory
Greedy choice idea and when it works
Activity selection and coin change with Indian denominations
Counterexamples
Lab
Solve activity selection for a seminar hall booking problem, write coin change greedy and find a coin system where greedy fails.
Homework
Explain why greedy works for activity selection but not for every coin system.
Deliverable
Greedy solutions with a counterexample note.
Weekly checkpoint
Decide whether greedy is valid for three problems.
You will be able to
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 27: Dynamic programming introduction
Theory
Overlapping subproblems and memoisation
Bottom-up tables
Examples: Fibonacci, climbing stairs, 0/1 knapsack, longest common subsequence
Lab
Compare naive and memoised Fibonacci run times, then solve knapsack for a shopkeeper's weight-limited carry plan with a table.
Homework
Solve a minimum coin change problem with a table.
Deliverable
DP solutions with filled tables and run-time comparison.
Weekly checkpoint
Fill a small DP table by hand; spot overlapping subproblems.
You will be able to
Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Week 28: Problem-solving workshop and mid-course assessment
Theory
Strategy for unfamiliar problems: restate, examples, brute force, improve
Choosing structures and algorithms together
Reading and writing time-limited solutions
Lab
Solve a set of eight mixed problems in a timed session and then review each solution's complexity and edge cases in pairs.
Homework
Rewrite two weakest solutions after feedback.
Deliverable
Annotated solutions with complexity statements.
Weekly checkpoint
Mid-course written and practical assessment.
You will be able to
Implement arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs, and compare their costs. Apply searching, sorting, recursion, greedy and dynamic programming techniques and estimate running time.
Databases and SQL Weeks 29–35
Week 29: Data, databases and the relational model
Theory
Files versus databases
Tables, rows, columns, keys and data types
SQLite and MySQL: where each is used
Lab
Set up SQLite and MySQL, create a school database and explore tables with a SQL client.
Homework
Identify entities and attributes for a clinic and list candidate primary keys.
Deliverable
A first database with two tables and sample rows.
Weekly checkpoint
Identify keys and data types for a given table.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Week 30: SQL basics: creating and changing data
Theory
CREATE TABLE and constraints
INSERT, UPDATE and DELETE
Why WHERE matters in updates and deletes
Lab
Create tables for students, courses and marks with constraints and practise insert, update and delete with safe WHERE clauses.
Homework
Write statements that fail on purpose to see each constraint working.
Deliverable
A SQL script creating and populating the school database.
Weekly checkpoint
Find the flaw in an UPDATE missing a WHERE clause.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Week 31: Querying: filtering, sorting and aggregates
Theory
SELECT, WHERE, ORDER BY, LIMIT and LIKE
COUNT, SUM, AVG, MIN, MAX
GROUP BY and HAVING; NULL handling
Lab
Write 15 queries on the marks data: toppers, class averages, subject-wise counts and students without marks.
Homework
Write queries answering five management questions in plain English first.
Deliverable
A query workbook with expected results.
Weekly checkpoint
Predict query output; choose WHERE or HAVING.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Week 32: Joins and subqueries
Theory
INNER, LEFT joins and join conditions
Subqueries and EXISTS
Why a bad join duplicates rows
Lab
Join students, courses and marks to build a report card query, find students with no enrolment and verify row counts by hand on small data.
Homework
Rewrite one subquery as a join and compare results.
Deliverable
Report-card and exception queries with verified results.
Weekly checkpoint
Predict the row count of INNER and LEFT joins on small tables.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Week 33: Database design and normalisation
Theory
Entity-relationship diagrams
One-to-many and many-to-many with junction tables
Anomalies and 1NF, 2NF, 3NF
Lab
Take a single wide order sheet, find its anomalies, normalise it into four tables and draw the ER diagram.
Homework
Design a schema for a bus ticket booking system.
Deliverable
ER diagram and DDL for the normalised design.
Weekly checkpoint
Identify the normal form violated in a table.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Week 34: Indexes and transactions
Theory
How an index speeds queries and its cost
Transactions, commit, rollback and ACID idea
Query plans with EXPLAIN
Lab
Time a query on 200000 rows with and without an index, and run a money-transfer transaction that rolls back after an error.
Homework
Pick which columns to index for a given workload and justify it.
Deliverable
A performance and transaction report.
Weekly checkpoint
Explain why a transfer needs a transaction.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions.
Week 35: Databases from Python and SQL safety
Theory
sqlite3 and a MySQL connector: connect, cursor, commit
Parameterised queries and SQL injection
Separating data-access code from application logic
Lab
Write a data-access module for the school database using parameterised queries and demonstrate then block an injection attempt.
Homework
Add search and report functions to the module with tests.
Deliverable
A tested data-access module.
Weekly checkpoint
Rewrite an unsafe query safely.
You will be able to
Design normalised relational schemas and write SQL for CRUD, joins, aggregates, indexes and transactions. Write unit tests, derive test cases, review code, and use AI assistants with careful verification.
Computing concepts Weeks 36–40
Week 36: Operating systems: processes and scheduling
Theory
What an operating system does
Processes, threads and context switching
CPU scheduling: first-come first-served and round robin
Lab
Observe processes with the task manager and ps or top, then simulate round-robin scheduling in Python for five jobs and compute average waiting time.
Homework
Compare FCFS and round robin on the same job list.
Deliverable
A scheduling simulation and a comparison table.
Weekly checkpoint
Compute waiting times for a small scheduling example.
You will be able to
Explain at concept level how operating systems, networks, the web and basic security work.
Week 37: Memory and file systems
Theory
Virtual memory, paging and why swapping slows a machine
Files, directories, permissions and inodes at concept level
Deadlock idea with a simple example
Lab
Explore file permissions and a directory tree on Linux, change permissions with chmod and explain the results.
Homework
Explain a scenario of a slow computer with full memory in plain words.
Deliverable
A permissions exercise log and a one-page memory explainer.
Weekly checkpoint
Interpret a permission string; choose the likely cause of slowdown.
You will be able to
Explain at concept level how operating systems, networks, the web and basic security work.
Week 38: Computer networks
Theory
Layers: link, internet, transport, application
IP addresses, subnets idea, ports and DNS
TCP versus UDP at concept level
Lab
Use ping, traceroute and nslookup to inspect a path to a website, and draw the layers a web request passes through.
Homework
Explain the difference between an IP address and a domain name with an example.
Deliverable
A network trace report with a layer diagram.
Weekly checkpoint
Order the steps from typing a URL to seeing a page.
You will be able to
Explain at concept level how operating systems, networks, the web and basic security work.
Week 39: The web: HTTP, clients and servers
Theory
HTTP requests, methods, status codes and headers
Client-server model, cookies and sessions
APIs and JSON
Lab
Inspect requests in the browser's developer tools and call a public JSON API from Python with the requests library.
Homework
Write a script that fetches data from an API and prints a summary.
Deliverable
An API client script with sample output.
Weekly checkpoint
Match status codes to meanings; trace a login using cookies.
You will be able to
Explain at concept level how operating systems, networks, the web and basic security work.
Week 40: Security fundamentals
Theory
Passwords, salted hashing and why not to store plain text
HTTPS and certificates at concept level; phishing
Common web risks: injection and cross-site scripting
Lab
Hash passwords with a salt using the standard library, show why plain text storage is dangerous and review a small program for injection risks.
Homework
Write a checklist of ten security habits for a small business website.
Deliverable
A password-hashing script and a security checklist.
Weekly checkpoint
Choose safe password storage; spot an injection risk in code.
You will be able to
Explain at concept level how operating systems, networks, the web and basic security work.
Software engineering and testing Weeks 41–44
Week 41: Software testing
Theory
Unit, integration and acceptance tests
Test case design: normal, boundary and invalid inputs
pytest basics, fixtures and test-first thinking
Lab
Write twenty pytest tests for the data-access module and a business-rule function, including boundary and failure cases, and fix defects found.
Homework
Measure what your tests cover and list what remains untested.
Deliverable
A test suite with a short coverage note.
Weekly checkpoint
Design test cases for a given function; read a failing test.
You will be able to
Write unit tests, derive test cases, review code, and use AI assistants with careful verification.
Week 42: Requirements and design
Theory
User stories and acceptance criteria
Layered design and simple UML sketches
Estimating work and managing scope
Lab
Write user stories for a small shop or clinic application and draw its layers, data model and main screens or endpoints.
Homework
Rank stories into must-have and later features with reasons.
Deliverable
A requirements and design document.
Weekly checkpoint
Write acceptance criteria for a given story.
You will be able to
Write unit tests, derive test cases, review code, and use AI assistants with careful verification. Plan, build, test and present a database-backed application as a project.
Week 43: Building a small web service
Theory
Flask routes, request and response
JSON endpoints and input validation
Connecting a web layer to the data-access module
Lab
Build a Flask service exposing list, add and search endpoints over the database and test it with curl and pytest.
Homework
Return correct status codes for invalid input and missing records.
Deliverable
A working Flask service with tests.
Weekly checkpoint
Choose the right method and status code for operations.
You will be able to
Explain at concept level how operating systems, networks, the web and basic security work. Write unit tests, derive test cases, review code, and use AI assistants with careful verification.
Week 44: Code review and responsible AI-assisted development
Verifying AI output: tests, documentation checks, licensing and privacy
Lab
Ask an AI assistant to write a reporting function, then review, test and correct it, logging each defect found.
Homework
Review a peer's code with five specific comments.
Deliverable
An AI review log and a peer review.
Weekly checkpoint
Given AI-written code, list defects and tests that would catch them.
You will be able to
Write unit tests, derive test cases, review code, and use AI assistants with careful verification.
Application project Weeks 45–48
Week 45: Project: proposal and design
Theory
Choosing a realistic scope
Schema, API and screen design review
Planning milestones and test strategy
Lab
Finalise the project proposal, schema and plan with the trainer and create the repository with an issue list.
Homework
Prepare the database script and a skeleton application.
Deliverable
Approved proposal, schema, plan and repository.
Weekly checkpoint
Proposal review with the trainer.
You will be able to
Plan, build, test and present a database-backed application as a project.
Week 46: Project: build core features
Theory
Implementing in small, tested increments
Keeping data access separate from logic
Using Git branches for features
Lab
Implement the core data model, data-access layer and first features with tests.
Homework
Complete one more feature and update the plan.
Deliverable
Working core features on a feature branch merged to main.
Weekly checkpoint
Progress demo with a test run.
You will be able to
Use the command line and Git, and debug programs systematically. Plan, build, test and present a database-backed application as a project.
Week 47: Project: testing and hardening
Theory
Edge cases, validation and error messages
Peer testing and bug triage
Security and performance checks
Lab
Swap projects with a peer, report five defects each, fix them and add tests so they stay fixed.
Homework
Write the README and user guide.
Deliverable
A tested, hardened application with a bug list closed.
Weekly checkpoint
Peer test report and fixes.
You will be able to
Write unit tests, derive test cases, review code, and use AI assistants with careful verification. Plan, build, test and present a database-backed application as a project.
Week 48: Project: presentation and review
Theory
Explaining design decisions
Demonstrating and answering questions
Reflecting and planning next learning
Lab
Final demo, code walkthrough and a viva where each learner modifies a function or query live.
Homework
Submit a tagged repository and a one-page reflection.
Deliverable
Tagged repository, README, schema diagram, test report and demo.
Weekly checkpoint
Final practical and viva.
You will be able to
Explain how a computer represents and processes data, and express solutions as algorithms before coding. Plan, build, test and present a database-backed application as a project.
Sample lessons
Week 18
Recursion and the call stack
A recursive function solves a problem by calling itself on a smaller version of the same problem. It needs a base case that stops the calls and a recursive case that moves toward that base case. Each call is stored on the call stack with its own variables, which is why too many calls cause a stack overflow. Drawing the calls on paper is the fastest way to understand and debug recursion.
f(0) returns 0
f(1) waits: 1 + f(0)
f(2) waits: 2 + f(1)
f(3) waits: 3 + f(2)
f(4) called first
Calls pile up until the base case, then answers return one by one.
Step by step
Write the problem as a smaller version of itself: factorial(n) = n * factorial(n-1).
Write the base case first: factorial(0) is 1.
Write the recursive case that calls the function with n - 1.
Trace factorial(4) by drawing each call and the value it waits for.
Run it, then try a negative number and observe the stack overflow error.
In real life
Your phone's file manager shows the total size of a folder by adding the sizes of its files and, for each sub-folder, repeating the same procedure inside it. That is recursion on a folder tree.
Worked example
Problem. What does f(4) return?
def f(n):
if n == 0:
return 0
return n + f(n - 1)
Solution. f(4) = 4 + f(3) = 4 + 3 + f(2) = 4 + 3 + 2 + f(1) = 4 + 3 + 2 + 1 + f(0) = 10. The base case returns 0, then the pending additions are completed.
Common mistakes
Forgetting the base case, which leads to infinite recursion and a RecursionError.
Calling the function with a value that does not get closer to the base case.
Try it yourself
Write a recursive function that sums the digits of a number and trace it for 4821.
Explain why recursive Fibonacci(40) is slow and how memoisation helps.
Week 32
SQL joins: combining tables correctly
Related data is stored in separate tables to avoid repetition, and a join combines it again for a report. An INNER JOIN keeps only rows that have a match on both sides, while a LEFT JOIN keeps every row from the left table and fills the missing right side with NULL. Most join mistakes come from a wrong join condition or from forgetting that one-to-many relationships multiply rows, so you should always check a result on small data by hand.
Student
Subject
Mark
Kept by
Anu
Maths
80
INNER and LEFT
Ravi
Maths
70
INNER and LEFT
Sita
NULL
NULL
LEFT only
Step by step
Identify the two tables and the matching columns, such as students.id and marks.student_id.
Write SELECT with the columns you need from both tables.
Add INNER JOIN ... ON students.id = marks.student_id and run it.
Change to LEFT JOIN and notice students with no marks now appear with NULL.
Count the rows you expect on paper and compare with the result.
In real life
A school office needs one report card showing student names with subject marks, while students who missed all exams still need to appear on the list so that follow-up can happen.
Worked example
Problem. students has 3 rows (Anu, Ravi, Sita). marks has 2 rows: (Anu, Maths, 80) and (Ravi, Maths, 70). How many rows do INNER JOIN and LEFT JOIN return?
Solution. INNER JOIN returns 2 rows (Anu and Ravi). LEFT JOIN returns 3 rows, because Sita is kept with NULL in the marks columns.
Common mistakes
Leaving out the ON condition, which produces every combination of rows.
Using INNER JOIN when unmatched rows must be shown, so missing students silently disappear.
Try it yourself
Write a query listing each course with the number of students enrolled, including courses with none.
Predict the row count when one student has three marks rows and you join with the students table.
Try the questions
The same skills are asked at three levels: School (Classes 6–12), College and Professional. Switch the level and the language (English or Tamil), and say how sure you are before you check: knowing what you are unsure about is part of learning.
Classes 6–12: everyday examples, no prior knowledge. Practice only. Nothing here is graded or saved.
Question 1 / 4 · Read a binary number
Computers store numbers using only 0 and 1. What is the binary number 101 in our usual decimal numbers?
Projects
Neighbourhood Library or Shop Management System
Build a database-backed Python application for a small library or shop in your locality. It must store data in a relational database, offer a console or Flask interface, include automated tests and show careful use of any AI assistance.
Tasks
Interview a real or imagined user and write at least eight user stories with acceptance criteria.
Design a normalised schema with at least four tables and an ER diagram.
Write a data-access layer with parameterised queries and a service layer with business rules.
Implement a console menu or Flask endpoints for add, search, update, delete and a report using a join and a GROUP BY.
Write at least 25 tests covering normal, boundary and invalid cases.
Maintain a Git history with feature branches and an AI review log.
Sample input
Issue book B105 to member M22 when M22 already holds the maximum of 3 books.
Expected output
The application refuses with the message 'Limit reached: return a book first', the database is unchanged and the matching test passes.
How it is assessed
Criterion
Weight
Requirements and design quality
15%
Schema and SQL
20%
Code structure, correctness and error handling
25%
Tests and debugging evidence
20%
Git, AI review log and documentation
10%
Demo and viva
10%
Stretch challenge: Add password-protected staff login with salted hashes and an index backed by EXPLAIN evidence.
Algorithm Toolkit and Benchmark Report
Build a small Python package of data structures and algorithms from your own implementations and produce a benchmark report that compares them and explains the results with Big-O reasoning.
Tasks
Implement a dynamic array, linked list, stack, queue, hash table and BST.
Implement linear and binary search plus insertion, merge and quick sort.
Write unit tests for each structure and algorithm including empty and single-element cases.
Benchmark operations for several input sizes and plot or tabulate the results.
Write a two-page report explaining which results match the expected complexity and which do not.
Sample input
Sort lists of 1000, 10000 and 100000 random integers with each sort and record the time.
Expected output
A table showing insertion sort growing roughly quadratically while merge and quick sort grow close to n log n.
How it is assessed
Criterion
Weight
Correct implementations
35%
Unit tests
25%
Benchmark method and data
20%
Report and complexity reasoning
20%
Stretch challenge: Add a heap and a graph class with BFS and compare priority queue implementations.
How you are assessed
Each week ends with a 20 to 30 minute checkpoint of 5 to 6 questions: code reading, output prediction, debugging, a short design or SQL item, plus a lab submission checked against written test cases. Every fourth week includes a timed problem-solving practical.
Practical work. Four practicals (weeks 12, 28, 35 and 48): solve unseen programming problems, implement or fix a data structure, write SQL against a given schema, debug a seeded failure and defend choices in a short viva.
What trainers look for
Weight
Correctness against test cases
30%
Code quality and design
20%
Algorithmic and data structure reasoning
20%
Database and SQL skills
15%
Testing, debugging and Git practice
10%
Explanation and responsible AI use
5%
Where this can lead
Prepares you for junior programmer, trainee software developer and database support roles.
Prepares you for degree-level study in computer science or further specialised courses in web, data or cloud development.
Gives a base for building small database-backed tools for local businesses.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
