Archive
1290 posts · Page 62 of 108. ← Blog
In C, a type is a promise about how many bytes a value occupies and how to interpret them. There's no hidden bignum, no automatic string, no safety rail — just fixed-width integers, floating-point, and the bit patterns underneath. Understanding C's types means understanding sizes, signedness, and the surprising rules of integer promotion, because in C the difference between `int` and `unsigned` can be the difference between correct and catastrophically wrong.
In C, a type is a promise about how many bytes a value occupies and how to interpret them — no hidden bignum, no safety rail, just fixed-width integers and the bits underneath. Understanding C's types means understanding sizes, signedness, and the surprising rules of integer promotion, where the difference between int and unsigned can be catastrophic.
The single most misunderstood thing about startup ownership is what happens to your slice when you raise money. Founders imagine they're "giving up 20%" and keeping a fixed 80% forever — but ownership isn't a slice carved from a fixed pie; it's a percentage of a share count that keeps growing. Every round issues new shares, and every new share makes everyone's existing percentage smaller. Understanding this — dilution, the cap table, and the option pool — is understanding what you actually own, and it's where founders most often get an unpleasant surprise.
The most misunderstood thing about startup ownership is what happens to your slice when you raise. Ownership isn't a slice of a fixed pie; it's a percentage of a share count that keeps growing. Every round issues new shares, and every new share makes everyone's percentage smaller. That's dilution — and it's where founders most often get an unpleasant surprise.
Financial ML lives under regulators, adversaries, and money-denominated errors — so you design backward from a business metric, not forward from a model.
What sets financial ML apart from general ML: strict regulatory scrutiny and mandatory explainability, high-stakes and immediately quantifiable errors, messy multi-source data, non-stationarity, and adversarial actors.
If your gateway will block a tool call, don't make the agent discover that by trying. Hand it a capabilities brief and stop paying for turns it can't complete.
If your gateway will block a tool call, don't make the agent find out by trying, because each blocked attempt is a wasted turn. A capabilities brief aligns what the model thinks it can do with what enforcement actually allows.
The reference capstone for the 26-part series — every canonical ADK term, defined concisely.
The capstone of the series: every core ADK concept defined in one place — agents and orchestration, tools, sessions/state/memory, context and callbacks, runtime and streaming, models, grounding, evaluation, protocols, and deployment.
Lesson 3 of Harness Engineering in Go — how a context deadline and `exec.CommandContext` reap a runaway snippet, why the two-shaped `Result` distinguishes a timeout from a failure, and the leak that makes a local subprocess a teaching tool, not a security boundary.
Lesson 3: run agent-written code behind a hard timeout with exec.CommandContext, distinguish OK from TimedOut, and face the leak — a subprocess is not a security boundary.
The most reliable way to establish causation is almost embarrassingly simple: flip a coin to decide who gets the treatment. Randomization is the one technique that defeats confounding completely — including confounders you never thought of — which is why the randomized controlled trial is the gold standard of causal evidence and why the A/B test is the most powerful tool an engineer has. This post explains why randomization works its magic, and the many ways real experiments still go wrong.
The most reliable way to establish causation is almost embarrassingly simple: randomize. Why randomization defeats all confounders at once (even unknown ones), why the A/B test is a genuine causal tool, and the many ways real experiments still go wrong (peeking, power, interference, broken randomization).
C is fifty years old and still runs the world — operating systems, databases, language runtimes, embedded devices, and the standard libraries under almost everything else. Learning C is learning how computers actually work: memory, pointers, and the thin layer between your code and the machine. This series builds C from the ground up, and it starts with what C is and what really happens when you compile it.
C is fifty years old and still runs the world — operating systems, databases, language runtimes, embedded devices. Learning C is learning how computers actually work: memory, pointers, and the thin layer between your code and the machine. This series builds C from the ground up, starting with what C is and what really happens when you compile it.
The lettered rounds — pre-seed, seed, Series A, B, C — sound like a fixed ladder every startup climbs, but they're really names for stages of risk and proof. Each round exists because a company has reduced a specific kind of uncertainty since the last one, and each is meant to fund reducing the next. Understanding what each stage is actually for — not just what it's called — tells you why a company raises when it does, how much, and what it needs to prove to raise the next.
The lettered rounds — pre-seed, seed, Series A, B, C — sound like a fixed ladder, but they're really names for stages of risk and proof. Each exists because a company has reduced a specific uncertainty since the last one. Understanding what each stage is for explains why a company raises when it does, how much, and what it must prove.
How the two Basel liquidity ratios are computed from raw positions, and why the hard part is a data pipeline, not a formula.
How the Liquidity Coverage Ratio and Net Stable Funding Ratio are computed: HQLA classification, outflow factors, and the reporting pipeline.
An autonomous agent injects its own plan-and-execute tools at runtime. If your gateway is fail-closed, you have to find and allowlist them — deliberately.
An autonomous harness injects its own tools at runtime, tools that don't exist at build time. Fail-closed governance is only complete when it turns that blind spot into a visible block, then allowlists the known-safe internals deliberately.
How ADK's config loader turns a declarative YAML file into a fully-built agent — and why treating an agent as data changes who gets to edit it.
Defining an agent declaratively in YAML and loading it via from_config — the loader reads, resolves, and validates the config into a built agent, so config-as-data works without writing code.