Cognate Press

Appending to a string is free until someone else holds it

Alden Pike — Sun, 11 Oct 2026 00:00:00 GMT

The same .= statement took 0.269 ms and 218.836 ms in two loops that differ by one assignment. What a zend_string costs, where literals live, and why implode is not the fix.

require(esm) Killed the Second Build, Not the Second Copy

Jonah Vail — Sun, 11 Oct 2026 00:00:00 GMT

Being able to require() an ES module removes the reason most packages shipped two builds. The dual package hazard is a layout problem, and it survived.

Reading a GC Log Line by Line

Marcus Venn — Sun, 11 Oct 2026 00:00:00 GMT

One run, one quantity, three answers. The allocation rate everyone derives from the default GC log is ten per cent low, and the log says why if you ask it correctly.

UTF-8 by Default Fixes a Silent Bug and Adds a Loud One

Elliot Sayer — Sun, 11 Oct 2026 00:00:00 GMT

Under a Latin-1 locale, CPython 3.13 reads a UTF-8 file as mojibake and raises nothing. 3.15 reads it correctly and raises on the Latin-1 file 3.13 read fine.

clrstack Shows the Waiter and syncblk Names the Lock Holder

Callum Reeve — Sun, 11 Oct 2026 00:00:00 GMT

In a dotnet-dump of a contested lock, clrstack -all marked no thread as the owner. syncblk named it, and a suspended await appeared only in dumpasync.

Document or Relational: Read-Time or Write-Time Cost

Elias Rowe — Sun, 11 Oct 2026 00:00:00 GMT

Relational modeling describes the entities and lets queries follow. Document modeling inverts that, and the inversion is the whole trade.

Green Tea cut my GC time 63%, and raised it 39%

Nolan Keir — Sun, 11 Oct 2026 00:00:00 GMT

One heap shape lost 63% of its collector CPU and gained 14% throughput. Another gained 39% collector CPU and lost nothing. Same flag, same binary pair, same machine.

A property hook emits the same opcode as a plain property

Alden Pike — Sun, 04 Oct 2026 00:00:00 GMT

Plain, backed and virtual property reads compile to one identical FETCH_OBJ_R. What separates them is a function call the opcode does not show, measured at nine times.

Your Reactive Graph Computed 4,11. That State Never Existed.

Jonah Vail — Sun, 04 Oct 2026 00:00:00 GMT

A single-pass push through a diamond recomputes the leaf twice, and the first result mixes a fresh value with a stale one. Two passes are what remove it.

Streams Versus Loops: What the JIT Sees

Marcus Venn — Sun, 04 Oct 2026 00:00:00 GMT

The same pipeline cost 7.05 times the loop over eight elements and 1.31 times over a million. The ratio everyone quotes is a measurement at a trip count.

A Container Given 1.2 CPUs Tells the Runtime It Has 2

Callum Reeve — Sun, 04 Oct 2026 00:00:00 GMT

Environment.ProcessorCount is the CPU quota rounded up, never below 1. The thread pool minimum follows it, and Server GC switches itself off at 1.

Connection Pool Sizing: Why More Connections Make It Slower

Elias Rowe — Sun, 04 Oct 2026 00:00:00 GMT

Past the point where the server can execute work in parallel, adding connections adds queueing rather than throughput — and moves the queue somewhere worse.

The GOGC I set next to GOMEMLIMIT never fired

Nolan Keir — Sun, 04 Oct 2026 00:00:00 GMT

GOGC=100 with a 256 MiB limit produced exactly what GOGC=off produced: same collections, same CPU share, same throughput. The tighter rule binds, the other goes quiet.

A declared property is cheaper than an array key

Alden Pike — Sun, 27 Sep 2026 00:00:00 GMT

One hundred thousand four-field records cost 143.54 bytes each as objects and 397.14 as associative arrays. Where the crossover is, and what one undeclared property costs.

Your Conditional Type Answered Twice. Both Answers Are Right.

Jonah Vail — Sun, 27 Sep 2026 00:00:00 GMT

A naked type parameter splits its union before the conditional runs, so IsArray comes back as 'no' | 'yes'. Read out of TypeScript 7.0.2.

The Cost of Optional

Marcus Venn — Sun, 27 Sep 2026 00:00:00 GMT

Identical source, five call sites, one JDK 26 run - nothing allocated at the first and twelve bytes at three others. The wrapper is not what decides.

Swapping Two Imports Moved 5.5 ms to a Different Module

Elliot Sayer — Sun, 27 Sep 2026 00:00:00 GMT

Importing logging before asyncio moves 5.5 ms from asyncio's line to logging's. The program does the same work. The cumulative column charges whoever got there first.

The Box You Pay For Is the One That Escapes

Callum Reeve — Sun, 27 Sep 2026 00:00:00 GMT

Assigning a struct to an interface allocated 0 bytes. Passing it across a call boundary allocated 24. A constrained generic allocated none, until its body asked for an object.

Composite Indexes: One Ordering, Not Three

Elias Rowe — Sun, 27 Sep 2026 00:00:00 GMT

Column order decides which queries a composite index can serve. The rule follows from the structure, and so do the cases where it does not hold.

A 404 from net/http costs 62 allocations

Nolan Keir — Sun, 27 Sep 2026 00:00:00 GMT

A static route through net/http's mux costs 85.6 ns and nothing on the heap. A path that matches no pattern costs 2125.5 ns and 62 allocations.

Two hundred thousand objects, and the collector never ran

Alden Pike — Sun, 20 Sep 2026 00:00:00 GMT

Two hundred thousand objects created and dropped, and zero collections. What puts an object in the root buffer, and why the collector's cost is set by what you keep alive.

Vite 8 Ships One Bundler, Not One Pipeline

Jonah Vail — Sun, 20 Sep 2026 00:00:00 GMT

Vite 7 depends on esbuild and Rollup; Vite 8 on neither. Serving one module from both majors shows what the swap to Rolldown changed and what it left alone.

lazy import Moved 26.8 ms and Removed None of It

Elliot Sayer — Sun, 20 Sep 2026 00:00:00 GMT

A lazy import of asyncio costs no measurable time and no modules at startup. Read the name once and 26.4 of the 26.8 ms come back. Deferral is not removal.

The Middleware That Looked Expensive Was Not the One Spending the Bytes

Callum Reeve — Sun, 20 Sep 2026 00:00:00 GMT

Removing UseRouting dropped per-request allocation by 2.29 KB in isolation — separated from authorization's share, routing itself costs about 24 bytes.

Why the Primary Key Is in Every Secondary Index

Elias Rowe — Sun, 20 Sep 2026 00:00:00 GMT

InnoDB stores the table inside its primary key. Almost every MySQL indexing consequence, good and bad, follows from that single decision.

The mutex was 68 times faster, until I added work

Nolan Keir — Sun, 20 Sep 2026 00:00:00 GMT

One goroutine: 2.5 ns for the mutex, 172.6 ns for the channel. Sixteen goroutines with real work: the channel wins by less than the harness's own error.

Three numbers for one process, and memory_limit reads the middle one

Alden Pike — Sun, 13 Sep 2026 00:00:00 GMT

memory_get_usage(), memory_get_usage(true) and ps disagree about one process. What each counts, which one memory_limit reads, and why a one-megabyte string costs two.

Object Shapes Are a Tree, and the Tree Is Shared

Jonah Vail — Sun, 13 Sep 2026 00:00:00 GMT

A hidden class is a node in a transition tree V8 keeps for the whole isolate — which is why an unrelated function can decide how your object is stored.

JFR: The Events You Actually Need

Marcus Venn — Sun, 13 Sep 2026 00:00:00 GMT

Sixty seconds of default settings produced 4.3 MB, three quarters of it one event type, and none of it answered whether the application was lock-contended.

A NamedTuple Read Cost 0.81x a Plain One, Then 1.9x

Elliot Sayer — Sun, 13 Sep 2026 00:00:00 GMT

On CPython 3.10 a NamedTuple attribute read cost 0.81x a read through an instance dictionary. On 3.11 it costs 1.90x. Nothing about NamedTuple changed.

dotnet-counters Shows the Queue's Delta, Not Its Depth

Callum Reeve — Sun, 13 Sep 2026 00:00:00 GMT

A thread pool queue held at two thousand work items read 1986 through one provider and -13 through the other, in the same second, in the same process.

Transaction Pooling Breaks Only Under Load

Elias Rowe — Sun, 13 Sep 2026 00:00:00 GMT

Transaction pooling is what makes PgBouncer worth deploying, and it silently removes session state your application may depend on.

A 1 MiB goroutine stack costs 136µs and reports 144 B/op

Nolan Keir — Sun, 13 Sep 2026 00:00:00 GMT

Reaching a 1 MiB stack copied it nine times. The copying cost 136µs of CPU that -benchmem reports as 144 bytes, because stack memory is not heap memory.

A by-reference foreach leaves a reference in every element

Alden Pike — Sun, 06 Sep 2026 00:00:00 GMT

Walking an array with foreach ($rows as &$row) wraps every element in a zend_reference. On a million integers that is 32 MB the loop never gives back.

What await Compiles To, and What It Costs

Jonah Vail — Sun, 06 Sep 2026 00:00:00 GMT

One async function compiled three ways — TypeScript's ES5 emit, V8's bytecode and the spec's Await steps — and the microtask turns each one predicts.

What a Safepoint Actually Stops

Marcus Venn — Sun, 06 Sep 2026 00:00:00 GMT

One collection, reported as 2.275 ms by the GC log and 29.6 ms by the safepoint log. The gap is time to safepoint, and each instrument hides a different part of it.

getsizeof Reports 296 Bytes, Then 96, for the Same Class

Elliot Sayer — Sun, 06 Sep 2026 00:00:00 GMT

sys.getsizeof reports 296 bytes for a class's first instance dict and 96 once twenty-six exist. The instance itself costs 96 bytes and getsizeof says 48.

EXPLAIN, ANALYZE, BUFFERS: Three Different Questions

Elias Rowe — Sun, 06 Sep 2026 00:00:00 GMT

Which variant you ran decides whether the numbers in front of you are the planner's estimate or a measurement, and whether the pages came from cache.

benchstat reported p=0.000 between a function and itself

Nolan Keir — Sun, 06 Sep 2026 00:00:00 GMT

Two sub-benchmarks calling the same function with the same argument came back 1.10% apart at p=0.000. What a benchmark measures is not only your code.

What a PHP variable actually is

Alden Pike — Sun, 30 Aug 2026 00:00:00 GMT

A zval is sixteen bytes, a value union and a type tag. What that tag says decides whether an assignment copies anything, what a reference costs, and which variable pays.

The Provenance Was Valid. The Commit Was Not.

Jonah Vail — Sun, 30 Aug 2026 00:00:00 GMT

An npm provenance attestation binds a tarball to a repository, a workflow and a commit. Reading the payload shows what it never claims.

How the JVM Finds and Loads a Class

Marcus Venn — Sun, 30 Aug 2026 00:00:00 GMT

A hello-world program loads 423 classes before it prints anything. Where they come from, what the JVM does to each one, and how to see it.

Slots Did Not Get Slower, One Build Did

Elliot Sayer — Sun, 30 Aug 2026 00:00:00 GMT

A read through __slots__ costs 24% more than one through an instance dictionary on CPython 3.13.2. Rebuild the same version and the gap goes away.

Server GC, Workstation GC, and the Numbers Between Them

Callum Reeve — Sun, 30 Aug 2026 00:00:00 GMT

Server GC finished 2.7 times faster and collected 17 times less often — and made the slowest request in the run 5 to 13 times slower. Both numbers are real.

N+1 Queries: What the ORM Is Actually Doing

Elias Rowe — Sun, 30 Aug 2026 00:00:00 GMT

One query for the list, then one more for every item in it. The cost is per statement, which is why the profiler shows a fast database and a slow request.

GOMAXPROCS is not your thread count

Nolan Keir — Sun, 30 Aug 2026 00:00:00 GMT

GOMAXPROCS=1 with 200 goroutines blocked in read(2) produced 202 OS threads. Measured on go1.27.0, alongside the container case Go 1.25 changed.

sync.Pool survives one GC, not two

Nolan Keir — Thu, 27 Aug 2026 00:00:00 GMT

A pool holding 100 objects lost none across one collection and all 100 across two. Here is the victim cache, and what it costs at 122,000 ops per millisecond.

Reading a Lockfile: Supply Chain in Practice

Jonah Vail — Wed, 26 Aug 2026 00:00:00 GMT

What package-lock.json actually records, what its integrity hashes do and do not prove, and where the real install-time risk sits.

Where Spring Boot Startup Time Goes

Marcus Venn — Wed, 26 Aug 2026 00:00:00 GMT

Startup time is class loading, condition evaluation and JIT warmup in some proportion. Measure the split before reaching for a fix.

Escape analysis is not a rule of thumb

Nolan Keir — Wed, 26 Aug 2026 00:00:00 GMT

The compiler said "does not escape" and the benchmark reported 104 KiB per operation. Both were right. What -gcflags=-m actually tells you.

Type Hints at Run Time

Elliot Sayer — Tue, 25 Aug 2026 00:00:00 GMT

Annotations cost nothing per call and everything at import. Reading __annotations__ takes 24 ns; resolving the same class with get_type_hints takes 3.4 µs, 140x more.

What the Go scheduler does when your goroutine blocks

Nolan Keir — Tue, 25 Aug 2026 00:00:00 GMT

A blocking syscall costs an OS thread. A blocking network read costs nothing. Measured with 200 goroutines, GOMAXPROCS=2 and a thread count.

Where Thread Pool Starvation Actually Comes From

Callum Reeve — Sun, 23 Aug 2026 00:00:00 GMT

Blocking on a task is the case the thread pool compensates for. Blocking on a sleep or an event is the case it cannot see, and it finished 2.5 times slower.

Why an Index Is Not Used: the Estimate, Not the Index

Elias Rowe — Sun, 23 Aug 2026 00:00:00 GMT

An index the planner ignores is usually a row-estimate problem. The fix starts with what the optimizer expected, not with the index definition.

PHP-FPM process management in production

Alden Pike — Thu, 20 Aug 2026 00:00:00 GMT

pm static, dynamic and ondemand, the memory ceiling nothing enforces, and how to size a pool from measurements rather than guesses.

Type-Level Narrowing: How TypeScript Decides What You Meant

Jonah Vail — Wed, 19 Aug 2026 00:00:00 GMT

Control flow analysis is a graph walk over your code. Knowing what widens a type again explains most of the errors that look wrong.

Reading a Thread Dump Without Guessing

Marcus Venn — Wed, 19 Aug 2026 00:00:00 GMT

A thread dump answers precise questions if you ask them precisely. What each state really means, and the traps that produce confident wrong diagnoses.

Where Your Django Request Time Actually Goes

Elliot Sayer — Wed, 19 Aug 2026 00:00:00 GMT

Removing Django's entire default middleware chain saved 0.02 ms per request. Fixing one N+1 query on a fifty-row list view saved 3.30 ms.

The State Machine Your async Method Compiles Into

Callum Reeve — Sun, 16 Aug 2026 00:00:00 GMT

An async method that never suspends allocates nothing. The same method, suspended once, allocates 160 bytes. The cost is not the keyword — it is the suspension.

What compiled DI containers actually buy you

Alden Pike — Thu, 13 Aug 2026 00:00:00 GMT

Container compilation moves reflection from request time to build time. What that removes, what it costs, and when it matters.

The Event Loop You Think You Know

Jonah Vail — Wed, 12 Aug 2026 00:00:00 GMT

Microtasks, rendering opportunities and starvation — what the loop actually does between your callbacks, in the browser and in Node.

The Real Cost of an async Call

Elliot Sayer — Wed, 12 Aug 2026 00:00:00 GMT

Awaiting a coroutine that never suspends costs 53 ns against 24 ns for a plain call. Wrapping the same coroutine in a Task and awaiting it costs 28,958 ns.

G1 versus ZGC: What the Pause Numbers Hide

Marcus Venn — Tue, 11 Aug 2026 00:00:00 GMT

Sub-millisecond pauses are real, and they are not the whole cost. What the two collectors actually trade, and which numbers to compare instead.

PHP arrays are not arrays

Alden Pike — Thu, 06 Aug 2026 00:00:00 GMT

One structure serves as list, dictionary and set. Packed and hashed layouts, what each costs in memory, and when a conversion happens.

What Actually Happens When Vite Serves a Module

Jonah Vail — Tue, 04 Aug 2026 00:00:00 GMT

A walk through one request to a Vite dev server: resolution, the transform pipeline, import rewriting, pre-bundling, and why production differs.

Escape Analysis and the Allocation That Never Happened

Marcus Venn — Tue, 04 Aug 2026 00:00:00 GMT

C2 can delete an object entirely by proving it never escapes. Here is when that works, when it silently stops, and how to measure the difference.

The GIL Is Not a Lock on Your CPU

Elliot Sayer — Tue, 04 Aug 2026 00:00:00 GMT

Eight threads of pure-Python arithmetic run at 0.98x the speed of one. The same eight threads doing IO run at 7.90x. The GIL is a scheduler, and it has a dial.

OPcache, the JIT, and where time actually goes

Alden Pike — Thu, 30 Jul 2026 00:00:00 GMT

OPcache removes compilation, not execution. The JIT reaches arithmetic-heavy code and little else. Where the remaining time lives.

Virtual Threads and the Pinning Problem

Marcus Venn — Thu, 23 Jul 2026 00:00:00 GMT

Virtual threads scale until something nails one to its carrier. Here is what still pins on modern JDKs, and how to see it happen.

What import Actually Does

Elliot Sayer — Thu, 23 Jul 2026 00:00:00 GMT

Importing asyncio costs 21.9 ms and pulls in 100 modules. Importing email costs 0.1 ms and pulls in one. Granularity predicts import cost; size does not.

Signals Are Not Magic: The Dependency Graph Underneath

Jonah Vail — Wed, 22 Jul 2026 00:00:00 GMT

Every signals library is the same forty lines of bookkeeping. Here is what those lines do, and where the four popular implementations diverge.

Benchmarking PHP without lying to yourself

Alden Pike — Thu, 16 Jul 2026 00:00:00 GMT

Microbenchmarks measure exactly what you tell them to, which is rarely what you meant. Method, noise, and the numbers worth reporting.

What the JIT Actually Does to Your Hot Loop

Marcus Venn — Tue, 14 Jul 2026 00:00:00 GMT

Tiered compilation, on-stack replacement and inlining decide how your loop really runs. Here is how to read those decisions instead of guessing.

The Shape of a Python Object

Elliot Sayer — Tue, 14 Jul 2026 00:00:00 GMT

An instance with three attributes costs 96 bytes, not the 344 sys.getsizeof reports, and __slots__ read 12% slower on the CPython 3.13.2 build measured here.

How V8 Decides to Optimize Your Function

Jonah Vail — Thu, 09 Jul 2026 00:00:00 GMT

Two functions that look identical can run at very different speeds. The difference is usually shapes, inline caches, and a deoptimization you never saw.

What happens when PHP runs your code

Alden Pike — Thu, 02 Jul 2026 00:00:00 GMT

A request walks from the SAPI to the Zend VM — lexing, compilation to opcodes, the OPcache lookup that skips both, and execution.