Reading up on performance

GitHub is rewriting its Git storage architecture, replacing the Spokes system with Azure Blob Storage to achieve a 35× write performance boost for agent-driven traffic.

Analysis of 111 airline websites shows 95% fail Google’s Core Web Vitals on mobile, with top‑rated carriers like Qatar Airways and Cathay Pacific among the slowest.

Chrome 155 adds JPEG XL decoding, delivering 30‑50% better compression than JPEG, HDR support and lossless transcoding via a memory‑safe Rust decoder.

Cloudflare releases the BEACON dataset, offering billions of anonymized real‑user performance measurements to reveal how web speed varies across browsers, devices, regions and site types.

By optimizing their largest Node.js service, the team reduced compute expenses by 38% through targeted performance improvements, better resource allocation, and refined workload scaling.

The article describes methods and tools used to improve the quality and stability of the Factorio game through modding, optimization, and community feedback.

The article proposes a unified frontend architecture based on client navigation, server content, and client affordances, showing how various frameworks fit this three‑layer model.

Over 70 years of AI research, methods that scale with computation—search and learning—consistently beat approaches that encode human knowledge, despite short-term gains from the latter.

S3's architecture is built for disk-era limits, but with cheap SSDs and fast networks, a new SSD-based disaggregated storage service could replace it — cloud providers lack incentive.

Lock coupling causes physical contention on root-node locks, limiting scalability despite no semantic contention among concurrent lookups, as shown by benchmark on a 16‑core 9950X3D with a 100,000‑node binary tree.

ClickHouse Managed Postgres enables strict memory overcommit so that out‑of‑memory conditions fail a single query instead of triggering an instance‑wide OOM restart, with no measurable throughput loss.

Using hardware synthesis and bitslicing, the author generates fast C/WebGPU poker hand evaluators for Hold'em and Omaha, achieving up to 100× speedup over table‑based methods.

This piece describes a technique or system change that freed an additional 100TB of RAM in data-center operations.

Running Qwen3-0.6B’s 28 decoder layers in Linux eBPF shows token inference possible but slow (~1.2 s), highlighting tradeoffs in fixed‑point math, memory, and INT4 quantization.

The author details porting a moto trials prototype from WebGL to a native Zig/WebGPU game, overcoming tooling and binding issues to achieve 120‑210 fps.

Inferact's TPU‑v7 megakernel for Kimi K3 achieves over 700 tokens per second with speculative decoding, nearly double the GB200 baseline at batch size 1.

BLAS defines standard low-level linear algebra routines used as the foundation for optimized numerical libraries like LAPACK and MATLAB.

DHH’s Rails World 2026 keynote reveals Hey’s backend rewritten in Rust by AI agents, cutting needs from 110 to 10 servers and hinting at Rails’ declining role.

The article shows how async generators combined with Promise.race let Express SSE handlers stream database query results as each finishes, improving perceived load time.

Claude and engineers made claude.ai 3x faster in two weeks by using Claude to build benchmarks, find bottlenecks, and ship 3,000 changes safely.

TypeSafe AI releases Jev, a System One model that provides structured, hallucination-free decisions at sub-500ms speeds, aiming to replace LLMs for automation workflows.

The maintainer of several widely-used C++ open-source libraries (ada, fastfloat, simdjson, simdutf) shares a summer of AI-optimization work on them.

The author spent the summer using AI techniques to optimize several widely used open-source libraries, including ada, fastfloat, simdjson, and simdutf.

A GitHub cleanup job saturated a database primary because its safeguard monitored only replica lag, not primary load, causing site-wide errors.

For local LLMs, memory bandwidth and size determine token speed and model capacity; Strix Halo offers more memory per dollar, while Apple Macs with higher bandwidth generate tokens faster.

Lovable's new Rust-based dev server OJ makes preview startups up to 4× faster and uses a fraction of Vite's memory, now open‑sourced on GitHub.

SpaceX streamlined the Raptor engine by eliminating external sensors, igniters, bolted flanges, and internalizing piping via 3D printing, raising thrust about 35% while reducing mass.

Homebrew 7.0.0 launches with faster installs, stronger sandboxing, a native macOS app, built‑in vulnerability checks, and drops macOS 10.15 support while moving Intel Macs to Tier 3.

By reusing TLS connections with Undici keep‑alive, the webhook sender eliminated most handshakes, cutting latency and saving over $2,000 monthly.

PlanetScale announces TIN, a Postgres full‑text search extension that outperforms existing indexes with up to 57× higher query throughput and lower latency.

Speculative decoding in vLLM enables vLLM to verify multiple draft tokens per target-model pass, boosting throughput on AMD GPUs depending on drafting method and acceptance rate.

Wrapture instruments Python code to measure self-time and aggregate statistics, identifying slow methods without modifying application code.

The author built buildprof to trace Bun's compile times, revealing that Full LTO linking and a monolithic Zig module caused slow builds, which improved with ThinLTO and crate splitting.

Pandas becomes inefficient beyond tens of gigabytes, but most analytics workloads stay under 100 GB and are better served by single‑machine tools like Polars or DuckDB.

A short, 20‑minute routine of specific exercises improves strength and mobility, making it easier for older adults to rise from the floor safely and independently.

The article shows how using Go's unsafe package to perform pointer arithmetic can eliminate bounds checks in hot paths, yielding over 2x speedup in benchmarks.

Andrew Hunter contrasts hyperscale performance tuning, where tiny changes yield big savings, with latency‑focused trading systems where profiling must capture rare, critical moments.

The article explains that running work on the browser's main thread incurs significant performance costs, advocating offloading tasks to workers.

Zod 4.5 introduces ahead‑of‑time schema compilation with z.compile(), cutting memory use up to 9× and adding features like z.creditCard() and z.validate().

Python's built‑in set and dict types can exhibit quadratic‑time behavior when many elements hash to the same bucket, causing worst‑case O(n²) performance.

The piece shows that fixing a maximum object count and always iterating the full array with sentinel values prevents use‑after‑free type confusion and guarantees flat latency under load.

Speedlify2 automates continuous website performance measurement for 1565 sites using parallel GitHub Actions runs, decoupled ranking, and more detailed metrics like Core Web Vitals and Axe CLI.

Chrome and Firefox shifting to fortnightly release cycles means RUM cohorts become smaller and faster-changing, requiring release-aware analysis and annotations to avoid misinterpreting performance shifts.

The article explains how developers can optimize on-device inference performance on Apple Silicon chips by leveraging Core ML, Metal, and efficient model quantization.

Vercel's Fluid compute architecture dynamically assembles tailored machines for builds, sandboxes, and functions, enabling instant provisioning and efficient resource use.

Ulrich Drepper’s LWN series introduces programmers to modern memory hardware, explaining DRAM, caches, NUMA, and how hardware limits affect software performance.

EvryStay migrated 4,403 backend tests from Jest to Bun, optimized MongoDB usage and test parallelism, reducing full suite runtime from 10 minutes to 33 seconds on an M5 Pro.

A branchless, autovectorized UTF-8 validation algorithm using a 4-byte lookbehind window achieves 10-80 GB/s, far outperforming branchy and DFA validators.

Modern hardware advances and efficient tooling eliminate any justification for sluggish software, arguing performance issues stem from avoidable developer choices.

Cloudflare cut over 100 terabytes of RAM used by its 1.1.1.1 DNS cache by redesigning cache layout and eviction policies without hurting query latency.

The article shows that by exploiting symmetries of boolean scans, only three primitives (∧, <, ≠) need fast implementations to derive all others efficiently.

Amdahl's law shows that overall speedup is limited by the unchanged fraction of workload, with maximum speedup S_max = 1/(1−f) as component speedup → ∞.

Cloudflare moved its blog to EmDash on Cloudflare Workers, added caching, redesigned the UI, and rolled out traffic gradually to boost performance and enable agent tools.

AI dramatically reduces the cost of software optimization, enabling workload-specific performance gains that were previously too expensive to pursue.

Carlos Bueno’s Mature Optimization Handbook argues that performance work should be measured, deferred until systems mature, and focused on the small critical fraction where gains outweigh costs.

On a Terasic DE0-Nano-SOC, two Cortex-A9 cores cannot see each other's memory writes despite enabled MMU, caches, and SCU, revealing a cache coherence failure.

LLMs diminish the need to learn language specifics, letting developers choose languages like Rust and Zig for speed and size, and tackle complex low‑level projects without deep expertise.

Kigo Studio’s Critical CSS Generator extracts above‑the‑fold styles, shows how to inline or defer them, and includes an HN discussion on its utility and concerns.

Benchmarking modern systems is unreliable due to JIT optimizations, OS scheduling, hardware variability, and environmental factors, requiring careful controls or many runs to understand true performance.

The author demonstrates four methods—exec, importNative, giant Nix file, and WASM—to embed SQLite queries in Nix, comparing their speed and resource usage.

A single window.innerWidth read during server render threw an error, causing Next.js to fall back to client-side rendering and produce soft 404s on ~190 pages.

SQLite can replace many specialized systems—search, document store, queue, cache, vector DB, etc.—by serving as a single-file, zero‑maintenance database for applications.

The article argues that Canvas can be a better choice than HTML for web apps with complex spatial interfaces like zoomable workspaces, but warns it sacrifices accessibility and built-in browser features.

TanStack Table V9 introduces a tree-shakable architecture, improved performance with up to 86% less memory usage, and first-class support for ten framework adapters via TanStack Store.

Octane compiles React‑style hooks, Suspense and actions ahead of time, removing the virtual DOM and hook rules while preserving familiar semantics.

By modifying OpenTelemetry's AWS SDK instrumentation to skip autoloaded services, the author cut Ruby heap usage from 163.8 MB to 67.1 MB, a ~60% reduction.

The article presents a nightly benchmark suite comparing bundle size, performance, and developer experience across major frontend frameworks to aid framework selection.

The article argues that programmers should learn SIMD techniques to improve performance in data-parallel workloads, covering basics, benefits, and practical examples.

The article argues that while modern CSS and JS features reduce the need for many build tools, bundling and minification remain essential for larger projects.

Sätteri combines a high-performance Rust Markdown/MDX engine with extensible JavaScript plugins to offer fast, customizable document processing for developers in web applications.

The visualization walks through a single HTTP request's ~211 ms journey, showing DNS, TCP, TLS, kernel, Node event loop, Postgres, and rendering.

Lobsters successfully moved from MariaDB to SQLite, cutting CPU and memory use, halving VPS costs, and keeping the site responsive after migration.

IBM Research argues effective model routing is a systems optimization problem balancing cost, latency, and accuracy, not a simple classification task.

Jon Hamm's ability to parody himself on screen is evaluated as a rare skill in the tricky practice of casting celebrities as fictionalized versions of themselves.

OpenAI powers ChatGPT's web experience for a billion users with React Router 7 streaming SSR, Tailwind CSS, off‑the‑shelf components, and aggressive feature flagging.

CD PROJEKT RED discusses balancing visual fidelity and identity with performance scaling to bring Cyberpunk 2077 natively to Mac using Metal, MetalFX, and the Game Porting Toolkit.

MarketWatch identifies 14 value stocks from the Russell 1000 Value Index with high revenue growth estimates through 2028, noting value stocks tend to outperform growth during high inflation.

Hacker News commenters debate whether monetary values must always be stored as integers, with quants arguing floats suffice for risk modeling but transfers require exact integer precision.

An experiment using Claude Code to autonomously optimize a file compression algorithm over 10 iterations, achieving competitive results against standard tools by iterating on an LZSS-based approach.

The VS Code team incrementally adopted TypeScript 7, a Go port of the compiler, achieving 4–7× speedups in builds and editor tooling.

Nub is a TypeScript-first toolkit for Node.js that provides a faster npm/pnpm run, a pnpm-compatible package manager, and a Node version manager, with no lock-in.

OpenAI splits WebRTC into a stateless relay and a stateful transceiver, using the ICE ufrag for routing to serve 900M voice AI users with low latency.

Service workers are essential for offline support, push notifications, and background sync, but other use cases are often better solved with simpler alternatives like HTTP caching or server-side logic.

PostHog's engineer used parallel Claude Code sessions to rewrite their SQL parser, achieving a 70x speedup by fuzzing against the old ANTLR-based parser as an oracle.