Laptop with layered screens of code, logic diagrams, and GitHub — franzdomingo.tech

Second Year as a Software Engineering Student: From Terminal to Tailwind

First year showed me how to write code.
Second year showed me why it matters — how code becomes systems, how data moves, how apps survive in the real world.

This year was where everything connected.

🧭 Curriculum That Hit Hard

Second year brought a wider view of software engineering:

Object-Oriented Programming (Java) helped me stop writing code and start designing it.
Discrete Structures trained my brain to think logically — not just to make it work, but make it right.
Operating Systems peeled the curtain off memory, scheduling, and what happens underneath an app.
Computer Architecture explained the hardware side of the code I write.
Information Management gave me SQL and the confidence to manage data instead of fearing databases.
Fundamentals of Analytics sparked my curiosity about data — which I’d revisit later in AI-heavy projects.

Also: Design Thinking taught me how to approach dev work as a problem-solver, not just a coder.

The goal wasn’t just passing — it was building something worth using.

💻 Tools & Tech I Started Using

Second year was when I began touching real-world tools:

Languages

JavaScript (ES6+): Finally understood event-driven programming
HTML + CSS: Moved past <center> tags and into layout systems
SQL: Created actual databases with relations and constraints

Frameworks & Libraries

React: My first component-based UI — confusing at first, addictive later
Tailwind CSS: Streamlined my frontend design, finally clean CSS
Next.js: My entry into SSR and static site generation

Tools & Platforms

Git & GitHub: Branching, pull requests, merge conflicts — real dev habits
Vercel: Where my portfolio first went live
MDX & Markdown: For structured blog writing and static content
JSON: For storing blog previews, dynamic content, and state

🚀 Projects I Built

My personal developer portfolio using Next.js + Tailwind
Simple blog engine powered by .mdx and JSON indexing
Local CMS simulation that fetched mock blog posts from filesystem APIs
CI/CD workflows via GitHub Actions for markdown deployment automation

I started small, but each project made me hungry for more control, more polish, and more depth.

📉 Challenges I Faced

I over-engineered early — adding TypeScript when I didn’t need to
React’s state and props confused me for weeks
I still didn’t fully grasp data structures under the hood — recursion haunted me
OS concepts like memory segmentation and paging felt abstract at the time

🧠 Lessons That Stuck

Frontend is its own discipline. Just knowing JavaScript isn’t enough — you have to care about user experience, too.
Git is not optional. It’s your timeline, safety net, and team bridge.
System-level knowledge pays off. You don’t need to build an OS, but knowing how one works gives you leverage when debugging anything.

🌐 Web Dev Became My Playground

By the end of the year, I was:

Designing and deploying UIs that worked across devices
Thinking in components and routes
Using GitHub for real collaboration, not just pushing code blindly
Starting to blog and document my journey with .mdx

It felt like I was no longer just coding for class — I was coding for myself.

“Second year gave me the tools. Third year tested if I knew how to use them.”