Contemporary work in IT is based on discrete state computing: logically instantaneous transitions between members of a finite and countable set of states. This is based in turn on a mathematical construct called the Finite State Machine. This model of computation has been wildly successful as a problem-solving mode, and it’s easy to do using increasingly inexpensive digital electronic circuits, so it’s no surprise that it has become dominant. It’s so prevalent that it’s a bit of a stretch for us to think outside of that particular box.
However, it wasn’t always this way. Discrete state computation (with a few cool exceptions such as the abacus and other mechanical calculators) wasn’t practical at all until the switching times of digital electronics became fast enough that they could reasonably approximate “instantaneous”, thus performing a helpful number of computational steps in a sensible span of time. Electronics in the real world were not useful for discrete state computing until the 1940s.
Before digital electronics, there were other computers that worked fine, solving problems quite well, including problems that would be considered hard programming projects today. These were analog computers, which had a radically different approach. They are worth looking at, not least because they model the actions of Complex Systems much more directly than anything we can do in the discrete state world.
Analog computers started out as purely mechanical devices. A slide rule is a fully mechanical analog computer, and a damned powerful one (which in skilled hands outperforms an ordinary keypad calculator for a lot of work, simply because punching all those keys can take longer than a few slipstick/graticule manipulations.) (Of course, you have to know what you’re doing, which is a hellish disadvantage in the minds of some.)
That is the essence of analog computing: there are moving physical parts. Instead of writing abstract logic to a universal logic machine, analog computers use real, physical length and angle to represent the state space of a problem.
When you add electrical machinery such as servos and synchros, you can do all kinds of new things.
Analog electromechanical computers, in their heyday, got quite large and complicated. They could solve dauntingly hard problems in real time: the most famous examples are probably the 20th Century naval gunnery fire control computers, which resolved the dizzying problems of throwing ballistic artillery shells dozens of miles from the guns of a rolling, pitching, maneuvering ship, through sea air of varying humidity and wind, in the direction of a target that was similarly maneuvering (and trying to work out where that target was going to be when the shells actually finished their trajectory.) The fire control computers actually moved the guns and turrets robotically to train them on the computed elevation and azimuth.
If you think about the problem in those terms, it seems kind of amazing that battleships and cruisers ever got sunk at all except by sheer accident; but analog technology was up to the grim task.
A less martial, and much more more charming, use of high-end analog computing was the tide-predicting machine. Not only did it embody something very close to what we today would call a Steampunk aesthetic, it carried out immensely complicated calculations in an elegant way. People relied on such machines up into the 1970s, when the digital revolution finally overturned their economic justification. Beautifully tooled, purpose-built electromechanical artifacts, all wires and gears and scaled pointers, just couldn’t provide the same ROI as software running on general-purpose digital computers.
Analog computers differ from discrete state computers in four main respects:
Hardware. Analog computers express algorithms in hardware, not in software.
Infinitesimal math. Where discrete state logic performs transitions between distinct states, analog computing treats state as an infinitesimally varying quantity. Discrete computing uses integers, and has to emulate the real numbers to any necessary precision; analog computing, by contrast, has no natural concept of integers. In an analog computer, a number is simply a mark engraved on a scale.
To put it another way: analog devices use calculus and trigonometry natively and have to emulate simple algebra by carefully machined markings; discrete state computing, quite the other way, must use numeric methods to emulate anything beyond algebra.
Domain input. An analog computer performs its actions over a continuous independent domain. Traversing that domain is the essential action of an analog device. This domain is sometimes time, as in the real-time resolution of multiple inputs in a fire-control computer; it’s sometimes some kind of master driving input standing in for time’s progress, as with the cranks that moved the early tide machines; and sometimes it’s just the dimensions and position of physical devices in motion - a scale’s linear position in a slide rule, the angular position of a synchro-servo controller, and so on. In no case is this domain discontinuous: instantaneous operations have no place in analog computing.
Holistic operation. Analog devices do not operate as separate parts. This is perhaps the oddest thing, from a digital computing perspective, because our first move, when looking at a programming problem, is to break it into separate subproblems. This doesn’t work in analog computing, which is actually analog’s biggest drawback (aside from the whole hardware-vs-software cost thing.) An analog computer has to be conceived and built as a whole in order to make sense, which is just a lot harder than the piecewise techniques we ordinarily use.
It’s significant that these characteristics of analog computing are also entirely true of Complex Systems.
Now, before anybody gets suspicious, I’d better say that I am emphatically not saying that we should throw out our existing machines and go back to analog computing in order to perform Systems modeling and computation. Digital logic is perfectly capable of emulating analog devices, and perfectly capable of modeling Complex Systems.
What I am saying is that thinking about the nature of analog devices can teach us a great deal about how to think about Systems; and that’s something we need, especially in light of the last 50 years or so of information processing practices. Everything we’ve done in computing for a long time has been oriented, not towards effective consideration of Systems, but towards how best to exploit the prodigious power of discrete state computation.
That tends to leave us a bit behind the curve when we do think about Systems. Given the nature of our world, I suspect we’ll need to find ways of modeling Systems better and better in years to come, and a lot of us will need to study some things that are, at this point, little-known and difficult specializations.
