Blog
Documenting my journey through software engineering, embedded systems, and continuous learning. Each post explores practical challenges, design decisions, and lessons learned from building real systems.
Synapse: A Knowledge Graph for the Whole Monorepo
- Obsidian graphs only show Markdown. My knowledge also lives in C++, Rust, Go, and Bazel files.
- {"Building a polyglot reference extractor in Go"=>"one interface, six file types, zero external dependencies."}
- Three bugs that only appeared when crawling real data, and what they reveal about parsing assumptions.
- Why tags need to be nodes, not metadata, to get clustering that looks like Obsidian.
Read article →
Code is a Thinking Tool, Not an Artifact
- PARA and CODE clicked immediately — but only handle half the picture for a developer
- Why a Markdown note about an iterator design decision could not survive six months
- Code comments as Zettel: the note and the proof in the same commit
- Neovim writes, Obsidian shows, both work on the same files
Read article →
Wrapping a C library in RAII: unique_ptr with custom deleters and why Subsystem can't be moveable
- SDL2 is a C library. In C++, using it without a wrapper leads to three recurring bug classes.
- How std::unique_ptr with a custom deleter solves all three, without overhead and without boilerplate.
- Why factory functions instead of direct construction, and why Subsystem is not moveable.
Read article →
When 'Close to the Hardware' Isn't Close Enough
- From a Rust HAL blinky to bare-metal C: writing the same LED without any framework
- Vector table, linker script, startup code: tracing the boot sequence by hand
- Why bit 0 of the reset vector matters and how `.data` makes it from flash into RAM
- The goal: see what 'close to the hardware' actually means once MCAL and AUTOSAR are out of the way
Read article →
From Read-It-Later to Zettelkasten: Automating My Reading Workflow with n8n
- From neglected Raspberry Pi to a VPS setup that automates my reading workflow
- n8n connects Readeck, Claude, and Forgejo into a Zettelkasten pipeline
- Only highlights and notes go to the LLM, not the full article
- A PR-based review flow: the generated note lands in my inbox every morning
Read article →
Beyond Busyness: Why Output Is Not Value
- Newport, Kim, Farley, Martin: different worlds, same conclusion
- Greenfield or legacy: flow, trust, and small batches create value in both
- Regulatory constraints are rarely the real barrier, organizational belief is
- The job is not to produce code, it is to reduce complexity and create value
Read article →
When 'It Works' Is No Longer Enough
- From working prototype to production-ready: refactoring a physics simulation
- Factory, Strategy, Builder patterns eliminate code duplication and silent failures
- std::variant over inheritance: compile-time safety instead of runtime crashes
- The goal: move error detection from runtime checks to compiler guarantees
Read article →
From Defensive Programming to Type-Driven Design
- Defensive programming: catching errors at runtime through discipline and process
- Type-driven design: making invalid states impossible at compile time
- In C: half the code is error handling. In Rust: types prevent the errors
- The goal: move safety from manual checks to compiler guarantees
Read article →
Why I Do Not Like Linux Distro Hopping but Keep Doing It Anyway
- From Xubuntu to EndeavourOS to Mint to Arch, each switch sharpens understanding
- Simplicity is not a limitation but a deliberate choice
- Easier to build aligned systems from scratch than reshape misaligned ones
- The real goal: a system that enables focus instead of distracting from it
Read article →
Dr. Strangelove or How I Learned to Stop Worrying and Love Testing
- TDD is not a testing technique but a design method
- Test behavior, not implementation: the key insight that changed everything
- Verification vs. Validation: building the product right vs. building the right product
- Tests as a safety net: refactor with confidence, not fear
Read article →
From C to Rust - Evolving Programming Languages in Automotive Development
- C remains essential for hardware-near programming where every cycle matters
- C++ bridges low-level efficiency with modern software design patterns
- Rust offers memory and thread safety at compile time without runtime cost
- The future is hybrid: choosing the right language for the right layer
Read article →