Tag: #performance

한국어English日本語中文

← All posts

• Cerebras Ultrafast and the Bottleneck in an Agent Loop — The Time 750 Tokens a Second Cannot Remove

  Cerebras and OpenAI announced an inference tier delivering up to 750 output tokens per second. The mechanism the announcement names is not compute but data movement, achieved by keeping weights in SRAM on the wafer. This

  2026-08-14 · 7 min read #llm#inference#hardware#latency#performance

• Open Source Worth Watching Right Now (2) Build Tools, Editors, CLIs, and Terminals

  Work that gets repeated dozens of times a day, such as installing packages, linting, and bundling, has been rewritten in native languages, and the waiting has come down from seconds to milliseconds. This post introduces

  2026-08-12 · 5 min read #open-source#developer-tools#cli#rust#performance

• A Single Instruction Can Take 62 Seconds — Latency Is a Property of the Path, Not of the Instruction

  The Assembly Hall of Shame is a leaderboard for the competition to make a single instruction as slow as possible. At the bottom, nop takes 1 cycle; at the top, fxrstor64 takes 198 billion cycles, or 62 seconds. Read that

  2026-08-09 · 11 min read #os-concepts#performance#cpu#microarchitecture#benchmark

• The 300x Is Not a Number You Get by Tuning PostgreSQL — The Volcano Model and Vectorized Execution

  A precise dissection of the 300x published alongside the pgrust 0.2 release. That figure did not come from changing a PostgreSQL setting; it is a ClickBench measurement of a database newly implemented in Rust, while the

  2026-08-09 · 9 min read #postgresql#database#performance#query-engine#simd

• What It Really Means to Hand-Tune a GPU Kernel — Making One Transpose Kernel 5x Faster

  Starting from threads, warps, and the memory hierarchy, this post covers what it actually means to hand-modify a GPU kernel. It explains why occupancy is a symptom rather than a goal, and why most kernels are bound by me

  2026-08-02 · 19 min read #cuda#gpu-kernel#nsight-compute#memory-bandwidth#performance

• The Mean Tells You Nothing — How to Debug Latency Through Distributions

  Farid Zakaria's post "The mean means nothing," published July 27, 2026 and reaching the top of Hacker News, covers a case where average latency got 9% worse after a caching layer rollout — from 112ms to 122ms. In the ver

  2026-07-31 · 14 min read #observability#latency#performance#histogram#percentile

• What Java Value Objects (JEP 401) Change — What You Gain and Lose by Giving Up Identity

  At 00:45 UTC on July 31, 2026, the JEP 401 Value Objects implementation merged into the OpenJDK mainline. Bundled into a single commit with JEP 539 (Strict Field Initialization), it added roughly 208,000 lines across 1,8

  2026-07-31 · 16 min read #java#jvm#valhalla#jep-401#performance

• Actually Fixing Core Web Vitals — The Order in Which You Bring LCP, INP, and CLS Down

  Scoring 98 in Lighthouse while Search Console stays red happens because the two tools measure different things. This post starts by laying out what LCP, INP, and CLS each measure and why the thresholds apply at the 75th

  2026-07-26 · 15 min read #performance#core-web-vitals#lcp#inp#cls

• HTTP Keep-Alive and connection reuse — the timeout race condition behind intermittent 502s

  When the backend logs contain no errors at all and only the load balancer intermittently mixes in 502s, it is usually a connection reuse race condition. At the exact moment the server closes an idle connection, the clien

  2026-07-26 · 15 min read #network#http#performance#load-balancer#tcp

• The Questions Distributed Tracing Actually Answers — Spans, Sampling, and Where the Time Went

  Tracing is what you need when the reports of slowness keep coming in but you have no idea which of ten services is the culprit. Starting from the structure of traces, spans, and context propagation, this post lays out wh

  2026-07-26 · 15 min read #observability#distributed-tracing#opentelemetry#tail-sampling#performance

• Why Load Average Is Not CPU Utilization — load average 24 With the CPU at 30%

  Covers the situation where the load average from uptime is above 24 while the CPU in top does not even reach 30%. Unlike other Unix systems, the Linux load average counts not only runnable (R) tasks but also D state (uni

  2026-07-26 · 14 min read #linux#performance#load-average#psi#troubleshooting

• When git gets slow — structural prescriptions for a large repository

  There is no single reason a repository gets slow. A long commit history, a huge number of files, and big binaries sitting in the tree are three different problems with three different prescriptions. This post starts with

  2026-07-26 · 11 min read #git#performance#monorepo#git-lfs#version-control

• How to Read EXPLAIN ANALYZE — Finding the Real Bottleneck in a Query Plan

  A walkthrough of how to read EXPLAIN ANALYZE output from beginning to end. Which order to read the nodes in, why cost is not a unit of time, what the gap between estimated and actual row counts tells you, and how to avoi

  2026-07-26 · 13 min read #database#postgresql#explain#query-optimization#performance

• Why a Big Connection Pool Costs You — Deciding Where to Put the Queue

  An explanation of the mechanism behind the phenomenon where enlarging a connection pool actually makes things slower. Why a connection is expensive under the process model of PostgreSQL, why it is better to put the queue

  2026-07-26 · 15 min read #database#postgresql#connection-pool#pgbouncer#performance

• Using HTTP Caching Properly — What Cache-Control, ETag, and stale-while-revalidate Actually Mean

  no-cache does not mean do not cache. It means store it, but revalidate before reusing it. Starting from that one-word difference, this post lays out the exact meaning of each Cache-Control directive, what conditional req

  2026-07-26 · 11 min read #web#http-caching#cache-control#cdn#performance

• Why You Fall Apart Only When It Matters — The Psychology of Choking and How to Train for Pressure

  Perfect in practice, broken in the real thing — choking under pressure is not a matter of talent or effort but a malfunction of the attention system. Starting from Jana Novotna at the 1993 Wimbledon final, this post look

  2026-07-20 · 7 min read #mindset#sports-psychology#pressure#performance#confidence

• ClickHouse Lazy Materialization — How a LIMIT 10 Trick Grew Into FINAL and JOIN

  ClickHouse's lazy materialization is an optimization that skips reading SELECT columns until sorting and LIMIT are finished, and it launched in 25.4 (April 2025) as a conservative feature that only kicked in for LIMIT 10

  2026-07-17 · 15 min read #database#clickhouse#olap#query-optimization#performance

• Content-Encoding: zstd — Safari 26.3 Fills In the Third Engine, and What's Next Is RFC 9842 Dictionary Compression

  In February 2026, Safari 26.3 added support for Content-Encoding: zstd, so all three browser engines now receive zstd responses, following Chrome 123 (2024-03) and Firefox 126 (2024-05). Because it's negotiation-based, a

  2026-07-17 · 12 min read #performance#web#network#browser

• Triton Gluon: The Language That Hand-Writes the Layouts the Compiler Used to Hide

  Gluon is a low-level GPU language built on the same compiler stack as Triton — it hands kernel authors the layouts, shared memory, and warp specialization that Triton normally keeps hidden. Its reason for existing is cle

  2026-07-16 · 19 min read #gpu#triton#kernel#compiler#performance

• React Compiler Got Ported to Rust — What Merged, What Did Not, and That "10x" Number

  On June 9, 2026, PR 36173 — a Rust port of React Compiler — merged into facebook/react main. It added more than 120,000 lines across 461 files, and the number "3x faster as a Babel plugin, about 10x faster in the transfo

  2026-07-16 · 19 min read #react#rust#compiler#performance#frontend