the explicit versus implicit distinction
Every step method computes the next value y_(n+1) from what it already knows. There are two ways the next value can enter the formula. Either it appears alone on the left — give the right-hand side, out pops the answer with plain arithmetic. Or it appears on BOTH sides, tangled inside the formula — and then 'computing' it means solving an equation. The first kind is explicit; the second is implicit. It is the single most consequential fork in the design of a numerical method.
Precisely: an explicit method writes y_(n+1) = (an expression in already-known quantities only), like Euler's y_(n+1) = y_n + h f(t_n, y_n) or any classical Runge-Kutta or Adams-Bashforth formula. You evaluate and you are done. An implicit method has y_(n+1) appearing inside f on the right, as in backward Euler y_(n+1) = y_n + h f(t_(n+1), y_(n+1)) or the trapezoidal rule — so each step requires solving a (generally nonlinear) algebraic equation for y_(n+1), usually by Newton's method. Implicit steps cost much more per step.
So why ever pay that price? Because implicit methods have vastly larger regions of absolute stability. An explicit method stays stable only if the step h is small enough; for a stiff problem 'small enough' can be absurdly tiny, forcing millions of steps just to crawl through a placid stretch. An implicit method can take large, stable steps over that same stretch. The rule of thumb: explicit methods are simpler and cheaper per step and are the default for non-stiff problems; implicit methods are the only sane choice for stiff ones. Real solvers often switch between them automatically.
Forward (explicit) Euler: y_(n+1) = y_n + h f(t_n, y_n) — answer pops out directly. Backward (implicit) Euler: y_(n+1) = y_n + h f(t_(n+1), y_(n+1)) — y_(n+1) is buried inside f, so for, say, f = -100 y you solve y_(n+1) = y_n - 100 h y_(n+1), giving y_(n+1) = y_n / (1 + 100 h), stable for any h.
Explicit: compute directly. Implicit: solve an equation — but stay stable on stiff problems.
Implicit is not automatically more accurate than explicit — a method's order governs accuracy. The real payoff of implicit methods is stability, which is what lets them take large steps on stiff problems where explicit methods are crippled.