Second Semester Begins — Database Systems, Dr. Bilal, and a Portfolio That Went Live
Second semester brought a new course, a new challenge, and a mid-term project that asked me to put my entire journey online for the world to see.
There is a version of a new semester that exists only in the imagination — clean notebooks, no pending assignments, every subject still full of possibility and none of them yet difficult. That version lasts approximately two weeks. Then the reality of the workload arrives, the subjects reveal their actual depth, and you are back to the familiar business of keeping up. Second semester at UET Faisalabad followed this pattern faithfully. But what made it different from first semester was not the difficulty — it was the context. I was no longer a student encountering university for the first time. I had a semester behind me, a 2.91 GPA that carried a specific lesson about preparation and consistency, and a clearer sense of what I was actually here to do.
The course that defined the opening of second semester was Database Systems, taught by Dr. Bilal Ahmad. If Programming Fundamentals had been about learning to think computationally — to break problems into steps, to instruct a machine precisely, to build things out of logic and syntax — then Database Systems was about learning to think structurally. How do you organize information so that it can be stored efficiently, retrieved quickly, and maintained over time without becoming inconsistent or corrupt? These are questions that sit at the foundation of nearly every software system that exists in the world today, from the simplest mobile application to the largest enterprise platforms, and understanding them properly requires a different kind of mental discipline than writing code.
Dr. Bilal Ahmad introduced us to SQL through MySQL, and the experience of writing queries for the first time had a quality I had not expected: it felt like asking questions in a language the computer could actually understand. A well-written SQL query is a precise question directed at a structured dataset — select this information, from this table, where these conditions hold, ordered in this particular way. The precision required is absolute. A missing comma, a misspelled column name, a logical condition that almost but not quite captures what you intended — any of these produces either an error or, worse, a result that looks correct but is not. Learning to write queries carefully, to verify their outputs against what you expected rather than assuming they are right, and to think clearly about what you are actually asking before you start typing — these were habits that Database Systems enforced rigorously from the very first week.
What surprised me about SQL was how quickly it started to feel intuitive. Programming, when I first encountered it, had a quality of fighting the language — of knowing what I wanted to express but not knowing how to express it in terms the interpreter would accept. SQL felt different. The structure of a query maps relatively naturally onto the structure of a question: I want these columns, from this table, filtered by this condition. Once the basic syntax was in place, the mental effort shifted from remembering how to write a query to thinking clearly about what information I actually needed. That shift — from syntax to semantics — was one of the markers of genuine progress, and it happened faster in Database Systems than it had in Programming Fundamentals.
Beyond SQL itself, the course covered the principles of database design. How do you move from a real-world problem — a university that needs to track students, courses, enrollments, grades, and faculty — to a structured relational database that captures all the relevant information without redundancy and without ambiguity? The answer involves identifying entities: the distinct things in the problem domain that need to be represented. It involves understanding the relationships between those entities: which ones are connected, in what direction, and with what constraints. It involves thinking about cardinality — whether a relationship is one-to-one, one-to-many, or many-to-many — and translating those relationships into tables and foreign keys that enforce them at the database level.
Dr. Bilal Ahmad approached database design the way he had approached programming: with an emphasis on understanding the reasoning behind each decision rather than simply learning the mechanical steps. Why do we normalize a database? Not because normalization is a rule to follow, but because redundancy creates problems — when the same information is stored in multiple places, any update to that information has to be made in every place, and when it is not, the database becomes inconsistent. Understanding the why behind the what is what separates a student who can complete assignments from an engineer who can design systems, and that distinction was present in every lecture.
The mid-term project for second semester was unlike anything I had done before. Rather than building a technical system or analyzing a dataset, I was asked to create a portfolio — a public, online record of my journey through these semesters, written in my own voice and accessible to anyone. The assignment was to document what I had learned, how I had learned it, and what the experience had actually felt like from the inside. The idea came from Dr. Bilal Ahmad directly, and it was framed not as a documentation exercise but as an act of professional identity — the deliberate creation of a digital presence that would outlast the semester and represent me as an engineer in progress.
Building the portfolio required its own set of technical decisions. I used Jekyll with the Chirpy theme, hosted on GitHub Pages. Jekyll is a static site generator — it takes markdown files and converts them into a complete website without requiring a backend server, a database, or ongoing maintenance beyond writing new posts. The setup process involved working with configuration files, understanding how Jekyll’s directory structure maps to the final site, and learning enough about how GitHub Actions works to understand why the site was or was not building correctly when I pushed changes. None of this was in the curriculum. All of it was necessary, and working through it independently was itself a form of the learning the portfolio was meant to document.
Writing the posts was the harder part. Technical setup has clear right answers — either the site builds or it does not, either the image loads or it returns a 404. Writing does not have that clarity. To describe an experience accurately enough that someone who was not there can understand it, you have to understand it yourself first. Sitting down to write about learning Python forced me to think carefully about what that experience had actually been — not what it was supposed to have been, not the sanitized version, but the actual sequence of confusion and partial understanding and occasional clarity that learning something genuinely new involves. The portfolio became a practice in honest reflection, and honest reflection turned out to be more difficult and more valuable than I had anticipated going in.
Dr. Bilal Ahmad’s suggestion to build this kind of public record reflects something he has emphasized consistently: that the work of becoming an engineer is not just technical but communicative. Knowing something and being able to explain it are different skills, and both matter. A portfolio does not replace technical ability — it sits alongside it, making visible the thinking that produced the work. For a student still in the early semesters of a Computer Engineering degree, building that habit of documentation early means that by the time the work becomes more sophisticated, the practice of writing about it is already established.
Second semester had begun. The database was being designed, the queries were being written, and for the first time, the learning itself was going on the record.
Dr. Bilal Ahmad’s work in AI and machine learning research is documented on his Google Scholar profile — worth exploring for anyone interested in where this field is heading.