Computers1

© Gualtiero Piccinini8/10/04

Abstract

According to some philosophers, there is no fact of the matter whether something is either a

computer, or some other computing mechanism, or something that performs no computations at

all. On the contrary, I argue that there is a fact of the matter whether something is a calculator or

a computer: a computer is a calculator of large capacity, and a calculator is a mechanism whose

function is to perform one out of several possible computations on inputs of nontrivial size at

once. This paper is devoted to a detailed defense of these theses, including a specification of the

relevant notion of “large capacity” and an explication of the notion of computer.

[I]t’s not helpful to say that the brain is a computer in the sense in which livers and hearts are (Searle 1992, p. 208).

In our everyday life, we distinguish between things that compute, such as pocket calculators, and

things that don’t, such as bicycles. We also distinguish between different kinds of computing

devices. Some devices, such as abaci, have parts that need to be manually moved, one by one.

These may be called computing aids. Other devices contain internal mechanisms that, once

started, operate on their data so as to produce a result without further external intervention. These

may be called calculators. Among things that compute, we single out a special class and call

them computers. At the very least, computers are special because they are more versatile than

other computing mechanisms—or any other mechanisms, for that matter. Computers can do

arithmetic but also graphics, word processing, Internet browsing, and myriad other things. No 1 Many thanks to Peter Machamer for his comments on earlier drafts. Ancestors of this paper were presented at the Canadian Society for the History and Philosophy of Science, Toronto, Canada, May 2002, at Computing and Philosophy (CAP@CMU), Pittsburgh, PA, August 2002, and at the University of Pittsburgh in January 2003. Thanks to the audiences for their feedback.

1

other artifacts come even close to having so many abilities. Computer versatility calls for an

explanation, and one goal of this paper is to sketch such an explanation.

In contrast with the above intuitive picture, some philosophers have suggested that there

is nothing distinctive about computers. Consider the following passage:

[T]here is no intrinsic property necessary and sufficient for all computers, just the interest-relative property that someone sees value in interpreting a system’s states as representing states of some other system, and the properties of the system support such an interpretation …. Conceivably, sieves and threshing machines could be construed as computers if anyone has reason to care about the specific function reflected in their input-output behavior (Churchland and Sejnowski 1992, p. 65-66).

If these authors are correct, then the double distinction between mechanisms that compute and

mechanisms that don’t, and between computers and other computing mechanisms, are ill

conceived. For according to them, there is no fact of the matter whether something is either a

computer, or some other computing mechanism, or something that performs no computations at

all. Whether anything is a computer, for these authors, is simply a function of the way we look at

it.

In the absence of a viable account of what computers are, it is tempting to conclude that

being a computer is an observer-relative matter, but anyone who accepts that conclusion has a lot

to explain away. She should explain away our intuition that there is something distinctive about

being a computer and our consequent practice of applying the term “computer” only to some

mechanisms—such as our desktops and laptops—and not to others. She should explain why we

think that the invention of computers was a major intellectual breakthrough and why there are

special sciences—computer science and computer engineering—devoted to studying the specific

properties of computers. Finally, she should explain why the mechanisms we ordinarily call

computers, but not other computing mechanisms that pre-date them (let alone non-computing

mechanisms), inspired the hypothesis that minds or brains are computers (von Neumann 1958,

Fodor 1975).

2

Explaining all of this away, I submit, is hopeless. For I hold that there is a fact of the

matter whether something is a calculator or a computer: a computer is a calculator of “large

capacity,”2 and a calculator is a mechanism whose function is to perform one out of several

possible computations on inputs of nontrivial size at once. The rest of this paper is devoted to a

detailed defense of these theses, including a specification of the relevant notion of “large

capacity,” and an explication of the notion of computer.

The topic of this paper is of interest for three reasons. First, computers are sufficiently

important, both practically and conceptually, that understanding what they are is valuable in its

own right. Second, a proper distinction between computers and other mechanisms, and between

different classes of computers, is part of the foundations of computer science. There is no

universally accepted notion of computer, and there have been numerous controversies over

whether certain machines count as computers of one kind or another (with nontrivial legal

consequences, cf. Burks 2002). Resolving those controversies requires clear and cogent criteria

for what counts as a computer of any significant kind, and this paper makes a step towards

providing such criteria. An example of how this illuminates a historical controversy will be given

in section 3 below. Finally, as will be illustrated in sections 4 and 5, a robust notion of computer

gives substance to theories according to which the brain is a computer.

The present analysis is conducted within the framework of what I call the functional

account of computing mechanisms, which I have formulated and defended elsewhere (Piccinini

2003, forthcoming a). According to the functional account, a computing mechanism is a

mechanism whose function is to perform computations. A computation, in turn, is the generation

of output strings of symbols from input strings of symbols in accordance with a general rule that

depends on the properties of the strings and applies to all strings. Finally, a string of symbols is a

sequence of concatenated discrete elements, each of which affects the mechanism based on its

2 This use of the phrase “large capacity” is due to John V. Atanasoff, who was apparently the first person to use the term “computer” for a kind of machine (Atanasoff 1940; Atanasoff 1984).

3

type and its position within the string.3 Furthermore, the explanation of computing mechanisms’

capacity to perform computations is given by a functional analysis of the mechanism, i.e. an

analysis in terms of the mechanisms’ components and the components’ functions.

It should go without saying that I assume that functional properties of mechanisms—

those that enter the functional analysis of mechanisms—are not observer-relative in the relevant

sense. This should be uncontroversial; even those who have argued that the notion of computer is

observer-relative (e.g., Putnam 1988, Searle 1992, Churchland and Sejnowski 1992) appear to

agree. The reason why they take the notion of computer to be observer-relative is that they do not

believe it can be analyzed in functional terms. I hope my detailed account will convince them

otherwise.

Within the framework of the functional account of computing mechanisms, I have

offered a detailed account of the components that enter the functional analysis of computing

mechanisms (Piccinini 2003). In analyzing computers, I will rely on the results of that account. I

distinguish between three classes of strings on the basis of the function they fulfill: (1) data,

whose function is to be the input of a computation; (2) results, whose function is to be the output

of a computation; and (3) instructions, whose function is to cause appropriate computing

mechanisms to perform specific operations. Lists of instructions are called programs. I also

appeal to four kinds of large-scale components of computing mechanisms: (1) processing units,

whose function is to execute any of a finite number of primitive operations on data; (2) memory

units, whose function is to store data, intermediate results, final results, and possibly instructions;

(3) input devices, whose function is to take strings of symbols from the environment and deliver

them to memory units, and (4) output devices, whose function is to take strings of symbols from

memory units and deliver them to the external environment. Some processing units can be 3 For a technical treatment of the theory of strings, see Corcoran et al. 1974. The present notion of computation over strings is a generalization of the rigorous notion of computation of functions over natural numbers, which was introduced by Alan Turing (Turing 1936-7) and other logicians. The present notion is relevant to the analysis of what are ordinarily called digital computers and computing mechanisms. In section 2.5 below, I will discuss so called analog computers and argue that they must be analyzed in terms of a different notion of computation.

4

further analyzed into datapaths, whose function is to perform operations on data, and control

units, whose function is to set up datapaths to perform the operation specified by any given

instruction.4

1 Calculators

Some authors have used the terms “calculator” and “computer” interchangeably. Following the

more common practice, I reserve “computer” to cover only a special class of calculators. Given

this restricted usage, a good way to introduce computers is to contrast them to their close

relatives, generic calculators.

A calculator is a computing mechanism made of four kinds of (appropriately connected)

components: input devices, output devices, memory units, and processing units. In this section, I

only discuss non-programmable calculators. So called “programmable calculators,” from a

functional perspective, are special purpose computers with small memory, and are subsumed

within the next section.5

Input devices of calculators receive two kinds of inputs from the environment: data for

the calculation and a command that determines which operation needs to be performed on the

data. A command is an instruction made of only one symbol, which is usually inserted in the

calculator by pressing an appropriate button. Calculators’ memory units hold the data, and

possibly intermediate results, until the operation is performed. Calculators’ processing units

perform one operation on the data. Which operation is performed depends only on which

command was inserted through the input device. After the operation is performed, the output

devices of calculators return the results to the environment. The results returned by calculators

are computable functions of the data. Hence, calculators—unlike the sieves and threshing

4 For more details on these large-scale components, and for their functional analysis in terms of simpler components, see Piccinini 2003.5 For more details on programmable calculators, and a statement that they are a kind of computers, see Engelsohn 1978.

5

machines mentioned by Churchland and Sejnowski—are genuine computing mechanisms.

However, the computing power of calculators is limited by three important factors.

First, (ceteris paribus) a calculator’s result is the value of one of a finite number of

functions of the data, and the set of those functions cannot be augmented (e.g., by adding new

instructions or programs to the calculator). The finite set of functions that can be computed by a

calculator is determined by the set of primitive operations on strings that can be performed by the

processing unit. Which of those functions is computed at any given time is determined by the

command that is inserted through the input device, which sets the calculator on one of a finite

number of initial states, which correspond to the functions the calculator can compute. In short,

calculators (in the present sense) are not programmable.

Second, a calculator performs only one operation on its data, after which it outputs the

result and stops. A calculator has no provision for performing several of its primitive operations

in a specified order, so as to follow an algorithm automatically.6 In other words, a calculator has

no control structure besides the insertion of commands through the input device.7 The operations

that a calculator can compute on its data can be combined in sequences, but only by inserting

successive commands through the input device after each operation is performed.

Finally, the range of values that calculators can compute is limited by the size of their

memory and input and output devices. Typically, calculators’ memories are of fixed size and

cannot be increased in a modular fashion. Also, calculators’ input and output devices only take

data and deliver results of fixed size. Hence, calculators can only operate within the size of those

data and results, and cannot outrun their fixed memory capacity.

As a consequence of these limitations, calculators lack computers’ most interesting

functional properties: calculators have no “virtual memory” and do not support “complex 6 Of course, each primitive operation of a calculator is performed by following a pseudo-algorithm (that is, an algorithm defined over finitely many inputs). But a calculator—unlike a computer—cannot follow any algorithm or pseudo-algorithm defined in terms of its primitive operations.7 A consequence of this is the often-remarked fact that calculators cannot perform branches; namely, they cannot choose among different operations depending on whether some condition obtains. (Branching is necessary to compute all computable functions.)

6

notations” and “complex operations.” In short, calculators have no “functional hierarchy.”

(These terms are explained in the next section.)

Calculators are computationally more powerful than simpler computing mechanisms,

such as logic gates or arithmetic-logic units. Nevertheless, the computing power of calculators is

limited in a number of ways. Contrasting these limitations with the power of computers sheds

light on why computers are so special and why computers, rather than calculators, have been used

as a model for the brain.

2 Computers

Like a calculator, a computer is made of four types of components: input devices, output devices,

memory units, and processing units. The processing units of modern computers are called

processors and can be analyzed as a combination of datapaths and control units. A schematic

representation of the functional organization of a modern computer (without input and output

devices) is shown in Figure 10-4.

7

Figure 1. The main components of a computer and their functional relations.

The difference between calculators and computers lies in the functional properties and

functional organization of their components. Computers’ processors are capable of branching

behavior and can be set up to perform any number of their primitive operations in any order (until

they run out of memory). Computers’ memory units are orders of magnitude larger than those of

calculators, and often they can be increased in a modular fashion if more storage space is

required. This allows today’s computers to take in data and programs, and yield results, of a size

that has no well-defined upper bound. So computers, unlike calculators, are programmable,

capable of branching, and capable of taking data and yielding results of “unbounded” size.

Because of these characteristics, today’s computers are called programmable, stored-program,

and computationally universal. (These terms are defined more explicitly below.)

If we were to define “computer” as something with all of the characteristics of today’s

computers, we would certainly obtain a robust, observer-independent notion of computer. We

8

would also lose the ability to distinguish between many classes of computing mechanisms that

lack some of those characteristics, yet are significantly more powerful than ordinary calculators,

are similar to modern computers in important ways, and were often called computers when they

were built. Because of this, I will follow the standard practice of using the term “computer” so as

to encompass more than today’s computers, while introducing distinctions among different

classes of computers. Ultimately, what matters for our understanding of computing mechanisms

is not how restrictively we use the word “computer,” but how careful and precise we are in

classifying computing mechanisms based on their relevant functional properties.

Until at least the 1940s, the term “computer” was used to designate people whose job was

to perform calculations, usually with the help of a calculator or abacus. Unlike the calculators

they used, these computing humans could string together a number of primitive operations (each

of which was performed by the calculator) in accordance with a fixed plan, or algorithm, so as to

solve complicated problems defined over strings of symbols. Any machine with an analogous

ability may also be called a computer.

To a first approximation, a computer is a computing mechanism with a control structure

that can string together a sequence of primitive operations, each of which can be performed by

the processing unit, so as to follow an algorithm or pseudo-algorithm (i.e., an algorithm defined

over finitely many inputs). The number of operations that a control structure can string together

in a sequence, and the complexity of the algorithm that a control structure can follow (and

consequently of the problem that can be solved by the machine), is obviously a matter of degree.

For instance, some machines that were built in the first half of the 20th century—such as the IBM

601—could string together a handful of arithmetical operations. They were barely more powerful

than ordinary calculators, and a computing human could easily do anything that they did. Other

machines—such as the Atanasoff-Berry Computer (ABC)—could perform long sequences of

operations on their data, and a computing human could not solve the problems that they solved

without taking a prohibitively long amount of time.

9

The ABC, which was completed in 1942 and was designed to solve systems of up to 29

linear algebraic equations in 29 unknowns, appears to be the first machine that was called

computer by its inventor.8 So, a good cut-off point between calculators and computers might be

the one between machines like the IBM 601, which can be easily replaced by computing humans,

and machines like the ABC, which outperform computing humans at solving at least some

problems.9 The exact boundary is best left vague. What matters to understanding computing

mechanisms is not how many machines we honor with the term “computer,” but that we identify

functional properties that make a difference in computing power, and that whether a machine

possesses any of these functional properties is a matter of fact, not interpretation. We’ve seen

that one of those functional properties is the ability to follow an algorithm defined in terms of the

primitive operations that a machine’s processing unit(s) can perform. Other important functional

properties of computers are discussed in the rest of this section.

Computers and their components can also be classified according to the technology they

use, which can be mechanical, electro-mechanical, electronic, etc., as well as according to other

characteristics (size, speed, cost, etc.). These differences don’t matter for our purposes, because

they don’t affect which functions can in principle be computed by different classes of computing

mechanisms. However, it is important to point out that historically, the introduction of electronic

technology, and the consequent enormous increase in computation speed, made a huge difference

in making computers practically useful.

2.1 Programmability

A computing human can do more than follow one algorithm to solve a problem. It can follow

any algorithm, which is typically given to her in the form of instructions, and thus she can

compute any function for which she has an algorithm. More generally, a human can be instructed

8 Atanasoff 1940. On the ABC, see also Burks and Burks 1988, Burks 2002, and Gustafson 2000.9 A similar proposal is made by Burks and Burks 1988, chap. 5.

10

to perform the same activity (e.g., knitting or cooking) in many different ways. Any machine,

such as a loom, that can be easily modified to yield different output patterns may be called

programmable. Being programmable means being modifiable so as to perform one’s activity in a

different way depending on the modification. Programmability is an important feature of most

computers. Computers’ activity is computing, so a programmable computer is a computer that

can be modified to compute different functions.

The simplest kind of programmability involves the performance of specified sequences of

operations on an input, without the characteristics of the input making any difference on what

operations must be performed. For instance, (ceteris paribus) a loom programmed to weave a

certain pattern will weave that pattern regardless of what specific threads it is weaving. The

properties of the threads make no difference to the pattern being weaved. In other words, the

weaving process is insensitive to the properties of the input. This kind of programmability is

insufficient for computing, because computing is an activity that (ceteris paribus) is sensitive to

relevant differences in input. This is because a mathematical function yields different values

given different arguments, so any mechanism that is computing that function must respond

differentially to the different input arguments so as to generate the correct output values. The

way to do this is for computing mechanisms to respond differentially to the different types of

symbols that make up the input and to the order in which they are concatenated into strings.

Accordingly, programming a computer requires specifying how it must respond to different

strings of symbols by specifying how it must respond to different types of symbols and different

positions within a string.10

What counts as a legitimate modification of a computer depends on the context of use

and the means that are available to do the modification. In principle, one could modify a

calculator by taking it apart and rewiring it or adding new parts, and then it would compute new

10 This distinction between programmability insensitive to the input and programmability sensitive to the input was inspired by a somewhat analogous distinction between executing a fixed sequence and using the output as input, which is made by Brennecke 2000, pp. 62-64.

11

functions. But this kind of modification would ordinarily be described as building a new machine

rather than programming the old one. So we should relativize the notion of programmability to

the way a machine is ordinarily used. This will not make a difference in the end, especially

because the kind of programmability that matters for most purposes is soft-programmability (see

below), where what counts as a relevant modification is determined unambiguously by the

functional organization of the computer.

Programmability comes in two main forms, hard and soft, depending on the type of

modification that needs to be made to the machine for it to behave in a different way.

2.1.1 Hard Programmability

Some early computers—including the celebrated ENIAC—had switches, plug-ins, and wires with

plugs, which sent signals to and from their computing components.11 Turning the switches or

plugging the wires in different configurations had the effect of connecting the computing

components of the machine in different ways, to the effect that the machine would perform

different series of operations. I call any computer whose modification involves the rewiring of

the machine hard programmable. Hard programming requires that users change the way the

computing components of a computer are spatially joined together, which changes the number of

operations that are performed or the order in which they are performed, so that different functions

are computed as a result. Hard programming requires technical skills and is relatively slow.

Programming is easier and faster if a machine is soft programmable.

2.1.2 Soft Programmability

Modern computers contain computing components that are designed to respond differentially to

different sequences of symbols, so that different operations are performed. These sequences of

symbols, then, act as instructions to the computer, and lists of instructions are called programs.

11 On the ENIAC, see Van der Spiegel et al. 2000.

12

In order to program these machines, it is enough to supply the appropriate arrangement of

symbols, without manually rewiring any of the components. I call any computer whose

modification involves the supply of appropriately arranged symbols (instructions) to the relevant

components of the machine soft programmable.

Soft programmability allows the use of programs of unbounded size, which are given to

the machine as part of its input. Since in this case the whole program is written down as a list of

instructions, in principle a soft programmable machine is not bound to execute the instructions in

the order in which they are written down in the program but can execute arbitrary instructions in

the list at any particular time. This introduces the possibility of conditional branch instructions,

which require the machine to jump from one instruction to an arbitrary instruction in the program

based on whether a certain condition (which can be checked by the processing unit(s)) obtains.

Conditional branch instructions are the most useful and versatile way of using intermediate

results of the computation to influence control, which is a necessary condition for computing all

computable functions.12 Since soft programmable computers can execute programs of unbounded

size and use intermediate results to influence control, they can be computationally universal (see

below).

There are two kinds of soft programmability: external and internal. A machine that is

soft programmable externally requires the programs to be inserted into the machine through an

input device, and does not have components that copy and store the program inside the machine.

For example, universal Turing Machines and some early punched cards computers—such as the

famous Harvard Mark I—are soft programmable externally.13

A machine that is soft programmable internally contains components whose function is

to copy and store programs inside the machine and to supply instructions to the machine’s

processing units. Internal soft programmability is by far the most flexible and efficient form of

12 This point is effectively made by Brennecke 2000, pp. 64-65.13 On the Harvard Mark I, see Cohen 1999.

13

programmability. It even allows the computer to modify its own instructions based on its own

processes, which introduces a final and most sophisticated level of computational control.14

A seldom-appreciated feature of internal soft programmability is that in principle, a soft-

programmable computer can generate (but not compute) non-computable outputs, that is, outputs

that are not computable by Turing Machines.15 If an internally soft programmable computer has

the ability to modify its program in a non-computable way (e.g., at random), then in principle the

execution of that (changing) program may yield an uncomputable sequence, and a computer that

is executing that program may generate such a sequence. I say that the sequence is generated, not

computed, because the relevant kind of program modification, which is responsible for the

uncomputability of the output, is not itself the result of a computation—it’s not itself a process of

transformation of input strings into output strings in accordance with a general rule that depends

on the properties of the input string and applies to all strings.

Internal soft programmability has become so standard that other forms of

programmability are all but forgotten or ignored. One common name for machines that are soft

programmable internally, which include all of today’s desktops and laptops, is stored-program

computers. For present purposes, however, it is better to use the term “stored-program” to refer

to the presence of programs inside a mechanism, whether or not those programs can be changed.

2.2 Stored-Program Computers

A stored-program computer has an internal memory that can store strings of symbols. Programs

are stored in memory as lists of instructions placed in appropriate memory units. A stored-

program computer also contains at least one processor. The processor contains a tracking

mechanism (program counter) that allows the processor to retrieve instructions from a program in

14 Cf. Brennecke 2000, p. 66.15 Alan Turing is one of the few people who discussed this feature of internally soft programmable computers; he used it in his reply to the mathematical objection to the view that machines can think. For an extended discussion, see Piccinini 2003b.

14

the appropriate order. The processor can extract strings of symbols from memory and copy them

into its internal registers (if they are data) or execute them on the data (if they are instructions).

After an instruction is executed, the tracking mechanism allows the control to retrieve the next

instruction until all the relevant instructions are executed and the computation is completed.

A stored-program machine need not be programmable. Some kinds of memory units are

read-only, namely they can communicate their content to other components but their content

cannot be changed. Stored-program calculators can be built using this kind of memory. Other

kinds of memory units are such that symbols can be inserted into them. This opens up the

possibility that a program be inserted from the outside of the computer (or from the inside, i.e.

from other parts of the memory or from the processor) into a memory unit, allowing a computer

to be (soft) programmed and the existing programs to be modified. Once the program is in the

appropriate part of the memory, the computer will execute that program on any data it gets. A

programmable stored-program computer can even be set up to modify its own program, changing

what it computes over time. Stored-program computers are usually designed to be soft

programmable and to execute any list of instructions, including branch instructions, up to their

memory limitations, which makes them computationally universal (see below). For this reason,

the term “stored-program computer” is often used as a synonym for “universal computer.”

The idea to encode instructions as sequences of symbols in the same form as the data for

the computation and the idea of storing instructions inside the computer are the core of the notion

of programmable, stored-program computer, which is perhaps the most fundamental aspect of

modern mechanical computing.16 At this point, it should be clear that not every computing

mechanism is a computer, and not every computer is a programmable, stored-program computer.

In order to have a programmable, stored-program computer, one needs to have a system of

symbols, a scheme for encoding instructions, a writable memory to store the instructions, and a

16 Patterson and Hennessy list these two ideas as the essence of modern computers (Patterson and Hennessy 1998, p. 121).

15

processor that is appropriately designed to execute those instructions. Several technical problems

need to be solved, such as how to retrieve the instructions from the memory in the right order and

how to handle malformed instructions. These properties of computers, the problems that need to

be solved to design them, and the solutions to those problems are all formulated in terms of the

components of the mechanism and their functional organization. This shows how the functional

account of computing mechanisms sheds light on the properties of computers.

2.3 Special-Purpose, General-Purpose, or Universal

Many old computers, which were not stored-program, were designed with specific applications in

mind, such as solving certain classes of equations. Some of these machines, like the ABC, were

hardwired to follow a specific algorithm. They are called special purpose computers to

distinguish them from their general-purpose successors. Special-purpose computers are still used

for a number of specialized applications; for instance, computers in automobiles are special-

purpose.

In the 1940s, several computers were designed and built to be programmable in the most

flexible way, so as to solve as many problems as possible.17 They were called general-purpose or,

as von Neumann said (von Neumann 1945), all-purpose computers. The extent to which

computers are general- or all-purpose is a matter of degree, which can be evaluated by looking at

how much memory they have and how easy they are to program and use for certain applications.18

General-purpose computers are programmable but need not be soft programmable, let alone

stored-program.

Assuming the Church-Turing thesis, namely the thesis that every effectively computable

function is computable by a Turing Machine, Alan Turing (1936-7) showed how to design

universal computing mechanisms, i.e. computing mechanisms that would take any appropriately 17 For an overview of early computers, see Rojas and Hashagen 2000.18 For a valuable attempt at distinguishing between degrees to which a computer may be called general-purpose, see Bromley 1983.

16

encoded program as input and respond to that program so as to compute any computable

function.19 Notice that Turing’s universal computing mechanisms, universal Turing Machines,

are not stored-program (see below for more discussion of Turing Machines).

We have seen that soft programmable computers can respond to programs of unbounded

length and manipulate their inputs (of finite but unbounded length) according to the instructions

encoded in the program. This does not immediately turn them into universal computers, for

example because they may not have the ability to handle branch-instructions, but no one builds

computers like that.20 Ordinary soft programmable computers, which are designed to execute all

the relevant kinds of instructions, are universal computing mechanisms. For example, ordinary

computers like our desktops and laptops are universal in this sense. Even Charles Babbage’s

legendary analytical engine was universal. Universal computers can compute any Turing-

computable function until they run out of memory. Because of this, the expressions “general-

purpose computer” and “all-purpose computer” are sometimes loosely used as synonyms of

“universal computer.”

2.4 Functional Hierarchies

Above, I briefly described the functional organization that allows soft-programmable computers

to perform a finite number of primitive operations in response to a finite number of the

corresponding kinds of instructions. Computers with this capability are computationally

universal up to their memory limitations. In order to get them to execute any given program

operating on any given notation, all that is needed is to encode the given notation and program

using the instructions of the computer’s machine language.

In early stored-program computers, this encoding was be done manually by human

programmers. It was slow, cumbersome, and prone to errors. To speed up the process of 19 For an introduction to computability theory, see Davis et al. 1994.20 Strictly speaking, branching is not necessary for computational universality, but the alternative is too impractical to be relevant (Rojas 1998).

17

encoding and diminish the number of errors, early computer designers introduced ways to

mechanize at least part of the encoding process, giving rise to a hierarchy of functional

organizations within the stored-program computer. This hierarchy is made possible by automatic

encoding mechanisms, such as operating systems, compilers, and assemblers. These mechanisms

are nothing but programs executed by the computer’s processor(s), whose instructions are often

written in special, read-only memories. These mechanisms generate virtual memory, complex

notations, and complex operations, which make the job of computer programmers and users

easier and quicker. I will now briefly explain these three notions and their functions.

When a processor executes instructions, memory registers for instructions and data are

functionally identified by the addresses of the memory registers that contain the data or

instructions. Moreover, each memory register has a fixed storage capacity, which depends on the

number of memory cells it contains. Virtual memory is a way to functionally identify data and

instructions by virtual addresses, which are independent of the physical location of the data and

instructions, so that a programmer or user need not keep track of the physical location of the data

and instructions she needs to use by specifying the register addresses of every relevant memory

location. During the execution phase, the physical addresses of the relevant memory registers are

automatically generated by the compiler on the basis of the virtual addresses. Since virtual

memory is identified independently of its physical location, in principle it can have unlimited

storage capacity, although in practice the total number of physical symbols that a computer can

store is limited by the size of its physical memory.21

In analyzing how a processor executes instructions, all data and instructions must be

described as binary strings (strings of bits) corresponding to the physical signals traveling through

the processor, and the functional significance of these strings is determined by their location

within an instruction or data string. Moreover, all data and instruction strings have a fixed length,

21 For more details on virtual memory, including its many advantages, see Patterson and Hennessy 1998, pp. 579-602.

18

which corresponds to the length of the memory registers that contain them. Complex notations,

instead, can contain any characters from any finite alphabet, such as the English alphabet.

Programmers and users can use complex notations to form data structures that are natural and

easy to interpret in a convenient way (similarly to natural languages). Thanks to virtual memory,

these strings can be concatenated into strings of any length (up to the computer’s memory

limitations). During the execution phase, the encoding of data structures written in complex

notations into data written in machine language is automatically taken care of by the functional

hierarchy within the computer (operating system, compiler, and assembler).

The processor can only receive a finite number of instruction types corresponding to the

primitive operations that the processor can execute. Complex operations are operations

effectively defined in terms of primitive operations or in terms of already effectively defined

complex operations. As long as the computer is universal, the Church-Turing thesis guarantees

that any computable operation can be effectively defined in terms of the primitive operations of

the computer. Complex operations can be expressed using a complex notation (e.g., an English

word or phrase; for instance, a high-level programming language may include a control structure

of the form UNTIL P TRUE DO ___ ENDUNTIL) that is more transparent to the programmers

and users than a binary string would be, and placed in a virtual memory location. A high-level

programming language is nothing but a complex notation that allows one to use a set of complex

operations in writing programs. For their own convenience, programmers and users will typically

assign a semantics to strings written in complex notations. This ascription of a semantics is often

implicit, relying on the natural tendency of language users to interpret linguistic expressions of

languages they understand. Thanks to virtual memory, complex instructions and programs

containing them can be of any length (up to the memory limitations of the computers). During

the execution of one of these programs, the encoding of the instructions into machine language

instructions is automatically taken care of by the functional hierarchy within the computer.

19

Notice that the considerations made in this section apply only to programmable, stored-

program, universal computers. In order to obtain the wonderful flexibility of use that comes with

the functional hierarchy of programming languages, one needs a very special kind of mechanism:

a programmable, stored-program, universal computer.

The convenience of complex notations and the complex operations they represent,

together with the natural tendency of programmers and users to assign them a semantics, makes it

tempting to conclude that computers’ inputs, outputs, and internal states are identified by their

content, and that computers respond to the semantic properties of their inputs and internal states.

For example, both computer scientists and philosophers sometimes say that computers

understand their instructions. The literal reading of these statements was discussed at length, and

rejected, in Piccinini 20003 and forthcoming a. Now we are ready to clarify in what sense

computers can be said to understand their instructions.

Every piece of data and every instruction in a computer has functional significance,

which depends on its role within the functional hierarchy of the computer. Before a program

written in a complex notation is executed, its data and instructions are automatically encoded into

machine language data and instructions. Then they can be executed. All the relevant elements of

the process, including the programs written in complex notation, the programs written in machine

language, and the programs constituting the functional hierarchy (operating system, compiler, and

assembler), can be functionally characterized as strings of symbols. All the operations performed

by the processor in response to these instructions can be functionally characterized as operations

on strings. The resulting kind of “computer understanding” is mechanistically explained without

ascribing any semantics to the inputs, internal states, or outputs of the computer.

At the same time, data and instructions are inserted into computers and retrieved from

them by programmers and users who have their own purposes. As long as the functional

hierarchy is working properly, programmers and users are free to assign a semantics to their data

and instructions in any way that fits their purposes. This semantics applies naturally to the data

20

and instructions written in the complex notation used by the programmers and users, although it

will need to be replaced by other semantics when the complex code is compiled and assembled

into machine language data and instructions. This shows that the semantics of a computer’s

inputs, outputs, and external states is unnecessary to individuate computing mechanisms and what

functions they compute.

2.5 Digital vs. Analog

Until now, I have restricted my analysis to devices that operate on strings of symbols. These

devices are usually called digital computers (and calculators). There are also so called analog

computers, which are no longer in widespread use but retain a theoretical interest. The distinction

between analog and digital computers has generated considerable confusion. For example, it is

easy to find claims to the effect that analog computers (or even analog systems in general) can be

approximated to any desired degree of accuracy by digital computers, countered by arguments to

the effect that some analog systems are computationally more powerful than Turing Machines

(Siegelmann 1999). There is no room here for a detailed treatment of the digital-analog

distinction in general, or even of the distinction between digital and analog computers in

particular. For present purposes, it will suffice to briefly draw some of the distinctions that are

lumped together under the analog-digital banner, and then analyze analog computers.

A first issue concerns modeling vs. analog computation. Sometimes scale models and

other kinds of “analog” models or modeling technologies (e.g., wind tunnels, certain electrical

circuits) are called analog computers (e.g., Hughes 1999, p. 138). This use is presumably due to

the fact that analog models, just like analog computers properly so called, are used to draw

inferences about other systems. The problem with this use of the term “analog computer” is that

everything can be said to be analogous to something else in some respect and used to draw

inferences about it. This turns everything into an analog computer in this sense, which trivializes

21

the notion of analog computer. But aside from the fact that both analog computers and other

analog models are used for modeling purposes, this use of the term “analog computer” has little

to do with the standard notion of analog computer; hence, it should be left out of discussions of

computing mechanisms.

A second issue concerns whether a system is continuous or discrete. Analog systems are

often said to be continuous, whereas digital systems are said to be discrete. When some

computationalists claim that connectionist or neural systems are analog, their motivation seems to

be that some of the variables representing connectionist systems can take a continuous range of

values.22 One problem with grounding the analog-digital distinction in the continuous-discrete

distinction is that a system can only be said to be continuous or discrete under a given

mathematical description, which applies to the system at a certain level of analysis. Thus, the

continuous-discrete dichotomy seems insufficient to distinguish between analog and digital

computers other than in a relative manner. The only way to establish whether physical systems

are ultimately continuous or discrete depends on fundamental physics. Some speculate that at the

most fundamental level, everything will turn out to be discrete (e.g., Wolfram 2002). If this were

true, under this usage there would be no analog computers at the fundamental physical level. But

the physics and engineering of middle-sized objects are still overwhelmingly done using

differential equations, which presuppose that physical systems as well as spacetime are

continuous. This means that at the level of middle-sized objects, there should be no digital

computers. But the notions of digital and analog computers have a well-established usage in

computer science and engineering, which seems independent of the ultimate shape of physical

theory. This suggests that the continuous-discrete distinction is not enough to draw the

distinction between analog and digital computers.

22 Cf.: “The input to a neuron is analog (continuous values between 0 and 1)” (Churchland and Sejnowski 1992, p. 51).

22

Previous philosophical treatments of the digital-analog distinction have addressed a

generic, intuitive distinction, with special emphasis on modes of representation, and did not take

into account the functional properties of different classes of computers.23 Those treatments do not

serve our present purposes, for two reasons. First, our current goal is to understand computers

qua computers and not qua representational systems. In other words, we should stay neutral on

whether computers’ inputs, outputs, or internal states represent, and if they do, on how they do so.

Second, we are following the functional account of computing mechanisms, according to which

computing mechanisms should be understood in terms of their functional properties.

Analog and digital computers are best distinguished by their functional analysis.24 Like

digital computers, analog computers are made of (appropriately connected) input devices, output

devices, and processing units (and in some cases, memory units). Like digital computers, analog

computers have the function of generating outputs in accordance with a general rule whose

application depends on their input. Aside from these broad similarities, however, analog

computers are very different from digital ones.

The most fundamental difference is in the inputs and outputs. Whereas the inputs and

outputs of digital computers and their components are strings of symbols, the inputs and outputs

of analog computers and their components are what mathematicians call real variables (Pour-El

1974). From a functional perspective, real variables are physical magnitudes that (i) vary over

time, (ii) (are assumed to) take a continuous range of values within certain bounds, and (iii) (are

assumed to) vary continuously over time. Examples of real variables include the rate of rotation

of a mechanical shaft and the voltage level in an electric wire.

The operations performed by computers are defined over their inputs and outputs.

Whereas digital computers and their components perform operations defined over strings, analog

computers and their components perform operations on real variables. Specifically, analog

23 Cf. Goodman 1968, Lewis 1971, Haugeland 1981, and Blanchowicz 1997.24 Authoritative works on analog computers, which I have used as sources for the following remarks, include Jackson 1960, Johnson 1963, Korn and Korn 1972, and Wilkins 1970.

23

computers and their processing units have the function of transforming an input real variable into

an output real variable that stands in a specified functional relation to the input. The discrete

nature of strings makes it so that digital computers perform discrete operations on them (that is,

they update their states only once every clock cycle), whereas the continuous change of a real

variable over time makes it so that analog computers must operate continuously over time. By

the same token, the rule that specifies the functional relation between the inputs and outputs of a

digital computer is an effective procedure, i.e. a sequence of instructions, defined over strings

from an alphabet, which applies uniformly to all relevant strings, whereas the “rule” that

represents the functional relation between the inputs and outputs of an analog computer is a

system of differential equations.

Due to the nature of their inputs, outputs, and corresponding operations, analog

computers are intrinsically less precise than digital computers, for two reasons. First, analog

inputs and outputs can be distinguished from one another only up to a bounded degree of

precision, which depends on the precision of the preparation and measuring processes, whereas

by design, digital inputs and outputs can always be unambiguously distinguished. Second, analog

operations are affected by the interference of an indefinite number of physical conditions within

the mechanism, which are usually called “noise,” to the effect that their output is usually a worse

approximation to the desired output than the input is to the desired input. These effects of noise

may accumulate during the computation, making it difficult to maintain a high level of

computational precision. Digital operations, by contrast, are unaffected by this kind of noise.

Another limitation of analog computers, which does not affect their digital counterparts,

is inherited from the physical limitations of any device. In principle, a real variable can take any

real number as a value. In practice, a physical magnitude within a device can only take values

within the bound of the physical limitations of the device. Physical components break down or

malfunction if some of their relevant physical magnitudes, such as voltage, take values beyond

certain bounds. Hence, the values of the inputs and outputs of analog computers and their

24

components must fall within certain bounds, for example 100 volts. Given this limitation, using

analog computers requires that the problems being solved be appropriately scaled so that they do

not require the real variables being manipulated by the computer to exceed the proper bounds of

the computer’s components. This is an important reason why the solutions generated by analog

computers need to be checked for possible errors by employing appropriate techniques (which

often involve the use of digital computers).

Analog computers are designed and built to solve systems of differential equations. The

most effective general analog technique for this purpose involves successive integrations of real

variables. Because of this, the crucial components of analog computers are integrators, whose

function is to output a real variable that is the integral of their input real variable. The most

general kinds of analog computers that have been built—general purpose analog computers—

contain a number of integrators combined with at least four other kinds of processing units, which

are defined by the operations that they have the function to perform on their input. Constant

multipliers have the function of generating an output real variable that is the product of an input

real variable times a real constant. Adders have the function of generating an output real variable

that is the sum of two input real variables. Variable multipliers have the function of generating

an output real variable that is the product of two input real variables. Finally, constant function

generators have the function of generating an output whose value is constant. Many analog

computers also include special components that generate real variables with special functional

properties, such as sine waves. By connecting integrators and other components in appropriate

ways, which may include feedback (i.e., recurrent) connections between the components, analog

computers can be used to solve certain classes of differential equations.

Pure analog computers are hard programmable, not soft programmable. For programs,

on which soft programmability is based, cannot be effectively encoded using the real variables on

which analog computers operate. This is because for a program to be effectively encoded, the

device that is responding to it must be able to unambiguously distinguish it from other programs.

25

This can be done only if a program is encoded as a string. Effectively encoding programs as

values of real variables would require unbounded precision in storing and measuring a real

variable, which is beyond the limits of current analog technology.

Analog computers can be divided into special purpose computers, whose function is to

solve very limited classes of differential equations, and general purpose computers, whose

function is to solve larger classes of differential equations. Insofar as the distinction between

special and general purpose analog computers has to do with flexibility in their application, it is

analogous to the distinction between special and general purpose digital computers. But there are

important disanalogies: these two distinctions rely on different functional properties of the

relevant classes of devices, and the notion of general purpose analog computer, unlike its digital

counterpart, is not an approximation of Turing’s notion of computational universality (see section

2.3 above). Computational universality is a notion defined in terms of computation over strings,

so analog computers—which do not operate on strings—are not devices for which it makes sense

to ask whether they are computationally universal. Moreover, computationally universal

mechanisms are computing mechanisms that are capable of responding to any program (written in

an appropriate language). We have already seen that pure analog computers are not in the

business of executing programs; this is another reason why analog computers are not in the

business of being computationally universal.

It should also be noted that general purpose analog computers are not maximal kinds of

computers in the sense in which standard general purpose digital computers are. At most, a

digital computer is capable of computing the class of Turing-computable functions. By contrast,

it may be possible to extend the general purpose analog computer by adding components that

perform different operations on real variables, and the result may be a more powerful analog

computer.25

25 For some speculations in this direction, see Rubel 1993.

26

Since analog computers do not operate on strings, we cannot use Turing’s notion of

computable functions over strings to measure the power of analog computers. Instead, we can

measure the power of analog computers by employing the notion of functions of a real variable.

Refining work by Shannon (1941), Pour-El has precisely identified the class of functions of a real

variable that can be generated by general purpose analog computers. They are the differentially

algebraic functions, namely, functions that arise as solutions to algebraic differential equations

(Pour-El 1974; see also Lipshitz and Rubel 1987, and Rubel and Singer 1985). Algebraic

differential equations are equations of the form P(y, y’, y’’, … y(n)) = 0, where P is a polynomial

with integer coefficients and y is a function of x. Furthermore, it has been shown that there are

algebraic differential equations that are “universal” in the sense that any continuous function of a

real variable can be approximated with arbitrary accuracy over the whole positive time axis

0t< by a solution of the equation. Corresponding to such universal equations, there are

general purpose analog computers with as little as four integrators whose outputs can in principle

approximate any continuous function of a real variable arbitrarily well (see Duffin 1981,

Boshernitzan 1986).

We have seen that analog computers cannot do everything that digital computers can; in

particular, they cannot operate on strings and cannot execute programs. On the other hand, there

is an important sense in which digital computers can do everything that general purpose analog

computers can. Rubel has shown that given any system of algebraic differential equations and

initial conditions that describe a general purpose analog computer A, it is possible to effectively

derive an algorithm that will approximate A’s output to an arbitrary degree of accuracy (Rubel

1989). From this, however, it doesn’t follow that the behavior of every physical system can be

approximated to any desired degree of precision by digital computers.

Some limitations of analog computers can be overcome by adding digital components to

them and by employing a mixture of analog and digital processes. A detailed treatment of hybrid

computing goes beyond the scope of this paper. Suffice it to say that the last generation of analog

27

computers to be widely used were analog-digital hybrids, which contained digital memory units

as well as digital processing units capable of being soft programmable (Korn and Korn 1972). In

order to build a stored-program or soft programmable analog computer, one needs digital

components, and the result is a computer that owes the interesting computational properties that it

shares with digital computers (such as being stored-program and soft-programmable) to its digital

properties.

Given how little (pure) analog computers have in common with digital computers, and

given that analog computers do not even perform computations in the sense of the mathematical

theory of computation, one may wonder why both classes of devices are called computers. The

answer lies in the history of these devices. As mentioned above, the term “computer” was

apparently first used for a machine (as opposed to a computing human) by John Atanasoff in the

early 1940s. At that time, what we now call analog computers were called differential analyzers.

Digital machines, such as Atanasoff’s ABC, which operated on strings of symbols, were often

designed to solve problems similar to those solved by differential analyzers—namely solving

systems of differential equations—by the manipulation of strings. Since the new digital machines

operated on symbols and could replace computing humans at solving complicated problems, they

were dubbed computers. The differential analyzers soon came to be re-named analog computers,

perhaps because both classes of machines were initially designed for similar practical purposes,

and for a few decades they were in competition with each other. This historical event should not

blind us to the fact that analog computers perform operations that are radically different from

those of digital computers, and have very different functional properties. Atanasoff himself, for

one, was clear about this: his earliest way to distinguish digital computing mechanisms from

analog machines like the differential analyzer was to call the former “computing machines

proper” (quoted by Burks 2002, p. 101).

28

2.6 Serial vs. Parallel

The distinction between parallel and serial computers has also generated some confusion. A

common claim is that the brain cannot be a “serial digital computer” because it is “parallel”

(Churchland et al. 1990, p. 47; Churchland and Sejnowski 1992, p. 7). In evaluating this claim,

we should keep in mind that digital computers can be parallel too, in several senses of the term.

There are many distinctions to be made, and our understanding of computers can only improve if

we make at least the main ones explicit.

There is the question of whether in a computing mechanism only one computationally

relevant event—for instance, the transmission of a signal between components—can occur during

any relevant time interval. In this sense, most complex computing mechanisms are parallel. For

example, in most computing mechanisms, the existence of many communication lines between

different components allows data to be transmitted in parallel. Even Turing Machines do at least

two things at a time; namely, they act on their tape and update their internal state.

A separate question is whether a computing mechanism can perform only one or more

than one computational operation during any relevant time interval. Analog computers are

parallel in this sense. This is the sense that connectionist computationalists appeal to when they

say that the brain is “massively parallel.” But again, most complex computing mechanisms, such

as Boolean circuits, are parallel in this sense. Since most (digital) computers are made out of

Boolean circuits and other computing components that are parallel in the same sense, they are

parallel in this sense too. In this respect, then, there is no principled difference between ordinary

computers and connectionist computing mechanisms.

A third question is whether a computing mechanism executes one or more than one

instruction at a time. There have been attempts to design parallel processors, which perform

many operations at once by employing many executive units (such as datapaths) in parallel.

Another way to achieve the same goal is to connect many processors together within one

supercomputer. There are now in operation supercomputers that include thousands of processors

29

working in parallel. The difficulty in using these parallel computers consists of organizing

computational tasks so that they can be modularized, i.e. divided into sub-problems that can be

solved independently by different processors. Instructions must be organized so that executing

one (set of) instruction(s) is not a prerequisite for executing other (sets of) instructions in parallel

to it (them), and does not interfere with their execution. This is sometimes possible and

sometimes not, depending on which part of which computational problem is being solved. Some

parts of some problems can be solved in parallel, but others can’t, and some problems must be

solved serially. Another difficulty is that in order to obtain the benefits of parallelism, typically

the size of the hardware that must be employed in a computation grows (linearly) with the size of

the input. This makes for prohibitively large (and expensive) hardware as soon as the problem

instances to be solved by parallel computation become nontrivial in size. This is the notion of

parallelism that is most relevant to computability theory. Strictly speaking, it applies only to

computing mechanisms that execute instructions. Hence, it is irrelevant to discussing ordinary

analog computers and connectionist computing mechanisms, which do not execute instructions.

In the connectionist literature, there is a persistent tendency to call neurons “processors”

(e.g., Siegelmann 2003). Presumably, the intended analogy is between a brain and a parallel

computer that contains many processors, so that every neuron corresponds to one processor. This

is misleading, because there is no useful sense in which a neuron can be said to execute

instructions in the way that a computer processor can. In terms of their functional role within a

computing mechanism, neurons compare more to logic gates than to the processors of digital

computers; in fact, modeling neurons as logic gates was the basis for the first formulation of a

computational theory of the brain (McCulloch and Pitts 1943). Nevertheless, it may be worth

noticing that if the comparison between neurons and processors is taken seriously, then in this

sense—the most important for computability theory—neurons are serial processors, because they

do only one functionally relevant thing (either they fire or they don’t) during any relevant time

interval. Even if one looks at an entire connectionist network as a processor, one gets the same

30

result; namely, that the network is a serial processor (it turns one input string into one output

string). However, neither neurons nor ordinary connectionist computing mechanisms are really

comparable to computer processors in terms of their organization and function—they certainly

don’t execute instructions. So, to compare connectionist systems and computer processors in this

respect is inappropriate.

Finally, there is the question of whether a processor starts executing an instruction only

after the end of the execution of the preceding instruction, or whether different instructions are

executed in an overlapping way. This is possible when the processor is organized so that the

different activities that are necessary to execute instructions (e.g., fetching an instruction from

memory, executing the corresponding operation, and writing the result in memory) can all be

performed at the same time on different instructions by the same processor. This kind of

parallelism in the execution of instructions diminishes the global computation time for a given

program, and it applies only to processors that execute instructions. It is a common feature of

contemporary computers, where it is called pipelining.26

The above parallel-serial distinctions apply clearly to computing mechanisms, but the

parallel-serial distinction is obviously broader than a distinction between modes of computing.

Many things other than computations can be done in parallel. For example, instead of digging ten

holes by yourself, you can get ten people to dig ten holes at the same time. Whether a process is

serial or parallel is a different question from whether it is digital or analog (in various senses of

the term), computational or non-computational.

3 Application 1: Are Turing Machines Computers?

Turing Machines (TMs) can be seen and studied mathematically as lists of instructions, without

any mechanical counterpart. But they can also be seen as a type of computing mechanism, which

is made out of a tape divided into squares and a unit that moves along the tape, acts on it, and is

26 For more details on pipelining, see Patterson and Hennessy 1998, chap. 6.

31

in one out of a finite number of internal states (see Davis et al. 1994 for more details). The tape

and the active unit are the components of TMs, whose functions are, respectively, storing

symbols and performing operations on symbols. The active unit of TMs is typically not further

analyzed, but in principle it may be functionally analyzed as a Boolean Circuit plus a memory

register. When they are seen as mechanisms, TMs fall naturally under the functional account of

computing mechanisms. They are uniquely identified by their functional analysis, which includes

their list of instructions.

There are two importantly different classes or TMs: ordinary TMs and universal TMs.

Ordinary TMs are not programmable and a fortiori not universal. They are “hardwired” to

compute one and only one function, as specified by the list of instructions that uniquely

individuates each TM. Since TMs’ instructions constitute full-blown algorithms, by the light of

the present analysis they are special-purpose computers.

Universal TMs, on the other hand, are programmable (and of course universal), because

they respond to a portion of the symbols written on their tape by computing the function that

would be computed by the TM encoded by those symbols. Nevertheless, universal TMs are not

stored-program computers, because their architecture has no memory component—separate from

its input and output devices—for storing data, instructions, and results. The programs for

universal TMs are stored on the same tape that contains the input and the output. In this respect,

universal TMs are analogous to early punched cards computers. The tape can be considered an

input and output device, and with some semantic stretch, a memory. But since there is no

distinction between input device, output device, and memory, a universal TM should not be

considered a stored-program computer properly so called, for the same reason that punched cards

machines aren’t.

Even after the invention of TMs, it was still an important conceptual advance to design

computers that could store their instructions in their internal memory component. So, it is

anachronistic to attribute the idea of the stored-program computer to Turing (as done, e.g., by

32

Aspray 1990 and Copeland 2000a). This exemplifies how a proper understanding of computing

mechanisms, based on functional analysis, can shed light on the history of computing.

4 Application 2: A Taxonomy of Computationalist Theses

Computing mechanisms have been employed in computational theories of mind and brain. These

theories are sometimes said to be metaphors (Eliasmith 2003), but a careful reading of the

relevant works shows that computationalism is a literal mechanistic hypothesis (Piccinini 2003c,

forthcoming b). The functional account of computing mechanisms can be used to add precision

to computationalist theses about the brain by taxonomizing them in order of increasing strength.

The theses range from the commonsensical and uncontroversial thesis that the brain processes

information to the strong thesis that it is a programmable, stored-program, universal computer.

Each thesis presupposes the truth of the preceding one and adds a further assumption to it:

1) The brain is a collection of interconnected neurons that deal with information and control

(in an intuitive, formally undefined sense).

2) Networks of neurons are computing mechanisms.

3) Networks of neurons are Boolean circuits or finite state automata (McCulloch and Pitts

1943).27

4) The brain is a programmable computer (Devitt and Sterelny 1999).

5) The brain is a programmable, stored-program computer (Fodor 1975).

6) The brain is a universal computer (Newell and Simon 1976).28

27 For the notions of Boolean circuit and finite state automaton and their computing power, see Piccinini 2003.28 Strictly speaking, (6) does not presuppose (5). For instance, universal TMs are not stored-program. In practice, however, all supporters of (6) also endorse (5), for the good reason that there is no evidence of a storage system in the environment—analogous to the tape of TMs—that would store the putative programs executed by brains.

33

Thesis (1) is sufficiently weak and generic that it entails nothing controversial about

neural mechanisms. Even a non-cognitivist (e.g., a behaviorist) should agree on this. I mention it

here to distinguish it from nontrivial computationalist theses and leave it out of the discussion.

Historically, thesis (3) is the first formulation of computationalism. Its weakening leads

to (2), which includes modern connectionist computationalism. Its strengthening leads to what is

often called classical (i.e., non-connectionist) computationalism. Classical computationalism is

usually identified with (5) or (6), but sometimes (4) has been discussed as an option. The above

taxonomy allows us to see that different formulations of computationalism are not equivalent to

one another, and that they vary in the strength of their assumptions about the functional properties

of neural mechanisms.

The above list includes only the theses that have figured prominently in the

computationalist literature. This list is by no means exhaustive of possible computationalist

theses. First, notice that (3) can be divided into a relatively weak thesis—according to which the

brain is a collection of Boolean circuits—and a much stronger one—according to which the brain

is a collection of finite state automata. The functional account of computing mechanisms shows

how to construct theses that are intermediate in strength between these two. For instance, one

could hypothesize that the brain is a collection of components that can execute complex pseudo-

algorithms (i.e., effective procedures defined only on finitely many inputs of bounded length),

like the multiplication and division components of modern computers.

Another possible version of computationalism is the hypothesis that the brain is a

calculator. This possibility is intriguing because no one has ever proposed it, even though

calculators are bona fide computing mechanisms. The functional account of computing

mechanisms sheds light on this fact. Among other limitations calculators have, the computational

repertoire of calculators is fixed. There is no interesting sense in which they can learn to compute

new things or acquire new computational behavior. One important factor that attracted people to

34

computationalism is the flexibility and power of computers, flexibility and power that calculators

lack. Because of this, it is not surprising that no one has proposed that brains are calculators.

The kinds of computers that are most strongly associated with computationalism are

programmable, stored-program, universal computers, because they have the exciting property that

given appropriate programs stored inside the machine, they can automatically compute any

computable function, and they can modify their programs automatically (which gives them an

important kind of learning ability).

5 Application 3: Questions of Hardware

It is often said that even if the brain is a computing mechanism, it need not have a von Neumann

architecture (Pylyshyn 1984, Churchland and Sejnowski 1992). In these discussions, “von

Neumann architecture” is used as a generic term for the functional organization of ordinary

digital computers. This claim is used to discount apparent dissimilarities between the functional

organization of brains and that of ordinary digital computers as irrelevant to computationalism.

The idea is that brains may compute by means other than those exploited by modern digital

computers.

It is true that not all computing mechanisms need have a von Neumann architecture. For

example, Turing Machines don’t. But this does not eliminate the constraints that different

versions of computationalism put on the functional organization of the brain, if the brain is to

perform the relevant kinds of computations. In the current discussion, I am intentionally avoiding

the term “von Neumann architecture” because it is so generic that it obscures the many issues of

functional organization that are relevant to the design and computing power of computing

mechanisms. The present account allows us to increase the precision of our claims about

computer and brain architectures, avoiding the generic term “von Neumann architecture” and

focusing on various functional properties of computing mechanisms (and hence on what their

computing power is).

35

If the brain is expected to be a programmable, stored-program, universal computer, as it

is by some versions of computationalism, it must contain programs as well as components that

store and execute programs. More generally, any kind of computation, even the most trivial

transformation of one symbol into another (as performed by a NOT gate) requires appropriate

hardware. So every nontrivial computationalist thesis, depending on the computation power it

ascribes to the brain, constrains the functional properties that brains must exhibit if they are to

perform the relevant computations. The following are general questions about neural hardware

that apply to some or all computationalist theses about the brain:

1. What are the symbols manipulated in the neural computation, and what are their types?

2. What are the elementary computational operations on neural symbols, and what are the

components that perform them?

3. How are the symbols concatenated to one another, so that strings of them can be

identified as inputs, internal states, and outputs of neural mechanisms and nontrivial

computations from input strings to output strings can be ascribed to neural mechanisms?

4. What are the compositional rules between elementary operations, and the corresponding

ways to connect the components, such that complex operations can be formed out of

elementary ones and performed by the mechanism?

5. If the system stores programs or even just data for the computations, what are the

memory cells and registers and how do they work?

6. What are the control units that determine which operations are executed at any given time

and how do they work? This question is particularly pressing if there has to be execution

of programs, because the required kind of control unit is particularly sophisticated and

needs to correctly coordinate its behavior with the components that store the programs.

36

When McCulloch and Pitts (1943) initially formulated computationalism, they had

answers to the relevant versions of the above questions. In answer to (1), they thought that the

presence and the absence of a neural spike were the two types of symbols on which neural

computations were defined. In answer to (2), they appealed to Boolean operations and claimed

that they were performed by neurons. In answer to (3) and (4), they relied on a formalism they in

part created and in part drew from Carnap, which is equivalent to a mixture of Boolean algebra

and finite state automata. In answer to (5), McCulloch hypothesized that there were closed loops

of neural activity, which acted as memory cells. In answer to (6), they largely appealed to the

innate wiring of the brain.29

When von Neumann formulated his own version of computationalism (von Neumann

1958), he also tried to answer at least the first two of the above questions. In answer to (1), he

thought that the firing rates of neurons were the symbol types. In answer to (2), he thought the

elementary operations were arithmetical and logical operations on these firing rates. Although

von Neumann’s answers take into account the functional significance of neuronal spikes as it is

understood by modern neurophysiologists, von Neumann did not have answers to questions 3 to

6, and he explicitly said that he did not know how the brain could possibly achieve the degree of

computational precision that he thought it needed under his assumptions about its computational

organization.30

Today’s computationalists no longer believe McCulloch’s or von Neumann’s versions of

computationalism. But if computationalism is to remain a substantive, empirical hypothesis

about the brain, these questions need to find convincing answers. If they don’t, it may be time to

abandon computationalism in favor of other functional explanations of neural mechanisms.

29 For a detailed analysis of McCulloch and Pitts’s theory, see Piccinini forthcoming b.30 For a more extended discussion of von Neumann’s theory of the brain, see Piccinini 2003a.

37

6 Conclusion

Contrary to what some maintain (e.g., Churchland and Sejnowski 1992), whether something is a

computer, and what kind of computer it is, is independent of observers. Computers are very

special mechanisms, whose function is to perform computations that involve long sequences of

primitive operations on strings of symbols, operations that can be directly performed by the

computers’ processors. Whether something performs computations, and what computations it

performs, can be determined by functional analysis. Moreover, different classes of computers

can be programmed in different ways or compute different classes of functions. These and other

useful distinctions between classes of computers can be drawn by looking at computers’

functional properties, and can be profitably used in historical and philosophical discussions

pertaining to computers.

This functional account of computers has several advantages. First, it underwrites our

intuitive distinctions between systems that compute and systems that don’t, and between

computers and other computing mechanisms (such as calculators). Second, it explains the

versatility of computers in terms of their functional organization. Third, it sheds light on why

computers, not calculators or other computing mechanisms, inspired the computational theory of

mind and brain. Fourth, it explicates the notion of explanation by program execution, i.e. an

explanation of a system’s capacity by postulating the execution of a program for that capacity.

Explanations by program execution are invoked in the philosophy of mind literature (cf.

Piccinini forthcoming c). Given the functional account of computers, explanations by program

execution are a special kind of functional explanation, which relies on the special kind of

functional analysis that applies to soft programmable computers. Soft programmable computers

are computers with processors that respond differentially to different strings of symbols, to the

effect that different operations are performed on the data. Program execution is a process by

which a (stable state of a) certain part of the mechanism, the program, affects a certain other part

of the mechanism, the processor, so that the processor performs appropriate operations on a

38

(stable state of a) certain other part of the mechanism, the data. A mechanism must be

functionally analyzable in this way to be subject to explanation by program execution.

Explanation by program execution is the most interesting genus of the species of explanation by

appeal to the computations performed by a mechanism. Appealing to the computations

performed by a mechanism is explanatory in so far as the mechanism is a computing mechanism,

i.e. a mechanism subject to the relevant kind of functional analysis. By identifying more

precisely the class of computers that support explanation by program execution and how they do

so, the functional account of computers vindicates the use of explanation by program execution in

the philosophy of mind (within the constraints of an appropriate functional analysis of the

relevant mechanisms).

Finally, the present account of computers can be used to formulate a rigorous taxonomy

of computationalist theses about the brain, which makes explicit their empirical commitments to

specific functional properties of brains, and to compare the strength of the different empirical

commitments of different computationalist theses. This makes it ideal to ground discussions of

computational theories of mind and brain.

ReferencesAtanasoff, J. V. (1940). Computing Machine for the Solution of Large Systems of Linear

Algebraic Equations. Ames, Iowa, Iowa State College.Atanasoff, J. V. (1984). "Advent of Electronic Digital Computing." Annals of the History of

Computing 6(3): 229-282.Boshernitzan, M. (1986). "Universal Formulae and Universal Differential Equations." The Annals

of Mathematics, 2nd Series 124(2): 273-291.Blanchowicz, J. (1997). "Analog Representation Beyond Mental Imagery." The Journal of

Philosophy 94(2): 55-84. Brennecke, A. (2000). Hardware Components and Computer Design. The First Computers-

History and Architectures. R. Rojas and U. Hashagen. Cambriedge, MA, MIT Press: 53-68.Bromley, A. G. (1983). "What Defines a "General-Purpose" Computer?" Annals of the History of

Computing 5(3): 303-305.Burks, A. R. (2002). Who Invented the Computer? Amherst, Prometheus.Burks, A. R. and A. W. Burks (1988). The First Electronic Computer: The Atanasoff Story. Ann

Arbor, University of Michigan Press.Cohen, I. B. (1999). Howard Aiken: Portrait of a Computer Pioneer. Cambridge, MA, MIT Press.Goodman, N. (1968). Languages of Art. Indianapolis, Bobbs-Merrill.

39

Churchland, P. S., C. Koch, et al. (1990). What is Computational Neuroscience? Computational Neuroscience. E. L. Schwartz. Cambridge, MA, MIT Press: 46-55.

Churchland, P. S. and T. J. Sejnowski (1992). The Computational Brain. Cambridge, MA, MIT Press.

Corcoran, J., W. Frank, et al. (1974). "String Theory." The Journal of Symbolic Logic 39(4): 625-637.

Davis, M., R. Sigal, et al. (1994). Computability, Complexity, and Languages. Boston, Academic.Devitt, M. and K. Sterelny (1999). Language and Reality: An Introduction to the Philosophy of

Language. Cambridge, MA, MIT Press.Duffin, R. J. (1981). "Rubel's Universal Differential Equation." Proceedings of the National

Academy of Sciences USA 78(8 [Part 1: Physical Sciences]): 4661-4662.Eliasmith, C. (2003). "Moving Beyond Metaphors: Understanding the Mind for What It Is."

Jounal of Philosophy C(10): 493-520.Engelsohn, H. S. (1978). Programming Programmable Calculators. Rochelle Park, NJ, Hayden.Fodor, J. A. (1975). The Language of Thought. Cambridge, MA, Harvard University Press.Gustafson, J. (2000). Reconstruction of the Atanasoff-Berry Computer. The First Computers-

History and Architectures. R. Rojas and U. Hashagen. Cambridge, MA, MIT Press: 91-106.Haugeland, J. (1981). "Analog and Analog." Philosophical Topics 12: 213-225.Jackson, A. S. (1960). Analog Computation. New York, McGraw-Hill.Johnson, C. L. (1963). Analog Computer Techniques, Second Edition. New York, McGraw-Hill.Hughes, R. I. G. (1999). The Ising Model, Computer Simulation, and Universal Physics. Models

as Mediators. M. S. Morgan and M. Morrison. Cambridge, Cambridge University Press: 97-145.

Korn, G. A. and T. M. Korn (1972). Electronic Analog and Hybrid Computers; Second, Completely Revised Edition. New York, McGraw-Hill.

Lewis, D. K. (1971). "Analog and Digital." Nous 5: 321-327.Lipshitz, L. and L. A. Rubel (1987). "A Differentially Algebraic Replacement Theorem, and

Analog Computability." Proceedings of the American Mathematical Society 99(2): 367-372.McCulloch, W. S. and W. H. Pitts (1943). "A Logical Calculus of the Ideas Immanent in Nervous

Activity." Bulletin of Mathematical Biophysics 7: 115-133.Newell, A. and H. A. Simon (1976). "Computer Science as an Empirical Enquiry: Symbols and

Search." Communications of the ACM 19: 113-126.Patterson, D. A. and J. L. Hennessy (1998). Computer Organization and Design: The

Hardware/Software Interface. San Francisco, Morgan Kauffman.Piccinini, G. (2003a). Computations and Computers in the Sciences of Mind and Brain.

Pittsburgh, PA, University of Pittsburgh. URL = <http://etd.library.pitt.edu/ETD/available/etd-08132003-155121/>

Piccinini, G. (2003b). "Alan Turing and the Mathematical Objection." Minds and Machines 13(1): 23-48.

Piccinini, G. (2003c). "Review of John von Neumann's The Computer and the Brain." Minds and Machines 13(2): 327-332.

Piccinini, G. (forthcoming a). "Functionalism, Computationalism, and Mental Contents." Canadian Journal of Philosophy.

Piccinini, G. (forthcoming b). "The First Computational Theory of Mind and Brain: A Close Look at McCulloch and Pitts's 'Logical Calculus of Ideas Immanent in Nervous Activity'. Synthese.

Piccinini, G. (forthcoming c). "Functionalism, Computationalism, and Mental States." Studies in the History and Philosophy of Science.

Pour-El, M. B. (1974). "Abstract Computability and Its Relation to the General Purpose Analog Computer (Some Connections Between Logic, Differential Equations and Analog Computers)." Transactions of the American Mathematical Society 199: 1-28.

40

Putnam, H. (1988). Representation and Reality. Cambridge, MA, MIT Press.Pylyshyn, Z. W. (1984). Computation and Cognition. Cambridge, MA, MIT Press.Rojas, R. (1998). "How to Make Zuse's Z3 a Universal Computer." IEEE Annals of the History

of Computing 20(3): 51-54.Rojas, R. and U. Hashagen, Eds. (2000). The First Computers-History and Architectures.

Cambridge, MA, MIT Press.Rubel, L. A. (1989). "Digital Simulation of Analog Computation and Church's Thesis." Journal of

Symbolic Logic 54(3): 1011-1017.Rubel, L. A. (1993). "The Extended Analog Computer." Advances in Applied Mathematics

14(1): 39-50.Rubel, L. A. and M. F. Singer (1985). "A Differentially Algebraic Elimination Theorem with

Application to Analog Computability in the Calculus of Variations." Proceedings of the American Mathematical Society 94(4): 653-658.

Searle, J. R. (1992). The Rediscovery of the Mind. Cambridge, MA, MIT Press.Shannon, C. E. (1941). "Mathematical Theory of the Differential Analyzer." Journal of

Mathematics and Physics XX(4): 337-354.Siegelmann, H. T. (1999). Neural Networks and Analog Computation: Beyond the Turing Limit.

Boston, MA, Birkhäuser.Siegelmann, H. T. (2003). "Neural and Super-Turing Computing." Minds and Machines 13(1):

103-114.Turing, A. M. (1936-7 [1965]). On computable numbers, with an application to the

Entscheidungsproblem. The Undecidable. M. Davis. Ewlett, Raven.Van der Spiegel, J., J. F. Tau, et al. (2000). The ENIAC: History, Operation and Recostruction in

VSLI. The First Computers-History and Architectures. R. Rojas and U. Hashagen. Cambridge, MA, MIT Press: 121-178.

von Neumann, J. (1945). First Draft of a Report on the EDVAC. Philadelphia, PA, Moore School of Electrical Engineering, University of Pennsylvania.

von Neumann, J. (1958). The Computer and the Brain. New Haven, Yale University Press.Wilkins, B. R. (1970). Analogue and Iterative Methods in Computation, Simulation, and Control,

Chapman and Hall.

41