2025W49
- SQLite JSON Superpower: Virtual Columns + Indexing — This is one of those “why didn’t I know about this sooner?” moments. The idea is simple but powerful: dump your JSON into SQLite, create virtual columns that extract specific fields on the fly, then slap indexes on those virtual columns. Boom, you’ve got schemaless flexibility with relational performance. No backfilling, no migration headaches. You can literally add a new indexed column later without touching your data. The beauty is in how it solves the eternal “should I go schemaless or relational?” debate by just saying “both.”
- Recortes 2025 — Javi’s year-end reflections hit different. It’s refreshing to read someone being this honest about the mental toll of being CEO while also celebrating running a 10k at 43. The quote about not being able to compete with someone having fun keeps bouncing around in my head. There’s something profound about acknowledging that working hard without questioning what you should actually work on is just lazy thinking with extra steps. Also, keeping a diary for his daughter to understand his life context later? That’s the kind of long-term thinking I respect.
- Litestream VFS — This genuinely blew my mind. You can query SQLite databases sitting in S3 without downloading the whole thing. Just fetch the pages you need using S3 range requests and an LRU cache. Point-in-time recovery is just a SQL pragma away. The LTX format compacts page versions so you’re not storing redundant data. This solves so many “I just need to quickly check production” moments without spinning up a whole restore dance. The technical elegance here is top-notch.
- Craft software that makes people feel something — Raphael built Boo, a code editor, mostly for himself because he wanted something with soul. His point about repetition killing creativity resonates hard. When coding becomes mechanical, you lose the spark that makes people go “wow.” What I appreciate most is his willingness to build something not commercially viable just because it matters to him. In an era obsessed with PMF and growth metrics, building for joy feels almost radical. The comparison to Lego is spot on too - the best software feels like play.
- The Long Run — Miguel went from being a non-runner to completing a full marathon, running through 18 cities along the way. But this isn’t really about running. It’s about rewriting your internal script. Once you do something you thought was impossible, the ceiling lifts everywhere else. “Discipline compounds quietly, until suddenly you’re a different person” is the kind of truth you only understand after experiencing it. The best part? He doesn’t frame it as inspiration porn, just an honest account of how doing hard things changes what you think you’re capable of.
- Transparent Leadership Beats Servant Leadership — The distinction here is subtle but important. Servant leadership can accidentally create dependency where you’re constantly clearing paths for people. Transparent leadership is about teaching people to clear their own paths. You coach, you connect folks directly, you explain the “why” so they can make good calls independently. The goal is to become redundant by leveling everyone up. I’ve seen too many managers become bottlenecks disguised as helpful. This framework gives language to why that feels wrong and what to do instead.
- Why I Ignore The Spotlight as a Staff Engineer — Not all impact comes from high-visibility projects. Some of the most valuable work is being the long-term steward of critical systems nobody thinks about until they break. The trade-off is less external glory, but you get to build deep expertise and solve genuinely complex problems. The “shadow hierarchy” concept is fascinating - getting recognition through customer team endorsements rather than flashy launches. “The most ambitious thing you can do is stay put, dig in, and build something that lasts” flips the typical career advice on its head, and honestly? It’s probably right more often than we admit.
- Delta Lake Atomicity — A solid technical breakdown of how Delta Lake gets atomicity without traditional WAL. Instead of page-level recovery, it uses copy-on-write: write new Parquet files, then atomically write a JSON log entry pointing to them. If something crashes mid-flight, the uncommitted files just sit there invisible since they’re not in the log. It’s clever because object storage guarantees single file write atomicity, so you piggyback on that rather than building your own transaction log infrastructure. Clean, simple, and it works.