The IWTLP blog

• Simpson's paradox, and a detector for it in 20 lines, A trend can point one way in every subgroup and the opposite way once you pool the data. It nearly cost Berkeley a lawsuit. Here is the mechanism, a from-scratch detector, and why the detector is a smoke alarm and not a verdict.
• The bootstrap, confidence intervals without the formula, Statistics is full of formulas for confidence intervals, one per situation, each with assumptions you might be breaking. The bootstrap throws them all out and uses one idea instead, resample your data and watch. Here it is in a few lines of R.
• What WebAssembly actually is, and why it escaped the browser, WebAssembly started as a way to run fast code in the browser, but in 2026 it is running on servers, at the edge, and inside Kubernetes. The idea is a tiny, safe, portable stack machine. Here is what that means, and why it is suddenly everywhere.
• Rust's rewrite wave, why C is being replaced in the places that matter, Rust is now in the Linux kernel, in browsers, in databases, and in cloud infrastructure at Microsoft, Google, and Amazon. This is not hype, it is a deliberate migration with one motivation. Here is what is driving the rewrite, and what it is not.
• Virtual memory, the lie every program believes, Every program on your computer thinks it has the whole memory to itself, starting at address zero. That is a lie the operating system tells, and it is one of the most elegant tricks in computing. Here is how address translation actually works, in a few lines of C.
• Gradient descent, explained by rolling downhill, Every model you have heard of is trained by one algorithm, gradient descent. The idea is a ball rolling downhill to the lowest point, and it is about three lines of code. Here it is, from minimizing a parabola to fitting a line to data.
• They logged in, they didn't break in, how credential attacks really work, The biggest breaches of 2026 share a quiet pattern, the attackers didn't exploit a clever bug. They used a real login. Here is why credentials are the number-one way in, and the small set of defenses that actually close the door.
• Build your own shell, and learn how every program gets started, The terminal feels like deep magic, but a working shell is about 30 lines of C. Writing one teaches you the three system calls, fork, exec, and wait, that every operating system uses to run every program you have ever launched.
• Vectors are a data type now, and how nearest-neighbor search works, The 2026 shift is that you no longer need a separate vector database, Postgres, MongoDB, and the rest now treat vectors as a built-in type. Here is what "vector search" actually is, why brute force does not scale, and the idea behind the index that fixes it.
• Build your own bytecode VM, and see how languages really run, Python, Java, and C# do not run your source code directly, they compile it to bytecode and run that on a virtual machine. The VM sounds intimidating but its core is a loop over a stack. Here it is in about 30 lines, plus a tiny compiler to feed it.
• How AI agents talk to tools, and to each other, 2026 is the year agents went from demo to production, and the unglamorous reason is a protocol. Agents needed a standard way to plug into tools, the way USB-C standardized chargers. Here is what that protocol actually is, in plain JSON.
• How a map works, Mercator, tiles, and your GPS pin, Every slippy map you have ever dragged, Google Maps, OpenStreetMap, is built on two pieces of math, flattening a globe and chopping it into tiles. Both fit in a few lines of Python, and once you have them you will know exactly where your blue dot comes from.
• What durable execution is, and why it is moving into Postgres, Microsoft just open-sourced pg_durable, which runs durable workflows inside PostgreSQL. The phrase "durable execution" sounds like jargon, but the idea is one every backend eventually reinvents. Here it is, with a tiny checkpoint-and-replay engine you can read.
• Race conditions, explained by causing one, A race condition is the bug that passes every test and then corrupts data in production once a month. The fastest way to understand it is to write one on purpose, watch a counter lose count, and then fix it three ways.
• Why AI is getting smaller, not just bigger, The headlines chase ever-larger frontier models, but the quieter June 2026 trend is the opposite, tiny models that run on your laptop's CPU. Here is why small language models work, what quantization actually does, and the trade-off you are making.
• A Hopfield network from scratch, and why the textbook rule fails, Hand a Hopfield network a corrupted memory and it heals it back to perfect. The famous Hebbian rule is one line, but when I stored five real letters it recalled garbage. Here is the failure, why it happens, and the one-line fix.
• Anatomy of an npm supply-chain attack, and the OIDC trust that broke, In June 2026 attackers pushed malicious versions of 32 popular npm packages without stealing a single password. They stole a trust relationship instead. Here is exactly how the CI/CD pipeline was turned into a publishing key, step by step.
• Build your own JSON parser, and meet recursive descent, JSON looks too simple to have a parser, and that is exactly why it is the perfect first one to write. In about 60 lines of Python you will turn text into data structures using recursive descent, the same technique behind real language parsers.
• Defending your dependencies, and verifying a package hash yourself, After the June 2026 npm attack, "audit your dependencies" advice was everywhere. Most of it is vague. Here is the concrete version, including a ten-line Python script that verifies a package's integrity hash the same way your lockfile does.
• The borrow checker, explained by fighting it, Rust's borrow checker is the thing everyone bounces off first. But its rules come from one idea, and the errors it throws are teaching you a real bug that other languages would have let ship. Here it is, by deliberately writing the code that makes it complain.
• The three joins, explained by implementing them, Every database join you have ever run was one of three algorithms underneath: nested-loop, hash, or sort-merge. They are short enough to write in Python, and once you have written them you will know exactly why the query planner picks one over another.
• What an AI coding agent actually does, the loop behind the hype, Claude Code went from zero to the most-used AI coding tool in eight months. Underneath the demos is a loop simple enough to write on a napkin: act, observe, decide, repeat. Here is the actual loop, and why it, not the model, is what makes an agent.
• What attention really is, explained by coding it, Every model in the headlines, GPT, Gemini, Claude, is a transformer, and the heart of a transformer is one operation: attention. It is simpler than the diagrams suggest. Here it is in about fifteen lines of numpy, built up from the one idea.
• Why uv is so fast, and what a dependency resolver actually does, uv is one of the fastest-growing tools in Python, 80x faster than pip on a warm cache. The speed is real, but the interesting part is the problem it solves: dependency resolution is a search problem, and most people have no idea their installer is solving one.
• AI, ML, DL, GenAI, LLMs, RAG, and Agentic AI, explained, These terms get used interchangeably, but they are not the same. Here is the hierarchy, from the big umbrella of AI down to agentic systems, what each one means, and how they fit together.
• Quantum computing basics in Python, without the hype, Strip away the hype and quantum computing is linear algebra you can simulate in Python. Here are qubits, gates, superposition, measurement, and why it matters, with code.
• What Monte Carlo simulation is, across finance, physics, and engineering, Monte Carlo is one simple idea, use random sampling to answer hard questions, that shows up everywhere from option pricing to particle physics. Here is the idea, with code.
• Fortran is still alive in aerospace and HPC. Here is why., Fortran is often called dead, yet it still runs weather models, CFD solvers, and supercomputers. Here is why a language from 1957 refuses to retire, and why it is worth learning.
• Learn chemistry with Python, from stoichiometry to molecular simulation, Chemistry and code fit together better than most people expect. With Python you can balance reactions, compute pH, model equilibrium, and even run a small molecular simulation.
• Build your own Redis from scratch, and talk to it with the real redis-cli, I rebuilt Redis's core in about 80 lines of Python, the RESP protocol, GET and SET, expiry, INCR, and a real TCP server. The actual redis-cli connects to it and it just works. Here is the whole thing, plus how Redis survives a restart.
• PID control explained with a line-following robot, PID is the control algorithm behind thermostats, drones, and self-driving cars, and a line-following robot is the perfect way to understand it. Here is each term, intuitively, with code.
• The rocket equation explained by coding it, The Tsiolkovsky rocket equation explains why spaceflight is hard and why rockets have stages. It is one line of physics, and coding it makes the tyranny of the equation obvious.
• Build your own git from scratch, and watch its hashes match the real thing, I rebuilt git's core in about 150 lines of Python, blobs, trees, commits, branches, log, and diff. Then I checked it against real git and the hashes matched byte for byte. Here is the whole model, the proof it is really git, and how merge works on top of it.
• SQL injection explained safely with a toy login, SQL injection is the classic web vulnerability, and the safest way to understand it is to break a toy login you built yourself, then fix it the right way with parameterized queries.
• What embeddings are, explained by building one, Embeddings power search, recommendations, and modern AI, but the idea is simple: turn things into vectors so that similar things sit close together. Here is how, with code.
• Data science portfolio projects that are not toy notebooks, A Titanic notebook will not get you hired. Here is what a real data science project shows, handling messy data, avoiding leakage, honest validation, and a clear story.
• Orbital mechanics with Python, from circular orbits to Hohmann transfers, Orbital mechanics is more approachable than it looks. With a little Python you can compute orbital velocity, periods, and the classic Hohmann transfer between orbits.
• Cybersecurity with Python, what beginners should actually build, Forget memorizing tools. The way to learn security is to build the primitives yourself, encoding, hashing, HMAC, a log parser, and a tamper check, so you understand how attacks and defenses work.
• The Python projects that actually teach you to code, Most "beginner project" lists are filler. Here are the projects that build real foundations, control flow, collections, files, JSON, and objects, in an order that compounds.
• Backpropagation explained by coding it, Backprop sounds intimidating but it is just the chain rule applied backward through a computation. Build it once by hand and neural network training stops being magic.
• Learn robotics programming by simulating a robot first, You do not need to buy hardware to learn robotics. Simulate a robot and you can build pose, odometry, sensors, control, and path planning, the parts that actually transfer.
• "IWTLP is live: learn to code by building, graded for real", Most learn-to-code sites check your output against a hidden string, so you can pass without understanding. IWTLP runs your actual code on a real runtime and grades behavior, across 4,800+ build-from-scratch exercises in 19 disciplines. It is live on Product Hunt today.
• Machine learning from scratch, what to build before using scikit-learn, scikit-learn makes models one line of code, which is exactly why beginners stay confused. Build these few things by hand first and the whole field stops being a black box.
• SQL for data analysis, the 10 query patterns that matter, Most analytical SQL is a handful of repeating patterns. Master joins, group by, window functions, CTEs, cohorts, funnels, and retention, and you can answer almost any data question.
• Pandas vs SQL, when to use each, Pandas and SQL overlap a lot, so which should an analyst reach for? A practical comparison of where each one wins, with the same operations side by side.
• Why project-based learning beats watching tutorials, Tutorial videos feel productive but rarely make you able to code. Here is why building beats watching, what "tutorial hell" really is, and how to escape it.
• Encoding vs encryption vs hashing, explained simply, Three things beginners constantly mix up. Encoding is for format, encryption is for secrecy, hashing is for integrity. Here is the difference, when to use each, and the mistakes to avoid.
• How to learn Python in 2026 when AI can write code, AI can generate Python in seconds, so why learn it? Because you still have to read it, debug it, and know when it is wrong. Here is what actually matters to learn now, and what you can lean on AI for.
• The coding interview patterns, explained by building them, Most coding interview questions are variations on a small set of patterns. Here are the ones that matter, two pointers, sliding window, fast and slow pointers, binary search, heaps, backtracking, and dynamic programming, with the tell that signals each.
• How to actually learn data structures and algorithms, A practical, three-phase plan for learning DSA that sticks: build each structure from scratch, learn the patterns, and practice with instant feedback, instead of grinding random problems.
• Learn CUDA and GPU programming without owning a GPU, You do not need an NVIDIA card to understand GPU programming. Learn the CUDA model, threads, blocks, memory hierarchy, and parallel patterns by building them, all in your browser.
• Learn quantitative finance with Python from scratch, A grounded path into quant finance with Python, returns and risk, portfolios, options and the Greeks, Monte Carlo, and backtesting, learned by building each model yourself instead of importing a black box.