Multics History
`
`Multics
`
`History
`
`11/16/2016
`
`01 Mar 2016
`
`Contents
`
`1. Summary of Multics
`1.1 Goals
`1.2 Notable features
`2. Inception
`2.1 Beginnings
`2.2 Initial construction
`2.3 Use at MIT
`2.4 Use at RADC
`2.5 The GE-655
`3. The 70s
`4. The 80s
`5. Termination
`
`See the Site Timeline for a chart of Multics sites by date.
`For a list of significant Multics dates, see the Multics Chronology.
` available on YouTube and the slides are available as a PDF. new
`A 1989 ACM talk by John Gintell on Multics history is
`1. Summary of Multics
`
`Multics (Multiplexed Information and Computing Service) is a timesharing operating system begun in 1965 and used until
`2000. The system was started as a joint project by MIT's Project MAC, Bell Telephone Laboratories, and General Electric
`Company's Large Computer Products Division. Professor Fernando J. Corbató of MIT led the project. Bell Labs withdrew
`from the development effort in 1969, and in 1970 GE sold its computer business to Honeywell, which offered Multics as a
`commercial product and sold dozens of systems.
`
`Multics included
`
`a supervisor program that managed all hardware resources, using symmetric multiprocessing, multiprogramming, and
`paging
`an innovative segmented memory addressing system supported by hardware
`a tree structured file system
`device support for peripherals and terminals
`hundreds of command programs, including language compilers and tools
`hundreds of user-callable library routines
`operational and support tools
`user and system documentation
`
`The design team's intention was that Multics would develop into a prototype information utility, as described in Martin
`Greenberger's 1964 Atlantic Monthly article,
` "The Computers of Tomorrow". As part of this vision, Multics was intended
`to provide interactive access to many remote terminal users simultaneously, in a manner similar to MIT's CTSS system.
`Multics combined ideas from other operating systems with new innovations. Security was a fundamental design requirement,
`in order to meet the utility goals. The team's ambition was that Multics would change the way people used and programmed
`computers.
`
`Multics was introduced in a series of papers at the 1965 Fall Joint Computer Conference:
`
`"Introduction and Overview of the Multics System," F. J. Corbató and V. A. Vyssotsky
`"System Design of a Computer for Time-Sharing Applications," E. L. Glaser, J. F. Couleur, and G. A. Oliver
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 1 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`"Structure of the Multics Supervisor," V. A. Vyssotsky, F. J. Corbató, and R. M. Graham
`"A General Purpose File System for Secondary Storage," R. C. Daley and P. G. Neumann
`"Communications and Input/Output Switching in a Multiplex Computing System." J. F. Ossanna, L. Mikus, and S. D.
`Dunten
`"Some Thoughts About the Social Implications of Accessible Computing," E. E. David, Jr. and R. M. Fano
`
`Many books and papers describe aspects of Multics.
`
`Multics ran on specialized expensive CPU hardware that provided a segmented, paged, ring-structured virtual memory. The
`supervisor implemented symmetric multiprocessing with shared physical and virtual memory. Standard Honeywell
`mainframe peripherals and memory were used. The operating system was programmed in PL/I.
`
`Elliott Organick's book, The Multics System, an Examination of its Structure, describes the system as it was in about 1968.
`MIT started providing timesharing service on Multics to users in fall of 1969. GE sold the next system to the US Air Force,
`and the military use of Multics led to some of the system's security features. Honeywell sold more systems to government,
`and to auto makers, universities, and commercial data processing services.
`
`In the 1980s, Multics became popular in France; Honeywell's partner Bull sold a total of 31 French Multics sites.
`
`Honeywell decided not to create a new hardware generation for Multics in the mid-80s and stopped developing the operating
`system. In 1987, Honeywell Bull also chose not to build new Multics hardware, and customer sites replaced their Multics
`systems with more modern hardware. MIT's Multics system was shut down in January, 1988.
`
`The last running Multics site, the Canadian National Defence site at Halifax, NS, shut down at the end of October 2000.
`
`1.1. Goals
`
`As described in the 1965 paper Introduction and Overview of the Multics System by Corbató and Vyssotsky, there were nine
`major goals for Multics:
`
`Convenient remote terminal use.
`Continuous operation analogous to power & telephone services.
`A wide range of system configurations, changeable without system or user program reorganization.
`A high reliability internal file system.
`Support for selective information sharing.
`Hierarchical structures of information for system administration and decentralization of user activities.
`Support for a wide range of applications.
`Support for multiple programming environments & human interfaces.
`The ability to evolve the system with changes in technology and in user aspirations.
`
`1.2. Notable features
`
`See Multics Features for more information.
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 2 of 15
`
`

`
`Multics History
`
`1.2.1. Segmented memory
`
`11/16/2016
`
`The Multics memory architecture divides memory into segments. User programs address segments directly; segments may be
`shared between different processes' address spaces. Each segment has addresses from 0 to 256K words (1 MB). The file
`system is integrated with the memory access system so that programs access files by making memory references.
`
`1.2.2. Virtual memory
`
`Multics uses paged memory in the manner pioneered by the Atlas system. Addresses generated by the CPU are translated by
`hardware from a virtual address to a real address. A hierarchical three-level scheme, using main storage, paging device, and
`disk, provides transparent access to the virtual memory.
`
`1.2.3. High-level language implementation
`
`Multics was written in the PL/I language, which was, in 1965, a new proposal by IBM. Only a small part of the operating
`system was implemented in assembly language. Writing an OS in a high-level language was a radical idea at the time.
`
`1.2.4. Shared memory symmetric multiprocessor
`
`The Multics hardware architecture supports multiple CPUs sharing the same physical memory. All processors are equivalent.
`
`1.2.5. Multi-language support
`
`In addition to PL/I, Multics supports BCPL, BASIC, APL, FORTRAN, LISP, SNOBOL, C, COBOL, ALGOL 68 and Pascal.
`Routines in these languages can call each other.
`
`1.2.6. Relational database
`
`Multics provided the first commercial relational database product, the Multics Relational Data Store (MRDS), in 1978.
`
`1.2.7. Security
`
`Multics was designed to be secure from the beginning. In the 1980s, the system was awarded the B2 security rating by the US
`government NCSC, the first (and for years only) system to get a B2 rating.
`
`1.2.8. On-line reconfiguration
`
`As part of its computer utility orientation, Multics was designed to be able to run 7 days a week, 24 hours a day. CPUs,
`memory, I/O controllers, and disk drives can be added to and removed from a Multics site's configuration while the system is
`running.
`
`1.2.9. Software Engineering
`
`The development team spent a lot of effort finding ways to build Multics in a disciplined way. The Multics System
`Programmer's Manual (MSPM) was written before implementation started: it was 3000 or so pages and filled about 4 feet of
`shelf space in looseleaf binders. (Clingen and Corbató mention that we couldn't have built the system without the invention of
`the photocopier.) High level language, design and code review, structured programming, modularization and layering were all
`employed extensively to manage the complexity of the system, which was one of the largest software development efforts of
`its day.
`2. Inception
`
`2.0.1 Precursors
`
`In the early 1960s, large-scale computing was dominated by mainframe computers that were controlled by batch processing
`supervisor programs. Users submitted jobs on punched cards and tape, and received printed output, punched cards, and tape
`after the job was run.
`
`"Conversational" computing, in which a single user typed commands to a computer and saw output immediately, had been
`done on the RAND Johnniac starting in 1953, and was the standard way of using smaller computers and research machines
`such as MIT's Whirlwind.
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 3 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`Timesharing, in which a large machine switched its attention between multiple users, giving each the impression of
`conversational computing with a "virtual" computer, had been proposed by John McCarthy in 1959, and by other computer
`scientists about the same time.
`
`Paging had already been demonstrated on the Atlas system in the early 60s (with 16 pages), and the Burroughs B5000
`incorporated segmentation. (Ted Glaser had been part of the B5000 design team.) MIT Professor Jack Dennis of MIT
`contributed influential architectural ideas to the beginning of Multics, especially the idea of combining paging and
`segmentation.
`
`2.1. Beginnings
`
`2.1.1. CTSS
`
`The Compatible Timesharing System (CTSS) was one of the first timesharing systems. It was developed at the MIT
`Computation Center by a team led by Fernando J. Corbató. CTSS was first demonstrated in November 1961 on the IBM 709,
`swapping to tape. In its mature form, CTSS ran on a modified IBM 7094 with a second 32K-word bank of memory, using
`two IBM 2301 drums for swapping, and provided remote access to up to 30 users via an IBM 7750 communications
`controller connected to dialup modems. Story:
` "The IBM 7094 and CTSS".
`
`The PLATO system at University of Illinois and the PDP-1 timesharing system at MIT were also demonstrated in 1961. The
`JOSS system, running on the RAND Johnniac, began operation in 1963.
`
`2.1.2. MIT Project MAC
`
`The history of Project MAC is described on a separate page. The Project MAC contract between MIT and ARPA was signed
`on July 1, 1963. The Computer Systems Research Group, led by Prof. Corbató, accounted for about a third of Project MAC's
`budget; its goal was to design and implement a successor operating system to CTSS.
`
`2.1.3. Selection of Hardware Vendor
`
`Visits to vendors were made in 1963, and the Multics specifications were developed and sent out to bid. Senior management
`visited IBM, Digital Equipment Corporation (DEC), Univac, and Control Data. When it came time to select a vendor for the
`computer that would support the new OS, the folklore is that IBM pitched the machine that would become the 360/65. They
`were not interested in the MAC team's ideas on paging and segmentation. Professor Joseph Weizenbaum, then a lecturer at
`MIT, introduced the MAC team to former colleagues of his from General Electric Phoenix, who were receptive and
`enthusiastic, and proposed what became the GE-645. DEC also responded to the bid. The GE proposal was chosen in May
`1964 ( much to the surprise and chagrin of IBM) and the contract signed in August 1964.
`
`The GE-645 was an enhanced version of the commercial GE-635, which in turn was a descendant of the GE M236
`minicomputer that GE Syracuse had supplied to the US Air Force for the MISTRAM missile tracking system in the early 60s.
`
`[Kazumasa Mine] At that time, John F. Couleur was responsible for General Electric's 600 product lines. Couleur co-operated with
`Edward L. Glaser of MIT on the design of the 645, adding paging, segmentation, associative memories or translation
`look-aside buffers (US Patent 3,412,382), and various functions MIT required, to the base GE-635. Nowadays, almost all
`computers supporting virtual memory have a TLB in their Memory Management Unit. Couleur's recollections are in The
`Core of the Black Canyon Computer Corporation, IEEE Annals of the History of Computing Vol. 17, No. 4: Winter 1995, pp.
`56-60.
`
`The family tree of GE and Honeywell large-scale computers is described in Jane King and Bill Shelly's article A Family
`History of Honeywell's Large-Scale Computer Systems, IEEE Annals of the History of Computing Vol. 19, No. 4, October/
`December 1997..
`
`2.1.4. MIT, Bell Labs, GE
`
`Bell Labs joined the Multics software development effort in November of 1964 and decided to obtain a GE-645. GE also
`agreed to contribute software development manpower as well as hardware system engineering. The three organizations
`worked out a structure for cooperation. The Trinity made major policy decisions. There was one person from each
`organization:
`
`Robert M. Fano (MIT)
`Edward E. David (BTL)
`John Weil, then Eugene White, then C. Walker Dix (GE).
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 4 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`The Triumvirate was in charge of actual management of the implementation. Membership changed over the years. The
`initial composition was
`
`Fernando J. Corbató (MIT)
`Ed Vance (GE)
`Vic Vyssotsky (BTL).
`
`The final composition was
`
`Fernando J. Corbató (MIT)
`A. L. Dean (GE)
`Peter G. Neumann (BTL).
`
`Jerome H. Saltzer and Edward L. Glaser were consultants to the triumvirate.
`
`Bell Laboratories personnel worked on Multics from their locations in New Jersey, dialing into the Project MAC CTSS
`system over 110 to 150 baud phone lines. Most of the Bell folks were located in Murray Hill NJ, with a few in each of
`Holmdel and Whippany. Bell's GE-645 was installed in Murray Hill.
`
`General Electric obtained office space in Technology Square for a programming team, called the Cambridge Information
`Systems Laboratory (CISL). Al Dean led this group. CISL was initially located on the 7th floor of Tech Sauare. The CISL
`people connected to CTSS using MIT's internal data switch. GE hardware engineering was located in Phoenix, AZ, along
`with Ed Vance and his management.
`
`2.1.5. Papers at 1965 FJCC
`
`Six papers describing Multics were presented at a special session at the 1965 Fall Joint Computer Conference. At the time,
`some people thought the system's goals were too ambitious, and that it couldn't be built, for example H. R. J. Grosch, in
`DATAMATION, November 1, 1971:
`
`Inspect now the far end, the impossible end, of the feasibility spectrum. Here we find that hecatomb called
`SAGE, and the other (all the other) command and control projects. We find the great corporate MIS
`systems-the automated board room, the self-optimizing model, the realistic management game. And,
`pardon my chuckles, if we turn over a few flat stones we may even find MULTICS.
`
`Other contemporary computer scientists argued against the idea of writing a system in a high level language, or with the use
`of virtual memory, on the grounds of inefficiency.
`
`2.2. Initial construction
`
`Professor Fano's initial goal for the project was to have a usable Multics system running by the end of 1965, but this didn't
`happen. A GE-635 was delivered to Project MAC in August 1965 for use running the 645 simulator, called the 6.36. Intense
`software development efforts to design and build Multics began in 1965, led by Corby and Bob Daley at Project MAC. The
`development team used the Project MAC CTSS system for file editing, file storage, and cross-compilation. They submitted
`645 simulator runs from CTSS which were run under batch mode on the 635.
`
`CTSS had been built using the existing tool chain for the Fortran Monitor System batch environment: the assembler, loader,
`object format, and subroutine linkage conventions. The Multics design started from scratch for all formats, conventions, and
`tools.
`
`Bell Labs contracted with Digitek, a software house with experience in compilers, in 1965 to produce a PL/I compiler for
`Multics. When it became clear that this project was going to fail, Doug McIlroy and Bob Morris of Bell Labs produced a
`compiler for EPL (Early PL/I), a subset of the full language. This compiler was written using Bob McClure's TMG language
`framework. It ran on CTSS and also under GECOS on the 635. Developing this compiler and learning to use it contributed to
`further delay.
`
`The GE-645 was delivered to Project MAC in January 1967, later than planned. Once the 645 was in place, a revised 645
`simulator, still running under GECOS, was used to execute the first major development milestone, "Phase .5," which ran an
`initial version of the Multics file system. The "Phase 1" milestone demonstrated native boot of Multics on the GE-645 and
`single-process execution in December 1967, and multi-process execution was demonstrated a few months later. These
`milestones represented the integration of many software components: memory management including paging, segmentation,
`and rings; file system including disk management; process creation, scheduling, and interrupt handling; terminal I/O; and
`user address space organization, command shell, and dynamic linking. Slow performance and system crashes required us to
`spend unplanned effort improving the system design during 1968 and 1969.
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 5 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`Multics was self hosting, able to compile itself on Multics using bootstrapped compilers, by the end of 1968. All Multics
`development, by Project MAC and GE users, moved from CTSS to Multics during 1969. Non-developer users began using
`Multics on a regular basis in July 1969, and MIT's Information Processing Center began providing Multics as a service in
`October 1969. EPL was replaced by a native compiler, Multics version 1 PL/I, in late 1969.
`
`Two interesting and candid papers describe the difficulties we encountered while building Multics. "Multics -- the First Seven
`Years", by Corbató, Saltzer, and Clingen, describes problems we encountered and lessons learned. "A Managerial View of the
`Multics System Development", by Corbató and Clingen, describes the major problems faced by the management team, the
`approaches to solving the problem, and some lessons we learned.
`
`2.2.1. The MSPM
`
`In 1965 and 1966, while waiting for the PL/I compiler to become available, the development team wrote the Multics System
`Programmer's Manual (MSPM). It was about 3000 pages; every section went through serious peer review and many sections
`were rewritten or deeply revised several times.
`
`The MSPM contained functional requirements, high-level design, and implementation plans for Multics. When we actually
`started building and integrating the system, we discovered that some of the MSPM designs were far too complex. Simpler,
`more efficient facilities were built instead, sometimes as interim measures intended to evolve into the full design eventually,
`and sometimes as recognition that the original plan attempted too much. The MSPM was updated to reflect some of the early
`redesigns, but quickly got behind. We did try to keep a particular section up to date, the one that documented the system
`module interfaces, i.e. the code that was actually in the system.
`
`See Development Documentation for a description of documents produced during development.
`
`2.2.2. Compilers
`
`PL/I was chosen as the programming language in 1964. A detailed discussion of the history and features of Multics PL/I is on
`a separate page. The EPL compiler produced assembly language which was processed by the EPLBSA assembler.
`
`2.2.3. Management
`
`In 1968-69 Multics was late and under significant financial pressure and threat of cancellation. Maybe this helped esprit de
`corps (as opposed to surface morale). A review by a select ARPA committee in 1968 was one time we came close to
`cancellation; they recommended that we continue.
`
`[Ed Fredkin] Professor Licklider, then the director of Project MAC, asked to see me. He told me, confidentially,
`that ARPA wanted to stop funding Multics. Licklider felt that there needed to be a graceful way for MIT to
`come to the conclusion, on its own, that the Multics project should be scrapped. I was sympathetic to Lick's
`position. He suggested to me that I serve on a committee which would study the state of the Multics project
`and which would obviously come to the conclusion that the best course of action was to terminate the
`project. I agreed.
`
`So the committee was formed and it met at MIT's Project MAC. We decided to have the key Multics figures,
`Professors Corbató and Saltzer (and, to my recollection, others) explain both the state of Multics and the
`state of the implementation project. It seemed to me, from their behavior, that it was obvious to them that
`the project was likely to be terminated. As this process started there was no doubt in my mind that the
`committee would come to the conclusion that Lick expected. As I listened to the Multics story I was
`impressed by 2 things: the fantastic accomplishments of the Multics team, and the miserably poor telling of
`it. Corby, so much under the gun to get the next set of things done, spoke mainly about the things they were
`urgently working on that month (or that week)!
`
`While I felt that the rest of the committee was leaning towards recommending termination, I began to realize
`that killing off Multics was a terrible idea. My reasoning was as follows: While the Multics project might have
`been overly ambitious, it was the sole embodiment a great number of very important ideas. The current
`efforts were taking advantage of lessons learned; knowledge and experience available nowhere else on the
`planet. If we killed off Multics, it was likely that these ideas would become lost art and would be discredited
`along with the whole Multics project; all to the possible detriment of many future projects. I decided that the
`committee had to come to the opposite conclusion to the one that Lick expected.
`
`I was so certain that my new position was correct, that I planned and contrived to do the following: figure
`out exactly how it could be arranged so that the committee as a whole would decide in favor of continuing
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 6 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`Multics. Was I manipulative? I don't remember the details but the answer is "Probably".
`
`[THVV] (Who was on this committee besides Larry Roberts, Butler Lampson, Ed Fredkin, and Dave Evans?) See Multics -- the
`First Seven Years and A Managerial View of the Multics System Development.
`
`2.2.4. Bell labs withdraws (4/1969)
`
`Bell Labs chose to withdraw from the Multics project in April 1969. Their goal in joining was to obtain a timesharing system
`for use by members of the technical staff at Bell Labs. When the planned time had passed, Multics was not ready to use, and
`it was clear that there was a lot more work to do. Bell was paying rent on its GE-645 and dedicating valuable people to the
`Multics effort, and continuing would prolong these costs with no trustworthy end date.
`
`"Over time, hope was replaced by frustration as the group effort initially failed to produce an economically
`useful system. Bell Labs withdrew from the effort in 1969 but a small band of users at Bell Labs Computing
`Science Research Center in Murray Hill -- Ken Thompson, Dennis Ritchie, Doug McIlroy, and J. F. Ossanna
`-- continued to seek the Holy Grail." --
` Lucent web page
`
`"... the problem was the increasing obviousness of the failure of Multics to deliver promptly any sort of
`usable system, let alone the panacea envisioned earlier." -- Dennis Ritchie,
` "The Evolution of the Unix Time-sharing System"
`
`2.3. Use at MIT
`
`Starting in October 1969, the MIT Information Processing Center took over operational responsibility for the GE-645
`computer. At that time, Multics performance exceeded that of CTSS, and was continuing to improve. The Multics system was
`used for MIT sponsored research projects, student computing, and departmental administration. In addition, about half of the
`MIT system's capacity was used by the Multics project to develop the operating system, supporting users from Project MAC
`and General Electric.
`
`See the MIT Site History for more description.
`
`2.3.1. TOSS summer study (7/1969)
`
`The Cambridge Project was an ARPA-funded political science computing project. (Given the nature of the research, the funds
`probably came from one of the security agencies, and were channeled through ARPA.) They worked on stuff like survey
`analysis and simulation, led by MIT Professor Ithiel de Sola Pool, J. C. R. Licklider and Douwe B. Yntema. Yntema had
`done a system on the MIT Lincoln Labs TX-2 called the Lincoln Reckoner, and in the summer of 1969 led a Cambridge
`Project team in the construction of an experiment called TOSS (terminal oriented social science? anyway it was intentionally
`a throwaway system). TOSS was sort of like Logo, with matrix operators. Its big feature was multiple levels of undo, back to
`the level of the login session. This feature was cheap on the Lincoln Reckoner, but absurdly expensive on Multics. This
`project provided some much-needed revenue to keep the 645 going until it could go public, and was a precursor to the
`Consistent System (see below).
`
`The first academic course at MIT taught using Multics, in the summer of 1969, was 6.231 Programming Linguistics, taught
`by professors Art Evans and John M. Wozencraft. It used the
` PAL language.
`
`2.3.2. MIT usage (10/69)
`
`MIT's Multics was finally opened for paying customers in October
`1969, several years later than planned. Pioneer users of the MIT
`system put up with a lot: crashes, poor response, constant change,
`arrogance from developers, and inexplicably missing features. The
`Multics developers and the MIT Information Processing Center
`management worked furiously to fix problems and make good on
`overdue promises, and to stave off abandonment of Multics by
`ARPA, GE, or large MIT users.
`
`2.3.2.1 Cambridge Project
`
`[John Klensin] MIT's Cambridge Project was a major user and revenue
`source. It built an application called the Consistent System, the
`largest application ever built on Multics and the most comprehensive
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 7 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`data analysis modeling and analysis system ever built. Consistent
`System developers and users pressed for better function, reliability,
`and performance and contributed important code and ideas to
`Multics. Applications built on the CS or its components became a
`major portion of the workload at several customer sites and
`contributed to the length of time a few of those systems stayed in
`operation. AFDSC comes particularly to mind here, although the
`Human Resources databases at EDS and some of the applications at Credit Lyonnais are probably also candidates.
`
`Multics accounts at MIT, 1969-70. From Project MAC
`Progress Report VII. I think I created this graph for the report
`using the Multics Graphics System.
`
`2.3.2.2 Operating System Development
`
`The main usage of the new Multics system, beginning in 1969, was system programming for Multics itself. The development
`team was mostly comprised of MIT staff members working at Project MAC, and GE staff members working at the
`Cambridge Information Systems Laboratory (CISL). In addition to using the MIT system for online editing and compilation
`of system programs, the MIT system could be reconfigured into two systems, one of which was used for service, and the
`other for a "development run," in which a new version of the supervisor was booted and tested.
`
`The GE-645 remained on the ninth floor of Technology Square's Alpha building and provided service to the MIT campus via
`the MIT private telephone exchange. The Project MAC members of the Multics development team were mostly on the fifth
`floor of the Tech Square Alpha building. CISL programmers were located on the seventh floor of the building, and later
`moved to the new Beta building across the courtyard. Some GE personnel in Phoenix, where the hardware was built,
`accessed the MIT system via GE's private phone network.
`
`CISL's language team under Axel Kvilekval and Bob Freiburghouse produced the version 1 PL/I compiler in 1968 and 1969,
`and Multics was recompiled and in many cases rewritten to take advantage of the much better code produced by the new
`compiler.
`
`2.3.2.3 Other MIT Usage
`
`Project MAC supported quite a few other users of the early Multics. Many of these users used Multics for document creation
`and formatting and electronic mail as much as they did programming. One group at Project MAC was working on what
`became the ARPANet, and they designed the hardware and software that connected Multics to the ARPANet as host 0 on
`IMP #6 in September 1971. Other Project MAC groups that used Multics included a group doing early research in relational
`databases.
`
`Other non-MAC research projects at MIT switched over from the overloaded CTSS to Multics, hoping to take advantage of
`the new machine's advanced features and lower costs. Computer science research projects outside MIT also secured accounts
`at the MIT Information Processing Center and used Multics.
`
`2.4. Use at RADC (8/1970)
`
`The second Multics site was at Rome Air Development Center, Griffiss AFB, Rome, New York. The computer was installed
`in late 1968 but was not used for Multics until 1970. Some
` research done at this site was classified intelligence studies.
`RADC also studied software engineering and software tools. They attached an associative processor, a Goodyear Staran,
`containing 1000 1-bit processors, to their Multics and did pattern recognition work. (The Staran daemon was assigned a load
`of 1.5.)
`
`See the RADC site history.
`
`[RFC 208] RADC was added to the ARPANet as host 18 as of 10/5/71.
`
`2.5. The GE-655
`
`The GE-645 was a very large computer, implemented in discrete component technology, that is, individual
`transistors, resistors, and so on soldered to circuit boards. Each CPU backplane was an enormous mass of
`wires, perhaps 7 feet by 3 feet, built by automated Gardner-Denver wire-wrap machines. Reliability of the
`large and complex machines was a continual problem, and GE systems were at a performance disadvantage
`compared to competitors like IBM who used integrated circuit technology.
`
` a machine known as the GE-655, which used integrated circuits
`In the late 60s, GE Engineering designed
`instead, and was much smaller and faster. The GE-655 shared the basic asynchronous design of the GE-645.
`3. The 70s
`
`GE-645 board
`
`http://multicians.org/history.html
`
`NETAPP, INC. EXHIBIT 1011
`Page 8 of 15
`
`

`
`Multics History
`
`11/16/2016
`
`3.1. GE Sells Its Computer Division to Honeywell
`
`GE sold its computer business to Honeywell in 1970. This was referred to as the "merger," and was announced to GE
`employees on 20 May 1970. (See Jean Bellec's story of Shangri-La.) Honeywell renamed the GE-655 to the Honeywell 6000
`Series and released the Honeywell 6070 in 1973; the EIS version was known as the Honeywell 6080. GE CISL became
`Honeywell CISL, still located in Technology Square, Cambridge. It had about 40 employees during the 1970s.
`
`3.2. Use of Multics at MIT
`
`MIT's Information Processing Center operated a Multics timesharing service with over a thousand registered users through
`the 1970s. Honeywell was a major customer of this service, and IPC, MIT Project MAC, and Honeywell CISL used the MIT
`site as the primary development tool for Multics operating system development. Project MAC's participation in Multics
`development gradually declined in the 1970s: its Computer System Research group widened its focus and dedicated a
`declining number of staff to Multics improvement. Some professors and student thesis research made valuable contributions
`to Multics during the 70s, and Project MAC used the Multics machine to develop and deploy its contributions to the
`ARPANet and TCP/IP.
`
`Computer science papers in the 1970s by Project MAC professors and Honeywell employees continued to publicize and
`document the ideas and lessons of Multics.
`
`3.3. Honeywell Offers Multics as a Product
`
`In the early 1970s, Honeywell decided to offer Multics as a product, targeting universities (like MIT), high-tech companies
`(like Ford and GM), and military customers (like the US Air Force, to whom Honeywell had sold a large number of
`computers as part of WWMCCS). This activity brought new team members into the Multics project: Honeywell marketing
`and Federal Systems marketing, and development organizations in Billerica MA, Phoenix AZ, and Paris, France.
`
`3.3.1. Commercial announcement (1/1973)
`
`There were several commercial announcements of Multics. The Honeywell 6180 was announced in January 1973 at the
`Boston Museum of Science. 6180 processors were about 1 MIPS each. A two-CPU system with 768KB of memory, 8MB of
`bulk store, 1.6GB of disk, 8 tape drives, and two DN355s, like MIT's system, had a purchase price of about $7 million. The
`6180 was faster and smaller than the 645, cost less, and included hardware architecture improvements that improv