Hello there!

An engineering student interested in:

• Game development
• Distributed systems
• Systems design
• Embedded programming

I like exploring different areas of software not because I'm trying to collect technologies, but because each domain teaches a different way of thinking.

Why I explore different domains

Building a 2D game in Unity forces you to think about state machines, timing, and responsiveness. Working on backend services teaches you about architecture, scalability, and reliability. Embedded projects remind you that resources are limited and every design decision matters.

After experimenting with all of these, I've started to see them less as separate fields and more like different sides of the same dice. Each project improves the way I think about software as a whole.

Also, it keeps things fun and interesting. I get bored easily.

Beyond code

Outside of coding, I spend a lot of time reading novels, folding origami, listening to music, or playing table tennis.

I'm also an avid gamer, especially games that punish you for mistakes and force you to improve, like Sekiro or other Souls-like titles. There's something satisfying about slowly mastering something difficult.

I like to think that my love for challenging games is just another way of saying I enjoy learning and improving. But maybe it just means I like getting frustrated and then feeling good about myself when I finally figure something out.

How I learn

I talk a lot. Mostly because I like explaining things.

One trick I use to deal with my not-so-great memory is relating concepts to other things I already understand. If two ideas connect somehow, they're much easier to remember.

So if someday I can't remember the exact command to get the description of a particular input in a Kubernetes deployment... please don't hate on me. I'll probably remember the concept, the architecture behind it, and five different ways it connects to something else.

Right now

I'm mostly focused on learning by building: experimenting with new systems, breaking things, fixing them again, and slowly getting better at designing software.