The shelf
I kept every lab folder from every semester on GitHub. Some as public repos, some private because a course was still running and the department was strict about it. When I sort them by date and open the README on each one, a pattern shows up. About three of the ten repos in this batch turned into something. The rest are still what they were on the last day of the semester. Lab submissions, zipped, forgotten.
The ones in this batch: streamlit-dbms and Academic-Project-DBMS-Hotel-Delivery-System (both DBMS, June and July 2022), Academic-Design-and-Analysis-of-Algorithms-DAA-lab-practice-files (September 2022), Academic-Data-Mining-Lab-Exercies-Files (October 2022), Opencv-study (October 2022), web-lab (December 2022, private), se (September 2022, private), Java-mini-project (July 2022, private), Academic-Project-Phase-II-Batch-10 (April 2024, private), and Android-Development-Labs (October 2024).
I am going to write about the ones that survived past the last submission date first, then the ones that did not, and I am going to be honest about why.
DBMS: the class that produced a real thing
The DBMS class in Semester 4 was taught by a faculty member who did not accept a screenshot of a working query as proof. You had to run it in front of her, and if you froze she asked you the same question a different way. That kind of pressure is why I remember INSERT INTO customer (C_id, f_name, l_name, c_location, pwd) VALUES ... by muscle memory now.
The mini-project for that class became Academic-Project-DBMS-Hotel-Delivery-System. A Streamlit app on top of a MySQL database, with a MongoDB side-collection for food images because the requirement was that we had to use both a relational and a document store. Login, hotel list, food list per hotel, order flow, and an admin page for the delivery-person assignment. The delivery person was picked randomly from a small pool, which was a hack that got a laugh from the reviewer and a full mark anyway.
Before Hotel-Delivery-System there was streamlit-dbms, which was the same idea one month earlier and much rougher. Free MySQL hosting from sql6.freemysqlhosting.net, hardcoded credentials in the file (I have since rotated them, but the fact that they are in the git history is a lesson I have paid for a few times since), a MongoDB Atlas free tier for the images, and one giant main.py. When I read the code now the thing that jumps out is that both files have the same authenticate function, and the newer one is worse. It goes back to SELECT pwd FROM customer WHERE c_id = '...' string interpolation. My earlier version at least tried to read the user document from MongoDB first. Somewhere between the two commits I forgot what I had learned.
That is a small thing. But it is the kind of small thing that a lab class does not catch, because the lab class checks that the query runs, not that it is safe. The DBMS faculty caught it in the viva. She asked what happens if a user types ' OR '1'='1 into the username field, and I did not have an answer. She marked me down and told me to fix it. I never fixed it in the repo. I fixed it in the next thing I wrote, and in the thing after that, and I still think of her when I write a parameterised query today.
That is the DBMS class turning into a shipped habit. The code is bad. The habit is good.
The DAA lab that was actually a Python typing tutorial
The DAA lab in Semester 5 had a numbered file for every experiment: 1.py, 2.py, 3.1.py, 3.2.py, all the way to 6.10.py. I have thirty files in the repo. The first one is bubble sort. The last one is a letter-frequency counter with a dictionary keyed on (frequency, word-index) tuples. The middle is a smear of greedy, dynamic-programming, and string problems.
The class was fine. The lab was fine. What actually stuck was that this was the first time I was writing Python every week for six months. I was in the CSE-AI stream, which meant I was going to write a lot of Python for the rest of the degree, and this lab is where I stopped fighting the language and started reaching for a dict comprehension by default. There is a file called 3.1.py where I wrote:
dict_freq[letter] = (freq_old + 1, curr_ind)
and then, three files later, I wrote the same thing as a defaultdict(list) because I had figured out I did not need the index at all. Nobody taught me that. The lab just gave me the reps.
The Data Mining lab, which was one lecturer away from being useful
Data Mining in Semester 5 was on paper the class I should have gone hardest at. Decision trees, naive Bayes, k-means, neural nets. Every one of those is a thing I use now, three years later, with different tools.
But the lab was in Weka, and the assignments were graded on the screenshot of the Weka output. I have kmeans.java, naive.java, neural.java, and reptree.java in the repo, and I have naive.py and decisiontree.py, and I have four PDFs of the printouts. The Python files were me sneaking sklearn in for my own sanity, because Weka's GUI froze on the college machines. naive.py is under thirty lines. It reads drug200.csv from Kaggle, label-encodes the categorical columns, fits GaussianNB, prints accuracy. It works. It is also what every other CSE-AI student in the country wrote that year.
I never went back to this lab folder to build on it. That is on me, but it is also on the shape of the lab. Screenshot-grading meant the incentive was to run the tool. The Python files I wrote for myself are the closest thing to actual learning in the repo, and I wrote them despite the class, not because of it.
Opencv-study: an unforced experiment
Opencv-study is the one repo in this batch that had no rubric. It is eight Python files, all mouse-callback experiments in OpenCV, and I wrote them because a senior mentioned that OpenCV was easy to poke at and hard to build serious things with. He was right on both counts.
There is a file called rainbow paint.py that sets up a 500x500 white canvas, hooks a mouse-move callback, and paints a 10-pixel square at the cursor position with an (x mod 255, y mod 255, 0) colour. That is the whole thing. When you sweep the mouse across the canvas you get bands of colour, and if you draw slowly enough the bands turn into a gradient. I remember running it for the first time and just moving the mouse around for two minutes, because the shape of the feedback loop was new to me. Type code, get pixels, do it again.
That is the feeling I chase now. Opencv-study was the first repo where the point of writing the code was to make something appear on screen.
The ones that stayed on the shelf
The web-lab repo (December 2022) is HTML files for a web-tech class. I do not remember the assignments. I have not opened the repo since.
The Java-mini-project (July 2022) was a Semester 3 group project. I was the person who typed the SQL. The repo is private because two friends wrote most of it. The class was where I first saw JDBC and swing in the same file, and it soured me on Java for GUIs.
The Software Engineering (se) repo from September 2022 has one README and no code. I created it during a lecture and never pushed anything real. That is the honest state of that class for me: I passed it, I have nothing to show for it, and the artefact I made was a Word document that lives on OneDrive.
Academic-Project-Phase-II-Batch-10 (April 2024) is the final-year project, private because the paper was under submission when I zipped the folder. That one earned its own long write-up already: the ITS swarm work with Rakesh, Karan, Sukesh, and Aashif, published at ICCIES 2025. It is the counter-example to this whole post, because it is a coursework repo that turned into a real conference paper. But it turned into that because of the four of us pushing each other, not because of any lab structure.
Android-Development-Labs (October 2024) is the last one chronologically. Eight PDFs, no code. The lab was Kotlin and XML layouts, and the deliverable each week was a PDF of screenshots. I did the assignments. I also wrote BloomCycle, my Kotlin dictionary app, in the same window as this class, and that is where the actual Android learning happened. The lab was the excuse, not the source.
What I actually built on
If I lay these out and ask which ones I still reach for, the honest answer is three: the DBMS class taught me to be paranoid about SQL, the DAA lab gave me my Python reflexes, and Opencv-study taught me that pixels-per-line-of-code is a good ratio to optimise for. The rest are proof that I turned up.
That is a fair ratio. Three out of ten is more than I would have guessed before I opened the folders. The teachers who mattered were the ones who made me defend the code out loud, and the labs that mattered were the ones where the deliverable was a running thing, not a screenshot. I try to remember that when I mentor undergrads now. Screenshots grade what the tool did. Code grades what you did.