▴

Reads

#
  • 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.
#
  • No, AI is not Making Engineers 10x as Productive — AI does not make engineers ten times more productive because much of coding involves thinking, reading, and preventing unnecessary work. AI helps with small tasks and gives short bursts of speed, but it often encourages haste and over-building. True productivity comes from experience, good habits, and teamwork, not just using AI tools.
  • All the cool kids are doing it — The author is unsure about using large language models (LLMs) for coding because they find them unreliable and costly. They feel LLMs don’t yet help much with complex or performance-focused programming tasks. However, they see some promise in LLMs for other uses like research help and code explanation.
  • The Sunday Morning Post: Why Exercise Is a Miracle Drug — Exercise improves many parts of the body and is better than any medicine. Studies show exercise helps cancer patients live longer and stay healthier.
  • Full-breadth Developers — Full-breadth developers who combine technical skills with product sense are thriving with new AI tools. Many companies struggle because they separate product and engineering roles too strictly.
  • Ramblings — Remote teams of 2-10 people can use personal “ramblings” channels to share thoughts without cluttering group chats. These channels help team members stay connected with short, informal updates and encourage creativity. Ramblings reduce interruptions and support social bonding, especially when no meetings are scheduled.
  • AI is eating the Internet — The Internet used to offer free content funded by ads from companies like Google and Facebook. Now, AI tools reuse content without sending visitors to original sites, hurting creators and changing how the web works. In the future, AI will control access to information, balancing ads, content makers, and users in new ways.
  • Slow — Some problems take humans many years or even centuries to solve, like building cathedrals or proving complex math theorems. Long-term projects need strong institutions and steady effort to keep going over time. Examples include scientific studies, historic buildings, and technology that may last for thousands of years.
  • Fast — Fast software changes how we work and feel by making tasks quicker and easier. It requires focus and simplicity, often cutting unnecessary features to deliver speed. As current LLM technology improves, speed will unlock new possibilities and transform our lives like never before.
  • Why I’m stepping down as Head of Engineering — The author is stepping down as Head of Engineering to focus on hands-on technical work they love. As the company grew, their role became more about management, which made them feel less connected and impactful. Stepping aside allows new leaders to scale the organization while the author contributes where they add the most value.
  • My favorite use-case for AI is writing logs — JetBrains created a small, fast AI model that helps developers write better log lines automatically in PyCharm. This model runs locally on your computer, making coding easier and debugging faster. It shows that focused, lightweight AI can be very useful alongside big, general models.
  • ​How magnesium affects your sleep and anxiety — Magnesium may help reduce mild anxiety but does not strongly improve sleep for most people. Many people do not get enough magnesium from their diet, and supplements can be useful, especially magnesium glycinate.
  • Coding with LLMs in the summer of 2025 (an update) — Large language models like Gemini 2.5 PRO help programmers by finding bugs, speeding up testing, and supporting design decisions when humans guide them carefully. To get the best results, programmers must provide clear context and stay actively involved in the coding process instead of relying on AI alone. Right now, working together with AI is more effective than letting AI work solo, but this may change in the future.
  • Why me? — When bad things happen, we often ask “Why me?” and feel singled out. But life brings both good and bad luck to everyone, and neither is guaranteed. Accepting this helps us feel less angry and more grateful for the good moments.
  • MCP: An (Accidentally) Universal Plugin System — I used to think MCP added nothing over APIs. But this post clicked: APIs exposes services, MCP wraps actions, there are mores actions than calling an HTTP service: CLI, scripts, anything runnable. It’s a universal interface for doing, not just calling. Surprisingly powerful.
  • Making Sense of a Noisy World — Trends come and go, but sharing thoughtful opinions helps us learn and grow. Honest views can challenge ideas and create meaningful conversations. Careful thinking makes our opinions valuable and helps us understand the noisy world.
#
  • Thrive in obscurity — Creative success often starts in obscurity, with many creators spending years sharing their work with few or no viewers. To stay motivated, focus on creating what you love instead of chasing popularity, as this will lead to better work and attract like-minded fans. Treat your early content as an investment for future audiences, knowing they may return to appreciate your journey later on.
  • If you are useful, it doesn’t mean you are valued — In your career, being useful means you get tasks done well, while being valued means you contribute to important decisions and have growth opportunities. Useful people may receive rewards, but they often feel stagnant and lack strategic involvement. To succeed, it’s crucial to recognize whether you are truly valued or just seen as a reliable worker.
  • My AI Skeptic Friends Are All Nuts — The author argues that LLMs can significantly assist software developers by handling tedious coding tasks, allowing them to focus on more important work. Despite skepticism about LLM-generated code quality, the author believes that these tools can enhance productivity and reduce the need for repetitive tasks. Ultimately, while LLMs may not replace all developers, they can streamline the coding process and improve efficiency.
  • A Smart Bear » You’re a little company, now act like one — Small companies often fear that being perceived as small will hurt sales, but this can actually alienate their best customers. Instead of adopting generic corporate language, they should present themselves authentically to attract Early Adopters who appreciate personal connections and are willing to provide feedback. By being honest and relatable, small companies can foster relationships that help them grow and improve their products.
  • Letter to Arc members 2025 — The Browser Company is shifting focus from Arc to a new product called Dia, aiming to create a better browser experience. They recognized that Arc had limitations and wanted to build something that integrates AI more effectively.
  • If nothing is curated, how do we find things? — The rise of social media has made it harder to find curated content, leading to information overload and mental exhaustion. Critics and curators are needed now more than ever to help sift through the vast amount of content available.
  • Thoughts on thinking — The author feels stuck and believes that their creative efforts are overshadowed by AI’s ability to produce better ideas quickly. They reflect on how using AI has diminished their own thinking and intellectual growth, despite having access to more information than ever.
#
  • What If We Made Advertising Illegal? — The idea of making advertising illegal may sound silly but couldn’t agree more. I’ve been unlucky enough to work for the industry and can’t imagine a better society with the current practices.
  • Notes on kindness — “So eventually, if you care, you leave”
  • The case against conversational interfaces — Conversational interfaces, like voice assistants and chatbots, often promise a new way to interact with technology but fail to replace traditional computing methods. Instead of replacing existing tools, AI should enhance them, allowing for seamless interactions that feel effortless.
  • How to Write Blog Posts that Developers Read — Didn’t like the main topic of the article since it’s focused on ways to attract readers to your blog posts. When I write I do it for myself and I expect other personal blogs to do the same. Anyway, some of the advice is good even if you’re not focused on attracting readers.
  • Tracing the thoughts of a large language model — Anthropic team explains how are they working on understanding Claude’s internal “reasoning” processes. This research branch could help improve AI reliability and transparency.
  • Cyanview: Coordinating Super Bowl’s visual fidelity with Elixir — Leaving aside the Elixir infomercial. Interesting read about how a team of nine have managed to build such an incredible product. It might sound simple but as someone who has been working with remote cameras in the past, ai can tell it’s more complex than it sounds.
  • Things that go wrong with disk IO — Short article emphasizing the critical importance of maintaining data integrity when developing applications that rely on disk interactions
#
  • Less ceremony, more shipping — Tinybird introduces their new deployment tool, which simplifies data schema changes for teams. This tool automates the entire deployment process, ensuring no downtime and minimizing errors. By applying software engineering best practices to data workflows, it allows developers to focus more on building rather than troubleshooting.
  • PlanetScale redesign — Twitter thread about how PlanetScale redesigned their website and the impact it had. And a follow-up showing how the original redesign was done using Google Docs!
  • IO devices and latency — Nice post about IO devices latency and how they have evolved. It comes with excellent illustrations. The author also wrote a Twitter thread with the making off and the impact this kind of educational technical posts have on their marketing.
  • The good times in tech are over — I don’t personally like the post but it’s true. Good times are over for software engineers that were not aware of what their job was.
  • Before AI Grew Up — A guy explaining to his kids in the future how AI feels nowadays. Nicely written and hopefully accurate.
Page 1 Next →