Vlad Orlenko𝅳

OLTP databases and analytical systems both try to minimize I/O, but they do it through entirely different abstractions. B-trees and secondary indexes serve transactional workloads where selectivity and random access dominate. Open table formats like Iceberg and Delta rely on partitioning, sorting, and metadata-driven pruning to achieve the same goal at analytical scale. In this post I explore what “index” really means in this world, and why we can’t just bolt secondary indexes onto analytical systems. https://lnkd.in/d6wrgD9t

208

18 Comments

Accidentally discovered a new way to work with GitHub Copilot today: write new tests based off test coverage reports. Copilot (or I) run this command to generate a report of all the uncovered lines in the current diff: pytest --cov --cov-report=xml && \ diff-cover coverage.xml --html-report coverage_report.html && \ open coverage_report.html Then Copilot reviews the report, summarizes the uncovered situations, and proposes new test cases to add, or if the code is truly unreachable, suggests deleting it. Just another reason why you should add diff-cover (or similar tool) to your projects!

115

4 Comments

Here is Gemini CLI’s September 22nd weekly update for v0.7.0 - 🎉 Build Your Own Gemini CLI IDE Plugin: We've published a spec for creating IDE plugins to enable rich context-aware experiences and native in-editor diffing in your IDE of choice. (skeshive) - 🎉 Gemini CLI Extensions - Flutter: An early version to help you create, build, test, and run Flutter apps with Gemini CLI - Nano banana: Integrate nano banana into Gemini CLI - Telemetry Config via Environment: Manage telemetry settings using environment variables for a more flexible setup. (jerop) - ​​Experimental Todo’s: Track and display progress on complex tasks with a managed checklist. Off by default but can be enabled via "useWriteTodos": true (anj-s) - Share Chat Support for Tools: Using /chat share will now also render function calls and responses in the final markdown file. (rramkumar1) - Citations: Now enabled for all users (scidomino) - Custom Commands in Headless Mode: Run custom slash commands directly from the command line in non-interactive mode: gemini "/joke Chuck Norris" (capachino) https://lnkd.in/g3D4Y7-S 🧵 #GeminiCLI #Gemini #AI #OSS #Flutter #IDE

95

2 Comments

Hand-tuning a system to achieve great performance is an anti-pattern. There should be no need to do so. Software exists to solve a problem for you; why should you have to tell it what's the best way for doing so? Instead, systems should be designed to automatically find the right configuration for things like number of elements in a batch, queue and buffer sizes, cache retention, etc. While it's an interesting question whether AI can help with that task, in most cases this isn't needed; classic control theory can do the job, fast, precisely, and cost-effective. As a maintainer of a library, and even more so of managed services, you should push back hard on every new knob, every additional setting, every new parameter for letting the user configure implementation details like that. It substantially reduces usability. It means pushing work to the user instead of having the software do it.

77

29 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

OpenSearch contributor Michael Froh has a wealth of information about Apache Lucene -- Elasticsearch, OpenSearch, Solr -- internals. And this article on Finate State Transducers (FSTs) is great. FSTs are one of the core data structures in Lucene's inverted index, and they've been massively fine tuned for performance over the years. https://lnkd.in/ehUcuNVj

54

3 Comments

GPT-5 for Developers: It is fantastic for coding - state-of-the-art in various benchmarks and real-world coding tasks, and excels in answering questions about complex codebases. It is significantly better at agentic tasks - for tool calling and instruction following. Developers can control the structure of the model outputs even more by providing their own context-free grammar. Available via our API in 3 different sizes: gpt-5, gpt-5-mini and gpt-5-nano - that give options for performance, cost & latency tradeoffs. It's only been a couple of hours and demand has been pretty crazy! https://lnkd.in/ghAfHAqQ

1,159

45 Comments

💡 Pro Tip: Did you know GitHub Copilot can help with code reviews before you even commit your changes? Just stage your changes, click the review icon, and let Copilot do the rest. In a few seconds, it will analyze your code and suggest improvements — all within your editor. You can review, accept, or discard the suggestions as needed. It’s a huge time-saver and a great way to catch issues early in the development cycle! Have you tried this feature yet? #GitHubCopilot #CodeReview #DevTips #AIForDevelopers

374

13 Comments

To my swarm friends, this is interesting ... Crystal is a desktop app that allows users to run, manage, inspect, and test multiple Claude Code instances at the same time using Git worktrees. Users can pick up conversations anytime and test changes immediately without leaving Crystal. It includes built-in rebase and squash features, and users can view diffs and monitor modifications. Crystal enables testing, comparing methods, and managing AI-assisted development workflows in a single desktop application. It's like remote control for Claude Code ... Very cool. Crystal GitHub Repo: https://lnkd.in/eZtdR3-d

51

8 Comments

A Case Study in Rewriting a Critical Service in Rust A great problem to have, when your payment service becomes a bottleneck 😀 Very interesting writeup about replacing computationally expensive service written in Go with a Rust based one. The performance analysis mentions things like reducing memcpy, using copy-on-write data structures, that might have been possible in Go, but may have been easier with Rust in this concrete case, with far better outcomes.

56

3 Comments

Today I published "Crafting Your Software", a deep-dive into Canonical's "craft" tools, and how they can be used to build a huge variety of software projects into lots of different kinds of artifact, with a common grammar and CLI experience. The crafts are fast becoming a critical part of the #Ubuntu developer experience, whether you're contributing OCI images, Snap packages or Debs. Take a look on the Ubuntu discourse! https://lnkd.in/ewkwAEWh

50

1 Comment

Can every Kafka topic become an Iceberg table: instantly, zero‑copy, and 100 % open‑source? At Aiven we think so. A native “Iceberg Topic” could erase connector tax, end lock‑in, and make *topic = table* the new default. We’ve just blogged about the roadblocks we see today and the path forward to build together. 🚀 #ApacheKafka #ApacheIceberg #OpenSource #DataStreaming https://lnkd.in/eptGbBTf

165

12 Comments

While the core architecture remains, today’s top LLMs (like GPT, Claude, Gemini, and Qwen) have introduced subtle but important changes — and interestingly, many of these choices are converging: ✅ Multi-query attention ✅ SwiGLU activations ✅ Revised LayerNorm placement ✅ New positional encoding strategies ...and more. To stay on top of these trends, I highly recommend two resources that have helped me deeply understand both what's changing and why it matters: 📘 This blog post by Sebastian Raschka is a fantastic summary: The Big LLM Architecture Comparison https://lnkd.in/dJBZFWsG 🎓 Stanford’s recent LLM lectures, which provide great context behind these architectural shifts and trade-offs. These changes aren’t just tweaks — they reflect deeper insights into scaling, efficiency, and alignment.

34

Installment number four of our Element of Programming Style review is "avoid temporary variables." In Kernighan and Plauger's example, they used bit of code that thought it was faster to say X2 * X2 than to say X2 ^ 2. (X2 ** 2 in FORTRANESE). The example included a lot of variables that were used just to hold temporary results as they were making calculations. There are lots of X and F followed by single digit numbers. It's easy to get lost in all the F1, X2 and F2s. Much easier to calculate: FX = (X1 - X2**2)**2 + (1.0 - X2)**2 or in C: fx = pow(x1 - pow(x2, 2.0), 2.0) + pow(1.0 - x2, 2.0); A modern example could be in converting a string of characters into an integer: for (p = str; isdigit(*p); p++) { val *= 10; val += *p - '0'; } This is in no way a suggestion, but it useful for some to see how a string is converted into an integer. I usually use the function strtol to do this. But it could be written for (p = str; isdigit(*p); p++) val = val * 10 + *p - '0'; In a way this example is too trivial to make the point very strongly. I wanted it to be easy to read, however, so you can better see how to fix the issue. If an expression will work, and it is clearer, then use that. In a way "val" is being treated as a temporary. Some people use stream of consciousness programming, and this might create temporary variables as they work out what needs to be done. That's fine for the first draft, but they need to go back and rewrite the code to be clearer. Just like writing prose. Don't rewrite your code? I hope never to see it. In older C code I sometimes see code that uses a shift instead of a divide. sector = offset >> 9; /* convert from byte offset into sector number */ What we really wanted to do was divide offset by 512, the usual sector size. A shift was faster in even the early processors than a divide. But today I know of no compiler that doesn't look for powers of two integer divide or multiply and convert to shifts. Ken Thompson's compiler I use daily certainly does it, and I remember it in Niklaus Wirth's Oberon compiler. I think it was in the Portable C Compiler from the 1980s, and even in Dennis' C compiler from 1973. sector = offset / 512; is just as fast. Note that sector size can now be 4096 on some newer drives. I think most drives are 4K sectors but some present a 512 addressing. If you like to transfer less than eight 512 sectors or at addresses that are multiples of 4K, you will get a speed penalty. These are sayings from Brian Kernighan and P J Plauger's book "Elements of Programming Style." Even though the code is FORTRAN and PL/I the book if very worth reading today. (The use of caps in the names of early programming languages goes back to when the machine rooms were very loud and you had to yell to be heard. And maybe because the devices only had upper case and some punctuation.) The book applies just as much to Python and JavaScript.

62

78 Comments