on the inter-linked origins of symbolic computing and the self-modifying, stored-program computer. NOTES: (1) EDVAC vs. Turing, ENIGMA p324 (critical) (2) IAS instruction set, 20TH, p343 (3) Manchester instruction set, 20TH p436 (only vestiges of ACE, but some vestiges) WEAK ITEMS TO COVER EXPLICITLY: Why is there lack of symbolic (eg. character) output in ACE-derived machines? (viz turing letter to gandy) Turing's abandonment of higher-level work goal ---- DROPCAP Computers are interesting because they manipulate arbitrary symbols, not merely because the can do arithmetic; in fact, numerical computation is a sub-set of symbolic computing. While this is obvious today, it was anything but obvious in the mid-1940's when electronic stored program digital computers came into existence. The goal of this paper is to show that this now-fundamental concept was almost completely ignored or misunderstood by nearly all of the first-generation computers' designer/builders (with one noteworthy exception) and that it was not widely recognized until electronic stored-program computers had existed for nearly a decade. Rather that argue with my-data-is-bigger-than-yours, I will use as evidence the actual instruction sets ("order code" in the local vernacular) of actual machines designed and built, from the 1940's through the early 1960's, and the appearance of symbolic/logical instructions will become visible. I will also explore the later "discovery" of the usefulness of logical instructions as they became available in second-generation machines. intro ----- Many histories concentrate on the development of the stored-program concept; clearly it was a critical development, but it only part of the story. To a large degree the stored-program idea was rendered obvious by the early 1940's; like many other scientific and technological developments, it occurred to many people more or less at the same time, because they were all subjected to the same pressures to solve the same problems, and critical portions appeared in literature and hardware before the first computers appeared. [IBM 604, ARITH?] Electronic, automatic stored-program digital computers didn't spring forth fully formed, they incremented out of the background, though the increments came extraordinarily fast due to many factors, the largest being the open and sharing nature of mathematical and physical-science societies, and the pressures, and enormous resources made available by governments during the war. The initial problem of builing large calculating computing machinery, but ultimately not a limiting one, was one of sheer scale. Generally speaking, even the most complex electronic devices had no more than a hundred or two tubes, and it was clear that large calculators were going to require thousands; one of the earliest large machines, ENIAC, contained approximately 18,000. It was widely believed that with such numbers that tubes were going to fail so often that no useful work could be done. However, with a radical rethinking of design parameters vacuum tobe reliability eliminated as a limiting factor rather quiickly. The next major problem was not so easily overcome -- storage ("memory"); regardless of architecture, real-world problems contain lots of input data, much intermediate-variable data, and real-life solutions require lots of mathematical and logical steps. This wasn't conjecture; there were plenty of large punched-card-based calculating machines and the problems of (literally) handling hundreds of pounds of cards were all too well known. Although it was recognized that though data on punched cards could approach a practical infinity, the requirement to physically transport cards from the output hopper back to the input hopper was many orders of magnitude too slow. Not to make light of the enormous problems of creating electronic logical and arithmetical controls, the problem of storage determined the capabilities of automatic computers for decades, and severely limited the ability to even make one at all (the world's first running stored-program computer[BABY] had 1024 bits of storage). As F.C. Williams said, "fast memory is not cheap, and cheap memory is not fast!". A long, linear array of memory or storage "cells", each of fixed size, is a simple organization for electronic components; you make one cell work, and replicate as many as you can afford. You know you want the largest possible store for data and intermediate variables; and you know that you want your complex and expensive machine to be "programmable", eg. the operations performed on the data must vary with the particular problem to be solved. It was abundantly obvious by the mid-1940's that fixed-function machines (relay calculators or ENIAC) were too inflexible, so the machine's operational orders need to be as flexible as your data. Building one memory store was daunting enough; to have to build a second for machine orders was simply too much. But with clever electronics, and a modest increase in complexity, you could put orders and data into the same store, eliminating the need for separate stores. By 1944 at least, [CHECK?] the stored-program concept was obvious enough to those actually working on calculating/computing machinery; no deep theory was needed, it was like falling off a chair to anyone with a budget and an engineering team. [LIST MACHINES WITH INCLUDED CONCEPTS] Pulling it off in actual hardware was another story; the early machines were often 100 times as large and complex as any electronic device ever built. Only the tiniest portions of the machines had ever been built and tested, yet the goal was so tantalizing and the value so high, and otherwise-conservative funding sources so revved up post-war, that the seemingly-impossible was actually done. DROPCAPS The modern vision of the stored-program concept appears to have been first written down by JvN in [EDVAC REPORT] in 1945, so he and/or his team frequently get credit for it; but the idea was well-known by then, though JvN certainly was a major contributor to this and many other ideas, such as the one-address machine with central accumulator, a design feature of EDVAC and it's American offshoots. JvN himself never claimed ownership of the idea; historical simplification and a few unfortunate personal agendas create that myth. DROPCAP Symbolic computing is the manipulation of symbols via machinery, and the machines that do this we generally call "computers". As used here, "symbols" includes any abstract representation within the machinery under discussion, except those interpreted directly as numbers. Symbols include the obvious, such as alphabetic text, and the less-obvious, such floating point arithmetic. (The treatment of floating point in first-generation computers is a good introduction to the dilemma of symbolic computing's history; though it is certainly not arithmetic (as a glance at the complexity of handling zero and signs in any floating point package will quickly show) and definitely is symbolic manipulation, few seemed to appreciate this at the time.) Related to symbolic manipulation is the obvious and stated ability of a stored-program electronic computer to "modify itself". Nearly all designs intended as general-purpose automatic, electronic computers incorporate this explicitly as a design feature as a manner in which a computer could load a new set of instructions/orders (today, the "program") into it's main store (though there were a few that used external means of inserting and extracting data into the main store). But here too, in this most fundamental design feature, there were definite ambivalences, implying that computers designers were not fully comfortable with their constructions. (It is revisionist to claim that computers are in fact numerical/arithmetical devices, since all symbolic manipulations in a digital computer are strictly the rules of boolean algebra; in the late 1930's when all this business started, mathematical logic was an exceedingly rarefied and "useless" branch of mathematics; it is the very acceptance of general-purpose digital computers that has made boolean logic so widespread.) DROPCAP Simply put, symbolic computing is what we today know computers are for. I don't mean to make light of the phenomenal and world-transforming mathematical revolutions brought on by computers, however, their development as mathematical machinery is far less obscure, and I assert separate from their originally-unintended use as symbolic manipulators. It is also obvious that nearly all of the early interest in electronic computers was for calculating, largely because complex mathematics was increasingly the limiting factor in the cutting edge of physics. (It probably didn't hurt to promote faster calculating machinery to less-than-enlightened bureaucrats and bean-counters.) Few in the earliest days of electronic, automatic computing acknowledged the usefulness of pure symbolic manipulation, if the knew of it at all. I don't say this lightly; the written record -- and the machinery left behind -- makes this abundantly clear. It wasn't until [WHEN] that a significant fraction of computers included built-in symbolic manipulation in hardware and/or software. the argument ------------ It's clear today that the innate ability to manipulate arbitrary symbols is what computers are all about. I assert that not only was this not obvious, that very few understood the implications, and further, that many didn't get it even after it was well-established. And it is no coincidence that the people who made all of the earliest advances, and in fact the first operating computers, were the same people who built, out of dire, life-saving need, machinery that did nothing else but symbolic manipulations, for code-breaking purposes during the war. Rather than a my-data-is-bigger-than-your-data argument, I will make my case by examining the instruction sets ("orders") of machines designed and sometimes built in the early years, with the assumption that regardless of claims made at that time or years later, the instruction sets are the embodied intent of the original machine and therefore its designers. Instead of researching historical conversations and relying on my data being bigger than yours, I will use the architecture and instruction sets, the "order code", of the historical machines as physical (sic) evidence, my assertion being that the order code, well documented and widely agreed to be correct, actually reflects what a particular machine's designers actually thought, and intended, at the time, regardless of any claims made then, or much later. First however some background is needed. I will examine the instruction sets of the following machines: COLOSSUS, built 1943 ENIAC, built 1946; programmable Nov 1947 EDVAC, designed 1946 (no machine named "EDVAC" built) Turing's ACE, designed 1946 Manchester Baby computer, built 1948 EDSAC, built 1949 Manchester Mark 1 [DATE] BINAC, built 1950 Pilot ACE, built 1950 (built by Womersley's crowd) IAS, MANIAC, built 1952 (EDVAC design) [why these machines] [filling out the argument, preparing for the analyses of order sets to be useful to the argument] DROPCAP There were two major design paths for automatic, electronic computers in [DATE][IS THIS TRUE?], JvN's EDVAC ("Electronic Discrete Variable Automatic Computer"), described in [EDVAC] and published in [DATE]; and Alan Turing's ACE ("Automatic Computing Engine"), the design published in [ACE] in [DATE]. [TIMING OF BABY? Also the "obviousness" of the stored-program concept clearly well-known and implicit in existing machines, eg. the IBM 604 [ARITH]?] DROPCAP Turing was the first to tie theoretical concerns to then-current technology to define a self-modifying, stored-program computer in the modern sense. This was implicit in his 1936 paper "ON COMPUTABLE NUMBERS..."[NOTE], more fully developed in his World War II work on cryptological machinery, and made explicit at least by 1946, in [ACE]. It is reasonable to assume[FOOTNOTE from ENIGMA; when did Hodges assert Turing grokked this?] Turing understood this at a much earlier date. For example, Turing made the explicit and correct statement that mathematical computing is a subset of symbolic computing (eg. "floating point arithmetic" isn't arithmetic per se, it is a simulation of arithmetic's rules with it's own set of behaviours and effects). It is now obvious why Turing was so clear on the symbolic uses of computing machinery: his wartime Bletchley Park experiences of designing, building and operating explicitly symbolic machinery for the purposes of breaking cryptological character codes. While nothing remotely computer-like was built then, a number of high-speed, all-electronic logic and arithmetic machines were built (one of which, COLOSSUS, was capable of a limited general manipulative ability) that clearly proved that this approach was a very fruitful one. DROPCAP JvN apparently saw stored-program as a means to the end of fast mathematical machines for other projects, eg. Los Alamos, at least initially. All of the early crowd emphasizes mathematical ability for their machines, most including hardware multiply and divide as a minimum. However, {EDVAC] report makes not one single mention of use remotely "symbolic" for his machine; the closest he comes is an immediate dismissal of sorting[EDVAC p218]. Further, he explicitly describes mechanisms to prevent a running program from modifying itself[p219]. (Not mentioned is how programs will get loaded in the first place, but it is extremely unlikely he overlooked this.) At least by [DATE FROM ARITH] he had abandoned the M digit separating data ffrom instructions. JvN certainly knew of Turing's work in general (since he invited him to work with him at Princeton in [YEAR]), and there is evidence[FROM ENIGMA][FROM 20TH] that he was aware of his work on [what the hell was he working on pre-ACE?] While it is possible that JvN was simply too determined in his mathemetical/hydrodynamical work for Los Alamos to devote any effort in the direction of symbolic functions, it seems unlikely that he would have not at least mentioned it in passing. WHERE DOES THIS BELONG The British B.P. experience set them as the inheritors of Turing's legacy. There is no question that British researchers had the first TWO working computers in the world. the machines ------------ COLOSSUS, 1943 -------------- Type: special-purpose programmable calculator Instruction set: "large number" of plugable, random logic gates Facilities: 5x5 memory (shift register) 501-bit stream generator Storage: 20 decade counters http://www.cranfield.ac.uk/ccc/bpark/colossus.htm A highly-specialized programmable calculator, COLOSSUS had some rudiments of modern computing, but by no means is it a computer. It was designed and built under wartime conditions to perform only cryptological functions (at which it excelled). Because of the rapidly-changing and often initially-unknown crypto algorithms, COLOSSUS had to be highly programmable. It was once "plugged up" to perform multiplications, and other taks far beyond it's original design requirements. {ref to performance vs. Pentium-based algorithm; see URL above?] While it's not a computer in any direct sense it is certain that those that worked on it or with it gained a massive head-start in understanding the requirements of a true stored-program computer. The very existence of the COLOSSUS machines, and therefore their capabilities, remained secret until the late 1970's [REFERENCE], and so until relatively recently it wasn't possible to acknowledge their place in the pre-history of computing. Furthermore, the British didn't share COLOSSUS-era work with the Americans, so it remained on their side of the Atlantic. [COLOSSUS REBUILD] ENIAC, 1946 ----------- Type: plug-programmable calculator Instruction set: Facilities: Storage: [n] 10-digit decimal numbers ENIAC was designed and built to be a patch-cord programmable calculator, but ended up being a true programmable calculator a year later. It was built to compute ballistic tables fo rth emilitary, as it's full name, "Electronic Numerical Integrator and Calculator", indicates. ENIAC was plug-programmable, and had a human-settable function table that stored constants for calculations. Data in and out was via punched cards. Like card-calculators before it, it could perform conditional computation, bsaed upon the sign of an accumulator (eg. stop when minus, etc). After a November 1947 brilliant modification suggested by JvN, ENIAC became a true programmable calculator. JvN's idea consisted of adding a device called simply the "converter", that translated decimal numbers entered into a large function table (banks of hundreds of switches arranged in rows, into which numerical constant tables were entered for calculations) into pulses that simulated the plugging of patch cords (thereby generating "instructions"). The converter created an added level of abstraction for the programmer/user; 60 order codes, ENIAC's new instruction set, that performed the electrical equivelant of plugging in patch cords, including a conditional instruction. While the added level of abstraction involved in the function table to plug-cord modifications greatly slowed the operation of the machine, the order-of-magnitude ease and speed of setup far outweighed any loss. It also allowed programs to be checked for correctness; the same program (decimal numbers) could be read in from a stack of punched cards and the "function table"/program checked for correctness. (Though it specifically could not load a program from any source into it's instruction store; hence ENIAC is not a "stored program" computer, though it is now fully programmable.) This is almost certainly the first machine with "software" as we know it today. JvN's function table::patch cord "hack" is an excellent example of software abstraction/hardware speed tradeoff (even though the hack is in fact hardware, it performs a symbolic translation for the users). Turing's ACE, 1946 (never built) ------------------ Type: Stored-program binary digital computer Organization: serial Storage: 6400 32-bit words register machine [get type name from CPU book] N address? 32 regs TS1 - 12 special 15 bit addr space Instruction set: 11 instructions, some sub-modes Instruction set: ~11 inst., 9 types ACE REPORT (p13, 54) B branch bit3, lvs PC+1 in reg allows recursion. else type A K, L, M, N register/data moves O output to card P read card Q CI to TS6 ("acc.") R logical p61, & | ~ op? =0 rot(n) S arithmetical (microcoded) T "microcode" Facilities: Storage: (4) ACE instruction set in Programmers Handbook Though this machine was never actually built, like von Neumann's EDSAC design the ACE had a large impact on the soon-to-be-built computers. It was documented in [ACE REPORT], published the same year as [EDVAC], to which document the ACE Report refers. However, ACE is not derivative of EDSAC; further, there is reason to believe [need ref] that JvN and Turing talked about computer design, not uncommon in the late 1940's. JvN was certainly aware of Turing's wartime work [ref] [ENIGMA? JvN states he knew of Turing's early work], in spite of [GOLDSTINE]. Architecturally, ACE is a reasonably "modern" machine, with no major architectural oddities (if you consider a serial machine not-odd), though there is some juggling of lower address bits to accomodate memory latency. However, unlike all contemporary machines, it was a very spare design; the ACE was to be a "software" machine. At that time, it was considered most reasonable to arrange that the encoded letter "A" (for instance) on a teleprinter or punched card be made to correspond, directly, in hardware, to the "ADD" instruction of the computer. Turing determined, and rightly so, that this was wasteful, and such things were better done in software. Rather than a centralized "accumulator" design, Turing designed the arithmetical elements to be more or less autonomous units, whose functioning ran in parallel with central control, which made it an extremely fast design. Turing went much further than this; the ACE Report specifies initial library subroutines (ACE was capable of reentry and recursion), including a free-form "assembly language". He makes explicit the conceptual differences between machine language (1's and 0's contained in memory), relocatable symbolic code (eg. an opcode and a memory reference to be resolved later) and written, human-readable opcodes, as well as named variable references and other modern constructs. These ideas were considered wild, and were not implemented in any first-generation systems. The ACE design was the only first-generation computer to include logical and bit-manipulation instructions; for all machines, the emphasis was on mathematics, and nearly all machines included hardware multiply and divide. The inclusion of logical instructions (AND, OR, INVERT, etc) was at once far-sighted, and entirely pragmatic -- Turing realized a decade earlier that all of what a computer could do could be simulated, or emulated, in a general-purpose symbol-manipulating computer; and the wartime work at Bletchley Park proved the importance and usefulness of character/symbol manipulation by machine. Alas, Turing was his own worst enemy; also in the ACE Report he delved into hardware design (pedestrian at best, along the way insulting the engineers that might build it) and scolded his own bureaucratic bosses for cowardice and lack of insight -- not a good way to finesse a difficult project. Another liability, not his fault, was that the direct experience he based much of his design on, his wartime cryptological machinery work, was under extreme secrecy; few could even know what he had worked on; this made much of his best ideas, based upon years worth of direct experience in computing, completely opaque, until largely declassified in the 1970's. Turing went through a number of versions of the ACE design. The Pilot ACE was based upon one of his earlier designs, version V. There were further versions of the ACE design, after the published report. * Refers to JvN "report on EDVAC Logical instructions (end sect. 4, p.27) Photo Pilot ACE, p128, 132+ * cf. Edvac, "risc" order set, do in SW even branch. (prob. from exp w/modding BP machines) * EDVAC design, 1946 ------------------ Manchester Baby computer, 1948 ------------------------------ Type: Stored-program binary digital computer Instruction set: Facilities: Storage: 1024 bits arranged as 32 words of 32 bits each http://www.computer50.org/index.html Programmer's reference manual http://www.cs.man.ac.uk/prog98/ssemref.html EDSAC, 1949 ----------- Type: Stored-program binary digital computer Instruction set: Facilities: Storage: BINAC, 1950 ----------- Type: Stored-program binary digital computer Instruction set: Facilities: Storage: Pilot ACE, 1950 (built by Womersley's crowd) --------------- Type: Stored-program binary digital computer Instruction set: Facilities: Storage: EDVAC, 1952 (encompasses IAS, MANIAC machines) ----------- Type: Stored-program binary digital computer Instruction set: Facilities: Storage: could not modify instructions until 1947, and for tagged instructions only, eg. address fields. (1) [Need orig. documents] Pilot ACE --------- Storage: Mercury delay line; 300 32-bit words Version V See 20TH p111 Though Pilot ACE was a faint shadow of Turing's ACE design, it's basic design features shown through. Turing's floating point routine code with it's optimum coding (eg. programming around serial memory latencies) made it nearly as fast as fixed-point arithmetic; on more conventional machines such as EDSAC, floating point was considered too slow to be useful. The autonomous-unit design was kept; for example, though the multiplier unit didn't handle signs, these could be calculated in software while the multiplier was working. The Pilot ACE machine however had it's logical instructions gutted by Womersley, who originally criticised Turing's design for being "outside the mainstream of computer design" [find ref in ENIGMA]. SOURCES ------------------------------------------------------------- APPENDICES TIMELINE NOTE: This needs to include first machines w/logical instructions. Lop off all extraneous machines! Atanasoff ABC (not stored?) On Computable numbers..., Alan Turing, 1937 ENIAC design begun, spring 1943 COLOSSUS, 1943, very programmable, tiny electronic data storage; proto-computer. (secret til late 70s') "First draft of a report on the EDVAC", JvN, June 1945 WHIRLWIND (digital) design begun, "late 1945" (20TH p 366) ENIAC, 15 February 1946 demonstration (footnote re: demo vs. first date) ACE Report [REAL NAME], Alan Turing, early 1946 "Preliminary discussion", JvN, 1946 "Planning and coding", JvN, 1947 ATLAS design begun, August 1947 20TH p490 ENIAC made switch-programmable, November 1947 20TH p459 GOOD DETAIL! MANIAC design /edvac/ begun, "1948" 20TH p460 Manchester "baby" ("baby MARK I") computer, runs, 21 June 1948 ENIGMA p413, 20TH p433 SWAC design begun /edvac/, May 1948 Pilot ACE design begun, "early 1949" 20TH p108 ORDVAC, ILLIAC design /edvac/ begun, 1949 EDSAC runs, 6 May 1949, first computer in daily service BINAC, aircraft design, ran Aug 1950, first American computer to run SWAC dedicated, August 1950 "Computing machinery and intelligence", Turing, October 1950 Pilot ACE, ran on Nov 1950, ATLAS ran, December 1950, second american machine 20TH p490 EDVAC/Moore School ? Ferranti Mark 1 IBM 701 design begun, early 1951 MANIAC runs, March 1952 IAS, 1952 ORDVAC delivered, /edvac/ March 1952 ILLIAC delivered, /edvac/ September 1952 IBM 701 delivered, December 1952 DEUCE? ACE?