Reads

• 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.

It’s been a while since the last time I published a post with the list of articles I’ve read. This one contains the highlights from the past few months.

• We Were Wrong About GPUs — Fly.io invested in GPU Machines to support AI/ML tasks for developers, but they learned that most developers prefer using APIs for AI instead of managing GPUs themselves. Despite the challenges and costs of deploying GPUs, they found that the demand for these machines was lower than expected. The company is now scaling back its GPU ambitions while focusing on improving its core product offerings.

• Why I think AI take-off is relatively slow — Tyler Cowen argues that the rapid adoption of AI is slowed down by inefficiencies in less productive sectors and human bottlenecks, like regulatory delays. He believes that while AI can improve productivity, it will not transform the economy as quickly as expected due to the challenges of integrating it with human work. Overall, Cowen suggests that AI might boost economic growth modestly, but noticeable changes will take time.

• Is it okay? — The author discusses the impact of language models on creativity and copyright, arguing that their reliance on the entire internet raises ethical concerns. He believes that if these models only replicate existing content without contributing to human creativity, it is problematic. However, if they lead to significant advancements in science and technology, their use may be justified.

• The Inner Ring — The concept of the “Inner Ring” describes the human desire to belong to exclusive groups, which can lead to negative actions and feelings of exclusion. This longing for acceptance can overshadow genuine connections and fulfillment in life. True happiness comes from focusing on meaningful work and relationships rather than chasing after superficial insider status.

• Introducing S2 — Introduction to S2, a new approach to streaming data storage.

• Ghostty: Reflecting on Reaching 1.0 — This is a personal reflection on the project.

• How to Pick Your Life Partner - Part 2 — To endure 20,000 days, 100 vacations, and 100,000 leisure hours with another human being and do so happily, there are three key ingredients necessary.

• How to Pick Your Life Partner - Part 1 — Given that the choice of life partner is by far the most important thing in life to get right, how is it possible that so many smart people get it so wrong?

• The secret inside One Million Checkboxes — Teens wrote secret binary messages in One Million Checkboxes. The author found them.

• Group Chat: The Best Way to Totally Stress Out Your Team — The perils of the modern communications conveyor belt that never ends, divides your attention, fractures your time, and chains you to FOMO.

• Reflections on Founder Mode — Reflections on a recent Paul Graham piece – and on the culture at Oxide

• Founder Mode — At a YC event last week Brian Chesky gave a talk that everyone who was there will remember. Most founders I talked to afterward said it was the best they’d ever heard. Ron Conway, for the first time in his life, forgot to take notes. I’m not going to try to reproduce it here. Instead I want to talk about a question it raised.

• Obsession — Reflections on the concept of healthy obsession and how it can be a source of motivation and success.

• Leaving Neovim for Zed — A journey through text editors and how I landed on Zed after years of Neovim

• Why I Built Litestream — Despite an exponential increase in computing power, our applications require more machines than ever because of architectural decisions made 25 years ago. You can eliminate much of your complexity and cost by using SQLite & Litestream for your production applications.

• It’s in the stories — The author reflects on the importance of storytelling in leadership, sharing anecdotes about influential figures.

• Two Threads, One Core: How Simultaneous Multithreading Works Under the Hood — Simultaneous multithreading (SMT) is a feature that lets a processor handle instructions from two different threads at the same time. But have you ever wondered how this actually works?

• Why German Strings are Everywhere — German Strings are a custom string format developed for optimized data processing, adopted by many databases, focusing on performance and memory efficiency.

• The Kafka Metric You’re Not Using: Stop Counting Messages, Start Measuring Time — Traditional offset-based monitoring can be misleading due to varying message sizes and consumption rates. To address this, you can introduce a time-based metric for a more accurate assessment of consumer group lag.

• So You Want To Build A Browser Engine — This article goes deep into all the complicated things involved in making a browser engine. It’s amazing how browsers keep getting better and adding more features while maintaining all the required complexity.

• Databricks, Snowflake and the future — This piece tells you about the recent meetings of Snowflake and Databricks. It focuses on how they are putting money into Apache Iceberg.

• The time I spent three months investigating a 7-year old bug and fixed it in 1 line of code — This is an interesting story about someone spending three months trying to fix a really old bug. And how they only needed one line of code to solve it. Nice read about debugging software and hardware.

• Local, first, forever — An insightful article on the local-first philosophy and the implementation of services without reliance on a centralized server. Includes an introduction to CRDT and a sample implementation.

• What Goes Around Comes Around… And Around… — A retrospective review of the evolution of relational database management systems over the past two decades. It gives a good overview of how things are and how have evolved.

• A write-ahead log is not a universal part of durability — Explores the concept of durability in databases, challenging the notion of a write-ahead log as a universal component.

• Unix’s fsync(), write ahead logs, and durability versus integrity — Expands on Phil Eaton’s post about database durability, incorporating the crucial aspect of integrity into the discussion.

• The Right Kind of Stubborn — Paul Graham talks about two types of stubbornesss: persistence and obstinacy. He explains that it’s good to keep going when you need to, but it’s bad when you won’t change your mind.

• Zed Decoded: Rope & SumTree — The Zed team explained how they use B+Tree (or SumTree) to deal with file content in their text editor. I have never considered how text editors use different structures to represent and manipulate huge strings while maintaining good performance. Interesting read.

• Why does SQLite (in production) have such a bad rep? — A short post about the controversy around SQLite, a database often perceived as unsuitable for production. The most interesting thing is the discussions originated in lobste.rs and Reddit

• In Codd we Trust (or not) — A brief reflection on Codd’s original idea, which separates logical and physical schema, and the significant role query planners and optimizers play in modern database performance. While I understand the point of letting experienced users write their queries and execute them as they are, I can’t fully agree.

• Some opinionated thoughts on SQL databases — Another opinionated reflection on relational databases and SQL. I agree with some points. Still, SQL is here to stay. The point that resonated more is how inefficient it is to use SQL as an API in some workloads. I’ve seen query parsing take +50% of the processing time in low latency and high throughput environments. Of course, those numbers are for very specific use cases (e.g., point queries) where the data being read is small, taking just a few milliseconds. Still, the overhead is relevant, and there is little room for improvement when using plain SQL. On the other hand, it is good to use almost all relational databases using a single API language. If you are an experienced PostgreSQL user, you can query a MySQL database without investing hours learning how the new API works.

• Senior Engineer Fatigue — An article to justify why older people get slower at their jobs. Jokes aside, it’s a good read about why sometimes you need to slow down to get faster. And it applies not only to senior engineers!

• What Happens When You Put a Database in Your Browser? — The browser is the new OS. A DuckDB article about running their software in browsers using Wasm. The text provides a good example of pre-visualizing parquet file schema on the fly from the browser.