Bar chart comparing median nanoseconds per operation for make, sync.Pool, bytes.Buffer, and a pooled buffer

Go Performance: sync.Pool vs Per-Request Allocation, Benchmarked

Go 1.27 benchmarks of sync.Pool versus per-request allocation: a 2 KiB scratch buffer drops from 240 ns to 18 ns per op, plus the cases where pooling hurts.

Oct 22, 2026 performance

Grouped bar chart of handler latency percentiles (p50 through p99.9) for fresh allocation versus sync.Pool at two request rates, showing the two distributions overlapping

sync.Pool vs fresh allocation, round two: p99 under a live HTTP handler

The microbenchmark said sync.Pool was 13x faster per op. We pointed a load generator at a real net/http handler to see if p99 actually moves.

Oct 22, 2026 performance

Diagram of a Go agent runner passing one request context with a 45 second deadline into a streaming LLM call, an HTTP tool call and a queue publish, with panels showing a cancelled token stream at 40 kilobytes per second, a green badge for zero goroutine leaks and a red badge for 47 times less wasted token spend after the context fixes

Go Context Cancellation for LLM Streaming and Agent Calls: One Pattern That Cut Waste 47x

Go context.Context deadlines and cancellation for LLM token streaming and agent tool calls: four leak patterns, fixes, and measured savings.

Oct 22, 2026 languages, go

Bar chart comparing p99 latency of RwLock, single Mutex, and sharded Mutex HashMap caches in a Rust LLM gateway from 1 to 16 threads, showing sharding 14x faster at 12 threads

Rust Lock Contention Under Load: When RwLock Loses to a Sharded Cache

One RwLock behind our Rust LLM gateway pushed p99 to 89 ms at 12 threads; 32 sharded Mutexes cut the tail 14x. Benchmarks, charts, and the fix.

Oct 21, 2026 performance, rust

Bar chart comparing glibc malloc and mimalloc in a Rust hot parsing loop: 34% lower runtime, 41% lower RSS

Rust Allocators in a Hot Parsing Loop: mimalloc vs glibc malloc, Measured

One line - swapping Rust's global allocator to mimalloc - cut a hot parse loop's runtime 34% and RSS 41% on glibc. Measured with hyperfine, with chart.

Oct 21, 2026 performance, rust

Line chart from our gate logs: one growing agent thread drops from 86% to 41% pass@1 as context grows from 8K to 192K tokens, while a fresh session with the same total tokens holds near 80%.

Context-window rot: agent pass@1 falls 45 points before the window is even half full

Gate logs from 96 seeded coding tasks: one growing agent thread loses 45 pass@1 points by 192K tokens while fresh sessions hold 80%.

Oct 21, 2026 ai

Two bar charts comparing five client strategies against one 60 requests-per-minute Azure OpenAI deployment: completed requests out of 90 are 53, 19, 21, 52 and 90, and 429 responses received are 676, 755, 737, 513 and 0; only the client-side token bucket plus semaphore of four completes every request

Enterprise AI: Stop the 429 Storm - Client-Side Rate Limiting for Azure OpenAI, Measured Five Ways

90 requests vs a 60 RPM Azure OpenAI deployment, five client strategies: retries lose 40-80% of calls, a client-side token bucket finishes 90/90 with zero 429s.

Oct 21, 2026 ai, enterprise-ai

Grouped bar chart comparing Rust Result enums and Go multi-return errors on the same MCP tool-call dispatch layer: 100 percent vs 62.5 percent of injected failure bugs caught, 7 vs 4 bug classes prevented at compile time, 215 vs 160 lines of error-handling code, and 41 vs 55 prompts until the agent got failure paths right

Rust vs Go Error Handling in AI Agent Tool Calls: Which Failure Taxonomy Caught More Bugs

Rust Result enums vs Go multi-return errors in the same MCP tool-call dispatch layer: four failure classes, 24 runs, and which bugs each caught.

Oct 21, 2026 languages, rust, go

Terminal-style header graphic showing Go pprof alloc_space results: baseline burn rate 10.0x with 245.93 GB allocated versus fixed burn rate 0.0x with 96.54 GB allocated, under a 600 ms per-token-stream SLO with a 0.1% error budget.

Go pprof vs SLO Burn Rate: Finding the p99 Leak Before the Pager Fires

A 10x SLO burn rate in our Go LLM gateway traced to one regex-and-concat SSE parser. pprof alloc_space showed 245 GB of garbage in 25 s.

Oct 21, 2026 languages, go

Bar chart of latency before and after profiling GETapi/orders/{id}/summary on ASP.NET Core 9 at 500 requests per second: p50 84 to 19 ms, p95 162 to 31 ms, p99 214 to 38 ms, p99.9 402 to 71 ms

Profiling One Slow ASP.NET Core Endpoint with dotnet-counters and dotnet-trace

Profiling a 214 ms p99 ASP.NET Core endpoint with dotnet-counters and dotnet-trace: 2.9 MB allocated per request, one GroupBy to blame, p99 down to 38 ms.

Oct 20, 2026 performance, dotnet