I’m Solin—someone who believes the best way to truly understand something is to build it yourself, break it apart, and then build it again. Whether it’s an interpreter for a programming language, a hardware authentication device, or reverse-engineering firmware from a portable media player, I learn by doing.

This blog is where I’ll document that journey: the projects I build, the systems I explore, the mistakes I make, and the insights I gain along the way. If you’re someone who finds joy in understanding how things really work—beneath the abstractions, past the documentation, down to the metal—you’re in the right place.

The Philosophy: Building and Breaking

There’s a fundamental disconnect in how we’re taught to learn technology versus how we actually internalize it.

Traditional education says: read the theory, understand the concepts, then apply them. But I’ve found the reverse works better for me: build something that barely works, break it trying to make it better, and discover the theory along the way.

When I wanted to understand how programming languages work, I didn’t just read about parsers and interpreters—I built SolarBASIC, a BASIC interpreter from scratch. Every error message taught me about syntax. Every variable scope bug forced me to understand stack frames. Every optimization attempt revealed why compilers make the choices they do.

When I wanted to learn about embedded systems, I didn’t start with an Arduino tutorial. I reverse-engineered the firmware of an older media player using Ghidra, traced execution flows, and documented the architecture. You learn far more from disassembling something real than from following a perfectly curated example.

This approach isn’t efficient. It’s messy. You make mistakes that could have been avoided by reading documentation first. But those mistakes become your anchors—you remember lessons learned through struggle far better than facts passively absorbed.

What I’m Exploring

My interests lie at the intersection of hardware, systems programming, and artificial intelligence—specifically in the layers that most people abstract away.

Hardware & Embedded Systems

I’m fascinated by the physical layer of computing. From overclocking memory to squeeze out performance gains, to modifying gaming consoles and understanding their boot sequence, to building ESP32-based FIDO2 hardware authentication keys—there’s something deeply satisfying about working at the hardware level.

These aren’t just experiments; they’re explorations of how silicon, firmware, and software collaborate to create the illusion of seamless computing.

Systems Programming & Reverse Engineering

There’s a special kind of satisfaction that comes from reading assembly code, tracing system calls, and understanding exactly what happens when you flip a bit. I use tools like Ghidra to reverse-engineer firmware, not because I need to crack anything, but because it’s the best way to understand how embedded systems truly operate.

I’ve worked on everything from analyzing automotive autonomous driving systems to building encryption tools with AES-256 and Argon2. The goal isn’t just to make things work—it’s to understand why they work.

AI & Machine Learning

Unlike my hardware work where I enjoy going low-level, my approach to AI is pragmatic: building things that work and learning the theory as it becomes necessary. I’ve built real-time sign language recognition systems using MediaPipe and Leap Motion, contributed Korean language support to the wire-pod project (an open-source server for Anki Vector robots), and experimented with multi-model AI architectures.

The intersection of AI and embedded systems is particularly interesting to me—how do you run inference on resource-constrained devices? How do you optimize models for real-time performance? These aren’t just theoretical questions; they’re challenges I encounter in actual projects.

Security & Cryptography

From building Eclipse, a custom encryption program with virtual drive mounting, to implementing TOTP and FIDO2 authentication on ESP32 hardware, I’m drawn to security that I can understand at a fundamental level. It’s one thing to use a library; it’s another to implement the primitives yourself and understand exactly where the security properties come from.

What to Expect on This Blog

This blog will be a mix of project documentation, technical explorations, and reflections on learning.

Project Deep Dives: I’ll write about projects as I build them—not just the polished final result, but the messy middle. The bugs that took hours to debug. The architectural decisions that seemed obvious in hindsight but were unclear at the time. The dead ends and pivots.

Technical Explorations: When I encounter an interesting system or technology, I’ll dig into it and share what I find. Expect teardowns, analyses, and experiments that might not have a practical purpose beyond understanding.

Learning Notes: As I explore new areas—whether it’s a programming language, a hardware platform, or a theoretical concept—I’ll document the process. These won’t be polished tutorials; they’ll be real-time learning logs.

Thoughts & Reflections: Occasionally, I’ll step back and think about the process itself. What does it mean to learn deeply? How do we balance breadth and depth? What’s the role of failure in understanding?

Why This Matters

In an era where most development happens at increasingly higher levels of abstraction—where you can build a web app without understanding HTTP, or train a neural network without understanding backpropagation—there’s value in going the other direction.

Understanding the foundations doesn’t just make you a better engineer; it changes how you think about problems. When you’ve built a memory allocator, you think differently about performance. When you’ve reverse-engineered firmware, you approach debugging differently. When you’ve implemented encryption primitives, you evaluate security differently.

This blog is for people who share that curiosity. Who aren’t satisfied with knowing that something works, but need to know how and why.

Let’s Explore Together

One unique feature of this blog: every post has an AI assistant trained specifically on its content. Have a question about something I wrote? Want me to elaborate on a concept? Need a different explanation? Just ask. Think of it as having a conversation with the ideas in each post.

I’m still learning, still exploring, and still making mistakes. But that’s the point. This blog isn’t about presenting polished expertise—it’s about sharing the journey of understanding.

Welcome aboard.

Let’s explore the layers most people abstract away.