Simulations

This is the abacus in free-play mode. Push beads to the bar to count them, clear the board whenever you like, and see the place-value readout update instantly.

Free-play with the whole machine. Click any glowing part to read its role, and puzzle out how data flows from the SSD to the CPU and back.

Free-play with the packaged chip. Lift the lid, follow a signal from a pin to the die and see exactly why the fragile silicon needs its epoxy home.

Free-play with the interactive transistor. Spin it around, flip to the NPN cutaway and watch electrons stream from emitter to collector through the thin base.

Free-play with the triode. Spin around the glowing glass, find the filament, cathode, grid and anode, and watch the blue electron stream do its thing.

Loops and if-else are where programs make decisions. Write a snippet, run it, and check your mental model against the real output.

A blank editor, a Run button, and a working C interpreter. Type any program and see its output - the fastest way to check what a construct really does.

Functions break programs into pieces; arrays hold many values. Practise the two together and learn which one C passes by value.

A decoder turns a binary code into 'one line out of many'. Feed the address 10 and line two lights up - exactly how a CPU picks a memory cell.

The full adder accepts a carry from the previous column, which is exactly what a multi-bit adder needs to chain digits together.

Every gate is a tiny boolean function. Run all input combinations and check the output against the truth table - then wire gates together.

Add two bits: the XOR gives the sum bit, the AND gives the carry. That two-gate circuit is the seed of all arithmetic in the CPU.

Karnaugh maps turn boolean simplification into a visual game: group adjacent 1s in powers of two, and each group removes a variable.

One switch, one lamp, one wire. Flip the switch and the lamp follows - the seed of every logic circuit you will ever build.

A multiplexer is a rotary switch made of gates. The select lines choose which input gets passed through - the basis of routing in hardware.

A class is a blueprint; an object is the thing built from it. Practise defining fields, methods, and how public/private controls access.

Inheritance reuses code; polymorphism lets one interface behave differently per type. Test both and see when virtual really matters.

A working C++ interpreter in the browser. Type any program, hit Run, and see exactly what the language does with it.

Operators are just functions with friendly syntax. Overload + for a class and suddenly a + b compiles and means exactly what you defined.

The 8085 is the classic 8-bit processor. Tour its internals and follow the path an instruction takes from memory to execution.

The 8085 does arithmetic and logic through the accumulator. Feed it operations and read the result and the flags after each step.

Keyboards and displays speak BCD; the CPU speaks binary. Practise the conversion routines that translate between the two.

Programs mostly move data and loop. Watch register-to-memory transfers, then a loop that counts down with DCR and JNZ.

Real programs move data in blocks. Practise walking memory with the H-L address pair and the data registers.

Subroutines avoid repeating code; lookup tables avoid recomputing. Practise both and watch the stack manage return addresses.

Each new key falls left or right of every node it meets. The rule is tiny, but it arranges the whole structure - and a sorted traversal falls out for free.

BFS visits everything one step away before anything two steps away; DFS burrows down one path to the end. Watch the difference on the same graph.

A hash function turns any key into a table index. When two keys land on the same slot they collide - watch what the table does about it.

People join the line at the back and leave at the front. When the buffer is circular, the tail wraps to the front and no cell ever goes to waste.

Start with a target in a sorted list. Binary search cuts the remaining space in half on every probe - find out exactly why it needs so few guesses.

The array is shuffled. Pick an algorithm, step through it, and watch how each technique decides where the next element belongs. The same data makes the differences obvious.

Operators wait on the stack while higher-precedence ones overtake them. Stepping through shows why 'a + b * c' becomes 'a b c * +' and not the other way around.

Three pegs, a stack of discs, one rule: never put a big disc on a small one. The recursive solution is three lines, yet it solves any size perfectly.

Derivatives measure change. Practice applying the power, sum and constant rules to polynomials and check your answer after every step.

An eigenvector is a direction a matrix merely scales; the eigenvalue is the scale factor. Practise finding the pair for a given matrix.

Integration undoes differentiation. Apply the reverse power rule, remember the constant of integration, and verify your antiderivative.

Many real problems reduce to solving Ax = b. Practise manipulating the equations and watch the solution emerge step by step.

Determinants tell you whether a system is solvable; inverses actually solve it. Practise both until the row operations feel natural.

Any smooth function can be rebuilt from its derivatives at a point. Add terms one by one and watch the polynomial hug the curve.

The ALU is the calculator inside the CPU. Pick an operation, feed it two values, and see the result - and the flags that come with it.

Cache is fast but small, so blocks must fight for slots. Each mapping strategy has a different rule for who goes where - and a different miss rate.

Fast memory is small and expensive; big memory is slow. The hierarchy hides the slowness by keeping the hot data near the CPU.

The CPU only really knows binary, but humans read decimal and hex. Convert the same number across bases and see the pattern behind each digit.

A pipeline works like an assembly line: the next instruction starts before the last finishes. Hazards break the rhythm and cost cycles.

Two's complement lets the same adder hardware do both addition and subtraction. Watch A - B become A + (-B) and see where the bits overflow.

Every 2D transform is a matrix applied to each vertex. Compose several and watch the shape move, spin, grow or flip on the canvas.

Screens are flat, so 3D scenes must be flattened. Parallel projection keeps sizes; perspective makes distant things smaller - and more real.

Bresenham replaces floating point with a running error term and integer decisions. Each step, it tests the error and chooses the best pixel.

A line on a screen is really a trail of lit pixels. DDA computes each next pixel from the last with a small fixed step - watch the increments.

Circles have eight-way symmetry, so the algorithm draws one eighth and reflects it. The midpoint decision keeps pixels on the curve.

Filling a polygon means deciding, for every pixel, whether it is inside. Scan-line spans and flood fills attack the problem differently.

CRC adds a remainder from polynomial division to each frame. The receiver recomputes it; a mismatch means the frame was corrupted.

Browsers need IP addresses, humans need names. DNS is the lookup system that translates between them, one server at a time.

A web request is just text over a socket. Build one by hand and see the method, path, headers and status codes that make the web work.

Design is about choices: one switch or many, a router in the middle, redundant links or none. Lay out the pieces and reason about the traffic.

A packet does not fly to its destination - it is handed from device to device, each one reading the destination and deciding the next hop.

One network address, one mask - and suddenly you can carve it into many subnets. Change the prefix and watch the host range shrink or grow.

The only way to master subnetting is to do it. This drill generator gives you a fresh problem each time and checks every answer.

Before any data flows, the two sides must agree on sequence numbers. The handshake does it in three messages - and every one of them is observable here.

The banker only lends when enough money remains to satisfy everyone. Each request is checked: if granting it could still let every process finish, it is safe.

A file system is a map from names to data. Create files and folders and watch how they are organised, addressed and found again.

The shell is the face of the OS. Every command you type is a small program - practice the essentials here before a real terminal.

Processes arrive needing chunks of memory. Where you place each one decides how much usable space is left - watch the holes multiply under each strategy.

Frames are scarce, so when a new page must load, one old one must leave. Each algorithm has its own idea of who should go - count the faults to see who's right.

Producers drop items into the buffer, consumers take them out. Without coordination a full buffer gets written to and an empty one gets read from.

The CPU can only run one process at a time, so someone must pick the next. Try each policy on the same workload and see who waits and who starves.

Aggregates collapse many rows into one summary number. GROUP BY gives each group its own summary - and HAVING filters those summaries.

Relational data lives in separate tables; joins put it back together. Run the same query with different join types and compare the row counts.

Every database starts with a CREATE TABLE. Type it, add some rows, and query them back - the whole pipeline in one screen.

A bank transfer is two updates that must behave as one. Wrap them in a transaction and see how COMMIT makes it permanent and ROLLBACK undoes it.

Views store a query, not data - every SELECT through them re-runs it. Indexes, on the other hand, are physical shortcuts that change how fast lookups go.

A* ranks candidates by g (cost so far) plus h (estimated cost to goal). With a good heuristic it aims straight at the goal instead of wandering.

Before AI gets clever, it searches. BFS fans out level by level; DFS dives down one path. Count the nodes each one expands on the same space.

An expert system captures human rules as IF-THEN statements. Given the right facts, an inference engine chains those rules to a conclusion.

Hill climbing always moves to the better neighbour. Smooth hills it climbs fast; bumpy terrain strands it on the first local peak it reaches.

The inference engine is the brain of an expert system. It decides which rule to fire next and which facts become available next.

In a two-player game, your opponent will play their best. Minimax assumes exactly that, backing the worst case up the tree to choose your move.

Dijkstra's algorithm is the classic single-source shortest path. Watch it expand to the nearest unsettled node, relaxing edges as it goes.

Merge sort divides until the pieces are trivial, then merges in order. Its cost never depends on the input - a fair trade for the memory it uses.

A spanning tree touches every vertex with no cycles; the MST does it as cheaply as possible. Watch the tree grow edge by edge.

Quick sort partitions around a pivot, then recurses on both sides. Run it on the same data with different pivots and compare the work.

Fibonacci(n) calls Fibonacci(n-1) and Fibonacci(n-2), which call it again. Watch the call tree duplicate work exponentially.

A context diagram is the widest zoom on a system: one box for the system, external actors around it, data flows between them.

A data dictionary catalogues every data element in the system. One place to define what each field means, its type and its length.

Level-1 breaks the single system box into its main processes, showing data stores and the flows between them.

The ER model is the blueprint of the database. Define entities, their attributes, and the relationships with cardinalities between them.

Use cases describe goals actors reach through the system. Draw the actors, the system boundary, and each use case inside it.

Given a guess at part of the plaintext - a crib - the Bombe tests rotor positions in parallel, eliminating every setting that contradicts it.

The Enigma is a rotor cipher machine: every keypress rotates a rotor, so the same letter is never encoded the same way twice. Play with a real working model.

AJAX lets the browser talk to the server while the page stays put. Watch a request go out and the response update the DOM in place.

HTML is the skeleton, CSS the skin. Add elements, write styles, and see the box model, colours and spacing respond instantly.

JavaScript turns a static page into an application. Select elements, attach event handlers, and update the DOM when events fire.

Most web apps are a database wrapped in PHP. Watch a query travel from PHP to MySQL and the rows come back into the page.

Forms are how users send data to the server. Trace the data from the form fields into the handler, and across requests via sessions.

One page, many screens. Media queries apply different CSS at different widths, and fluid units let content reflow instead of break.

Edges are where pixel values change fastest. Gradient filters measure that change - the first step for object boundaries and shape analysis.

Images have frequencies too: smooth areas are low, edges are high. Filter in the frequency domain and the inverse FFT brings it back to pixels.

A washed-out image has pixels crowded into a narrow brightness band. Equalization remaps them to spread across the whole range.

Morphology works on shapes, not shades. Erosion shrinks bright regions, dilation grows them; opening and closing combine the two.

A filter kernel is a small matrix that scans the image; each output pixel is a weighted neighbourhood sum. Blur with averages, sharpen with laplacians.

Thresholding turns a greyscale image binary: every pixel above the threshold becomes white, below becomes black. It is the simplest segmentation.

Mining finds relationships between attributes. Correlation quantifies linear ones - a first pass at which attributes predict which.

Before any algorithm runs, the data must be understood. Compute the descriptive summaries that expose centres, outliers and distributions.

Regression is data mining in its simplest form: learn a function that predicts a numeric target. Fit the line and test its predictions.

Before a packet can move, someone must turn names into IPs and IPs into MACs. Watch both resolvers do their jobs in the capture.

Network security starts with integrity: knowing a frame was not altered. CRC detects corruption, and tampering makes it flip detectable bits.

A new device has no address, so it broadcasts for one. DHCP's four-message dance hands it a lease - plus the gateway and DNS it needs.

Ping is the network's health check. It fires an ICMP echo request and waits for a reply - revealing whether a host is reachable and how far it is.

HTTPS is HTTP over TLS. Before a single byte of application data, the two sides agree on ciphers, prove identity and derive shared keys.

Analytics is aggregation at scale. Group the data, filter the groups, and compute the summaries that turn rows into insight.

Reporting rarely reads one table. Practise the join forms that assemble multi-table views and the subqueries that refine them.

Advanced databases live and die by their schema. Define constraints and test exactly which inserts and updates the engine refuses.

Production databases serve many writers at once. Practise the transaction boundaries that keep concurrent updates consistent.

Derivatives are the heart of calculus. Practise the power, exponential and chain rules until each step is second nature.

Integration reverses derivatives and measures area. Practise the standard antiderivatives and the substitutions that unlock harder ones.

A limit asks what a function approaches. When plugging in gives 0/0, factor and cancel - practise that move until it is automatic.

A geometric series multiplies each term by a fixed ratio. With a small ratio the terms shrink fast enough to sum to a finite value.

Some vectors are special: the matrix only stretches them. Find those directions (eigenvectors) and the scale factors (eigenvalues).

Systems of equations are everywhere in CS. Practise solving them and reading the three outcomes from the reduced form.

A Markov chain moves between states with fixed probabilities. After many steps the distribution settles into an equilibrium - exactly what powers PageRank.

The determinant is a single number that encodes a lot: whether a matrix is invertible, whether a system is solvable, how volumes scale.

A matrix is a function on space: it rotates, scales, shears. Watch the rotation matrix turn vectors and track where each lands.

In Bohr's atom the electron can only live on discrete shelves, not anywhere. Jumping between shelves emits or absorbs a photon of exactly the right energy.

Everything moving has a wave, and its wavelength is Planck's constant divided by momentum. For big objects the wave is invisibly tiny; for electrons it can be the size of an atom.

A diode is a one-way street for current. It ignores reverse voltage until a limit, then lets a tiny leakage through - and it lets forward current flow once a small threshold is crossed.

Every charge paints an invisible picture in the space around it. Place charges, toggle the field view, and move a test charge to feel how the field pushes it.

Light, radio, WiFi - all are EM waves. An electric field and a magnetic field swing together, at right angles to each other, carrying energy across empty space at light speed.

Bring atoms together and their energy levels split into bands. If the bands touch, electrons flow easily - a metal. If a wide gap separates them, it is an insulator. Semiconductors sit in between.

When hydrogen glows, it does not glow with every colour - only with the exact colours matching its level spacings. The pattern of lines is hydrogen's identity card.

A charge only feels a magnetic force while it is moving across the field. That force never speeds it up - it only bends its path, curving it into a perfect circle.

Electric current makes magnetism. The field curls in circles around the wire, and its direction depends on which way the current flows - the right-hand rule in action.

Where p-type meets n-type silicon a wall of charge - the depletion region - forms. Forward bias tears the wall down and current flows; reverse bias builds it up and blocks.

Push torque on the disc and watch it spin up. Change its radius or mass and feel how much harder it becomes to spin - that is moment of inertia, rotation's answer to mass.

Pure (intrinsic) silicon conducts a little, and more when hot. Add donor atoms and electrons appear for free; add acceptors and holes appear. That doping is the craft of chip-making.

Pull the mass and let go. The spring pulls it back past equilibrium, overshoots, and oscillates. Heavier mass means slower swings; stiffer spring means quicker ones.

A seesaw tilts when the torques on each side disagree. Move the weights, or change their size, and watch which way it tips - a longer arm makes a small weight just as strong as a heavy one close in.

A tiny current into the base unlocks a much bigger current between collector and emitter. Below a threshold the transistor is OFF; above it, ON; between, it amplifies.

A particle's wave has a trade-off: squeeze its position into a tiny spot and its momentum becomes fuzzy; let the position spread out and the momentum sharpens.

One dataset, many summaries. The mean, median and mode each answer a different question about the centre, and the spread measures say how tightly grouped the data is.

Two datasets can share a mean yet differ wildly in spread. Measure the dispersion to see which is consistent and which is volatile.

Raw numbers are noise; grouped they become a shape. Choose class intervals and watch the histogram rise and fall to show where the data lives.

A distribution assigns probabilities to outcomes. Change the mean and variance of a normal, or the p of a binomial, and watch the whole shape respond.

With three groups, comparing pairs invites errors. ANOVA asks one question: are the group means different, given how noisy each group is?

Does observed data match what theory predicts? The chi-square test measures the total squared discrepancy and decides if it is too large to be chance.

A sample gives an estimate, but how sure are we? The confidence interval brackets the unknown population mean with a chosen level of confidence.

Correlation measures how two variables move together. A perfect straight line gives r = ±1; scattered data gives r near zero.

Regression draws the line that best fits the data - minimising the squared vertical gaps. The slope tells you the rate of change between the variables.

A hypothesis test asks: is the observed difference real or just chance? Compute the test statistic, find the p-value, and compare with the significance level.