Skip to the content
Software Made Clear
Search the whole site About

TOPIC 57 ARTICLES

CS Foundations

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

Help me choose a first step
LATEST IN CS FOUNDATIONS Where software terms come from: seven origin stories checked

EXPLORE THE TOPIC

Browse the articles

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

01 / 11 ARTICLES

Start with the essentials

Build a mental model for code, complexity and the ideas behind common explanations.

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 →
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 →
COMPARISON Compiler vs interpreter See how compilation and interpretation work together in real toolchains, when code is translated, and which checks can catch errors before execution begins. Read it →
COMPARISON Abstract class vs interface in Java: what each one shares Use one Java export example to compare interfaces and abstract classes: what callers can request, what objects inherit, and when neither needs a base class. Read it →
DEEP DIVE Buzzwords are not understanding Learn a practical test for real technical understanding: turn jargon into mechanisms, examples, trade-offs, and failure cases without losing the truth. Read it →
DEEP DIVE Deterministic finite automata: trace one state at a time Build a machine that checks whether a binary string ends in 01, follow its state changes, and see why an early match is not enough. Read it →
DEEP DIVE Encapsulation in Java: keep object state valid See 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. Read it →
DEEP DIVE Luhn algorithm: calculate and check a check digit Run the Luhn checksum by hand, see exactly which digits are doubled, and learn what a valid check digit can and cannot prove. Read it →
DEEP DIVE Python RecursionError: fix the cause before raising the limit Fix maximum recursion depth exceeded in Python. Distinguish a missing stop condition, a self-calling property, a cycle, and a genuinely deep input. Read it →
DEEP DIVE Python try, except, else and finally: follow one failed conversion Learn Python try/except with runnable examples. Trace else and finally, catch the right exception, and avoid hiding unrelated failures. Read it →
DEEP DIVE Where software terms come from: seven origin stories checked Check the evidence behind bug, daemon, kernel, cache, compiler, algorithm and software engineering, including which familiar stories remain contested. Read it →

02 / 11 ARTICLES

Choose a data structure

See how lists, maps, queues and caches change what an operation costs.

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 →
DEEP DIVE Hash tables: keys, collisions and lookup cost Follow a key to its bucket, try colliding inputs, and distinguish expected lookup cost, resize cost and Java HashMap's capacity trade-offs. Read it →
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 →
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 →
DEEP DIVE Hash collisions: chaining and linear probing on the same keys Insert the same colliding keys with chaining and linear probing. Follow lookup, full-table misses and deletion, then check each model's limits. Read it →
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 →
DEEP DIVE Linked list in Python: build one, then choose the right container Implement a minimal singly linked list in Python, check its operation costs, and learn when list or collections.deque is the better tool. Read it →
DEEP DIVE Linked list vs array: count the search before insertion Understand O(1) linked-list insertion after a known node, the cost of finding that node, and the difference between traversal and repeated array shifts. Read it →
DEEP DIVE LRU caches See 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. Read it →
DEEP DIVE Priority queues and binary heaps in Python Use Python heapq to build a binary heap, retrieve priorities, keep equal-priority tasks in arrival order, and understand operation costs. Read it →
COMPARISON Stack vs queue: choose which item leaves next Compare stack and queue removal on the same jobs. Learn LIFO and FIFO, choose an implementation, and see why FIFO does not guarantee completion order. Read it →

03 / 14 ARTICLES

Navigate trees and graphs

Traverse relationships, find routes and understand balanced search trees.

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 →
COMPARISON BFS vs DFS Follow BFS and DFS through the same graph, see why BFS finds fewest-edge paths, and compare their Python implementations, memory use and failure cases. Read it →
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 →
VISUALISER AVL tree visualiser Load and share an insertion sequence. Compare a plain search tree with an AVL tree, inspect rotations and see how insertion order changes height. Read it →
DEEP DIVE Bellman–Ford algorithm: shortest paths with negative edges Follow two edge scans to find a cheaper route, then see why a reachable negative cycle prevents some shortest distances from existing. Read it →
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 →
DEEP DIVE Diameter of a binary tree: join two downward paths Find a binary tree's diameter in Python. Count edges correctly, see why the longest path can miss the root, and use iterative postorder traversal. Read it →
DEEP DIVE Eulerian path: use every edge exactly once Choose and undo roads on a four-vertex map, distinguish edge coverage from visiting every vertex, and see how a stack builds an Eulerian path. Read it →
DEEP DIVE Hamiltonian path: visit every vertex once Try a route, undo a choice that leaves a vertex unreachable, and distinguish Hamiltonian paths from Eulerian paths and cheapest routes. Read it →
DEEP DIVE Kruskal's algorithm: connect vertices at the lowest total cost Choose cheap edges, reject one that closes a loop, and use connected groups to build a minimum spanning tree or forest. Read it →
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 →
DEEP DIVE Topological sort: Kahn's algorithm in Python Trace a dependency order, run Kahn's algorithm in Python, detect a cycle, and compare DFS with graphlib's TopologicalSorter. Read it →
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 →
DEEP DIVE Validate a binary search tree: carry the ancestor bounds Validate a binary search tree in Python with ancestor bounds. See why parent-only checks fail, how duplicates work, and how to avoid recursion limits. Read it →

04 / 9 ARTICLES

Solve it efficiently

Follow search, sorting and dynamic programming problems step by step.

DEEP DIVE Binary search Find 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. Read it →
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 →
VISUALISER Sorting algorithm visualiser Step insertion, merge, and selection sort through the same array and watch their comparison counts diverge. Read it →
DEEP DIVE Longest common subsequence: keep order, allow gaps Step through an LCS table and recover a sequence in Python. Compare memoization, rolling rows and Hirschberg when choosing how much state to keep. Read it →
DEEP DIVE Longest common substring: find a shared run of characters Follow a matching run through a small table, see why a mismatch resets it, and recover the longest substring with two rows of working memory. Read it →
DEEP DIVE Longest palindromic substring: expand from every center Find the longest contiguous palindrome in a string by expanding around odd and even centers, with code and a precise complexity bound. Read it →
DEEP DIVE Selection sort: find the next smallest value Watch selection sort finish an array early but keep scanning, count its work, and see how swapping can reverse equal-key records. Read it →
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 →
DEEP DIVE 0/1 knapsack: choose the items, not just the best value Compare taking and leaving each item, fill a small knapsack table, recover the chosen set, and avoid accidentally reusing the same item. Read it →

05 / 7 ARTICLES

Understand memory and threads

See where programs store data and what can fail when work runs together.

COMPARISON Stack vs heap Compare call-stack frames and independent heap allocations, with the ownership, lifetime and runtime details that shape the choice. Read it →
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 →
COMPARISON Mutex vs semaphore Compare mutex and semaphore behaviour in Java and Python. Change who releases to inspect owner checks, repeated releases and permit counts. Read it →
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 →
DEEP DIVE LLM quantization: what Q3 and Q4 actually mean See what LLM quantization changes inside model weights, why Q3 is not three decimal places, and how lower-bit formats trade memory traffic for approximation. Read it →
DEEP DIVE Memory leaks See 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. Read it →
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 →

06 / 5 ARTICLES

Follow data across networks

Trace packets, connections and protocols from a request to a secure response.

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 →
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 →
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 →
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 →
COMPARISON OSI vs TCP/IP Compare OSI’s seven-layer reference model with the Internet model’s four layers, map common protocols, and trace three concrete request failures. Read it →