ࡱ > 7 "g bjbjUU " 7| 7| ;Q l ( ( ( < z z z 8 4 T < 7 F \ " ~ ~ ~ ~ > d 4 7 7 7 7 7 7 7 $ >8 ^: -7 ( T ~ ~ T T -7 ' ( ( ~ ~ B7 ' ' ' T ( ~ ( ~ 7 ' T 7 ' ' . r 6 T ( ( 6 ~ : @p< > z $# | o6 6 4 X7 0 7 }6 V ; & ; 6 ' < < ( ( ( ( Computers
Gualtiero Piccinini
8/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]ts 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 dont, 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 mechanismsor any other mechanisms, for that matter. Computers can do arithmetic but also graphics, word processing, Internet browsing, and myriad other things. No 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 systems 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 dont, 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 mechanismssuch as our desktops and laptopsand not to others. She should explain why we think that the invention of computers was a major intellectual breakthrough and why there are special sciencescomputer science and computer engineeringdevoted 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).
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, 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 type and its position within the string. 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 mechanismsthose that enter the functional analysis of mechanismsare 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 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.
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.
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, calculatorsunlike the sieves and threshing machines mentioned by Churchland and Sejnowskiare genuine computing mechanisms. However, the computing power of calculators is limited by three important factors.
First, (ceteris paribus) a calculators 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. In other words, a calculator has no control structure besides the insertion of commands through the input device. 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 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.
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.
Figure SEQ Figure \* ARABIC \s 1 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 todays 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, todays 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 todays computers, we would certainly obtain a robust, observer-independent notion of computer. We 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 todays 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 centurysuch as the IBM 601could 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 machinessuch 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.
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. 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. 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. Weve seen that one of those functional properties is the ability to follow an algorithm defined in terms of the primitive operations that a machines 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 dont matter for our purposes, because they dont 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.
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 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 ones 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.
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 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.
Hard Programmability
Some early computersincluding the celebrated ENIAChad switches, plug-ins, and wires with plugs, which sent signals to and from their computing components. 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.
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. 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. 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 computerssuch as the famous Harvard Mark Iare soft programmable externally.
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 machines processing units. Internal soft programmability is by far the most flexible and efficient form of 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.
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. 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 computationits 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 todays 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.
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 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. 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 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.
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. 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. 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 encoded program as input and respond to that program so as to compute any computable function. Notice that Turings 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. 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 Babbages 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.
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 computers 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 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 computers 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.
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, 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 computers 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.
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 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 computers inputs, outputs, and external states is unnecessary to individuate computing mechanisms and what functions they compute.
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 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. 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.
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. 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. 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 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 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 computers 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 builtgeneral purpose analog computerscontain 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. 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 Turings notion of computational universality (see section 2.3 above). Computational universality is a notion defined in terms of computation over strings, so analog computerswhich do not operate on stringsare 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.
Since analog computers do not operate on strings, we cannot use Turings 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 0(t<( 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 As output to an arbitrary degree of accuracy (Rubel 1989). From this, however, it doesnt 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 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 Atanasoffs ABC, which operated on strings of symbols, were often designed to solve problems similar to those solved by differential analyzersnamely solving systems of differential equationsby 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).
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 eventfor instance, the transmission of a signal between componentscan 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 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 cant, 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 sensethe most important for computability theoryneurons are serial processors, because they do only one functionally relevant thing (either they fire or they dont) during any relevant time interval. Even if one looks at an entire connectionist network as a processor, one gets the same 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 functionthey certainly dont 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.
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.
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 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 componentseparate from its input and output devicesfor 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 arent.
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 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.
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:
The brain is a collection of interconnected neurons that deal with information and control (in an intuitive, formally undefined sense).
Networks of neurons are computing mechanisms.
Networks of neurons are Boolean circuits or finite state automata (McCulloch and Pitts 1943).
The brain is a programmable computer (Devitt and Sterelny 1999).
The brain is a programmable, stored-program computer (Fodor 1975).
The brain is a universal computer (Newell and Simon 1976).
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 thesisaccording to which the brain is a collection of Boolean circuitsand a much stronger oneaccording 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 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).
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 dont. 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).
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:
What are the symbols manipulated in the neural computation, and what are their types?
What are the elementary computational operations on neural symbols, and what are the components that perform them?
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?
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?
If the system stores programs or even just data for the computations, what are the memory cells and registers and how do they work?
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.
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.
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 Neumanns 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.
Todays computationalists no longer believe McCullochs or von Neumanns 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 dont, it may be time to abandon computationalism in favor of other functional explanations of neural mechanisms.
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 dont, 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 systems 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 (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.
References
Atanasoff, 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.
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 =
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.
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, Birkhuser.
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.
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.
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).
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.
For more details on these large-scale components, and for their functional analysis in terms of simpler components, see Piccinini 2003.
For more details on programmable calculators, and a statement that they are a kind of computers, see Engelsohn 1978.
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 calculatorunlike a computercannot follow any algorithm or pseudo-algorithm defined in terms of its primitive operations.
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.)
Atanasoff 1940. On the ABC, see also Burks and Burks 1988, Burks 2002, and Gustafson 2000.
A similar proposal is made by Burks and Burks 1988, chap. 5.
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.
On the ENIAC, see Van der Spiegel et al. 2000.
This point is effectively made by Brennecke 2000, pp. 64-65.
On the Harvard Mark I, see Cohen 1999.
Cf. Brennecke 2000, p. 66.
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.
Patterson and Hennessy list these two ideas as the essence of modern computers (Patterson and Hennessy 1998, p. 121).
For an overview of early computers, see Rojas and Hashagen 2000.
For a valuable attempt at distinguishing between degrees to which a computer may be called general-purpose, see Bromley 1983.
For an introduction to computability theory, see Davis et al. 1994.
Strictly speaking, branching is not necessary for computational universality, but the alternative is too impractical to be relevant (Rojas 1998).
For more details on virtual memory, including its many advantages, see Patterson and Hennessy 1998, pp. 579-602.
Cf.: The input to a neuron is analog (continuous values between 0 and 1) (Churchland and Sejnowski 1992, p. 51).
Cf. Goodman 1968, Lewis 1971, Haugeland 1981, and Blanchowicz 1997.
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.
For some speculations in this direction, see Rubel 1993.
For more details on pipelining, see Patterson and Hennessy 1998, chap. 6.
For the notions of Boolean circuit and finite state automaton and their computing power, see Piccinini 2003.
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 environmentanalogous to the tape of TMsthat would store the putative programs executed by brains.
For a detailed analysis of McCulloch and Pittss theory, see Piccinini forthcoming b.
For a more extended discussion of von Neumanns theory of the brain, see Piccinini 2003a.
PAGE
PAGE 2
* 3 } 8 C % ' ( , - < s ] p % & K =! I! ! ! (" 8" " " # # # # $ $ $ $ ' ' s/ t/ / / 35 >5 5 6 6 6 6 6 6 6 6 j U
j CJ Uj 0J CJ U
j 0J U6]
6CJ ] CJ
5CJ \ j 0J CJ UCJ L ! ) * 3 H I G
c s n K $ $ d ` ` ^ d $a$ $
& F a$ ;U g !g $ $ +& ' + u. 0 h2 3 25 35 >5 6 6 6 E7 F7 : z> x@ D H hK iK yK N S $d a$ d ` d 6 6 7 E7 B B E E F F iK yK K K S S W W JX KX Y Y 8[ N[ ] ] *a +a Fb Pb c c c c Pe Qe e e e e 8f 9f j j s s 5w ew _x nx y y { { | | | | 2 J
" # * Ò * 2 i o E N O P ˰ ΰ
6CJ ] j 0J CJ UCJ H*CJ j U mH nH u XS V W W W 7[ 8[ N[ ] a c Te h j j j m |r 4w 5w ew Fy { } 1 2 J U d d ` U ֆ $ ȕ ݙ M @ ? R D / d ^ ` d d d ` = K ٵ + 7 R p q K V e k Z v a v < A G M 6]
j CJ
j CJ
6CJ H*]CJ H*
j CJ j 0J CJ UCJ
6CJ ]Q ` a v | g k x d { | - ] @
& F d d d ` d ^ ` M z
{
( ( ( ( + + Q- *; 5; < &< '< (< < < < < = != "= $= p= = = = > A> B> C> f> > > > -? Y? ? ? @ !@ K@ M@ @ @ @
A A
A ?A gA A A >B qB rB tB B C
C C 6C ZC C C D AD uD wD D D D D D D %E OE E E F >*CJ
5CJ \ CJ H*j 0J CJ U
6CJ ] CJ X@
|
}
2 ) u G! H! ! " # # q$ % % ( + d `
& F d $ a$ $
! d `a$ d ^ ` d
& F d + Q- R- ]- 0 D3 9 ); *; 5; ; 6< < 1= = Q> > ? u? ? T@ @ A {A A h7$ 8$ H$ ^h` h^h` ` d d ` A B C wC C D D E hE F F F G -H H FI J sJ J `K L L M M .N N O 7$ 8$ H$ h^h` h7$ 8$ H$ ^h` F F CF F F F F F SG G G G G H "H H H H H H $I QJ cJ dJ fJ J J J J @K ^K L L rL L [M M M M M M M M M N nN N N N N N jO O O O O O O O P P P P P
Q qQ Q Q Q Q Q VR hR iR kR R R rS S S S T T T %U :U ;U *
6CJ ] >*CJ CJ
5CJ \ZO O O P &Q Q R yR
S S rT T 9U ;U V jW Y )Z Z [ \ ] \] j^ ^ ^ _ h^h` h7$ 8$ H$ ^h` jW kW W W X X :Y @Y Y Y )Z *Z Z Z [ [ [ [ \ \ ] ] \] ]] j^ k^ ^ ^ ^ ^ ^ ^ _ _ _ !_ ` ` ` ` ` ` Ua Va a a /b 0b b b c c ]c ^c
d d Ed Fd d d e e Sf Tf f f g g g g g g g g g g g g "g 0J mH nH u0J
j 0J UCJ j 0J CJ U6]
j 0J U N_ _ ` ` ` Ua a /b b c ]c
d Ed d e Sf f g g g g g g g g !g "g h^h` &`#$ 1h / =!"#$% i; D d R
C . A c o m p u t e r 4 b : ᅕ!LivEl : D n : ᅕ!LivElPNG
IHDR TBM sRGB pHYs + :+IDATx^=-ə"!$ '+H %NL` ъd Lؕd'Y"#%
ѫ>Uz?@ #dZ @ q @v<͆ 0 \ pю @ .4 pQE;fC @ .J hl@ c E x
@Oe@^zl~3茱dbu]\ T%ʔ[5,j
`ڮ0@ @ K %@hڮ0 o cw(>iFP̘ @ p jV>RT mČ A .4F ` @ ( O! p
1 KȞ *Bw
Һ X #, `
A@ =?{y`؏-%C 0u` &$۟F#w:Zi# v
A ؗ K`:¢ lvlb=WM[ gdKrvb֍&.`Q+ Vc co:1j,J-=G+/hw~?\ }5㏕/3?:Y&7o|EO| T)Y prū_϶w^WSf{ܨ%USփ,X]Zյ2" ݑR '1/_"%wEől 6+{ H`DZ]J'q0Y-|Ǔ
U) rA' RAk+R l DAD
]cM(\h}`V ,!uXcNNf OWTktanJBۖBb UankI:Dhh "IZT(%F;n}֣=s?(*(q6^Hv lK:{YP2;%))\|dP# e7'b\%cy 3k)$`xGg
0O
j9
eaÝ@#C@bU@,\ g @\tl6l+4@a g 蝍-Ǫ }81Ak@Jh v$WWlBT#8Fm "։सMQ3`Tba~ I"?x5E!/m^{!woN8~XbNƱt"D죱NE˚RhFd 8ioQ H1,mK_}tɥl\_ :]OedNYWsӝ> J+'V2 l ,۹Cu;칿 |!Q%8z?N_%ӉVA˂FҐ.iB p$&p:N9&pQC\ˌe7~;N}>x8*68m
-uC i-ݼ1_S* Qʱc2\>DdHS]\,l
.huc@V 8@n:[@X avPSfpTXd( fgE2W . =
Cv/lY͆zO U $#0Æ)f
}Bt=R_1td J pϴFC,/Xj'NhbΠ5_v_'Y6GtyV0(rH^o DiKxs*oa~= '.@8Ԙȑ'xfh?MV`B ÀG0^N8t{T!:# N^#qTwP ZnqifHwTِ~N\]Իi@YLW ӎG b~UD 4;ebX3 }'+]v;aI|0LoՀ3EV u;N==ibۿ h<(߯y|ЧUaWL G
oP6ڳ] S! ?H" ;BR #}]B
7 q8g٥6+vƯ6,.x2R~z: ) >.]4MC]EkޱQaն?;nWi5? Ndv-u IP@ؕ$0.AZ`'+*V5'
6.>#<^I֮oGN~?Pl:8չ )7z2cvk@ubgjo ~N;
]gv`#Jܺ5j Pc&^Tcq pG}D! HN6& =d {jWÖCAy%}-l{2m
ݦG^$knm g5`˥7סNom`;津%
lG?\? }H v7I6;ON@GV-ߊNu@.EYtbWolc 6$@PO'bĄ'
%KhNko7#`[WBl44; `G }Ҹ 㞄~_gL4dѧ?+^HpPn! -#h"s,W TT~x{-uwH $Nsf #4U}HyoK& ] z>gI'{uάi}u
LB J_1qC< }x|_}>d@iPǻwJE?mitqB@ sw4r /OJ[[r @"D1g?zeEKS8(4}{_=c>A}A]v?6뷏!)&ODG>)!PFٙ
!7?SԂ9(,'C7ot- >+'N~Nw?Eʨt? !.)dv Byӝ0(tg ׯ Sg! N焆UZMZN@ r ]B_$5] K "I93^._-J< 3Bi9ʩ4 { H ij{ }Zo
cBހN
xw& Ύx@ Hz`CeŠ7 "A꽁 |L#;¸@OoOzvînB@PSю$>tO@ａx;mLTKG^Af
p"AmЅ @8!DpC?5~<_@z'`" 0}o:v3j { 'tv@b qTG {~hŝ _ % d8ѻM@"A i-#1_(ixu* a=!}*ro `p"N1PU=^(%FWk [г> oz꽁 \F[bOK(mfJ/jw^#lS
j@zq
W" ޯʕ ?$c녁7! gʟ \ h)Ȁpp[$_
ɦ1 \T{[cV! " ߫$}+8tR0HxG Z:1ЛFE~C1 ةO)v w ipo ojX'|_HU1
xOCS@{'H#9 |>:d~Q`ϧ u$4#N{Տ~8ɖ? { "axv`w }nTl 7{_K?wXdn~~̃*$C{ `dsD BugMk}hgX
I?qm{,%ŶOP)T, M{Ǐo~Gv dkoVD(?6- ,\F /O%V}E $em9y?ί<_ ~_5L_>8F 0EQYQ 7Ó "sN
tZ\
ؠ/NiB[yҴ%*1N !?
uQo]4so=VI/; xO,,K>
T,$>;6^
B ]BWX[ 1s+o^ yoH(PvsurnN/ ̸AK? zҹ
!F}=1Y*|Mk2Pъl&H+AP9?f~p759Өʆy?c'.Pvv.ik/鿙wuRn\V7[ QYm_In"
,̔(ֳ]~ݰU<1P} M#f |{~w[ ObHozUgf%hO{W̓|<+;p1U#W1Di$#\aUd%uop ;s]3?`g[\*<XHj궈{Y M o<(;]8kj l穣CyV@'%e)K7(3w} .C y=]..g]osF?r( s{v.il}LSwvO|W?<算! -^k`(}_@^Wh dp7lz
v
~
(8m
LLq
9v]C`䮝Nl3O q'$+oGߎkQq~= \/Ӟ˷$I^ϛ
$& F⎜
`1YPD[zjh 13-D o 'PYxPҚ-SӳE_X杪VhTIHN#I
b뮨"3'%Mp+!QMuݻoH)p5(2% }¢/%t>΄o# }]>;Pڹ{ۻ
t'U?]e- -ߣCٞ](A 6Pudi~5~e_l ;_ސ:j0+ AS# }vd'8q@^̍!Di; hr^l||̗O_u~<ϐ&PWB> O͵䯄d1!UoҾ /H@NJ#uȓ=_D $Ij9Uf~! ]=V3ݡc}' U27,dN% ;M4JY:>H=@p f\eh*-l{y?MN7 =
ʮ(hlbd 4*ʠs zlf_uW sđWyV f=M7hZ7t&p]e /d fF3mMT
L柕kփ'8ٷ'KY` ՑWyV ( GB~R2*,h#Y$ @/$wJ?7g@٦$[1
hn_NH*J; u"sNطrJn"BETg Q]cwN{KɘMD21vQ;
+s!mGhYe .{OLSf>qi ";)IQv_?zm 5͟Lz;'w
zcث
=-@[ Ջ53urJ ~'仿 ^X=[AbBo[bZz qժuWqQ.75:u /ꢎC p {u^d{ CPY;T |%EZFa;2B@ =sza~ifͨñ2Hb9w}L;O Zzカ}?5ݞu9_F}ȗB \ "v '-$M`V N/7|#lli ~nW'ScAf㺴Oo5@,PkR:\H??ɤxV-TcLլ YЯY\b&TL%A,0r[=A:(K.gԘŧKn}um/3mQ1؏vvu T qE~LO ?}h` H32dd%'`9 0TW tR ް}fӛcIP+"/zن
D*(Ե?¢uW sA\}^M. ]/A w )ުB>vΨd ]x% <=B| 04MdweYSx m$_ l`P;co
] JC; W\@%
б- ǯid ђ!C7D ^MhПmh S ֏ s
?UOf8KN S&7 8 Dzj?8u" \
%A sz#W'pp@u{@ų C,h7KY u2R*n5
Q u r ?KiG tyVLfOdFP hIAF@
5ǜa@W|@u &
/w${Uv*m)6[/ pB^nqM0[) -v8PRQyRx- p "Z2ROnEiˊA\@WD lx]͆{ ;
p[O @+_ϧl3riif!1^v Y*펾tkD zt!V{?(0R \6Oh
Y!`` |&A,$YL
r ;Q1j.8]p0 Hl$!뤹 i'! 3lE ~\ndk( 0;&
$ ! "gۆD"V#Â8Ի^h s &AOvTmWG߫q? LFlfu!XK1!\ ΤɄ+(h+_$#+k1t0aHhFhX#XKسk+ ]= wv_
kw_QDEz"4I+] Zjt\3OF>+?uY)U}Ī">bsBkP- 4-f4^GI <8\`8r* zP~_(2a! Vw8 c\6)jCPILEnh]_!M@dK
v,;]f/Uuc3J'ץӐfr
8Ųo+ {a)Jcc']d@^~ЁY@6`p
G쐉06U)L-4.3m!]vsl8Y,'ol
2$%>vcO쩻K~Cc@ zO # e=GC V։GK Mu{jL P{>c1R tMB hsD6rg=G}
4F@>CwP ~NK|f'QGMGÝbf@4+ u⋢Ş !_U11!0)
DB9]]}U@#ym^G^x? .-f8y0)
8<"]=g/O Y4aeg KJ ",E O}ɶp@ T 9 ߖOԜV. cRa
b~Hpx!ps2H! o?]# r ܛ`T 'ˍSC8S@>Ѯ_ Nm)FA`I^>)#($J C:ն40_m<yK p!N9NΛ$H[3.@DZ&\@cY_5{7w\Uλ.Jkno?w[[8( "RB
@;z߽Z5 ߿4%ÒR >OTi[$N6ﯲ蟾U[j0G?` &=az&*k/s[BJSM M )D@ds[Z|
ψ1ǼMsO|nGV.Mk $@ # X~ߏ
; ~< g@u)0r\S $w- (\3煰&$ <MH8E] >u.*O "M=@KGZ6%0kK _ %!ZV70'q#XѠ"1 PC #X P,yva4.o \ye]vd%Q{7! 5<@}oX ,pBuQ?7;Gj P4I h :^oy?
YM{@Zfp@^ ~No?_OS_e6\)/ z[Y=(' 7Q/:W^d |.)L@`g 5w cxy 髭iCJB `@?5Wtsvk[ˎM T"04@ EW_\J~\ɣPL?@$ 0QMn e oI>U?e U @"OM` -4>jdjo u 0B
nLvS@ }B@`4^>T}qίmY ̔_<6 и0S} ֿ~LLP)m//>o<|
(X: pA ̾%qoꕐ)@KiE
]G+ p` 4 ~rO&tm6 ؍ O@- [
yuoo0ipVN
Nu"S@#P V Wf{z1;6:;) W#m`}~B@Z wo@`@@3}*t 7ﯣ@:XpMg=R& Џﯿwy 7/+|* ,B DmahGn@`*-Fx}P I` ȀQ? Φ5/ Z
+x+C2 j;| TŬlh vX
@`Y ]0 @ ! ,K X0 @ ! ,K X0 @ ! ,K X0 @ ! ,K X0 @ ! ,K X0 @ ! ,K X0 @ ! ,KA/u$?
( ' '<.0>[{m V K]C @ V XR "P4=/Jljs]vkJe
"@h/ ٮИK%C .4 @v<͆PD <_Z q# w!
ˋgŭl`ȡ"@ s@ ;7tϊ{@`#; U vC f|X" PS s@ F 04G ( @`z\@K+wZBQsGW;>9E> @%
1@X\i6 1 @v<͆ 0 \ pю @ .4 pQE;fC @ .J hl@ c E x
@ ` @ ( O! @ % \i6 1 @v<͆ 0 \ pю @ .4 pQE;fC @ .J hl@ c E x
@ ` @ ( O! @ %4:NUGX5 IENDB`
i 8 @ 8 N o r m a l CJ _HaJ mH sH tH H @ H H e a d i n g 1 $$
& F @& a$ 5\] T @ T H e a d i n g 2 $$
& F @&a$ 5\]^J aJ L @ L H e a d i n g 3 $$
& F @&a$ 5\^J aJ L L H e a d i n g 4 $$
& F < @&a$
5\aJ R @ R H e a d i n g 5 ' $
& F
> @&^ ` 5\L L H e a d i n g 6 $
& F < @&a$ 5CJ \aJ > > H e a d i n g 7 $
& F < @&a$ D D H e a d i n g 8 $
& F < @&a$ 6]R R H e a d i n g 9 $
& F < @&a$ CJ OJ QJ ^J aJ < A@ < D e f a u l t P a r a g r a p h F o n t > "@ > C a p t i o n $x x a$ 5CJ \aJ 8 &@ 8 F o o t n o t e R e f e r e n c e H* 6 @ 6
F o o t n o t e T e x t CJ aJ D C@ "D B o d y T e x t I n d e n t p^p` < @ 2< F o o t e r $
!dh a$ CJ & )@ A& P a g e N u m b e r : '@ Q: C o m m e n t R e f e r e n c e CJ aJ 4 b4 C o m m e n t T e x t CJ aJ 0 B@ r0 B o d y T e x t d CJ R R@ R B o d y T e x t I n d e n t 2 h7$ 8$ H$ ^h` J S@ J B o d y T e x t I n d e n t 3 d ` CJ ' % # s+ + A B O JT *] _ Pa 8b o u w x { " O z $ ' "c
q / d e ! / `
W ` g
"
V p "c ! ) * 3 H I G c s n K +" # ' u* , h. / 21 31 >1 2 2 2 E3 F3 6 z: x< @ D hG iG yG J O R S S S 7W 8W NW Y ] _ Ta d f f f i |n 4s 5s es Fu w y 1} 2} J} U ւ $ ȑ ݕ M @ ? R D / ` a v | g k x d { | - ] @ | }
2 ) u G H q ! ! $ ' Q) R) ]) , D/ 5 )7 *7 57 7 68 8 19 9 Q: : ; u; ; T< < = {= = > ? w? ? @ @ A hA B B B C -D D FE F sF F `G H H I I .J J K K K L &M M N yN
O O rP P 9Q ;Q R jS U )V V W X Y \Y jZ Z Z [ [ \ \ \ U] ] /^ ^ _ ]_
` E` ` a Sb b c c c c c #c H 0 0 0 0 0 @ 0 @ 0 @ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 21 0 21 0 21 0 21 0 21 0 21 0 21 0 21 0 21 0 21 0 21 0 21 0 21 21 0 hG 0 hG 0 hG 0 hG 0 hG ( 0 hG hG 0 S 0 S ( 0 hG hG 0 7W 0 7W 0 7W 0 7W 0 7W 0 7W 0 7W 0 21 21 0 f 0 f 0 f 0 f 0 21 21 0 4s 0 4s 0 4s 0 4s 0 4s 0 21 21 0 1} 0 1} 0 1} 0 1} 0 1} 0 1} 0 1} 0 1} 0 1} 0 1} 0 21 21 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 21 21 0 ` 0 ` 0 ` 0 ` 0 ` 0 ` 0 ` 0 ` 0 0 0 0 0 0 0 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0 @ 0
0 @ 0 @ 0 @ 0
0 6 M F jW "g $ S U @
+ A O _ "g !g 2 2 2 "c t ! ! _ T o c 4 4 2 4 2 5 0 9 _ T o c 4 4 2 4 2 5 1 0 _ T o c 4 4 2 4 2 5 3 2 _ T o c 4 4 2 4 2 5 1 1 _ T o c 4 4 2 4 2 5 1 2 _ T o c 4 4 2 4 2 5 1 3 _ T o c 4 4 2 4 2 5 1 4 _ T o c 4 4 2 4 2 5 1 5 _ T o c 4 4 2 4 2 5 1 6 _ T o c 4 4 2 4 2 5 2 2 _ T o c 4 4 2 4 2 5 2 3 _ T o c 4 4 2 4 2 5 2 4 31 2 iG f 5s 2} a | #c
<1 D3 xG f cs H} t #c ? ? c c R \ ! ) . 3 > C
> C I N > I h q ; D U a 57 >7 7 7 68 B8 8 8 19 :9 9 9 9 9 : : ; ; )= .= = > > > > > > > ? &? ? @ S@ [@ @ @ A A B $B 6B :B B B B B B B H H MJ SJ J J K K K K K K M M N N N !N N N N N N O O O %O (O [O hO O O ;Q R R IS RS YS bS V V X X OZ XZ Z Z Z Z [ [ \ \ 7_ @_ K_ V_ _ _ _ _ 9` >` c c #c / 6 2 3 3 D3 E E
F F [P hP ޏ ɑ 1 @ $ - < g v & 6 >
7 0 J U Z ( ( * ]+ 7 7 8 58 9 /9 : P: : ; ; ,; u; ; ; ; < < = >= ?= h= {= =
? ? ? ? ? @ A $A %A PA A A B B B B C C ]E E @G _G rH H H H I I I J nJ J J J K K L M M M N N O O O P rP uP P P P 8Q ;Q =Q ~Q V W Z Z c c #c 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 * G f K ! ! ! I I :Q ;Q \ \ U] W] ] ] /^ ^ E` ` a ha ia sa }a Sb c c c c c #c g u a l t i e r o p i c c i n i n i 5 C : \ M y D o c u m e n t s \ F a l l 0 4 \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i 5 C : \ M y D o c u m e n t s \ F a l l 0 4 \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i 5 C : \ M y D o c u m e n t s \ F a l l 0 4 \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i 5 C : \ M y D o c u m e n t s \ F a l l 0 4 \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i 5 C : \ M y D o c u m e n t s \ F a l l 0 4 \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i A : \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i b C : \ D o c u m e n t s a n d S e t t i n g s \ g p i c c i n i \ M y D o c u m e n t s \ C o m p u t i n g M e c h a n i s m s \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i b C : \ D o c u m e n t s a n d S e t t i n g s \ g p i c c i n i \ M y D o c u m e n t s \ C o m p u t i n g M e c h a n i s m s \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i b C : \ D o c u m e n t s a n d S e t t i n g s \ g p i c c i n i \ M y D o c u m e n t s \ C o m p u t i n g M e c h a n i s m s \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c g u a l t i e r o p i c c i n i n i b C : \ D o c u m e n t s a n d S e t t i n g s \ g p i c c i n i \ M y D o c u m e n t s \ C o m p u t i n g M e c h a n i s m s \ V a r i e t i e s o f C o m p u t e r s 1 1 . d o c $[ރ dc~ل )t.n Lh}G( h h^h`OJ QJ o( ^`o( ) ^` . pL p^p`L . @ @ ^@ ` . ^` . L ^`L . ^` . ^` . PL P^P`L . ^`o( . ^` . pL p^p`L . @ @ ^@ ` . ^` . L ^`L . ^` . ^` . PL P^P`L . P ^`P @ @^@` . 0 ^`0 . . ` `^`` . . . ^` . . . . ^` . . . . .
^`
. . . . . .
` ^`` . . . . . . .
0 0^0` . . . . . . . . Lh} dc )t )7 ;Q \ ` Sb #c @ , "c @ U n k n o w n G z T i m e s N e w R o m a n 5 S y m b o l 3& z A r i a l " 1 h qRS|F 2 '6 o$ < $ 0 d 1d Z 2Q V a r i e t i e s o f C o m p u t e r s g u a l t i e r o p i c c i n i n i g u a l t i e r o p i c c i n i n i Oh +'0 $
@ L X
d p x Varieties of Computers ari gualtiero piccinini ual Normal r gualtiero piccinini 6 al Microsoft Word 9.0 @ F# @ |2@ ֒NE@ p 2 ՜. +,D ՜. +,X h p
washington university 4 1d
Varieties of Computers Title 8 @ _PID_HLINKS A P > - 6 c o m p u t e r 4
! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
R o o t E n t r y F p D a t a
i; 1 T a b l e ; W o r d D o c u m e n t " S u m m a r y I n f o r m a t i o n ( D o c u m e n t S u m m a r y I n f o r m a t i o n 8 C o m p O b j j O b j e c t P o o l p p
F Microsoft Word Document
MSWordDoc Word.Document.8 9q