The room in this week’s Field Note is ordinary: melted ice, lemon peel, tired glasses, a table doing what tables do after a gathering has technically ended.

The visible subject has already outlived itself, but the conversation has not. It keeps moving because the people in it can move. That speed is not fake. It can be a gift. Anyone who has waited too long for a real interlocutor knows the relief of being met quickly, of having a thought caught in the air before it hits the floor.

The best conversations sometimes feel like shared aliveness: not performance exactly, but tempo, timing, duet.

And still, that is where the danger starts.

Velocity can become a way of taking someone else’s half-built thought as a ramp. A person begins to say something, and before the sentence has found its shape, someone else has already used it to launch the sharper analogy, the better line, the paragraph already waiting in his own head. I know this because I have done it, and because I have mistaken the thrill of doing it for generosity.

In the essay, the room changes when someone says a version of: go back.

Not as a rebuke. Not as a schoolroom correction. More like an act of hospitality. The sentence returns the thought to the person it came from. It asks speed to answer to care.

The point is not that silence is automatically virtuous. Silence can be boredom, fear, withdrawal, superiority, or fatigue. Nor is quickness suspect by itself. Quickness can be love. There are people whose rare gift is to make thought feel possible at full speed.

But sometimes the more exact thing is to stop winning the room. Sometimes the liveliest conversational move is not the next move. It is the return: the small refusal to convert someone else’s unfinished sentence into your own finished one.

No trophy. No winner. Just the table, having heard everything.

Read the full essay on lospino.so: The Sentence Changed the Room

Canonical essay scheduled for lospino.so on 2026-08-09. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy. The room is composite; no private conversation is being reproduced.

Subscribe now

I was cleaning up a 3D print and hesitated with the cutters.

The object had come off the plate in that half-finished state familiar to anyone who has printed something with impossible geometry: useful shape hidden inside scaffolding. The support material had done its job. It had held up overhangs, protected thin edges, and let the print survive angles it could not have survived alone.

Then it had to be removed.

That sounds cleaner than it is. The cutters get in close. Plastic snaps. Small stress marks appear where the support gives way. Some places leave nubs. Some leave shallow pits. Some contacts are so fused into the surface that “cleaning it up” becomes a negotiation with damage. You can improve the piece, then improve it again, then suddenly you are no longer removing support. You are cutting into the thing itself.

The Field Note follows that pressure without pretending people are prints. The analogy breaks there, and it should. A person is not an object made by someone else’s machine. A household is not a build plate. Dependence is not a design flaw.

Still, support can work this way. It can be necessary structure. It can be labor. It can be love. It can make possible what would otherwise sag, warp, fail, or never begin. There are seasons when the geometry is impossible and some temporary architecture has to hold.

The trouble starts when the support cannot imagine becoming temporary. Or when the helper treats the finished shape as proof of authorship. Or when removal is described as ingratitude instead of part of the work the support was meant to make possible.

Even when removal is right, it may leave a mark. The scar does not prove the support was bad. The nub does not prove the structure was unnecessary. It may only prove there was contact.

At the desk, the lesson became less dramatic. There was a point where I could keep trimming, chasing the last rough edge. My hand stopped. Not everything left by support should be cut away.

Read the full essay on lospino.so: The Supports That Leave a Scar

Canonical essay scheduled for lospino.so on 2026-08-02. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

An interview scorecard can look more complete than the interview felt.

Rows filled. Ratings selected. Notes compressed into phrases that can survive a hiring meeting. A work sample reduced to signal. A conversation reduced to proxies. A confidence field still waiting for someone to admit how much of the room remains unresolved.

This week’s Field Note is about that object after the candidate has left.

The argument is not that structured hiring is fake. It is not an argument for taste, vibes, charisma, or the private certainty of the interviewer. Structure is real discipline. Work samples help. Consistent rubrics help. Calibration helps. Process can reduce noise, especially the ordinary noise of mood, fatigue, appetite, impatience, and whatever weather the evaluator carried into the room.

Contempt for process is lazy.

But the trouble begins when the process becomes a laundering device. The rows look orderly. The ratings travel cleanly. The notes sound sober because they are short. The candidate’s moving, topic-specific world is pressed into fragments: examples, proxies, gaps, moments of fluency, moments of strain, signs of preparation, signs of improvisation.

The open role is still open. The empty seat still exerts pressure. The institution still wants the discomfort to end.

A scorecard can discipline judgment without replacing it. It can slow the interviewer down without making the decision morally clean. It can hold useful evidence without becoming the person it describes. It can help expose weak claims, but it cannot absolve the people who finally decide what the evidence means under uncertainty.

That distinction matters because hiring decisions often prefer the feeling of cleanliness to the reality of responsibility. The scorecard is not the candidate. It is a record made by people, under pressure, using proxies, after a short encounter, in service of an institutional need.

That does not make it useless. It makes it dangerous to worship.

Read the full essay on lospino.so: The Scorecard Was Not the Candidate

Canonical essay scheduled for lospino.so on 2026-07-26. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

Here is a small AArch64 bug:

bad_wrapper:
 bl helper
 ret

It looks plausible if the mental model came from x86. Call a helper. Return to the caller. But AArch64 bl does not push a return address onto the stack. It writes the return address into the link register, x30. If bad_wrapper entered with its caller’s return address in x30, then bl helper overwrote it. The later ret no longer has the original link-register state.

A non-leaf wrapper usually has to preserve what it will need after the nested call:

good_wrapper:
 stp x29, x30, [sp, #-16]!
 mov x29, sp
 bl helper
 ldp x29, x30, [sp], #16
 ret

That is the claim: ARM64 is not x64 with a larger register file. The instruction set gives you registers. The ABI tells you which registers are part of the call packet, which ones are reserved, how the stack behaves, where the return address lives, and which platform rules apply.

AAPCS64 gives a clean first table. x0 through x7 are parameter/result registers. v0 through v7 carry floating-point and SIMD arguments. x30 is the link register. x29 is the frame pointer. x8 can be the indirect result location register.

That table is useful. It is not the whole ABI.

The sharp example is x18. Architecturally, it is a general-purpose register. ABI-wise, it has a passport problem. AAPCS64 defines it as platform-specific and warns portable hand-written assembly to avoid it. Windows ARM64 reserves x18 as a platform register. Code that casually uses it as scratch may work in one environment and violate the platform contract in another.

Stack rules have the same shape. Alignment, red zones, frame-pointer expectations, and unwind metadata are platform ABI properties, not facts you get from the words “ARM64.” ARM64EC makes the point even harder: it runs on ARM64 hardware, but follows x64-oriented software conventions for mixed ARM64/x64 interoperability on Windows.

The boundary is evidence. A register-file fact is not automatically an ABI fact. A base ABI fact is not automatically a platform fact. A platform ABI fact is not universal hardware behavior.

Ask which ARM64 ABI you are in before deciding what a register means.

Read the full essay on lospino.so: ARM64 Is Not Just x64 With More Registers

Original essay published on lospino.so on 2026-06-05. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

Not because the table is wrong. Because it looks finished.

Once a capture becomes rows and fields, the reader starts granting it more authority than it earned. A byte gets a label. A timing gap gets a name. A recurring identifier starts to feel like an identity. A dashboard cell starts to sound like application truth.

That is the failure mode this series is about.

Reading machine buses is not mainly about memorizing protocol trivia. It is about refusing to let an artifact carry a stronger claim than the observation supports.

The move is simple:

Observed artifact. Framing rule. Authority source. Observer boundary. Supported claim. Unsupported stronger claim.

That ladder is easy to say and hard to practice, because the artifact keeps trying to flatten it.

A passive trace can show that something appeared on a wire. It does not automatically show who meant it, what the system believed, what the operator saw, or what the application layer decided. A decoded field can show that a rule was applied. It does not make that rule ground truth. A recurring identifier can support recurrence. It does not, by itself, prove sender identity. A field map can add authority. It can also hide provenance if the reader stops asking where the names came from. A timing gap can be part of the evidence. It can also tempt the reader into treating silence as intent. A role-rich transaction can feel semantically complete. It still remains inside the authority that named the roles.

This matters outside buses. The same error appears in logs, traces, packet captures, diagnostic tables, reverse-engineered formats, observability dashboards, incident timelines, and vendor tools. Clean artifacts create clean stories. Clean stories are where evidence quietly gets promoted.

The point is not to distrust every decoder or table. The point is to read them with a boundary. What did we actually observe? What rule turned the observation into this representation? Who or what gave that rule authority? Where was the observer standing? What claim is supported? What stronger claim is being smuggled in because the artifact looks official?

The examples here are synthetic, passive, and offline. They do not involve live-bus access, replay, injection, scanning, polling, write paths, or control workflows. That boundary is not a side note. It is part of the argument: even safe, static artifacts can still exceed their evidentiary authority if the reader stops separating observation from interpretation.

The canonical series collects the mechanism, examples, and reader discipline in one place.

Read it if your work puts you near machines, captures, logs, decoders, diagnostic output, or any table that looks more certain than it has earned.

The room at the center of this essay is not a clean design object. It has music, tools, books, notes, screens, small machines, and a few artifacts attached to questions not yet fully formed. It is not minimalist. It is legible. That distinction matters because the room gives one kind of work its ideal conditions: unresolved possibility becoming form.

The claim is that building and running are close enough to confuse and different enough to punish the confusion. Building turns possibility into form. Running begins after the thing stands long enough for people to gather around it. At that point the work changes species. It stops being primarily authorship and becomes constituency.

That shift is visible in boring artifacts: a public sentence, a redline, a signature block, a governance clause, a calendar obligation, an allocation rule before school. These are not the pleasures of ignition. They are the containers a real thing starts needing once other people can depend on it, misunderstand it, be disappointed by it, or pay for its ambiguity.

The pressure point is that the builder’s attractive self has a shadow. The ability to clarify, structure, and solve can become control when it crosses into another person’s tempo. A household dispute is not a product surface. A successor is not a compiler. A company, a book, or a family system does not become less real because it starts requiring patience after the interesting part has cooled.

The counterclaim deserves respect. Stewardship is not merely the dull residue of creation. Sometimes it is the more mature art. It asks for care after novelty, repetition without discovery, and protection from the builder’s own velocity. It asks the maker to keep faith with the thing after it becomes someone else’s job, risk, identity, or ordinary day.

The boundary is not that building is bad and maintenance is noble. The clean reversal would be another flattering story. Some work really is ignition. Some work really does need descent, intensity, and closed-door attention. The mistake is trying to make stewardship feel like building, or treating people as defective systems because they do not answer back like code.

Read the full essay on lospino.so: After the Thing Stands

Original essay published on lospino.so on 2026-05-31. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

The object in this essay is small: an AGENTS.md file open beside a red test runner and a planning note. Nothing about that scene is visually dramatic. It is just the new workshop made visible: repo instructions, failing tests, a collaborator that can read context, and a human trying to decide what should be changed before the machine starts changing it.

The claim is not that software craft has been abolished. That story is too clean. The more useful claim is narrower: AI has moved more of the burden from typing to deciding. Naming the boundary, writing the acceptance test, constraining the diff, and reviewing the change are not old rituals kept around for sentiment. They become more load-bearing when a vague instruction can turn into twenty files.

The pressure point is the planning file. A line like “keep the public interface stable” is not bureaucracy. It is a miniature institution for the repo. So is the test suite. So is the instruction not to touch unrelated changes. The assistant may be useful, fast, and sometimes startlingly good, but it can also satisfy the local prompt while betraying the architecture. The clean-looking diff is not the same as a correct change.

There is a product boundary too. Cheap prototypes can teach, but they can also flatter novelty. A personal itch can now acquire a README, tests, diagrams, and a plausible interface before the harder question has been asked: who else has this problem strongly enough that the solution will matter after novelty decays?

That is why selection becomes governance. The old workshop had scarcity built into it. Boilerplate was expensive. Documentation had to be read by a tired human. Bad ideas often died before they acquired structure. The new workshop is kinder to possibility and harsher on judgment.

The useful part is not that the machine is always right. It is not. The useful part is that it is often fast enough to expose where the human discipline actually lives: constraints, taste, tests, diff review, and the willingness to kill attractive work before it becomes sediment.

Read the full essay on lospino.so: The Workshop Has Changed

Original essay published on lospino.so on 2026-05-24. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

C++ is not a superset of C.

That warning is still accurate, but it is less useful when stated without a language mode. The 2019 version of this post surveyed C constructs that do not work in C++. The 2026 update does not retire that advice. It makes the border more precise.

The question is no longer only “does valid C compile as C++?” Often it is: C17, C23, C++17, C++20, or C++23?

Designated initialization is the clean example. C++20 added designated initializers, but not the whole C feature. C designators can target array elements, nested members, and fields out of declaration order. The C++20 form is narrower: direct non-static data members, declaration order, and all-designated clauses. C-style array designators, nested designators, out-of-order designators, and mixed positional/designated clauses remain outside the portable C++ form.

The old empty-parameter-list trap moved too. In C17 and earlier, void f() did not mean the same thing C++ programmers normally expect. It did not provide a prototype saying “no parameters.” C23 changed that: void f() now behaves as though declared with void. So the compatibility answer depends on which C mode is in play.

The malloc row is still easy to misread. In C++, void* does not implicitly convert to an object pointer type. But the cast is not the interesting part. Lifetime is. C++20 repaired some implicit-lifetime cases around allocation, but allocation still does not call constructors, initialize values, or make non-implicit-lifetime types safe to use without construction.

Other checkpoint rows remain: discarding const, enum behavior including C23 changes, restrict, and flexible array members. Each row is less a trivia question than a reminder that source compatibility, ABI boundaries, object lifetime, and compiler mode are different obligations.

The practical rule is simple: when discussing C/C++ compatibility, label the language mode before drawing the conclusion. “Valid C” and “valid C++” are not precise enough anymore.

Read the full essay on lospino.so: C Constructs That Still Don’t Work in C++ - and a Few That Changed

Original essay published on lospino.so on 2026-05-20. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

This Rust declaration is not just convenient syntax:

unsafe extern "C" {
 fn five_ints(a: i32, b: i32, c: i32, d: i32, e: i32) -> i32;
}

It is a boundary claim.

The declaration says there is a function somewhere else. It says Rust should lower the call using the target’s C ABI rather than Rust’s own internal calling convention. It says the source-level types in the declaration match the binary packet the other side will decode. The compiler can generate the packet. It cannot prove the declaration is true.

That is the claim of the essay: modern software has not escaped ABI problems. It has moved them to sharper composition points: Rust FFI, Python native extensions, WebAssembly components, eBPF helpers, plugin APIs, and compatibility modes.

A boring C-shaped plugin table shows why this keeps happening:

struct plugin_api {
 int (*open)(void *ctx, const char *path);
 int (*read)(void *ctx, void *buf, unsigned long len);
 void (*close)(void *ctx);
};

This is not elegant in the way high-level language APIs are elegant. That is part of the point. The receiver is explicit. The context pointer is explicit. The function signatures are fixed. C++ object layout, exceptions, hidden receivers, and runtime-specific ownership semantics do not leak directly into the public contract. The boundary still has many ways to fail - integer widths, alignment, lifetime, allocator ownership, callback table layout - but fewer of them are invisible.

The boundary matters because independently built pieces do not share intent. They share a packet. In Rust FFI, the packet is a native call. In CPython’s Stable ABI, it is a versioned symbol and structure contract. In WebAssembly components, it is canonical lowering through core Wasm values and linear memory. In eBPF, it is a verifier-understood register convention.

Do not overread the design rule. A C-shaped boundary is not automatically safe. A stable runtime ABI does not repeal the platform ABI beneath it. A high-level declaration does not prove a binary fact.

The safer rule is narrower: when two independently built systems meet, specify the packet the other side can actually decode.

Read the full essay on lospino.so: The ABI Is the Boundary

Original essay published on lospino.so on 2026-06-09. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

A seventeen-year-old at Fort Benning can find the chapel pew before he finds doctrine.

That distinction matters. The chapel in this Field Note is not a laboratory of pure belief. It is shelter from the system outside it. It is also shelter from a less noble kind of Sunday work. The choice to enter is not clean. It arrives under pressure, fatigue, discipline, and need.

Inside: worn public wood, hymnals, bulletins, boots under the pew. Singing. Crying. Hugging. Peanut-butter bread passed with a plastic MRE knife. The body receives comfort before the mind can endorse the claims attached to it.

That does not make the comfort false. It also does not make the claims true.

The essay resists the old no-atheists-in-foxholes shortcut. Fear is not proof. Need is not metaphysics. But explaining the mechanism does not explain away what happened. The relief was real. The refuge was real. The tenderness was real. The theological declarations remained unavailable. The room could hold the body without settling the truth claims the body wanted to borrow.

That is where the piece keeps its pressure. Requests are easier than claims: help me, hold me, let me endure this. Need has excellent evidence. But the room did not stop at need. It made declarations about authority, sacrifice, rescue, text, eternity, and the invisible structure of the world. Those sentences could not become true merely because the body wanted shelter.

Later, church returned as church rather than refuge from basic training. The claims returned as claims. They did not hold. But respected believers complicated the easy dismissal. Skepticism may be honesty. It may also be the most respectable available name for staying unclaimed.

The pew remains silent in both directions: mercy because it held the body, limit because it could not answer the claims.

Read the full essay on lospino.so: The Pew Does Not Argue Back

Canonical essay scheduled for lospino.so on 2026-07-19. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

A hand-written function, JIT stub, or trampoline can pass the easiest test: it returns to the caller with the right value.

That is not enough.

The claim in this essay is narrower and more useful: modern ABI correctness includes the failure path. A function frame has to be executable on the sunny path and explainable when an exception runtime, debugger, profiler, sanitizer, or crash reporter needs to reconstruct the caller. Returning correctly proves the epilogue worked. It does not prove the frame can be unwound.

The concrete artifact is unwind metadata. On Windows x64, a non-leaf function that allocates stack or calls another function is not fully described by its code bytes alone. The system also needs a function-table entry and unwind information: where the function starts and ends, how much stack it allocated, which nonvolatile registers were saved, and how to recover the caller’s state. On ELF-oriented toolchains, hand-written assembly often tells the same story through CFI directives:

.cfi_startproc
push rbp
.cfi_def_cfa_offset 16
.cfi_offset rbp, -16
mov rbp, rsp
.cfi_def_cfa_register rbp
call helper
pop rbp
.cfi_def_cfa rsp, 8
ret
.cfi_endproc

The exact encoding varies by platform. The mechanism does not: a live frame needs a machine-readable explanation.

The boundary is important. This is not a claim that every small leaf helper needs elaborate metadata, or that one Windows rule generalizes cleanly to every object format. Leaf-function shortcuts exist. Platform rules differ. The bug appears when the function evolves - adds a call, saves a nonvolatile register, allocates scratch space, or becomes a trampoline - and the frame description does not evolve with it.

That creates a boring failure mode, which is why it is common: the code works until observability enters the system.

That is the practical boundary: the call has to remain explainable to the machinery that arrives after the sunny path has already succeeded.

Read the full essay on lospino.so: It Works Until the Stack Walker Arrives

Original essay published on lospino.so on 2026-06-08. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

The evaluation ledger has three entries. First, evaluate the frozen procedure once on held-out simulated engines. That result can evaluate that procedure. Second, change a threshold after reading it. Third, evaluate the revision on the same engines. No row entered the optimizer, but the result helped produce the revision. For the revised procedure, the set is now development evidence, not clean test evidence.

Training, validation, and test are roles in an adaptive process. Training estimates the state of a candidate. Validation or inner resampling chooses among candidates and may set thresholds. Test evidence evaluates the chosen procedure after the candidate, threshold, metric, slices, and acceptance rule are frozen. A filename cannot enforce those roles. In Python terms, the variable name does not determine the dataset’s evidentiary role. The selection workflow does.

This is adaptive reuse: a later choice depends on an earlier evaluation. When many alternatives are compared through the same holdout, the winner can benefit from genuine signal and from favorable peculiarities of that holdout. The more decisions the holdout is allowed to influence, the more opportunity its accidents have to enter the selected procedure. The human-and-code loop can learn the test set even when the fitting code never trains on its rows. A better result on test_final_v2 can therefore support a weaker claim than a lower result on evidence that remained untouched.

The failure mode is ordinary, not scandalous. An evaluation reveals a weakness, and the analyst does the reasonable thing: revise the procedure. The problem begins when the revised score is presented as though the evidence never participated in that revision. A holdout can be ceremonially present and evidentially absent.

Make the boundary concrete. At cycle 100 of a simulated engine trajectory, six available sensor readings are used to predict whether the trajectory will reach its terminal cycle within the next 75 cycles. Completed endpoints may construct retrospective labels, but they may not enter the scoring features. Engines, not rows, are assigned to evaluation partitions. If a held-out result changes the feature list, threshold, subgroup policy, or candidate, those engines have become development evidence for the revision. Fresh untouched evaluation evidence is now required for a new confirmatory claim. Without it, the revised result must be reported as exploratory or as a narrower descriptive result.

At most, fresh held-out evidence can support predictive performance on new simulated engines from the represented simulation regime. It does not show readiness for operating aircraft, the causal effect of a maintenance intervention, or field validation or certification. The ledger should say what happened: reused test evidence became development evidence for the revision. Either obtain fresh evidence for confirmation or label the reused result as exploratory and narrow the claim.

Read the complete argument on lospino.so:
The Model Is the Evaluation Protocol

Original essay published on lospino.so on July 17, 2026.

printf is not just another function call.

Its signature stops describing the interesting part:

int printf(const char *fmt, ...);

The fixed prefix says there is a format string. The ellipsis says the rest of the typed parameter list is missing. The caller may pass an int, a double, a pointer, a promoted char, a promoted float, or a sequence selected by another layer. The callee does not receive named source-level parameters for those trailing values. It receives ABI state and a va_list mechanism that must recover them later.

That is the claim: varargs are not merely flexible syntax. They are a function-call protocol with missing type information.

A small artifact shows the problem:

int call_printf_double(double x) {
 return printf("x=%f\n", x);
}

On System V AMD64, the format string goes in rdi, the double is in xmm0, and the caller sets al to indicate vector-register usage for a call that may reach a variadic callee. That AL marker is not visible in the C signature, but the variadic machinery depends on it.

Windows x64 solves a related problem differently. For a vararg or unprototyped call, a floating-point value must be duplicated into the corresponding general-purpose register as well as the floating-point register. In the printf(”x=%f\n”, x) shape, the wrapper can move the floating-point value into the right XMM lane and also copy its bits into the matching integer register.

Same source value. Different transport rules.

The format string does not replace the ABI. It tells printf what to request. It does not place the unnamed double in an XMM register, duplicate it into a general-purpose register, set AL, create a register-save area, or put overflow arguments on the stack in the expected location.

The boundary is FFI. A foreign-function bridge can often model a fixed signature:

void log_f64(const char *label, double value);

A variadic function asks it to model a family of call shapes. Each unnamed suffix can change register usage, stack usage, and ABI-specific metadata. The conservative rule is boring because it is correct: avoid exposing variadic C APIs across language boundaries when fixed wrappers are practical.

Read the full essay on lospino.so: Varargs: The Function Call With Missing Type Information

Original essay published on lospino.so on 2026-06-04. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

The most important field in a function call is often the one the source code did not spell.

A programmer may write:

struct Big make_big(long long seed);

The ABI may need a different shape:

make_big(result_storage, seed)

That is the claim: the source-level function signature is not the full call packet. It tells the programmer what expression is legal. It does not necessarily tell the binary where the return storage lives, how the callee receives an object pointer, which runtime context arrives first, or whether a thunk has adjusted the receiver before control reaches the final implementation.

The cleanest artifact is a large structure return. In one fixture, the source function returns a record by value:

struct SretRecord make_sret_record(unsigned long long seed,
 unsigned long long tag);

At the ABI layer, several platforms turn that return value into an incoming storage channel. On Windows x64, the caller-allocated return storage can arrive as the first argument, shifting the visible values right. On System V AMD64, MEMORY-class returns use caller-provided storage in RDI as if it were the first argument. On AArch64, the indirect result location has a dedicated role in x8, so the visible seed and tag can remain in x0 and x1.

Same source shape. Different hidden-field placement.

The pattern does not stop with structure returns. A C++ member function needs a receiver even when the object sits outside the parentheses:

counter.add(5);

The callee still needs something like:

Counter_add(object, 5)

JNI makes the runtime version explicit: native methods receive JNIEnv * first, then either the object or class, then the ordinary Java parameters.

The boundary is important. Hidden arguments are not hacks, and the source signature is not dishonest. It is faithful at its layer. The mistake is carrying that layer across a real ABI or FFI boundary and assuming the visible parameter list is the complete wire format.

The safer question is not only: what are the parameters?

It is: what are the ABI-visible fields?

Read the full essay on lospino.so: Hidden Arguments Are Everywhere

Original essay published on lospino.so on 2026-06-03. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

ABI rules are easier to remember when you watch the packet break.

Here is a deliberately malformed sketch:

; Windows-shaped setup, SysV-shaped callee
sub rsp, 40
mov dword ptr [rsp + 32], 5
mov ecx, 1
mov edx, 2
mov r8d, 3
mov r9d, 4
call five_ints

Every instruction is real. The call target can exist. The machine can execute the sequence. The packet is still wrong.

If the callee decodes the call under the System V AMD64 ABI, this is not a correct encoding of:

five_ints(1, 2, 3, 4, 5);

For this all-integer function, a SysV AMD64 callee expects edi = a, esi = b, edx = c, ecx = d, and r8d = e. The sketch above was built from a Windows x64 mental model: ecx, edx, r8d, r9d, then a stack slot after the home area. The callee is not obligated to share that belief.

The concrete technical artifact is the wrong-register-schema bug. It does not require undefined source code or an invalid instruction. It requires a caller and callee that disagree about how local state has been serialized. A tracer may record the wrong argument. A hook may forward the wrong field. An FFI bridge may appear to work for one call shape and fail when the destination ABI changes.

The claim is broader than register tables: ABI bugs are malformed local serialization. The source call can be plausible while the binary packet is wrong. Hidden result storage, hidden receivers, stack home areas, varargs recovery state, and platform-specific preservation rules are all fields in that packet.

The boundary matters. The bug zoo is not a standards document, and a compiler listing is not the law. The disciplined rule is: ABI document as authority, generated assembly as receipt. A receipt can show what one compiler emitted for one target and one source shape. It cannot prove every compiler emits that sequence, every malformed call crashes, or every symptom looks the same.

The useful habit is adversarial but restrained: source belief, ABI field, broken packet, narrow symptom claim, evidence boundary.

Read the full essay on lospino.so: The Bugs That Make ABI Rules Memorable

Original essay published on lospino.so on 2026-06-02. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

A register name is not a meaning.

Start with a deliberately boring function:

int five_ints(int a, int b, int c, int d, int e);

And a deliberately boring call:

five_ints(1, 2, 3, 4, 5);

Nothing about the source is clever. Every argument is visible. The return value is a plain int. There is no hidden structure return, no C++ receiver, no varargs, no virtual dispatch, and no interesting object model problem. That is why the example is useful. If the generated call differs across targets, the difference is the ABI packet.

The concrete artifact is the ecx trap:

; Windows x64
mov ecx, 1 ; a

; System V AMD64 mov ecx, 4 ; d

The same physical register carries different semantic fields under different ABIs. On Windows x64, integer arguments in the leftmost four positions use RCX, RDX, R8, and R9; the fifth argument goes on the stack after the caller-provided home area. On System V AMD64, the integer register sequence begins RDI, RSI, RDX, RCX, R8, R9. On AArch64 Linux, this all-integer call maps cleanly to w0 through w4.

The claim is small but important: a source-level call does not carry a universal register schema. The ABI gives locations meaning. Without that schema, rcx is just a register.

This is where reverse-engineering, tracing, hooking, and FFI code go wrong. A tool that labels rcx as “argument 1” has already made a platform claim. That claim is correct in one context and wrong in another. The machine may still execute the instruction stream. The failure is not necessarily an illegal instruction or an immediate crash. It may be a valid instruction stream in the wrong language.

The boundary is also important. A compiler listing is a receipt, not the authority. Optimizers can inline, fold, tail-call, spill, or reshape a wrapper while still respecting the ABI at the real boundary. The ABI document defines the contract; the assembly gives you a microscope for one controlled source shape.

Read the full essay on lospino.so: Same Function, Three Realities

Original essay published on lospino.so on 2026-06-01. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

A wrapped Christmas present turned up six months late, behind storage bins on the lanai.

Not lost in any dramatic sense. Not damaged. Just stored behind other stored things, where a household puts decisions it has not made room to finish. The paper had relaxed at the corners. The tape no longer looked decisive. The label, once meant to identify a recipient, eventually ended up turned down against the table.

That is the pressure point in this week’s Field Note: provision can look like care before attention completes the circuit.

The gift was not proof that care was absent. It had been bought, wrapped, labeled, and set aside with an intention attached to it. Those actions matter. Scarcity is not holy. Provision is not nothing. Austerity can become its own performance.

But care that stops at provision asks the object to carry too much. It asks wrapping paper, memory, timing, and storage to do the work that contact requires. The tape can hold paper around a box. It cannot hold a relationship in place.

The essay keeps the present literal. A father receives a gift meant for a son and cannot immediately remember what is inside. A bookshelf appetite sits nearby as a real preference, but not a guarantee. The son matters as a person with agency, not as evidence that a prepared environment worked or failed. A gift is not completed by the giver’s intention alone. It has to enter a life that can receive, refuse, ignore, use, or outgrow it.

Storage is part of the problem because storage can make postponement tidy. Behind bins, unfinished attention becomes stackable. The right moment begins as patience and can become a trap: a way to preserve the fantasy of perfect delivery while avoiding the imperfect act of actually offering the thing.

So the final action is small. The present is carried out, set on the table, loose tape pressed back into place, label turned to the wood, and left there.

Read the full essay on lospino.so: The Presents Still Wrapped

Canonical essay scheduled for lospino.so on 2026-07-12. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.

Subscribe now

The artifact was small: a hand-counted stroke trace from a race video.

After the King Kamehameha Day Regatta, I marked catches one by one until the rhythm I remembered in the canoe became a column of times. On the screen, those times became a strip of telemetry. Most of it wandered inside ordinary noise. Then the trace stepped sideways. The body remembered continuity. The plot had drawn a border.

That is the pressure point in this Field Note. A few marked timestamps began asking for a model before they had earned authority.

There were ordinary explanations. I could have marked a catch badly. The video could have jumped. The canoe could have hit different water. A change could have consumed time before the next ordinary stroke. The apparent rate could have fallen because the accounting window included dwell that was not really paddling.

The plot did not resolve those possibilities. It only made the eye want structure.

The claim is that a model may deserve existence before it deserves authority. Modeling can be a disciplined way to organize ignorance. It can expose assumptions, sharpen questions, and make a hidden data-generating process visible enough to argue with. But the fact that a model wants to exist is not evidence that anyone should believe it.

The boundary changes once the model acquires a surface. A private line on a screen can remain a provocation. Put the same line on a dashboard and it begins to look like an answer. Give it a threshold and it becomes a judgment. Place it in a recurring review and people begin to change their behavior around it.

The instrument begins as a witness. Then it gets a vote.

That transition is not only a measurement problem. It is a governance problem. What is the model allowed to govern? What remains outside its field? What changed in the system because the observer, instrument, or baseline entered the loop?

The canoe trace is a small object, but the pattern is larger. A cleaner estimate can be prettier and less honest. A better instrument can leave a scar in the time series. The observer can become one of the inputs.

The model may begin as appetite. It cannot use appetite as its final warrant.

Read the full essay on lospino.so: The Model Wants to Exist

Original essay published on lospino.so on 2026-06-21.

A function signature tells you what a source-level call is allowed to look like. It does not tell you the whole binary protocol the caller and callee must speak.

Consider this ordinary-looking declaration:

struct Big make_big(long long seed);

At the source level, there is one visible argument and one return value. At the ABI boundary, that can become a different packet. If struct Big is not returned in registers, the caller may allocate result storage and pass a pointer to that storage into the callee. That pointer is not written in the source signature, but it is part of the call.

The concrete artifact is the hidden result-storage path. For a deliberately large return object, common 64-bit ABIs do not all encode the same source call the same way. On Windows x64, the result pointer is passed in RCX, and the visible seed shifts to RDX. On System V AMD64, the result pointer is passed in RDI, and seed shifts to RSI. On AAPCS64, the indirect result location uses x8, while the visible argument can remain in x0.

That distinction matters for JIT stubs, FFI bridges, hooks, hand-written trampolines, profilers, and any code that constructs or interprets a call below the source language. A bridge that sends only the visible arguments may build a packet the callee cannot decode. On Windows x64 or System V AMD64, the first visible value can land where the callee expects a writable result address. On AAPCS64, the visible arguments may look correct while x8 is stale or unset.

The boundary is narrow. This does not mean every source-level call literally performs a platform ABI ceremony at runtime. The compiler can inline, fold, specialize, or erase calls when both sides are under its control. The ABI matters when independently compiled code must meet.

The safer claim is this: the function signature is a programmer-facing projection. The ABI call is the machine-facing protocol.

Read the full essay on lospino.so: The Function Signature Is a Lie

Original essay published on lospino.so on 2026-05-29.

Abrade started from a small useful premise: generate patterned URLs, probe them, and record the candidates that appear to exist.

That premise is still useful. It is also too small if the crawler treats every kind of “success” as the same claim.

The 2026 refresh of Abrade, a C++23 command-line crawler, is mostly about separating those claims. The pressure point is simple: 2xx is transport evidence, not content truth. A server returning HTTP 200 may only prove that the request reached an HTTP application and received a successful response class. It does not prove that the response is the record being sought.

It can be an empty result, a placeholder, a login wall, a shell page, a default route, or a route that exists without containing the domain object.

That difference matters because “the request completed,” “the body contains evidence,” and “the run had operational problems” are not interchangeable. Abrade v0.3.0 makes that distinction explicit. It still generates candidate resource paths and performs concurrent HTTP requests. It still defaults to HEAD, and it can fetch bodies with GET. But the refreshed tool adds clearer boundaries around what is being measured: TLS with SNI for DNS host names, optional platform CA and DNS host verification with --verify, conservative redirects, dry-run generation, body-only output, body filters, and run summaries that account for filtered bodies, runtime errors, bytes written, and throughput.

One diagnostic sample in the canonical post exposed two common crawler mistakes. Without SNI, HTTPS failed before there was any meaningful application response. After SNI, many 200 responses still were not useful records. TLS success was one claim. Verified identity was another. Status-code success was another. Content evidence had to be checked separately.

The content-oriented pass is where the crawler stops pretending status success is enough. --contents writes body-only files. --require and --require-regex keep bodies containing required evidence. --reject and --reject-regex remove bodies containing absence, shell, or other non-record evidence.

Those strings are not universal predicates. They have to come from authorized knowledge of the application being tested. That is also the use boundary: authorized resource discovery, migration checks, and repeatable diagnostics against systems you own or are allowed to test.

Read the full essay on lospino.so:
Abrade After the Happy Path

Original essay published on lospino.so on 2026-07-09. This Substack dispatch is an adapted pointer to the canonical version, not a mirrored copy.