Christian Simon

Sonnet 4.5 is special in many ways, but one I worked directly, is very exciting. Sonnet 4.5 is the first model that is aware of how much usable context it has left (test it - you can just ask it on https://claude.ai). Why is this a big deal? When models run in an agentic loop they need to decide when to stop and provide an answer. If they run out of tokens without providing an answer thats very bad. So most models have been trained to avoid that at any cost. But without knowing how many tokens are left models will cut their efforts short just to be on the safe side - we call that "agentic laziness". With Context Awareness feature models like Sonnet 4.5 always know how many tokens they have left and can use it to the fullest. You can also use this feature in a creative way: ask the model to spend no more than X thousand tokens or ask it to compact it's context (if such tool is available) before they run out of context. Read more at: https://lnkd.in/eMT3pQAh

276

3 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

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

209

18 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

📝 Blogged: "Let's Take a Look at... Lower Java Tail Latencies With ZGC" #Java 25, released earlier this week, is the first Java release with long-term support (LTS) which ships with Generational ZGC. I took this garbage collector for a spin, exploring how it lives up to its promise of sub-millisecond GC pause times. 👉 https://lnkd.in/dYW_9KfU

78

5 Comments

Terraform plans are noisy. We made them visual. When a terraform plan has dozens (or hundreds) of changes, it's hard to quickly understand what's going on. We fixed that in the Terrateam UI. Inspired by feedback from Derek Morgan, Terrateam now breaks down plan outputs by resource, showing what will be created, updated, or destroyed, with visual diffs for each field. #terraform

51

2 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

We just opened up Depot Registry to accept any container image via standard docker push - not just images built on Depot 🚀 This eliminates one of the most frustrating tradeoffs in container infrastructure: choosing between "the registry that works fast" and "the registry that has your existing images." Now you can docker push any image directly to Depot Registry. Your existing images, third-party images, images built elsewhere - doesn't matter. Standard Docker workflow, but now your images can live right next to where your builds are already happening. No more thinking about pull limits or egress fees. You get high-performance global distribution without having to build on Depot if you don't want to. The workflow is straightforward: - Create a Depot project - docker tag your-image https://lnkd.in/dBEcfAeW - docker push https://lnkd.in/dBEcfAeW - Get global CDN-backed pulls everywhere You can also depot pull by tag now, not just build ID. Whether you built with Depot or pushed from elsewhere, the pull experience is consistent. Container registries shouldn't be the reason your team dreads deployments. Yet somehow we've all accepted that slow pulls and arbitrary limits are "industry standard." Your container registry should be invisible infrastructure that just works fast, not a bottleneck you have to architect around. Full quickstart guide: https://lnkd.in/dw6EYGgZ What's the most frustrating infrastructure tradeoff you've had to make recently?

41

2 Comments

𝟰 𝘄𝗮𝘆𝘀 𝘁𝗼 𝗺𝗮𝗸𝗲 𝘆𝗼𝘂𝗿 𝗖𝗜/𝗖𝗗 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘄𝗼𝗿𝗸 CI/CD is not just about automation. It’s about shipping with confidence, catching issues early and moving fast without chaos. Here’s how teams can get it right: 🔵 1. 𝗧𝗲𝘀𝘁 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗯𝘆 𝗱𝗲𝗳𝗮𝘂𝗹𝘁 Unit, integration and security tests should run automatically. If something fails, the pipeline blocks it. 🟣 2. 𝗞𝗲𝗲𝗽 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 𝗳𝗮𝘀𝘁 Slow pipelines get ignored. Speed matters if you want quick feedback and real adoption. 🟠 3. 𝗦𝗵𝗶𝗳𝘁 𝘀𝗲𝗰𝘂𝗿𝗶𝘁𝘆 𝗹𝗲𝗳𝘁 Scan early, manage secrets properly and bake in permission checks from the start. 🟢 4. 𝗠𝗮𝗸𝗲 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁𝘀 𝗽𝗿𝗲𝗱𝗶𝗰𝘁𝗮𝗯𝗹𝗲 The goal is safe, repeatable releases that don’t need heroics or manual fixes. Gif Credit: Chandresh Desai #cicd #devops #automation

61

1 Comment

How does GitHub approach measuring developer productivity, and the impact of AI in their own engineering organisation? With DX. With 150M+ developers using their platform and thousands of engineers building GitHub itself, developer productivity is central to their ability to innovate, attract talent, and deliver value to customers. We're so proud to partner with GitHub as they continue to define the future of software development. Data from DX now informs decisions and investments at every level of the org--from senior leadership to team managers--across AI tools, modern services, and monoliths.

77

5 Comments