2025W38

A few interesting articles I read over the past few days

• Surviving Long-Running Projects — A nice reality check on how grueling big projects can be. The author basically says: expect them to drag on, plan for “boring” maintenance, and set up routines to keep your motivation and mental health intact. It’s more about staying sane than about technical tricks.
• How we built it: Real-time analytics for Stripe Billing — This is a cool peek under the hood. Stripe walks through how they built real-time analytics on top of billing, mixing Kafka, Flink, and their own in-house magic. It’s a story about scaling data pipelines to billions of events and still keeping dashboards snappy.
• 9 Things Every Fresh Graduate Should Know About Software Performance — Basically “performance isn’t magic.” It covers the usual suspects (memory allocation, cache, I/O, concurrency) but framed as a gentle guide for juniors. Solid reminders even for experienced devs.
• A brief history of threads and threading — A fun historical tour of how we got to modern threading. From early OS days to today’s multicores, it’s an eye-opener on how messy and evolutionary concurrency really is.
• Hired Through GitHub: Part 1 — The author tells how showing work on GitHub led directly to job offers. It’s a feel-good story about the value of public contributions and writing about your code.
• In response to a developer asking about systems — This is like a mini-manifesto on what “systems” really means. The takeaway is: stop chasing trendy tools and learn fundamentals — OS, networks, distributed systems. That’s how you actually “get” systems.
• From 19k to 4.2M events/sec: story of a SQLite query optimisation — Absolute banger. The author squeezes insane performance out of SQLite with indexing, batching, and clever SQL tweaks. Great reminder that small changes in schema/queries can be game-changing.
• UTF-8 is a Brilliant Design — A love letter to UTF-8. The author explains why it’s elegant, backwards-compatible, and just plain clever. Makes you appreciate how much thought went into something we all take for granted.
• Being good isn’t enough — A short but punchy post: skill alone won’t get you ahead. Communication, visibility, and timing matter too. Basically: don’t hide behind code.
• Introducing Direct Compress: Up to 40x Faster, Leaner Data Ingestion for Developers (Tech Preview) — Marketing-y but interesting. A new ingestion tech promising 40x faster loads. The takeaway: data infra vendors are pushing more on-the-fly compression to cut storage and speed up analytics.
• When more threads make things worse — A cautionary tale of over-threading. Past a point, adding threads doesn’t help — it can create livelocks, context switching overhead, and general sadness. A good read if you’ve ever said “let’s just throw more threads at it.”
• You can try to like stuff — An odd but uplifting essay about cultivating taste. The author argues that liking things is a skill you can practice, not just something that happens. Kind of refreshing.
• Reflections on Tinybird — A personal reflection from someone using Tinybird. They talk about what impressed them, what didn’t, and lessons learned from building real-time APIs. Interesting outsider’s perspective.
• Do the simplest thing that could possibly work — Classic XP wisdom retold. The post champions simplicity over cleverness. Don’t over-engineer; just do the simple thing first and iterate.
• Developer’s block — Like writer’s block, but for coders. Talks about burnout, procrastination, and ways to get unstuck. Feels relatable if you’ve ever stared at your editor unable to start.
• The First Time I Was Almost Fired From Apple — Great storytime. An engineer recounts a near-disastrous mistake at Apple and what it taught them about responsibility and learning under pressure.
• Linear sent me down a local-first rabbit hole — A cool piece about discovering local-first architectures (like CRDTs) after using Linear. Shows how design decisions in apps can spark curiosity about deeper tech.
• Local-first search — Builds on that same local-first theme. Explains how search can work offline-first with sync happening in the background. Makes you rethink how “search” has to be architected.