First Year as a Software Engineering Student: From Curiosity to Compiler Errors
If you asked me on Day 1 what a compiler was, I’d say it was a printer.
By the end of first year, I knew it was a judgmental machine that screamed at my mistakes every time I hit Run.
This was the year of foundations — messy code, missed semicolons, and small victories that felt like breakthroughs.
🧱 The Foundation That Built Me
Most of my growth in first year came from confusion.
🖥️ Key Courses
- Introduction to Computing taught me what computing even is — from hardware basics to how the internet actually works.
- Computer Programming 1 & 2 (C and Java) were the core — long nights of writing programs line by line and wondering why my output was blank.
- Human-Computer Interaction opened my eyes to users. It wasn’t just about code that worked — it was about how people use it.
- Data Structures & Algorithms (introduced at the tail end) broke me and rebuilt how I thought about problem-solving.
We also had Readings in Philippine History, Science, Technology & Society, and Gender & Society — and I didn’t understand it then, but they reminded me that developers build for people, not just machines.
🧪 Lab Time Was Survival Mode
Labs were graded live. Every bracket, variable, and typo could drop your grade.
- Lab exams were terrifying: write a working Java program under time pressure with zero Stack Overflow.
- We used basic editors — sometimes even Notepad++ — and compiled in terminal.
- Debugging meant reading every line out loud and praying you didn’t forget a semicolon.
The moment I passed a lab exam without errors was when I first felt like a real programmer.
💻 What I Built
They weren’t impressive — but they mattered:
- A terminal-based ATM simulator with login and withdrawal options.
- An inventory management system that barely handled file I/O.
- A simple calculator that somehow gave wrong answers for
7 * 9.
None of it survives today — I lost the projects when I reformatted my MacBook.
Lesson learned: Always use Git. Always back up your code.
⚠️ What Broke Me
- Understanding memory allocation in C — felt like fighting with a ghost.
- Forgetting Java’s class rules mid-lab exam.
- PE classes scheduled right after a 3-hour programming lab. (My brain ran marathons before my body did.)
- Spending 6 hours fixing a bug, only to realize the error was a capital letter in a variable name.
🧠 What I Took With Me
-
Logic matters more than language. If you understand the logic, switching from Java to Python is just translation.
-
Programming is pattern recognition. The more you break things and fix them, the faster you recognize how to solve new ones.
-
Every error is feedback. And the compiler is your most honest teacher.
-
Start small, but think big. I didn’t know I’d end up building LLM-connected mobile apps. But that seed started here — with terminal projects and burning curiosity.
🛠️ My Toolchain (Back Then)
- Languages: C, Java, a bit of Python
- Tools: Visual Studio Code, BlueJ, Windows Terminal
- Methods: Trial-and-error, manual testing, reading compiler errors like riddles
- Storage: Local folders… no Git, no backup (mistake)
🧩 Academic Meets Practical
Even non-CS subjects taught me something:
- PE classes built discipline — and showed me when to stop and recover.
- History and Communication reminded me that developers exist in teams, societies, and timelines.
- Personal and Professional Effectiveness made me reflect on time management — something every dev needs more than frameworks.
“First year didn’t teach me to build apps — it taught me to think like someone who eventually would.”