eric dransfeldt

We process 14M messages/sec with sub-100μs latency. When rewriting our feed handler, Rust seemed like the obvious choice - we use it successfully across our stack... We chose C++ instead. I'm re-sharing our blog post on the technical choices behind that decision.

283

14 Comments

2025 hot take: I'm not sold on Test-Driven Development (TDD). After years in the industry, I’ve seen few teams fully commit to TDD and even fewer stick with it long-term. I’ve been on teams that have completed projects with TDD and ones that started with TDD but dropped it when it became more of a blocker than a boost. The biggest untold truth? TDD success stories often come down to survivorship bias. The teams that succeed with TDD would likely succeed without it, too. Why? Because the teams that have the most success with TDD are usually made of senior engineers who’ve built similar systems countless times before. Here’s how I see it: If you’ve studied for a test so well that you could write both the questions and the answers before you take it, you’re going to ace that test no matter what. In essence, TDD works best when you already know the answers. But really then TDD isn't the main or even a contributing reason for a project's success. What do you think? Is TDD overrated or am I missing something?

366

321 Comments

Screw vibecoding. You know what LLM coding agents are *really* useful for? Reverse-engineering legacy code! "Hey can you research and explain how the flux capacitor settings are loaded, specifically where are the margadon-level overrides applied exactly?" It's a lifesaver.

390

101 Comments

LLMs are powerful, but they are stateless machines. They don’t carry memory or intent, they work with the context you provide at that moment. The same model can feel brilliant in one scenario and completely off in another. The difference is not the model, but the context and use case we design around it. The technology is already here. The real opportunity lies in how we shape it to solve real problems.

103

11 Comments

Seeing quite a few discussions lately about Kafka/Iceberg integrations being "zero-copy" or not. I think this is largely missing the point. First, where I agree is that this integration should be "zero-effort" for users. Materializing a Kafka topic into an Iceberg table shouldn't require more than a click of a button. Queries should provide a uniform way for accessing the data in both a topic and the corresponding table. This is the stream/table duality, and it should Just Work™. Now, whether this requires to store the bytes of data once in a Kafka topic, and a second time elsewhere for table access, shouldn't really matter from a user perspective. I'd argue storing the data twice is actually a benefit, and in fact it's a pattern well established: it resembles the design of WAL and table files known from databases for decades. I don't think anyone ever complained about this structure in their RDBMS? Which makes sense, it's an implementation detail, opaque to users. But as it turns out, having log and table data separately is even more advantageous for the deconstructed database that is Kafka and Iceberg: you can have multiple readers of the same log (Kafka topic), materializing views in multiple destinations and systems optimized for specific use cases. Maybe multiple Iceberg tables with different projections (think PII), maybe an Iceberg table and a full-text index in Elasticsearch, maybe an... you catch my drift. Furthermore, the log is replayable, so you can recreate views if needed, or you can implement new use cases you didn't originally have in mind. All in all, I think "zero copy" is mostly a red herring. Sure, it can be an optimization for certain scenarios, but mostly it's a distraction from the immense value you get from combining Kafka and Iceberg when done the right (seamless) way.

127

26 Comments

In distributed systems, reliability isn’t just about retries and durability, it’s about knowing who owns recovery. My latest post, based on the Coordinated Progress model I posted previously, explores how reliable triggers create responsibility boundaries and how those boundaries shape resilience, observability, and complexity. https://lnkd.in/diCmywnS

117

8 Comments

LLM and developer productivity It's common to hear the question: how much developer productivity do LLMs really offer? Most people expect an answer focused on automating a certain percentage of coding work. My take is different. In any reasonably large organization, it's rarely the actual coding that eats up the most time. Think about complex projects—there's always that pressure to deliver now and then refine things over time. Often, what separates a high-performing team from an average one is simply how many attempts they need to get it right. This is where LLMs can be game-changing. Even with less experienced folks, you can use LLMs to research and map out a system design in a couple of days that's far more likely to hit the mark sooner, cutting down those iterative cycles to reach maturity. This alone can make teams massively more productive, even before a single line of code is generated by the LLM. Any code it does help write is just the cherry on top. For me, the biggest win with LLMs isn't just a percentage gain here or there; it's about a significant leap in the quality of what's delivered and making the entire team more agile. That's not just an increase; it's a multiplier effect.

171

5 Comments

Here is Gemini CLI’s weekly update for v0.2.1 - 🎉 Gemini CLI Zed Integration 🎉: Zed Industries has integrated their first third-party agent…Gemini CLI! Watch Gemini CLI weave through your codebase and integrate Zed’s context to super power your workflow. - Launch a Gemini CLI Thread in Zed’s Agent Panel to get a fully integrated experience (follow the agent, review code like a pull request, etc.) - Announcement: https://lnkd.in/gVvBg4Pn - Settings Dialog: Access and modify Gemini CLI settings through a new UI panel accessed via /settings (ali-aljufairi) - Message Queuing: Type and queue messages while the AI is responding, which are then sent automatically (akhil29) - Code Stats: View the lines of code added and removed during a session using /stats or via OTEL. (bulkypanda and agarwalravikant) - Custom Slash Commands: - Shell executions can utilize user provided arguments (abhipatel12) - YOLO mode is now respected (abhipatel12) - MCP: - Improved OAuth support. Connect to services like GitHub and other third-party tools using OAuth with a client ID and secret (emeryray2002) - Root change notification support. Automatically notifies MCP servers when the root directory(s) are updated. (jakemac53) - Better Multi-line Input Support: Run /terminal-setup to configure your terminal to allow shift + enter support in the prompt box (deepankarsharma) - Headless Allow All Edits: Allow Gemini CLI to edit files headlessly with --approval-mode auto_edit (bulkypanda) - VSCode Multi-Workspace Picker: When in a multi-workspace environment you will now be asked to pick one (skeshive) - Double Escape to Clear: Quickly clear the prompt box buffer by pressing the Escape key twice. (lifefloating) - Ctrl + C to Cancel: Cancel in-progress responses with a single Ctrl+C (JayadityaGit) https://lnkd.in/guhg-D2w #GeminiCLI #OSS #Gemini #AI

282

6 Comments

This is quality work. So glad to see compiler team digging in and getting a richer picture than “build fast” or “build slow”. I definitely think we need to focus on the perception of rust as having slow builds (and the reality it’s based on), but to do that, we need to be clear on what workflows and use patterns we are targeting. The fix for fast CI turnaround is not the same as the fix for fast iteration on a broken test, and iterating on a test is not the same as debugging a type error. https://lnkd.in/eSKkNgXb

98

There’s plenty to be excited about with AI (and plenty to be skeptical about too 😄). One area I’ve stayed consistently excited about is: AI for code migrations. Cracking that nut could unlock a huge amount of capacity for every tech org. Think about all the toil: keeping libraries current and dealing with breaking changes, upgrading language versions, migrating between frameworks… Google shared their experiences earlier this year, Amazon is promoting Q, and a number of startups are exploring the space. At Spotify, we’ve been running our own experiments inspired by Goose (thanks Block!) – and it feels like we’re right on the cusp of this having very real impact. We’ll be sharing more soon! In the meantime, I’d love to hear: What’s been your experience here? #ai #aimigrations

139

21 Comments

There's an unfortunate trend in technical publishing where "Modern" in the title usually means "will be outdated by Thursday." Jesús Espino's (whom I'm glad to have met in Florence this year) new book on REST API development in Go earns its prefix through an almost rebellious act: it champions Go's standard library over the framework-of-the-month club we've all joined at various points in our careers. The thesis here is simple and mildly subversive. You can build production-grade APIs without immediately importing half of GitHub. Want middleware? Write it yourself first with http.Handler. Need an ORM? Understand database/sql before you reach for GORM. This "pedagogical restraint" is rare enough to be noteworthy and valuable enough to be worth your time. What actually impressed me was the book's structural honesty. It doesn't pretend you architect everything perfectly from day one. This mirrors how real systems actually evolve, which suggests Espino has actually maintained services that kept him awake at night 🤣 . The book builds a shopping list API incrementally across chapters, adding authentication, security, caching, and deployment strategies as you go. The real value proposition isn't that this book will make you an expert. Nothing does that except building and maintaining real systems. But it will give you the mental models to become one. In an industry addicted to complexity and novelty, a book that demonstrates how to build things simply and well with concrete examples is almost subversive (really). It won't revolutionize how APIs are built, but it will make you better at building them. Sometimes that's exactly what you need.

64

5 Comments

I'm becoming more convinced that AI is going to eliminate a lot of software dev jobs, but maybe not for the reasons originally speculated on. AI is unlikely to every write "good" code, or solve hard problems, etc. The evolution of token generation text from generic training data doesn't converge to that end state. However, most org don't need "good" code either; they need rapid barely functional prototypes which they can sell. Most executives have no idea how robust code is, and most problems can be patched around long enough to get to some sort of exit (for the executives or the company). Previously these companies needed jr/mid devs to code solutions, and indirectly trained up and/or discovered more senior devs in the process; now, that process will be able to be mostly automated with AI. As a result, that pipeline will go away (we are already seeing this, with recent grads). By ~10 years from now, maybe 50% of the current software dev jobs will be gone, I think. By ~20 years, we'll likely see a marked decline in software quality, as very few people/orgs will try to (or be capable of) producing quality software. We'll standardize LCD garbage, and companies will try to excuse it as "progress" and "just as good as anything else".

102

72 Comments

I've been experimenting with Roo lately, and as I suspected, it seems to send the entire task history back and forth, leading to high input token usage. At the same time, I'm working on a more advanced version of Zrb's `LLMTask`, and I believe I can optimize it to reduce token costs. ### Common strategies for minimizing input tokens: - **Partial chat history**: Only include a portion of the conversation. This is the simplest approach, but it's less effective for long interactions. It's also tricky with models like Claude that expect the user's message to be the first one. - **Vector database retrieval**: Store past messages in a vector DB and retrieve relevant ones as needed. - **Chat summarization**: Summarize the history and send that instead of the full conversation. While the third approach is promising, doing it too frequently might introduce other issues. ### My adjusted strategy: - Only summarize the chat history when it exceeds a certain threshold (e.g., more than 5 messages). - Extract key details from the conversation—like user preferences, name, etc.—to retain important context. This should help reduce token usage without losing essential information.

23

3 Comments