Tag: #performance

한국어English日本語中文

← All posts

• Redis 8.8's Array Type — The First New Core Data Structure Since Streams, and What Valkey Doesn't Have

  In May 2026, Redis 8.8 and Valkey 9.1 shipped six days apart. Redis 8.8 adds Array, a new core data structure built directly by antirez — a sparse index-addressed container for data where the index itself carries meaning

  2026-07-16 · 16 min read #redis#valkey#data-structures#performance#open-source

• Why QUIC Gets Slower on Fast Internet — Receiver-Side CPU and the Kernel QUIC That Hasn't Arrived

  QUIC clearly won on handshake latency and loss recovery — Google's internet-scale measurements show an 8.0% (desktop) drop in search latency and an 18.0% drop in video rebuffer rate as evidence. But once the link gets fa

  2026-07-16 · 20 min read #network#protocol#performance#linux-kernel

• pg_plan_advice in Postgres 19: The Compromise From a Project That Has Long Refused Hints

  The PostgreSQL project has refused optimizer hints for a long time. But PostgreSQL 19 Beta 1, released on June 4, 2026, added two contrib modules built by Robert Haas: pgplanadvice and pgstashadvice. This isn't Oracle-st

  2026-07-16 · 14 min read #postgresql#query-planner#query-optimization#database#performance

• .NET 11 Runtime-Async: A Progress Report on Moving the Async State Machine from Compiler to Runtime

  C's async/await has been purely a compiler feature since 2012 — Roslyn rewrites the method body into a state-machine class, and the runtime executes it without ever knowing it was async. .NET 11's runtime-async moves tha

  2026-07-16 · 18 min read #dotnet#csharp#async#jit#performance

• CXL Memory Tiering: How Far Has the Kernel Come — What DAMON Merged, and What the Numbers Didn't Measure

  Even when CXL hardware is plugged into a server, it's the kernel that actually decides which pages are hot and which are cold and moves them. As of July 2026, Linux mainline has received DAMON/DAMOS-based tiering pieces

  2026-07-16 · 19 min read #hardware#cxl#memory#linux-kernel#performance

• The Elite Athlete Mindset, With the Poster Peeled Off — What the Research on Practice, Pressure, and Belief Actually Shows

  The elite athlete mindset is a staple of motivational posters, but the actual sports psychology is more careful, and more interesting, than the slogans. This post walks through Carol Dweck's growth mindset (and the false

  2026-07-11 · 5 min read #mindset#psychology#performance#sports#deliberate-practice

• LLM Caching, Explained — Why Prompt Caching and Prefix Caches Save You Money

  Why does a matching prompt prefix cut costs to a tenth? The answer lives in the transformer's KV cache. Because attention is causal, the Key/Value vectors of earlier tokens never change no matter what comes after — so th

  2026-07-08 · 7 min read #ai#llm#caching#inference#performance

• Reading htop and top — How to Decode Every Number

  Open htop or top on Linux and a flood of numbers pours out. The difference between VIRT, RES, and SHR; the process state letters; why load average is not CPU usage; what the meter colors mean; and zombie processes — this

  2026-07-05 · 7 min read #linux#performance#htop#sysadmin

• Big-O in Practice: Complexity Without the Math Anxiety

  What O() actually means, the common complexity classes with real-world examples, when constants win because n is small or the cache matters, the O(n squared) that hides in nested loops and N+1 queries, space complexity,

  2026-06-22 · 11 min read #algorithms#performance#fundamentals

• Cache Invalidation, Explained

  "There are two hard things in computer science: cache invalidation and naming things." This post covers why caching is so hard, strategies like TTL, write-through, write-behind, and cache-aside, the cache stampede (dogpi

  2026-06-19 · 15 min read #performance#caching#systems

• Mechanical Sympathy: Writing Code the Hardware Likes

  Two pieces of code with the same time complexity can differ by tens of times in the real world, and the reason lives in the hardware. CPU caches (L1/L2/L3) and cache lines, data locality in arrays versus linked lists, br

  2026-06-18 · 15 min read #performance#systems#cpu

• Why ripgrep Is So Fast

  ripgrep beats grep not through magic but through an accumulation of decisions: the Rust regex crate built on finite automata (no backtracking), SIMD-accelerated memchr, parallel directory traversal, respecting .gitignore

  2026-06-17 · 12 min read #rust#performance#tools#cli

• The Reconcile Loop in Depth — Idempotency, Error Handling, Queues, and Performance

  A deep dissection of the reconcile loop: the request flow (informer to workqueue to reconcile), Result and requeue, idempotency patterns, status and conditions, predicate event filters, rate limiting and concurrency, cac

  2026-06-15 · 18 min read #kubernetes#operator#reconcile#controller-runtime#performance

• ingress-nginx Production Tuning — Performance, Timeouts, Connections, keepalive

  A practitioner tuning guide for running ingress-nginx reliably in production: workers and connections, upstream keepalive, the three timeouts, buffering, compression, rate limiting, HPA scaling, graceful reload, and a 50

  2026-06-14 · 14 min read #ingress#kubernetes#nginx#performance#devops

• Kernel Tuning for Low-Latency Trading Systems — The War Against Microseconds

  How to tune the Linux kernel in domains like HFT and market making where microseconds decide profit and loss. Covers CPU isolation recipes, NUMA alignment, the kernel-bypass spectrum, C-state pinning, PTP time synchroniz

  2026-06-13 · 17 min read #linux#kernel#low-latency#trading#performance

• The Evolution of the Linux CPU Scheduler — From CFS to EEVDF

  We follow the evolution of the Linux scheduler, from CFS implementing fairness with vruntime and a red-black tree, to EEVDF which became the default in kernel 6.6 to address latency-sensitive workloads. Covers cgroup CPU

  2026-06-13 · 17 min read #linux#kernel#scheduler#cfs#eevdf

• A Packet Journey — Tracing the Linux Kernel Networking Stack

  We dissect the full path a packet takes from the NIC through DMA, ring buffers, NAPI, and the IP/TCP layers to the application socket. Covers RSS/RPS/RFS multi-core scaling, GRO/GSO/TSO offloads, XDP, socket buffer tunin

  2026-06-13 · 19 min read #linux#kernel#networking#tcp#xdp

• Hacking the Linux Memory Hierarchy — swap, zram, and the Wild Idea of Swapping to VRAM

  The nbd-vram project, which exposes GPU VRAM as an NBD block device to use as swap, made waves on Hacker News. Starting from there, this post covers Linux memory management fundamentals, swappiness and zram/zswap tuning,

  2026-06-12 · 16 min read #linux#memory#swap#zram#kernel

• Real GPU Compute in the Browser — A Hands-On Guide to WebGPU Compute Shaders and WGSL in 2026

  WebGPU's real attraction isn't 3D — it's compute. We run matrix math, ML inference, image filters and parallel reductions inside the browser, in WGSL, without CUDA and without wasm. Workgroups, dispatch, bind groups, sto

  2026-05-14 · 17 min read #webgpu#compute-shader#wgsl#gpu-computing#browser

• Tailwind CSS 4 Deep Dive — Oxide Engine, Vite-First Architecture, CSS-First Config, and a Real v3 Migration Story for 2026

  Tailwind CSS 4 is not a point release. It is a rewrite — the engine is in Rust, the JS config file is gone, the content array is gone, and the entire toolkit of modern CSS is now wired straight into the framework. A year

  2026-05-14 · 18 min read #tailwind-css#tailwind-v4#oxide#vite#css