11 series · 77 posts
Series
Some things do not fit in one piece. These are the runs: each part stands on its own, and they are stronger read in order.
Biomechanics from Video
8 parts
The measurement programme behind Athlete Intelligence: what "accurate" means for a joint angle, why 2D beat 3D on the angles that matter, how a camera can be taught to grade its own footage, and what the system refuses to measure. Every figure is one I measured, including the ones that came out badly.
- 01What "Accurate" Means For a Joint Angle
- 02From Pixels to a Knee Angle
- 03Why 2D Beat 3D on the Angles That Matter
- 04Facing, Sign, and the Error That Mirrors Everything
- 05Teaching a Camera to Grade Its Own Footage
- 06Triangulation, and How Many Cameras You Actually Need
- 07What the System Refuses to Measure
- 08Kinetix: An Agent Harness Inside a Clinical System
Agent Harness
4 parts
The layer between a language model and software that already exists: what to expose, how to keep it safe, and how to store an agent so it can be changed without a deploy.
Vision in the Real World
3 parts
Pose estimation and image models pointed at problems that pay: a bowling action, a clinical record, a diseased field seen from a drone.
Machine Learning for Biology
6 parts
From what a peptide is, through the descriptor zoo and protein language models, to screening four hundred thousand natural products and docking the survivors.
- 01Peptides 101: The Tiny Molecular Sentences Your Body Writes
- 02Turning a Peptide Into Numbers: A Tour of the Descriptor Zoo
- 03What ESM-2 Learned That Letter-Counting Couldn't
- 04Your Negatives Decide Your Accuracy: 92% That Means Nothing
- 05From 400,000 Natural Products to 20 Candidates
- 06Molecular Docking Without the Jargon: A Key, a Lock, and Both of Them Wobble
LLM and Agent Security
6 parts
Security for systems built on language models, where the oldest bug wears a new face: the model treats every piece of text as an instruction, so untrusted input is untrusted code. Prompt injection, direct and indirect, the blast radius of a tool-calling agent, masking PII and secrets before they reach the model, exfiltration through the model own output, and the harness that keeps an agent inside the authority of the person who asked. Every attack paired with the practice that contains it.
- 01Why AI Security Is a New Problem: The Model Has No Data Channel
- 02Prompt Injection: Direct, Indirect, and Why Filtering Fails
- 03The Agent's Blast Radius: Giving a Confused Deputy Hands
- 04Sensitive Data: Masking PII and Keeping Secrets Out of the Model
- 05Exfiltration Through the Model's Mouth: Output Is an Attack Surface
- 06LLM Security in Practice: A Checklist and the Mindset Behind It
Mixture of Experts
2 parts
How sparse expert models route a token, and what to do about the one expert that holds everyone else up.
Retrieval and RAG
2 parts
Which retrieval numbers actually matter, and a reproducible way to find out which stack to build on.
Security From the Ground Up
7 parts
How systems get broken, and how they get defended, from first principles. Every vulnerability is one confusion: code mistaking data for instructions, or trusting input it should have checked. SQL injection, cross-site scripting, cross-site request forgery, broken access control, memory corruption, and what actually stops each one. Written to make you a developer who does not ship the bug, not a headline.
- 01What Security Actually Is: Trust Boundaries and the Two Master Bugs
- 02SQL Injection: When Your Query Is Written by the Attacker
- 03Cross-Site Scripting: Running Your Code in Someone Else's Browser
- 04Cross-Site Request Forgery: Making the Victim's Browser Do It
- 05Broken Access Control: Logged In Is Not the Same as Allowed
- 06Binary Exploitation: When Data Overwrites Code's Own Bookkeeping
- 07Network Security: Who Are You Actually Talking To?
AI Foundations
10 parts
A run through the classical ground: linear algebra, search, adversarial search, constraint satisfaction, logic, and planning. Written for someone starting from nothing.
- 01Math for AI Made Simple: The Linear-Algebra Lego Set Behind Every Model
- 02Machine Learning 101: PyTorch, TensorFlow & Decision Trees
- 03Intelligent Agents & Search: A Baby-Steps Tour from ‘What is Rational?’ to ‘How do we find the goal?’
- 04Beyond Classical Search: Hill-Climbers, Hidden Worlds & Agents That Learn on the Fly
- 05Adversarial Search 101: From Minimax to AlphaZero, How AI Plans When an Opponent Fights Back
- 06Constraint Satisfaction 101: From Sudoku Logic to Map-Coloring Zen
- 07Logical Agents 101: Slaying the Wumpus with Pure Reason
- 08First-Order Logic Made Friendly: From ‘Socrates Is Mortal’ to Automatic Proofs
- 09Classical Planning 101: From STRIPS Blocks to Graphplan Magic
- 10Brains Behind the Bots: Classical Planning from Ground Up
Building Backends
8 parts
The plumbing that turns a prototype into a service, written between 2019 and 2023: the handful of design patterns you actually use, choosing between Django and FastAPI, what a database transaction really guarantees, when to reach past SQL and when not to, REST APIs that age well, the real-time spectrum from polling to WebSocket to WebRTC, gRPC between services, and the small tricks that keep a backend boring. Problems, solutions, and the reason behind each.
- 01Design Patterns You Actually Use, and the Ones You Should Not Reach For
- 02Django or FastAPI: How the Framework Shapes the Code You Write
- 03Databases and ACID: What a Transaction Actually Promises
- 04SQL or NoSQL: Just Use Postgres, and the Cases Where You Should Not
- 05Designing a REST API That Ages Well
- 06Real-Time: Polling, WebSocket, WebRTC, and What Is on the Wire
- 07gRPC: How Services Talk When the Client Is Another Server
- 08Backend Best Practices: The Tricks That Keep a Service Boring
Problem Solving From Zero
21 parts
Twenty parts, written between 2016 and 2021, from counting the steps in a loop to implementing machine learning by hand. Greedy, graphs, dynamic programming, game theory, number theory, strings, segment trees, and what the memory hierarchy does to all of them. Every part assumes only the part before it.
- 01Counting the Steps: What Your Loop Actually Costs
- 02Big-O Without the Maths: Naming the Shape of a Curve
- 03Prefix Sums and Two Pointers: The Array Tricks You Will Use Forever
- 04Sorting: What to Know, What to Call, and What to Sort By
- 05Pointers and Linked Lists: Addresses, and the Data Structure Made of Them
- 06Binary Search, and Binary Search on the Answer
- 07Greedy: When Taking the Best Now Is Provably Right
- 08Recursion and Backtracking: Trusting a Function You Have Not Finished Writing
- 09Memoisation: Paying Once for an Answer
- 10Dynamic Programming Is a Table You Fill In
- 11The Knapsack Family, and When the State Is a Set
- 12Graphs: How to Store One, and Breadth-First Search
- 13Depth-First Search: Cycles, Components, and Topological Order
- 14Shortest Paths: Dijkstra, Bellman-Ford, Floyd-Warshall
- 15Disjoint Sets, and the Cheapest Way to Connect Everything
- 16Game Theory: Nim, Losing Positions, and the Grundy Number
- 17The Number Theory You Actually Need
- 18Strings: Hashing, KMP, and the Z-Function
- 19Fenwick Trees and Segment Trees: When Updates and Queries Interleave
- 20Machine Learning Algorithms by Hand
- 21Memory: Why the Array Wins Even When the Step Count Says Otherwise