Archive
1290 posts · Page 61 of 108. ← Blog
Pointers are the heart of C, the feature that makes it powerful and the one that makes it dangerous. A pointer is just a variable that holds a memory address — but that simple idea is how C functions modify their callers, how arrays and strings work, how dynamic memory is managed, and how data structures are built. Everything hard and everything essential in C runs through pointers.
Pointers are the heart of C — the feature that makes it powerful and the one that makes it dangerous. A pointer is just a variable holding a memory address, but that simple idea is how C functions modify their callers, how arrays and strings work, how dynamic memory is managed, and how data structures are built. Everything essential runs through pointers.
The chicken-and-egg problem of early fundraising is valuation: pricing a company with no revenue and no track record is nearly impossible, and haggling over an arbitrary number wastes time both sides would rather spend building. SAFEs and convertible notes are the elegant workaround — instruments that let a company raise money now and postpone the valuation question until later, when there's more to go on. They're how most early-stage rounds actually happen, and understanding their two key knobs (the cap and the discount) is essential for any founder or early employee.
The chicken-and-egg problem of early fundraising is valuation: pricing a company with no revenue is nearly impossible. SAFEs and convertible notes are the elegant workaround — instruments that let a company raise now and postpone the valuation question until later. Understanding their two key knobs, the cap and the discount, is essential.
Large language models earn their place in regulated finance as fast, well-supervised assistants — not as autonomous agents with a hand on the money.
Where LLMs fit in regulated finance: document analysis/extraction, retrieval-grounded Q&A, and agentic decision support — plus the guardrails (grounding, human-in-the-loop, output validation, audit trails) that keep them…
Passing an SDK client through a checkpointed agent workflow crashed on circular references. The fix reshaped how I cross @step boundaries.
Threading an SDK client through a checkpointed workflow crashed with maximum recursion depth exceeded. The checkpoint boundary is a serialization boundary: JSON only, values and keys, and anything non-serializable gets injected out-of-band at the composition root.
Lesson 5 of Harness Engineering in Go — a triage step that first-matches a keyword and hands the request to a specialist, and the exact place a substring table stops being able to think.
Lesson 5: a triage router first-matches a keyword to hand intent to a specialist, and the exact point a substring table stops being able to think.
Often you can't run an experiment — it's unethical, infeasible, or too slow — but you still need to know whether something causes something. Observational causal inference is the set of techniques for extracting causal conclusions from data you didn't control, by reconstructing the comparable groups that randomization would have given you for free. This post covers the main tools (adjustment, matching, propensity scores) and the uncomfortable assumption they all depend on.
When you can't experiment, observational methods reconstruct the comparable groups randomization gives for free — adjustment, matching, propensity scores. All share one goal (remove confounders' influence) and one unprovable Achilles' heel: the 'no unmeasured confounding' assumption. How to use them honestly.
C's control flow is the ancestor of the syntax you already know — `if`, `while`, `for`, `switch`. Its functions look familiar too, but they hide a defining C fact: arguments are passed by value, always copied. Understanding pass-by-value, and the call stack that makes function calls work, is the bridge to the hardest and most important topic in C — pointers.
C's control flow is the ancestor of the syntax you already know, and its functions look familiar too — but they hide a defining C fact: arguments are passed by value, always copied. Understanding pass-by-value, and the call stack that makes function calls work, is the bridge to the hardest and most important topic in C: pointers.
Valuation feels like it should be a fact — what the company is "worth" — but for an early-stage startup with little revenue and an uncertain future, there is no objective number to discover. Valuation is a negotiated price, not a measurement, and understanding that changes how you think about it: it's the price at which you sell ownership, it directly determines how much you're diluted, and chasing the highest possible number can quietly work against you. This post demystifies where valuations come from and why the number matters less than founders think and differently than they expect.
Valuation feels like it should be a fact — what the company is 'worth' — but for an early-stage startup there's no objective number to discover. Valuation is a negotiated price, not a measurement: it's the price at which you sell ownership, it directly determines your dilution, and chasing the highest number can quietly work against you.
A technically excellent model is worthless until it changes a number someone cares about. Here is how to design backward from that number.
Why technically excellent models never ship: no clear business metric, organizational buy-in, validation and model-risk sign-off, monitoring, and the prototype-to-production chasm.
An agent that burns its turn budget without finishing is neither a success nor an error. Give it a distinct outcome and a typed event stream.
The scariest agent failure is the runaway loop that never finishes. Cap every run at max_turns and make EXHAUSTED a first-class outcome, neither a failure nor a silent success, with a typed event stream you can route on.
Lesson 4 of Harness Engineering in Go — three collaborating stores (a thread, a knowledge index, and a summarizer) behind interfaces, and an honest accounting of where each local stand-in leaks.
Lesson 4: memory is three stores, not one — an append-only thread, a keyword knowledge index, and a lossy first-and-last summarizer — and an honest account of where each local stand-in leaks against Azure.
Causal reasoning gets dramatically clearer when you draw it. A causal graph is a diagram of what causes what — nodes for variables, arrows for causal influence — and it turns fuzzy debates about confounding and adjustment into visual rules you can actually check. This post introduces causal graphs (DAGs) and the single most useful thing they do: tell you exactly which variables to control for, and which ones you must leave alone.
Causal reasoning gets clearer when you draw it. A causal graph (DAG) turns fuzzy debates about confounding and adjustment into visual rules: the three building blocks (chain/mediator, fork/confounder, collider) and why 'control for everything' is wrong — adjusting the wrong variable adds bias.