`
`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
Accessing this document will incur an additional charge of $.
After purchase, you can access this document again without charge.
Accept $ ChargeStill Working On It
This document is taking longer than usual to download. This can happen if we need to contact the court directly to obtain the document and their servers are running slowly.
Give it another minute or two to complete, and then try the refresh button.
A few More Minutes ... Still Working
It can take up to 5 minutes for us to download a document if the court servers are running slowly.
Thank you for your continued patience.
This document could not be displayed.
We could not find this document within its docket. Please go back to the docket page and check the link. If that does not work, go back to the docket and refresh it to pull the newest information.
Your account does not support viewing this document.
You need a Paid Account to view this document. Click here to change your account type.
Your account does not support viewing this document.
Set your membership
status to view this document.
With a Docket Alarm membership, you'll
get a whole lot more, including:
- Up-to-date information for this case.
- Email alerts whenever there is an update.
- Full text search for other cases.
- Get email alerts whenever a new case matches your search.
One Moment Please
The filing “” is large (MB) and is being downloaded.
Please refresh this page in a few minutes to see if the filing has been downloaded. The filing will also be emailed to you when the download completes.
Your document is on its way!
If you do not receive the document in five minutes, contact support at support@docketalarm.com.
Sealed Document
We are unable to display this document, it may be under a court ordered seal.
If you have proper credentials to access the file, you may proceed directly to the court's system using your government issued username and password.
Access Government Site