Skip to the content
Software Made Clear
About

PILLAR

CS Foundations

Trees, traversal and complexity, plus the networking, memory and concurrency ground beneath them — the material most people meet first, minus the ceremony.

New to this topic? Help me choose a first step →

Browse the articles

Pick a question that interests you, or narrow the list above.

August 31, 2026 DEEP DIVE 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. Read it →
August 31, 2026 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. Read it →
August 31, 2026 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. Read it →
August 19, 2026 COMPARISON 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. Read it →
August 19, 2026 DEEP DIVE 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. Read it →
August 19, 2026 COMPARISON 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. Read it →
August 19, 2026 REFERENCE 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 DEEP DIVE 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. Read it →
August 19, 2026 DEEP DIVE 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 COMPARISON 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 COMPARISON 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 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. Read it →
August 19, 2026 DEEP DIVE 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. Read it →
August 18, 2026 DEEP DIVE 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. Read it →
August 18, 2026 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. Read it →
August 18, 2026 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. Read it →
August 17, 2026 COMPARISON 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. Read it →
August 17, 2026 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. Read it →
August 17, 2026 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. Read it →
August 15, 2026 VISUALISER 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. Read it →
August 15, 2026 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. Read it →
August 15, 2026 VISUALISER 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. Read it →
August 15, 2026 VISUALISER 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. Read it →
August 14, 2026 COMPARISON 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. Read it →
August 7, 2026 DEEP DIVE 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. Read it →
May 28, 2026 VISUALISER 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. Read it →