SEARCH
Everything on the site
Find paths, articles and tools.
Don’t know the term yet? Choose what you want to do →
205 pages to explore
RESULTS
Architecture in the real world8 of 8 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 pathDesign for clarity9 of 9 steps available. A short route from finding an article to reading it comfortably, using clear hierarchy, spacing and familiar interaction patterns.Learning pathDistributed basics4 of 8 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 pathRunning a software factory28 of 28 steps available. Connect requests, AI-assisted coding, tests and review. Learn how to save progress, handle failures and decide which steps still need a person.Learning pathGrowing as a developer11 of 11 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 pathHow a database keeps your data7 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 pathTrees and traversal3 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 pathArchitecture & System DesignBoundaries, transaction scope, queues, and the distributed-system failures that follow from all three — written from systems already running when I arrived.Topic hubCareer & CraftPractical decisions for a developer's career: choosing work, learning useful skills, earning trust, searching for a role, and growing without making work your whole life. Concrete examples, honest boundaries, and named sources.Topic hubDatabases & PersistenceIndex 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 hubInterface designMake complex interfaces easier to scan, navigate and enjoy reading. Practical principles for hierarchy, spacing, language and humane interaction.Topic hubSoftware Factories & AI Coding WorkflowsHow to turn a request into a tested software change with AI agents, existing development tools and people who review the work and handle failures.Topic hubCS FoundationsTrees, traversal and complexity, plus the networking, memory and concurrency ground beneath them — the material most people meet first, minus the ceremony.Topic hubAVL tree visualiserLoad and share an insertion sequence. Compare a plain search tree with an AVL tree, inspect rotations and see how insertion order changes height.VISUALISERB-Tree vs LSM-TreeCompare B-tree and LSM-tree write, read and compaction costs through two visual models, then choose what to measure for your workload.COMPARISONLuhn algorithm: calculate and check a check digitRun the Luhn checksum by hand, see exactly which digits are doubled, and learn what a valid check digit can and cannot prove.DEEP DIVEAI decision models explained: choices and checksFollow a support request through rules, model classification and application checks. Learn what decision models such as Jev do, and what they do not prove.DEEP DIVEDeterministic finite automata: trace one state at a timeBuild a machine that checks whether a binary string ends in 01, follow its state changes, and see why an early match is not enough.DEEP DIVEEulerian path: use every edge exactly onceChoose and undo roads on a four-vertex map, distinguish edge coverage from visiting every vertex, and see how a stack builds an Eulerian path.DEEP DIVEEvent sourcing explained: rebuild state from eventsReplay a cart's events, load a snapshot and see a stale read model catch up. Compare event sourcing with CQRS and ordinary event delivery.DEEP DIVEEvents, and what they promiseFind 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 DIVEHamiltonian path: visit every vertex onceTry a route, undo a choice that leaves a vertex unreachable, and distinguish Hamiltonian paths from Eulerian paths and cheapest routes.DEEP DIVEMutex vs semaphoreCompare mutex and semaphore behaviour in Java and Python. Change who releases to inspect owner checks, repeated releases and permit counts.COMPARISONTransaction boundariesChoose which changes must commit together, keep remote calls outside local transactions, and test the failure gap with an interactive outbox example.DEEP DIVETransactional outbox: a crash and retry exampleStep through an outbox crash, compare direct publishing, and run a SQLite example showing why a saved message can still be delivered twice.DEEP DIVETwelve-Factor app configuration: what belongs in the environment?Keep one build while changing deployment settings. Try missing values and a preview pointing at production, then review secret delivery and rotation.DEEP DIVEBuzzwords are not understandingLearn a practical test for real technical understanding: turn jargon into mechanisms, examples, trade-offs, and failure cases without losing the truth.DEEP DIVEWhere software terms come from: seven origin stories checkedCheck the evidence behind bug, daemon, kernel, cache, compiler, algorithm and software engineering, including which familiar stories remain contested.DEEP DIVECode Review in the Age of AI-Generated PRsA read order and copy-paste checklist for reviewing an AI-authored pull request, plus the sourced figures that motivate each step and where each one comes from.DEEP DIVEDoes AI Actually Slow Down Junior Developer Learning?One study found a 4.15-point quiz gap after AI-assisted coding. See what it measured, what it did not, and how to use AI without delegating the learning.DEEP DIVEAI coding and the human attention bottleneckKeep AI-generated changes understandable: decide permissions before coding, inspect code and tests, and stop starting work when reviewers cannot keep up.DEEP DIVEThe Bus Factor in an AI-Written Codebase: How to Measure Who Actually Understands Your CodeAudit your AI code bus factor with five concrete comprehension checks, an interactive adjustment, and a transparent hypothetical example.DEEP DIVEBinary tree vs binary search treeKnow 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.COMPARISONConnection pooling: reuse, sizing and waitingSee how a database connection pool reuses connections. Change a twelve-query example to compare pool size, database capacity and where queries wait.DEEP DIVEHash collisions: chaining and linear probing on the same keysInsert the same colliding keys with chaining and linear probing. Follow lookup, full-table misses and deletion, then check each model's limits.DEEP DIVEHash tables: keys, collisions and lookup costFollow a key to its bucket, try colliding inputs, and distinguish expected lookup cost, resize cost and Java HashMap's capacity trade-offs.DEEP DIVEIsolation levels, and what each one lets throughStop 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 DIVELinked list vs array: count the search before insertionUnderstand O(1) linked-list insertion after a known node, the cost of finding that node, and the difference between traversal and repeated array shifts.DEEP DIVEServerless architecture: what the provider managesFollow a serverless image job, change where its result is saved, and see how cold starts, scaling, retries and service limits affect the design.DEEP DIVESOA vs microservicesCompare an ESB-centred service design with microservices, change a message contract, and see why independent deployment still needs compatible boundaries.COMPARISONStack vs queue: choose which item leaves nextCompare stack and queue removal on the same jobs. Learn LIFO and FIFO, choose an implementation, and see why FIFO does not guarantee completion order.COMPARISONAbstract class vs interface in Java: what each one sharesUse one Java export example to compare interfaces and abstract classes: what callers can request, what objects inherit, and when neither needs a base class.COMPARISONBFS vs DFSFollow BFS and DFS through the same graph, see why BFS finds fewest-edge paths, and compare their Python implementations, memory use and failure cases.COMPARISONEncapsulation in Java: keep object state validSee how a private list can still break a class's rules. Try direct access, a read-only view and a snapshot, then run a complete Java example.DEEP DIVELongest common subsequence: keep order, allow gapsStep through an LCS table and recover a sequence in Python. Compare memoization, rolling rows and Hirschberg when choosing how much state to keep.DEEP DIVELongest common substring: find a shared run of charactersFollow a matching run through a small table, see why a mismatch resets it, and recover the longest substring with two rows of working memory.DEEP DIVEPriority queues and binary heaps in PythonUse Python heapq to build a binary heap, retrieve priorities, keep equal-priority tasks in arrival order, and understand operation costs.DEEP DIVETopological sort: Kahn's algorithm in PythonTrace a dependency order, run Kahn's algorithm in Python, detect a cycle, and compare DFS with graphlib's TopologicalSorter.DEEP DIVEData warehouse designChoose a warehouse's fact grain, shared dimensions and history rules. Step through a failed reload to see why delete and insert must commit together.DEEP DIVEExponential backoffSee 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 DIVEgRPC vs RESTSee 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.COMPARISONHashMap vs HashtableFind 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.COMPARISONIdempotency keys and safe retriesGive 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 DIVEKey-value storesSee 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 DIVELatency vs throughputLearn 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.COMPARISONLoad balancers, concretelySee 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 DIVELong pollingLearn 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 DIVEMemory leaksSee how lost allocations and unwanted retained references cause memory leaks, why a flat usage curve does not rule one out, and what a collector can reclaim.DEEP DIVEMerge sortLearn 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 DIVEWhat actually changes between mid and seniorSee 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 DIVEOSI vs TCP/IPCompare OSI’s seven-layer reference model with the Internet model’s four layers, map common protocols, and trace three concrete request failures.COMPARISONPages, heaps and tuplesSee how PostgreSQL stores row versions inside pages, when HOT can avoid index work, and why reusable space is different from a smaller table file.DEEP DIVEProcess vs threadUnderstand what each of them actually owns, so you can tell which failures stay contained inside one and which take everything else down with them.COMPARISONRate limitingSee 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 DIVEHarness engineering: the tools and checks around an agentSee how a harness supplies tools and permissions, enforces access rules, and lets you replace a component without silently changing its meaning.DEEP DIVEEphemeral environments and seed dataGive an agent a runnable test environment with isolated state and invented data. Learn what to preserve, what to clean up and which startup costs to measure.DEEP DIVEFrom vague request to ready ticketTurn a vague request into a coding task by checking the existing code, asking specific questions and recording the behaviour and tests people agreed on.DEEP DIVEWhat a prototype can and cannot proveMatch each product assumption to evidence that can answer it. A room-booking example separates usability, demand, feasibility and running the service.DEEP DIVEA good developer career does not need to take over your lifeDefine enough in terms of work, income, learning, and life outside the job. Choose ambition deliberately instead of treating every spare hour as career debt.DEEP DIVEHTTP 202 background jobs: accepted is not completedFollow one background export from HTTP 202 to a finished file. Separate job status from a lost connection, and make retries and user messages tell the truth.DEEP DIVEDo AI agents learn? Memory is not model trainingDistinguish conversation history, saved memory, retrieval, changed instructions and model training. Follow one preference and see what to test.DEEP DIVEAI agent user experience: keep people in controlDesign agent interfaces that show the permitted task, support precise corrections and make approvals meaningful, without inventing confidence scores.DEEP DIVEAI confidence explained: what does 90% mean?Distinguish a model's confidence score from measured accuracy. Work through calibration, missed cases and thresholds without treating certainty as permission.DEEP DIVEWhy AI-generated tests can pass with the wrong codeRun a booking example where tests miss a deadline bug. Add the missing boundary check and see what coverage and mutation testing tell you.DEEP DIVEThe AI vampire: when faster coding creates more workWhat the AI vampire means, what the research supports, and how a worked review-budget example helps teams avoid turning faster coding into overload.DEEP DIVEAn Angular software factory, one feature at a timeFollow one Angular booking feature from agreed behaviour to reusable components, server checks and tests, then reuse the parts that should stay consistent.DEEP DIVEAsk for help without handing over the whole problemExplain what you are trying to do, what you observed, and where your reasoning stops. Make it easy for a colleague to help without hiding uncertainty.DEEP DIVEBellman–Ford algorithm: shortest paths with negative edgesFollow two edge scans to find a cheaper route, then see why a reachable negative cycle prevents some shortest distances from existing.DEEP DIVEBig-O without the ceremonyLearn 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 DIVEBinary searchFind a target in a sorted array by halving the range, trace the O(log n) search, then see how Python bisect turns the same idea into insertion points.DEEP DIVEBuild a developer portfolio that shows judgementUse a small project to show decisions, tests, and honest limitations. Help a reviewer understand your contribution without a large unpaid side project.DEEP DIVEBuild a skill practice loop, not a course collectionChoose a developer skill you can demonstrate, practise it on a bounded task, and use specific feedback to decide what to change on the next attempt.DEEP DIVEBuild career confidence from specific evidenceSeparate how confident you feel from what you can demonstrate. Use bounded practice, honest feedback, and clear limits instead of trying to sound certain.DEEP DIVECharacterization tests: make an AI refactor saferRecord existing behaviour before an AI refactor. Run a cancellation example that catches an accidental change, and separate preservation from correctness.DEEP DIVEChoose a stretch assignment with support, not just more riskCheck the scope, authority, time, and review behind a development opportunity. Distinguish a useful stretch from unsupported responsibility.DEEP DIVEdeque in PythonKnow 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.REFERENCETurn vague AI requests into decisions you can testReplace a vague request to find useful information with explicit questions, supplied comparison text, meaningful outcomes and reviewed test cases.DEEP DIVEDesigning tools for AI agents: clear inputs, safe actionsFollow a document update through tool discovery, exact identifiers, version checks and permissions. Learn why valid JSON is not a valid action.DEEP DIVEDeveloper career advice: start with the decision in front of youA practical reading guide to 24 developer career questions: direction, workplace conversations, learning, job searches, and sustainable growth.DEEP DIVEDiameter of a binary tree: join two downward pathsFind a binary tree's diameter in Python. Count edges correctly, see why the longest path can miss the root, and use iterative postorder traversal.DEEP DIVEEvaluate a developer job by the working weekUse concrete interview questions to investigate a developer role's actual work, support, and constraints before comparing offers or accepting a title.DEEP DIVEKruskal's algorithm: connect vertices at the lowest total costChoose cheap edges, reject one that closes a loop, and use connected groups to build a minimum spanning tree or forest.DEEP DIVELearn from a job rejection without inventing the reasonSeparate confirmed feedback from guesses, review your interview against observable criteria, and choose one improvement without rewriting your whole identity.DEEP DIVELRU cachesSee how an LRU cache chooses what to remove, compare it with FIFO one request at a time, and separate a cache's size limit from the freshness of its values.DEEP DIVEMake a lateral career move without starting from zeroTranslate existing experience into a new developer role, identify the gaps honestly, and agree on a transition that gives you a fair chance to learn.DEEP DIVEMentor a developer without taking over the workGive enough explanation and support for a learner to act, then check their understanding on another task. Distinguish teaching from urgent delivery.DEEP DIVEMentor or sponsor: ask for the help you actually needDistinguish advice from advocacy, make a specific request, and build useful career support without expecting one influential person to solve everything.COMPARISONModel cascades: when a cheap first decision saves moneyCalculate a two-stage AI workflow's complete cost, then count the relevant material its first filter misses. Compare savings without quietly lowering quality.DEEP DIVEMVCC without the jargonSee how row versions let ordinary reads see a consistent view, why the snapshot changes with isolation level, and when old versions cost space.DEEP DIVENegotiate a developer offer without bluffingPrepare an honest offer negotiation around the work, your priorities, and real alternatives. Make a specific request without inventing competing offers.DEEP DIVENetwork through useful relationships, not constant self-promotionReconnect with colleagues and meet people through shared work. Ask clear, respectful questions without treating every contact as a potential transaction.DEEP DIVEOLTP vs OLAPCompare a checkout and a sales report on the same orders. See when row or column layout helps, and why a separate reporting workload may be useful.COMPARISONOnboard by mapping the work, not memorising the organisationBuild a practical onboarding map of users, decisions, delivery steps, and people. Use a safe first change to discover what the documentation leaves out.DEEP DIVEUse one-to-ones to make career decisionsBring a concrete development question to your manager, leave with a decision and owner, and keep routine project updates from consuming the whole meeting.DEEP DIVEPython RecursionError: fix the cause before raising the limitFix maximum recursion depth exceeded in Python. Distinguish a missing stop condition, a self-calling property, a cycle, and a genuinely deep input.DEEP DIVEPython try, except, else and finally: follow one failed conversionLearn Python try/except with runnable examples. Trace else and finally, catch the right exception, and avoid hiding unrelated failures.DEEP DIVERAG troubleshooting: find where the evidence was lostTrace a wrong RAG answer from its source through indexing, retrieval and context assembly. Separate missing evidence from a model misreading good evidence.DEEP DIVESay no by making the trade-off visibleRespond to extra work with a clear account of capacity, alternatives, and decision ownership instead of a hidden promise to work longer.DEEP DIVESelection sort: find the next smallest valueWatch selection sort finish an array early but keep scanning, count its work, and see how swapping can reverse equal-key records.DEEP DIVESingle-agent vs multi-agent: when splitting the work helpsCompare one agent with several using the same task. See when separate investigations help, when dependencies get in the way, and what to measure.COMPARISONSpecialist or generalist: choose the problem before the labelDecide where to deepen your skills and where breadth helps. Compare specialist and generalist work against an actual team problem, not a career stereotype.COMPARISONThe star schemaChoose one fact-row grain, then compare a flat dimension with a snowflake. See what changes in the query and what still needs measuring.DEEP DIVETell engineering interview stories without inflating your roleExplain a real engineering contribution with enough context, decisions, and results to be useful, while preserving shared credit and uncertainty.DEEP DIVETest a career direction before you commitTry the work behind a job title before changing careers. Build a small experiment that tests one important assumption without betting your livelihood.DEEP DIVETurn vague feedback into a practice planTranslate feedback such as 'be more strategic' into a specific situation, expected behaviour, and a fair way to check whether your next attempt improves.DEEP DIVEType-safe AI output is not the same as a correct decisionA model can select a valid document ID and still select the wrong document. Separate output shape, meaning, permission and execution with one worked example.DEEP DIVEUnlearn a habit that no longer fits your roleKeep the experience that still helps while changing a habit whose assumptions no longer fit. Test a replacement behaviour on a bounded piece of work.DEEP DIVEValidate a binary search tree: carry the ancestor boundsValidate a binary search tree in Python with ancestor bounds. See why parent-only checks fail, how duplicates work, and how to avoid recursion limits.DEEP DIVEWhat is an AI agent? Follow the next decisionFollow a support request to see how an AI agent chooses tools, uses their results and stops—and how that differs from a chatbot or fixed workflow.DEEP DIVEWhen to stop pursuing a career planDecide whether to continue, change, or stop a career plan by checking its assumptions and future costs, rather than defending the effort already spent.DEEP DIVEWhy software development involves so much arguingSoftware disputes often come from hidden technical work, split authority, and different incentives. Learn how to turn recurring arguments into decisions.DEEP DIVEWhy PostgreSQL is not using your indexUse EXPLAIN to check why PostgreSQL chose a scan: inspect index conditions, row estimates and costs before changing the query or statistics.DEEP DIVEWrite a developer CV with evidence, not a tool inventoryShow what you did, why it mattered, and which skills the work demonstrates. Keep technology names useful and avoid invented metrics or keyword stuffing.DEEP DIVEWrite status updates that help someone decideTurn a list of engineering activity into a short update that explains what changed, what remains uncertain, and what decision or action is needed.DEEP DIVE0/1 knapsack: choose the items, not just the best valueCompare taking and leaving each item, fill a small knapsack table, recover the chosen set, and avoid accidentally reusing the same item.DEEP DIVEDeterministic steps and AI stepsChoose scripts for explicit rules and AI for investigation. See when one model call is enough, when a workflow fits, and which checks code must enforce.DEEP DIVEGolden sets: testing the factoryCompare agent changes on repeatable tasks with expected outcomes, turn discovered failures into regression cases and measure complete runs rather than one step.DEEP DIVELoop engineering: when an AI agent should retry or stopDesign repeated agent work around actual test results, saved progress and stopping rules. Follow a repair loop and a recurring maintenance example.DEEP DIVEWhat a merged change costsCalculate agent costs across complete tasks, including retries, failed runs, test environments and human review. Compare savings without weakening checks.DEEP DIVEWhen an agent stops and asksDesign an agent's handover to a person: ask a specific question, save progress, route it to someone who can decide and resume after checking the answer.DEEP DIVEArchitecture decision recordsRecord why an architecture choice was made, which assumptions could change it, and when to review it without rewriting the history of the decision.DEEP DIVEReviewing without starting a fightWrite code review feedback that names a problem, explains its consequence and distinguishes required fixes from suggestions, with a worked example.DEEP DIVECRDTs explained: merge a counter across two replicasFollow two offline replicas through a concrete counter merge, then see why delivery rules, deletes, metadata costs, and global invariants still matter.DEEP DIVEData warehouse vs databaseCompare operational databases and data warehouses: transaction versus analysis workloads, integrated history, reporting replicas, and hybrid systems.COMPARISONDatabase replicationUnderstand PostgreSQL replication through a booking example: what reaches the standby, what commits wait for and why replay lag is not a data-loss timer.DEEP DIVEWriting it down before you build itSee 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 DIVEOrchestrator, or just a pipeline?Decide whether an agent task fits your existing CI pipeline or needs saved workflow state for approvals, restarts and shared ownership.DEEP DIVEThe coding agent and its repair loopFollow a coding agent from a ready task to a tested change, including limited repair attempts, scope changes, blocked tests and a handover to a person.DEEP DIVEUnit vs integration testCompare test boundaries with a runnable booking example: a fake accepts duplicate slots while SQLite rejects them. See what each check establishes.COMPARISON12-factor agents: actions, saved progress and retriesLearn the twelve agent-design principles through a pull request that times out: what the model proposes, what the program allows and how work resumes.DEEP DIVEHow agents hand work over through saved recordsSee what one agent should leave for the next: the request, changed code, test results and unfinished work, with an example handover record.DEEP DIVEContext engineering: what an AI agent needs to seeLearn how to choose an agent's instructions, code and test results, avoid stale information, and distinguish context engineering from prompting and RAG.DEEP DIVEContext rot: when to shorten or restart an AI sessionRecognise repeated mistakes and buried requirements in an AI coding session. Learn what context rot means, when to reset and which work to preserve.DEEP DIVEIncidents back into the backlogTurn repeated errors into useful follow-up work: group related events, update existing tickets and distinguish a returning defect from delayed old reports.DEEP DIVEMeasuring a factory honestlyCompare similar work with and without a software factory, counting review, rework and quality alongside speed. Avoid rewarding code volume over useful changes.DEEP DIVEPrompt injection in a pipelineSee how instructions hidden in tickets, code or logs can redirect an agent, why structured handovers do not remove the risk and which permissions to restrict.DEEP DIVEResearch, plan, implement: prepare the next coding stepGuide an agent through existing code: find the current behaviour, agree on the change, plan a testable part and pass on findings without a whole chat history.DEEP DIVEScoped credentials and the kill switchLimit what each agent can read and change, stop new and active work, and test that temporary permissions expire without relying on instructions alone.DEEP DIVEAI software factory limits: tests, maintenance and reviewSee what passing tests can miss in an AI software factory: duplicated rules, growing review queues and changes that are difficult to undo.DEEP DIVESpec-driven development: keeping specifications and code alignedLearn which specifications to maintain, how they differ from implementation plans, and what to do when the written rule, tests and running code disagree.DEEP DIVEThe human merge gateDecide what a person must review before an agent's change is merged, how consequences affect review depth and how to prevent approval becoming a formality.DEEP DIVEThe pull-request review agentUse an AI reviewer to inspect proposed code, tests and requirements. Keep revision-specific findings separate from fixes, build results and merge approval.DEEP DIVEVerifying after the deployCheck that the intended version is serving before judging a release. Distinguish missing version information, rollout delays and failed behaviour checks.DEEP DIVEWhat a software factory isSee how a software factory connects planning, coding, tests and review, what AI agents do, and where a person still needs to decide.DEEP DIVEWho owns the factoryDecide who maintains the agent tools, answers questions and handles failures. Match support hours and the manual fallback to how teams use the factory.DEEP DIVEThe aesthetic-usability effect on reading pagesA polished article can feel easier to use while hiding real friction. Learn how to shape a calm reading page and test whether readers can actually use it.DEEP DIVEWrite article titles and links that help people browseMake article lists easier to scan with specific titles, front-loaded summaries, descriptive section headings, and links that name their destinations.DEEP DIVEBounded contexts, concretelySee how bounded contexts keep different meanings separate, translate external API facts at the edge, and avoid a shared model that spreads confusion.DEEP DIVEChange data captureSee 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 DIVECompiler vs interpreterSee how compilation and interpretation work together in real toolchains, when code is translated, and which checks can catch errors before execution begins.COMPARISONCongestion controlLearn 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 DIVEConsistent hashing explained with a key movement exampleCompare modulo sharding with a hash ring, then see exactly which keys move when a node joins and what virtual nodes, replication, and hot keys change.DEEP DIVEDesign search results that help when nothing matchesMake zero-result searches understandable and recoverable with a clear explanation, visible scope, useful next actions, and honest feedback.DEEP DIVEJakob's Law for article discovery: familiar paths, clearer choicesUse familiar navigation and search patterns to help readers find articles, then test whether your distinctive design still makes the next step obvious.DEEP DIVELinked list in Python: build one, then choose the right containerImplement a minimal singly linked list in Python, check its operation costs, and learn when list or collections.deque is the better tool.DEEP DIVELLM quantization: what Q3 and Q4 actually meanSee what LLM quantization changes inside model weights, why Q3 is not three decimal places, and how lower-bit formats trade memory traffic for approximation.DEEP DIVELongest palindromic substring: expand from every centerFind the longest contiguous palindrome in a string by expanding around odd and even centers, with code and a precise complexity bound.DEEP DIVEWhen are you no longer a junior developer?No fixed year ends a junior role. Compare your team's level criteria with a worked example of taking a small feature from unclear request to checked result.DEEP DIVEProgressive disclosure for a large article libraryHelp readers explore a large catalogue with useful topic previews, clear routes to every article, and search that reveals all relevant matches.DEEP DIVEDesign a reading column for long articlesChoose a calm text width, line height and heading rhythm for long articles, while giving diagrams and tables the space they need.DEEP DIVERecursion, drawnWatch 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 DIVESingle table inheritance: one table for a class hierarchySee how a discriminator maps several entity types to one table, then decide when sparse columns and schema coupling outweigh simple queries.DEEP DIVESorting algorithm visualiserStep insertion, merge, and selection sort through the same array and watch their comparison counts diverge.VISUALISERA spacing system that makes interfaces easier to understandUse a small spacing scale to show which interface elements belong together, separate article cards clearly, and give page sections room to breathe.DEEP DIVEStack vs heapCompare call-stack frames and independent heap allocations, with the ownership, lifetime and runtime details that shape the choice.COMPARISONTCP vs UDPKnow 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.COMPARISONThe TLS handshakeLearn 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 DIVEMake article indexes easier to scan with visual hierarchyGive readers a clear path through an article index by making the topic and title prominent, then placing summaries and metadata in supporting roles.DEEP DIVEClustered indexesSee why InnoDB's primary key decides where a row physically lives, why every secondary index carries a copy of it, and what a wide key costs a schema.DEEP DIVEWhy good developers become bad managersSee why software companies promote people into roles they are not good at, how the Peter Principle shows up in engineering, and what actually fixes it.DEEP DIVEB-tree splits, key by keyInsert 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.VISUALISERBinary search tree visualiserInsert 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.VISUALISERBuffer overflowsLearn 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 DIVEAlgorithm and data structure visualisersEvery interactive visualiser on this site in one place, each one showing the single thing about its structure that a still picture flattens away.VISUALISERDead letter queuesSee 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 DIVEDeadlocks, seenWatch 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 DIVEDijkstra visualiserStep 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.VISUALISERInfluencing a design you do not ownSee 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 DIVEDistributed tracingSee 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 DIVEDynamic arraysSee 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 DIVERed-black treesLearn 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 DIVESenior, staff, and the ladder aboveSee what actually separates a senior engineer from a staff one, and whether that title is worth chasing before your day-to-day scope changes.COMPARISONShipping without supervisionSee 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 DIVEStrangler-fig migration, from the insideReplace a running production system without stopping it, and see the routing and data-ownership decisions that actually determine whether it survives.DEEP DIVEMaking the case to the people who fund itSee 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 DIVEGetting the title to match the workSee 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 DIVEThe write-ahead logSee 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 DIVETree traversal ordersFour 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 DIVEVirtual memoryLearn 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 DIVEWhat a Kafka topic actually isSee 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 DIVEWhen a message broker is the wrong answerSee 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 DIVEEstimates you can defendSee 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 DIVEWhy quicksort is fast in practiceLearn 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 DIVEInterview questionsPractise software interview questions, then follow each answer to an explanation or visualiser.ReferencesLanguage referenceBrowse Python and Java guides to control flow, containers and object design.References