SEARCH
Everything on the site
Search the whole site: follow a learning path, read an article, or try a tool.
Don’t know the term yet? Choose what you want to do →
109 pages to explore
RESULTS
Architecture in the real world 7 of 7 steps available. Boundaries, transactions and the organisational reasons behind both. Every node here came out of a system that was already running when I arrived. Learning path Distributed basics 2 of 6 steps available. What the network does to assumptions you did not know you had made, until it breaks them. Retries, ordering, and the honest version of exactly-once. Learning path Running a software factory 19 of 19 steps available. A pipeline of narrow agents carrying a change from a request to a deployed result, with a person on every decision that matters — mechanism before plumbing. Learning path Growing as a developer 9 of 10 steps available. The only path here that is not about a system. It runs from shipping work without supervision to being asked what the team should build next, and it ends where the hiring conversation starts. Learning path How a database keeps your data 7 of 7 steps available. How a database actually keeps your data, in the order that makes each step explain the next. Seven steps from a row on a page to a deadlock in production. Learning path Trees and traversal 3 of 5 steps available. Five steps from what a tree is to why databases put them on disk. Two of them are visualisers, so you build the shapes yourself before the prose explains them. Learning path Architecture & System Design Boundaries, transaction scope, queues, and the distributed-system failures that follow from all three — written from systems already running when I arrived. Topic hub Career & Craft What actually changes as you get more senior, how to disagree with an architect and still ship, and what a promotion case is really made of. Every page names the published source it was checked against, the same as everywhere else on this site. Topic hub Databases & Persistence Index structure, lock behaviour, MVCC, write-ahead logs, compaction. Every one of them is state that changes over time, which is what a diagram is for. Topic hub Software Factories & Harness Engineering What it takes to run a change through a pipeline of narrow agents and still be able to sign your name under the result, and the numbers behind the claims. Topic hub CS Foundations Trees, traversal and complexity, plus the networking, memory and concurrency ground beneath them — the material most people meet first, minus the ceremony. Topic hub B-Tree vs LSM-Tree Take the B-tree when reads must stay predictable and the LSM-tree when writes outrun where you can place them — one bill now, one bill later, your choice. COMPARISON Buffer overflows Learn why writing past the end of a buffer is rarely the real bug, what sits in the memory it lands in, and why the class still tops the weakness lists. DEEP DIVE Congestion control Learn why TCP carries two separate limits on how much it may send, which one the network controls, and why confusing them sends you tuning the wrong thing. DEEP DIVE Database replication See why a replica is fed the log rather than the data, what the default setting quietly trades away, and how much you actually lose when a primary dies. DEEP DIVE Dead letter queues See the four things that actually send a message to a dead letter queue, why only one of them is your code failing, and how the cycle protection works. DEEP DIVE Exponential backoff See why retries hit hardest exactly when a system is already failing, why spacing them out is not enough on its own, and where the multiplication comes from. DEEP DIVE Red-black trees Learn what the colouring rules actually buy, why you almost never write one yourself, and the contract that quietly breaks a sorted map from the inside. DEEP DIVE Reviewing without starting a fight See how to leave review comments that get taken well, and which battles are worth blocking a merge over, rather than quietly letting them go. DEEP DIVE Writing it down before you build it See why most design docs go unread, and how to write one that gets real comments before the build starts, instead of complaints after it ships. DEEP DIVE Influencing a design you do not own See how to push back on a design you do not own without losing the argument or the relationship, by writing your case down first, in detail. DEEP DIVE Events, and what they promise Find out what an event actually guarantees once it leaves the service that raised it, and which of those promises the consumer has to absorb itself. DEEP DIVE What actually changes between mid and senior See what a step up in seniority really asks for, why it is not more code, and how to tell whether you are already doing it in your current job. DEEP DIVE Senior, staff, and the ladder above See what actually separates a senior engineer from a staff one, and whether that title is worth chasing before your day-to-day scope changes. COMPARISON Shipping without supervision See what actually earns you the right to ship without someone checking first, and how to keep that trust once nobody is looking over your shoulder. DEEP DIVE Making the case to the people who fund it See how to make technical debt make sense to the people who fund the work, by trading it for scope instead of arguing over code quality itself. DEEP DIVE Getting the title to match the work See what actually belongs in a promotion packet, and how to gather the evidence for it before the case has to be built entirely from memory. DEEP DIVE Estimates you can defend See where estimates actually go wrong and why the error compounds across tasks, so you can give a number you are able to stand behind later. DEEP DIVE Hand-offs through artifacts See why agents in a pipeline never call each other, what the orchestrator is actually for, and which system holds the state when a run dies halfway. DEEP DIVE Deterministic steps and AI steps See which parts of an automated run belong in a script, which genuinely need judgement, and why an instruction file can only ask where a hook can refuse. DEEP DIVE Ephemeral environments and seed data See why a git clone is not a runnable system, why every agent run needs a throwaway database of its own, and why the seed data must be synthetic. DEEP DIVE From vague request to ready ticket See why the arrow that sends a request back is the one that decides whether a factory works, what a context pack holds, and what must never be rewritten. DEEP DIVE Golden sets: testing the factory See why a change to shared agent instructions needs a regression gate, what belongs in the replay set, and why a per-attempt success rate flatters a pipeline. DEEP DIVE Incidents back into the backlog See how fingerprinting turns ten thousand production errors into one prioritised defect, and why the polling cursor and the release decide whether it works. DEEP DIVE Measuring a factory honestly See why a baseline collected before you start is the only thing that makes a target testable, and which of your metrics improve fastest by being gamed. DEEP DIVE Orchestrator, or just a pipeline? See why a first agent workflow runs fine on the build system you already have, and the specific signals that say a durable engine has earned its place. DEEP DIVE Prompt injection in a pipeline See why hidden instructions in a ticket or a log line are an architecture problem, how removing one capability per agent closes it, and what is left over. DEEP DIVE Scoped credentials and the kill switch See why a permission matrix belongs to the workflow, not the system, why the interesting cells are the empty ones, and why one off switch is not a kill switch. DEEP DIVE The builder, and its repair loop See why the agent that writes the code is the least interesting one in a factory, what its repair loop must be capped at, and what it may never touch. DEEP DIVE The harness See what the shared instruction files actually do, why they need a precedence order, and why the harness regresses far more often than the model does. DEEP DIVE The human merge gate See why a person approving every merge is a design property rather than a trust issue, how attention scales with risk, and how the gate really fails. DEEP DIVE The PR review agent See why the unit of review is not the commits an author pushed, what the build already owns, and why letting the reviewer push fixes costs you its independence. DEEP DIVE Verifying after the deploy See why a green build is not evidence a change works, how to wait for the deployed revision instead of the clock, and where post-deploy checks turn dangerous. DEEP DIVE What a merged change costs See why the price per token predicts almost nothing about an agent bill, what actually drives it, and which levers cut it — in order of how much they save. DEEP DIVE What a software factory is See why a pipeline of coding agents is two loops rather than a conveyor belt, what the return arrow does, and which published numbers do not transfer. DEEP DIVE When an agent stops and asks See what an agent must record when it blocks, who the question should go to, and why the resume path — not the question — is the half teams forget to build. DEEP DIVE Who owns the factory See which jobs a software factory quietly creates, why each one needs a named person rather than a team, and which unclaimed roles fail first in an incident. DEEP DIVE Architecture decision records Write down the cheapest documentation a team ever produces, in the one format still worth reading a year later when nobody remembers why a call was made. DEEP DIVE BFS vs DFS Pick the traversal that answers your question instead of the one you remember, and know which of the two can run out of stack on a deep graph. COMPARISON Binary search Learn why binary search finds an insertion point rather than a value, what that changes about duplicates, and why the fast search rarely decides the cost. DEEP DIVE Binary tree vs binary search tree Know which of the two you actually have, because the ordering rule is the only thing making a lookup cheap — and nothing in the type enforces it for you. COMPARISON Bounded contexts, concretely Learn where the same word is allowed to mean two different things across a codebase, and who has to arbitrate the day those two meanings collide badly. DEEP DIVE Change data capture See why reading the database's own log beats polling for changes, what a replication slot guarantees, and the way that same slot can take the server down. DEEP DIVE Clustered indexes See why a primary key decides where a row physically lives, why every other index carries a copy of it, and what a wide key costs across a whole schema. DEEP DIVE Data warehouse design Learn why a warehouse is modelled for the questions it has to answer rather than the transactions it records, and what that choice costs you at load time. DEEP DIVE Data warehouse vs database Learn which questions each of them is built to answer, so you stop asking a system tuned for one row at a time to summarise a whole year of them. COMPARISON deque in Python Know when a Python deque beats a list, why the middle stays O(n) while both ends stay O(1), and how maxlen silently discards the data you meant to keep. REFERENCE Distributed tracing See what one header has to carry for a request to stay one story across a dozen services, and why the identifiers are standardised but the meaning is not. DEEP DIVE Dynamic arrays See why appending to a growable array is cheap on average but occasionally copies everything, and why no serious library will tell you its growth factor. DEEP DIVE gRPC vs REST See what a binary contract between two services buys you and what it costs in reach, so the choice follows your callers rather than the fashion. COMPARISON Hash tables See what the constant-time promise of a hash table is actually conditional on, why the load factor is the dial behind it, and what oversizing one costs you. DEEP DIVE Key-value stores See why a flat key space pushes structure into your naming, why expiry belongs to the data rather than your code, and the command that blocks a server. DEEP DIVE Latency vs throughput Learn why a system can get busier and slower at the very same time, and work out which of the two numbers your users are really complaining about. COMPARISON Linked lists Learn why a linked list's famous O(1) insertion is only free once you already hold the node, and why an array wins most of the cases people reach for it. DEEP DIVE Load balancers, concretely See how round robin, least connections and a hash actually differ, and which of them stops working the moment a server keeps anything in its own memory. DEEP DIVE Long polling Learn how holding a request open turns polling into something that behaves like a push, and which of your timeouts will quietly break the day it does. DEEP DIVE LRU caches Learn what least-recently-used ordering actually promises, why the cache key is the whole argument list, and the two settings that turn a cache into a leak. DEEP DIVE Memory leaks Learn why the dangerous leak is not memory you cannot reach but memory you can, and why a garbage collector fixes one of those problems and not the other. DEEP DIVE Merge sort Learn why the merge is the easy half, why the sort your language ships looks for order that is already there, and what stability actually promises. DEEP DIVE MVCC without the jargon Understand why readers never block writers under MVCC, because every transaction is looking at its own snapshot instead of fighting over the same row. DEEP DIVE OLTP vs OLAP Tell the two workloads apart by what they are judged on, so you stop trying to make one schema serve a checkout and a year-end report at once. COMPARISON OSI vs TCP/IP Learn which of the two models describes something that actually runs on your machine, and which one is only useful for naming where a problem sits. COMPARISON Pages, heaps and tuples See what a database row physically is on disk, what happens when an update no longer fits its page, and why that single fact explains half of table bloat. DEEP DIVE Priority queues See why a priority queue is not a sorted list, why iterating one hands you a jumble, and what the heap underneath actually promises about the front of it. DEEP DIVE Process vs thread Understand what each of them actually owns, so you can tell which failures stay contained inside one and which take everything else down with them. COMPARISON Rate limiting See what the HTTP specification fixes about rate limiting, what it deliberately leaves to you, and why the counter you pick decides the burst you allow. DEEP DIVE Recursion, drawn Watch the call stack build and unwind as a real data structure instead of an abstraction, and recursion stops feeling clever and starts feeling obvious. DEEP DIVE SOA vs microservices See what genuinely changed between the two beyond service size, and which of the older ideas quietly came back once the services multiplied. COMPARISON Stack vs heap See why one allocation is a single register move and the other is a search, and why only one of the two can leak the memory you forgot to give back. COMPARISON The star schema See why the fact table stays narrow and the dimensions stay wide, and what happens to every query the day somebody normalises those dimensions away. DEEP DIVE Strangler-fig migration, from the inside Replace a running production system without stopping it, and see the routing and data-ownership decisions that actually determine whether it survives. DEEP DIVE TCP vs UDP Know when a dropped packet breaks your feature and when it costs nothing, so you stop reaching for TCP by reflex and paying for a round trip you never needed. COMPARISON The write-ahead log See why the log commits before the data file does, so a crash mid-write costs you a replay instead of a corrupted table and a very bad on-call night. DEEP DIVE The TLS handshake Learn what a handshake actually agrees before any data moves, why the order of the steps is the security, and what the fastest mode quietly gives up. DEEP DIVE Topological sort See how a build order falls out of counting prerequisites, and why whatever is left over at the end of the run is the most useful output you get. DEEP DIVE Transaction boundaries Find the single line in a codebase that decides what succeeds or fails together, and why it is usually drawn once, early, and never revisited after. DEEP DIVE Unit vs integration test This is not a purity argument about test pyramids. It is a question of which category of failure you would rather hear about first, and how loudly. COMPARISON Virtual memory Learn what the hardware does between the address in your code and the memory chip, and why a program can hand out more memory than the machine has. DEEP DIVE What a Kafka topic actually is See what a topic really is on disk, why order holds inside one partition and nowhere else, and what that single fact decides about your consumers. DEEP DIVE When a message broker is the wrong answer See three real systems that reached for a queue to patch a missing transaction boundary, and what broke later because a broker cannot supply one. DEEP DIVE B-tree splits, key by key Insert keys one at a time and watch a B-tree page fill, split and push its middle key up a level, until the shape that indexes rely on makes sense. VISUALISER Big-O without the ceremony Learn exactly what a Big-O claim is promising and what it is deliberately ignoring, so the notation becomes a tool again instead of interview folklore. DEEP DIVE Connection pooling Find out why two hundred open connections make a database slower than twenty do, and where the real ceiling sits before your pool size makes things worse. DEEP DIVE Hash collisions See chaining and open addressing handle the same collision differently, and find the load factor where one of those two strategies starts to hurt you. DEEP DIVE Why quicksort is fast in practice Learn why quicksort's real worst case almost never happens in practice, and why cache locality quietly does more work than the pivot strategy does. DEEP DIVE HashMap vs Hashtable Find out what actually separates the two beyond a capital letter, and why the older one is still in the language long after it stopped being advice. COMPARISON Mutex vs semaphore See why one of them has an owner and the other only counts, and which class of bug each choice quietly makes possible once the code gets busy. COMPARISON Stack vs queue See why the end you take from decides what the structure is good for, and which everyday jobs quietly need one of them rather than the other. COMPARISON AVL tree visualiser Insert values in sorted order and watch a plain search tree collapse into a list while an AVL tree beside it rotates and holds its height near log n. VISUALISER Algorithm and data structure visualisers Every interactive visualiser on this site in one place, each one showing the single thing about its structure that a still picture flattens away. VISUALISER Deadlocks, seen Watch two transactions grab the same two locks in opposite order, so the next deadlock in your logs reads as a diagram instead of an unreadable stack trace. DEEP DIVE Dijkstra visualiser Step through Dijkstra one relaxation at a time and see why it always takes the cheapest frontier node, and why one negative edge weight breaks the guarantee. VISUALISER Isolation levels, and what each one lets through Stop treating isolation levels as a safety dial and start treating them as a list of anomalies you have agreed to tolerate, so surprises stop being surprises. DEEP DIVE Sorting algorithm visualiser Step two sorting algorithms through the same array and watch their comparison counts diverge, so "n log n" stops being a phrase and becomes a number. VISUALISER Compiler vs interpreter Understand what moves when translation happens before the program runs instead of during it, and why your errors arrive at a different time as a result. COMPARISON Tree traversal orders Four traversal orders differ by one line of code — pick the right one on purpose and your sorted output, serialised tree, or shallow answer stops being luck. DEEP DIVE Why your index is not being used Find the exact row count where Postgres stops trusting your index, fix the statistics instead of forcing a plan, and stop guessing why the query slowed down. DEEP DIVE Idempotency keys and safe retries Give every retry a key, store its result in the same transaction as the effect, and stop worrying whether a lost response means the work happened twice. DEEP DIVE Binary search tree visualiser Insert values one at a time and watch insertion order decide the shape of a binary search tree, and that shape quietly decide every lookup's real cost. VISUALISER