Archive
1046 posts · Page 9 of 88. ← Blog
Engineers are trained to believe that a good enough product wins on its own merits. It doesn't. The graveyard of technology is full of superior products that lost to inferior ones with a better go-to-market strategy — a clearer answer to who the customer is, why they'd buy, and how they'll ever hear about it. Building the thing is half the job; getting it to the people who need it is the other half, and it's the half engineers most often neglect.
Engineers are trained to believe a good enough product wins on its own merits. It doesn't. The graveyard of technology is full of superior products that lost to inferior ones with a better go-to-market strategy — a clearer answer to who the customer is, why they'd buy, and how they'll ever hear about it.
You write applications that run on top of an operating system every day, and mostly you can ignore it — until a performance mystery, a concurrency bug, or a resource limit forces you to understand what's underneath. The OS is doing two jobs for you constantly: managing the hardware's finite resources, and giving you clean abstractions over messy reality. Understanding those two jobs is understanding the machine your code actually runs on.
You write applications on top of an OS every day and mostly ignore it — until a performance mystery, concurrency bug, or resource limit forces you to understand it. The OS does two jobs: managing finite hardware, and abstracting messy reality. Understanding them is understanding the machine your code runs on.
A container feels like a lightweight virtual machine, but it isn't one — there's no guest OS, no hypervisor, no virtualization. A container is just a normal process that the Linux kernel has been told to isolate and constrain. Understanding that — namespaces for isolation, cgroups for limits, images for packaging — demystifies containers and everything Kubernetes builds on them.
A container feels like a lightweight virtual machine, but it isn't one — no guest OS, no hypervisor, no virtualization. A container is just a normal process the Linux kernel has been told to isolate (namespaces) and constrain (cgroups).
CI/CD is the assembly line of modern software — the automated path from a developer's commit to running production code. It's the practice that turned releases from rare, terrifying events into routine, boring ones, and "boring releases" is one of the highest compliments in software. It's also the first capability any platform provides.
CI/CD is the assembly line of modern software — the automated path from a developer's commit to running production code. It turned releases from rare, terrifying events into routine, boring ones, and 'boring releases' is one of the highest compliments in software.
Ownership is the idea that makes Rust Rust — the mechanism that delivers memory safety without a garbage collector. It's a set of three simple rules with deep consequences, and it's the one concept you must genuinely understand, because everything distinctive about the language flows from it. This is the heart of the series.
Ownership is the idea that makes Rust Rust — the mechanism that delivers memory safety without a garbage collector. Three simple rules with deep consequences, and the one concept you must genuinely understand, because everything distinctive flows from it.
Writing the same function three times for three types is the kind of duplication that rots a codebase. Generics let you write it once, over any type — and Rust's twist is that this abstraction costs nothing at runtime, because the compiler generates the specialized versions for you. Zero-cost abstraction starts here.
Writing the same function three times for three types is duplication that rots a codebase. Generics let you write it once over any type — and Rust's twist is that this abstraction costs nothing at runtime, because the compiler generates the specialized versions.
The power of code agents comes with a sharp edge: you are executing code written by an LLM, and an LLM can be wrong, or manipulated into writing something harmful. Running that code unsandboxed is one of the most dangerous things you can do in an application, so sandboxing isn't optional for code agents — it's the price of admission.
The power of code agents comes with a sharp edge: you are executing code written by an LLM, which can be wrong or manipulated. Running it unsandboxed is one of the most dangerous things you can do — so sandboxing is the price of admission.
In a model-driven agent, tools are everything the agent can actually do — the model supplies the reasoning, the tools supply the capability. Strands makes defining them almost trivial (decorate a Python function) and plugs into MCP's large ecosystem, so equipping an agent well becomes the developer's main lever.
In a model-driven agent, tools are everything the agent can do — the model supplies the reasoning, the tools supply the capability. Strands makes defining them trivial and plugs into MCP, so equipping an agent well is the developer's main lever.
Two more levers of control: how hard the model thinks, and how you bound what it spends. Both have measured sweet spots — and both have a trap that quietly wastes money. The sharpest is a cap that most people reach for first and that saves nothing at all: max_tokens.
Two levers of control: how hard the model thinks, and how you bound what it spends. Both have measured sweet spots — and both have a trap that quietly wastes money. The sharpest is a cap most people reach for first that saves nothing: max_tokens.
Answering questions over your own data is the most common LLM application, and LangChain gives you the whole pipeline as composable, swappable components — loaders, splitters, embeddings, vector stores, retrievers — behind standard interfaces. The retriever, in particular, is just another Runnable, so RAG becomes a chain like any other.
Answering questions over your own data is the most common LLM application, and LangChain gives you the whole pipeline as composable, swappable components — loaders, splitters, embeddings, vector stores, retrievers. The retriever is just another Runnable.
Dependency injection is the least flashy Pydantic AI feature and quietly one of the most important — it's what lets your agents reach real databases, API clients, and user context without hard-wiring them, and it's the single biggest reason Pydantic AI agents are so testable. Borrowed straight from how good backend frameworks work, applied to agents.
Dependency injection is the least flashy Pydantic AI feature and quietly one of the most important — it lets agents reach real databases and clients without hard-wiring them, and it's the single biggest reason Pydantic AI agents are so testable.
Compliance requires you to collect and keep a great deal of personal data; privacy law requires you to protect it, limit it, and sometimes delete it. Data privacy is the compliance domain that governs the data all the other controls depend on — and it turns "how you handle personal information" from a courtesy into a set of enforceable engineering obligations.
Compliance requires you to collect and keep a great deal of personal data; privacy law requires you to protect it, limit it, and sometimes delete it. Data privacy governs the data all the other controls depend on — turning data handling into enforceable engineering obligations.