Why a PDE will not fit in a computer
A partial differential equation ties together how a quantity changes in time and in space. The cleanest example, and our companion for this whole rung, is the one-dimensional heat equation u_t = a * u_xx: the temperature u(x, t) along a thin rod, where u_t is the rate of change in time and u_xx is the second derivative in space, and a > 0 is how fast heat diffuses. Intuitively it says a point heats up when it is colder than the average of its neighbours — heat flows downhill. The trouble is that u(x, t) is a function of a continuous x and a continuous t, so it carries infinitely many values. No computer can store a function defined at every one of uncountably many points.
So we make the oldest bargain in numerical PDEs: we agree to know u only at a finite scaffold of points, and to settle for an approximation everywhere else. This is the discretize-then-solve strategy that has shadowed every rung of this ladder — we met it turning an integral into a sum and a derivative into a difference quotient. A PDE just does it in two directions at once, space and time. The art of this rung is doing the swap so that the discrete recipe genuinely tracks the continuous physics, and not, as we will see, some plausible-looking impostor that quietly blows up.
Laying the grid
Pick a spatial step h and a time step k, and lay down a computational grid: the points x_j = j*h (j = 0, 1, ..., M) march across the rod, and the time levels t_n = n*k (n = 0, 1, 2, ...) climb upward. Think of it as graph paper, the rod running left-to-right and time running bottom-to-top. At each crossing sits one number, written u_j^n, our approximation to the true temperature u(x_j, t_n). The superscript n is a time level, not a power — that clash of notation trips up everyone once, so read u_j^n as 'the grid value at column j, row n'. Our entire job is to fill in this lattice of numbers, row by row, starting from a known bottom row (the initial temperature) and the two edge columns (the boundary conditions).
Picture the lattice concretely. The bottom row, n = 0, is fully known — it is the initial temperature u(x, 0) sampled at every column. The leftmost and rightmost columns, j = 0 and j = M, are also pinned down for all time: these are the boundary conditions, say the ends of the rod held in ice. Everything in the interior is unknown, and a scheme is simply a rule that fills one fresh row at a time, computing each value on row n+1 from values already settled on the rows beneath it. We never store more than a couple of rows at once; the past scrolls off the bottom as we climb.
Replacing a derivative with a stencil
Now the key move. A derivative is a limit of difference quotients; on a grid with fixed spacing we cannot take the limit, so we keep the quotient. This is exactly the finite-difference formula idea from the differentiation guide, now applied in space. For the second spatial derivative u_xx we reuse the second-order central difference: u_xx at node j is approximately (u_{j-1} - 2*u_j + u_{j+1}) / h^2. Three neighbouring values, weighted +1, -2, +1, divided by h^2. That little weighted pattern of nodes is a finite-difference stencil — the reusable shape we stamp down at every interior grid point to read off a derivative from arithmetic alone.
Where does that -2-in-the-middle pattern come from, and how good is it? Taylor's theorem again. Add the expansions of u(x + h) and u(x - h): the first-derivative terms cancel by symmetry, the u(x) terms combine, and what survives, after dividing by h^2, is u''(x) + (h^2 / 12)*u''''(x) + ... So the stencil's truncation error is O(h^2): it is the exact second derivative of the data plus a leftover of size proportional to h^2. Halve h and that error drops by four. This O(h^2) tag is the stencil's order of accuracy in space, and it is the first number we check when we ask whether a scheme is any good.
Assembling the scheme — and stepping forward
Now discretize both sides of u_t = a * u_xx at grid node (j, n). For the time derivative, use the simplest forward difference in time, u_t at (j, n) is approximately (u_j^{n+1} - u_j^n) / k. For the space derivative, use the three-point stencil on the current row n. Setting the two approximations equal gives (u_j^{n+1} - u_j^n) / k = a * (u_{j-1}^n - 2*u_j^n + u_{j+1}^n) / h^2. Because only one unknown, u_j^{n+1}, appears on the future row, we can simply solve for it. This is the FTCS scheme — Forward-Time, Central-Space — and it is the prototype explicit method.
let r = a * k / h^2 (the mesh ratio)
u_j^{n+1} = u_j^n + r * ( u_{j-1}^n - 2*u_j^n + u_{j+1}^n )
row n+1 (new) <- built entirely from row n (old)
stencil shape: u_{j-1}^n u_j^n u_{j+1}^n
\ | /
+----- u_j^{n+1}Look at what we have built. To get the entire new row, we sweep j across the interior and apply that one formula — every future value is written explicitly in terms of values we already know. There is no linear system to solve, just one multiply-add per node. With the mesh ratio r = a*k / h^2, the update reads u_j^{n+1} = r*u_{j-1}^n + (1 - 2*r)*u_j^n + r*u_{j+1}^n, a weighted average of three neighbours. When 0 < r <= 1/2 all three weights are non-negative and the new value is a genuine average, comfortingly like the physics: heat smooths out. That is the first whisper of stability, and it is no accident — the next guide makes that hint precise.
Does the discrete equation mean the right thing?
We swapped a continuous PDE for an algebraic update, but did we swap it for the same equation? The honest test is consistency: plug the true solution u(x, t) into the discrete formula and ask how badly it fails to satisfy it. That mismatch is the scheme's local truncation error, and it is just the sum of the two stencil errors we already computed — O(k) from the forward time difference, O(h^2) from the central space difference. As h and k both shrink to zero, that error vanishes, so the discrete equation does converge to u_t = a*u_xx. A scheme is consistent when its truncation error tends to zero with the grid spacing; FTCS is consistent, of order O(k) + O(h^2).
What you have, and where the rung goes
You now own the full pipeline of the finite-difference method: lay a grid over space and time, replace each derivative by a stencil of neighbouring grid values, equate the two sides at every interior node, and march the solution upward row by row from the initial condition. We did it for the heat equation, but the recipe is the template for the whole subject — the wave equation u_tt = c^2 * u_xx just uses a second-difference stencil in time as well, giving the leapfrog scheme; advection and full fluid models follow the same playbook with different stencils. Every value we compute is, of course, an approximation: the truncation error of the stencils sets a floor, the grid we can afford sets the resolution, and floating-point round-off lurks beneath it all.
Two cliff-hangers carry into the rest of the rung. First, FTCS put the space stencil on the old row, making the update explicit and cheap — but we hinted it is only safe when r <= 1/2. Put the stencil on the new row instead and every node couples to its unknown neighbours, forcing you to solve a linear system each step: an implicit scheme, the explicit-vs-implicit choice that guide 2 unpacks. Second, that r <= 1/2 limit is no folklore; guide 4 derives it cleanly from von Neumann analysis and the famous CFL condition. Between them, guide 3 pins down the deep result tying it all together — that for a consistent scheme, stability is exactly what you need for convergence. The grid and the stencil are the easy part; making them tell the truth is the rest of the climb.