Genesis

GM was an early computer user, using punched card machines as early as 1952 for engineering analysis. In 1955 they moved their computing services into the new Data Processing department of GM Research Laboratories. In 1956, together with North American Aviation, they developed the first "official" batch processing operating system for IBM systems, GM-NAA I/O. In 1958 they were one of the earliest users of IBM's new FORTRAN compiler.^[1]

In June 1958 GM Research started a program to better understand the problems and potential improvements in the industrial design process.^[1] The team found that each step of the process -from initial conception and body styling through engineering design and finally to detailed parts drawings- used different types of diagrams. Each division within the company had to have their own drawing departments to support them. Time was being lost, and errors introduced, when the diagrams moved from one department to another and had to be re-drawn into the local format. Even the task of looking up the diagrams in the engineering libraries represented a significant amount of time. When modifications were made to drawings, this process repeated itself.

Convinced that automation was a solution to at least some of these problems, in 1959 Donald Hart tasked the Data Processing department of GM Research to start developing a system to store diagrams for rapid retrieval and simple modifications.^[2] The idea was that the diagrams would be digitized into the computer, displayed interactively to allow rotations, scaling and projections, and then printed on demand. Lookups would be handled via punched card queries, which would allow operators to quickly retrieve documents for manipulation into whatever local format the user needed, and then print it. Repetitive queries could be automated simply by saving the card stack.

Prototype

The Data Processing department had already been experimenting with an IBM 704 computer displaying points on the IBM 780 display which were recorded to 8 mm film. One early use was plotting traffic simulations.^[1] However, the displays were not based on storage tubes, so the images disappeared shortly after they were drawn. In order to keep the image on the screen, the program had to be put into a loop, continually refreshing the display. While this was happening the computer could not be used for other tasks. Although it was suitable for demonstration purposes, a real-world system would need additional hardware to offload this task from the CPU.

Another problem was printing the diagrams. GM solved this problem by using an approach developed by Boeing, replacing the milling head of a computerized milling machine with a ball-point pen and connecting the inputs of the mill to the 704 computer. To address the extremely limited amount of memory available on the 704, they broke the diagrams down into 32-by-32-inch squares, which could be plotted with enough accuracy that they could be loaded up as separate tiles and still line up perfectly when plotted as part of complete diagrams. A set of rollers were added to allow the plotter to move a single 96-inch-wide (2,400 mm) piece of paper around the drawing surface on demand, meaning that the paper did not have to be cut into pieces. The paper was delivered in rolls, allowing diagrams to be any length.^[2]

The final problem was to convert the existing diagrams, on paper, into computer data. The solution was to re-print the diagrams onto clear acetate and place them in front of the 780 display. The computer then moved the display's dot across the screen, where it would be periodically occluded by the lines on the acetate. A photomultiplier tube noticed these drops in output and recorded them. Since diagrams consist largely of whitespace and a few lines, a simple raster scan would be too time-consuming. Instead, when the program noticed a line it would scan a circle of points around the last hit, attempting to find the line again. The system allowed the digitizing of 6,000 points a second.^[3] The output was a set of cubic polynomials that described the line smoothly.

DAC-1

The system, known as Digital Design, was demonstrated and improved throughout 1959. In order to avoid confusion over the term "digital", which at that time was most closely associated with fingers and not computing, the name changed to DAC-1.^[2] By the summer it was clear the basic idea was feasible. In August, the team was given the go-ahead to start work with IBM to purchase an IBM 7090 computer and develop commercial versions of the display hardware.

The production system had to not only manipulate existing drawings, but also be capable of modifying them in the computer. Although the computer would not normally be used to produce new artwork, once the diagrams were scanned into the system, changes could be made without going through the entire scanning process again.

Once digitized, additional software could be used to convert the lines into a 3D shape. This was groundbreaking research at the time, and generated a flurry of research papers.^[4] Once converted, the diagrams could be output into the APT numerical control language for direct output on milling machines. This would allow a design team to sketch out their ideas, put them into the system and clean them up, and then have the milling systems produce a physical model.

IBM partnership

In July 1960 IBM presented GM with a formal development contract for a "Graphic Expression Machine", or "Project GEM".^[5][6] The system was hosted by the 7090, IBM's then-standard large business offering, partnered with two new channel controllers for the yet-to-be-released IBM 1301 hard disk system, and a custom controller to drive multiple graphical terminals. Output from the terminals could be sent to a plotter, 35 mm slide film.^[7] IBM estimated the system would be installed within 18 months after signing the contract. GM accepted the offer in November 1960.^[8]

Development took longer than expected. While the 7090 was being installed at GM Research in Warren, MI, the GM teams were given use of one of IBM's own 7090s in Kingston, NY. As the original production date grew closer the number of GM employees traveling to NY became a serious budget problem, which was addressed when GM rented a Convair aircraft for ferry flights between the two sites. A more serious problem was the scanner system, and a joint GM-IBM team was able to finally address the issues.^[9]

The system was given a full demonstration run at IBM's Kingston site in December 1962. The demonstrations were so well attended that bleachers were set up so that all of the attendees could see the terminal screen. The high usage demands during the demos eventually led to the disk system crashing.^[8] The production DAC-1 system went live in Warren in April 1963.^[8] At the time the 1301 was not ready, so an IBM 1401 and IBM 1405 were used instead.^[9]

DAC-1 was one of the earliest production CAD systems to enter use, only the Itek built Digigraphics system beat it, albeit to the extent of a single machine before it was taken over by Control Data Corporation.^[10]

In November 1963, DAC-1 was used to create a model of a trunk lid in a straight-through manner. An original sketch was read in, cleaned up on the terminal, converted into 3D and then output to a milling machine.^[11]

Alpine

With the successful delivery of DAC-1, IBM turned to commercializing the system in "Project Alpine". The results of Alpine were the IBM 2250 graphics terminal, 2280 film recorder and 2281 film scanner. Unlike the DAC-1's 7090, the Alpine products were all aimed for use with the newly announced IBM 360 series of computers. The graphics terminal was quite successful and IBM became a major CAD vendor. The film printer and scanner found little use among customers that were moving to all-digital workflows, and were later withdrawn as supported products.^[8]

End of DAC

DAC had always been intended to be a sort of "large area experiment", not a production system. As an experimental system, DAC was extremely successful, but the designers were well aware that additional development would be needed to make it really useful. In 1967 the CAD project was officially ended. By this point IBM had long abandoned the 7090 series for the 360, and was already working on its replacement, the IBM System/370. DAC was moved from Research to Fisher Body, but being outdated it was later donated to the University of Michigan.^[12]

When polled, team leaders within the project universally pointed to the batch-oriented operating system as the primary impediment to a truly interactive design system, with computer performance and a hierarchical file system as secondary concerns. This led to the MCTS system, "Multiple Console Time Sharing System", a version of Multics adapted for their own use, which they developed on the CDC STAR-100 computer.^[12]

Operating system

The DAC-1 system included its own custom operating system, known, as was typical at the time, simply as "monitor". Monitor was based on the earlier batch processing systems developed at GM and IBM, but fed in the batches not from punched cards, but from the attached channel controllers instead. Terminals that had to exchange information with the host computer would place data in the controller for relay, which would cause an interrupt. The host machine would service the interrupt by copying the data from the terminal into the batch monitor, which would run it as if the input had come from a card stack. The DAC program consisted of a variety of small programs which were called by the batch monitor. Their output was then copied back to the terminals as if they were printers. Users who were not actively interacting with the terminals at any given time automatically gave up their time to other users.^[9] Although the term was not in widespread use at the time, the DAC-1 system was thus an early example of a time-sharing system.

Unlike traditional batch systems, where operators manually scheduled workflows for fastest possible access to resources, DAC-1's workload would be unpredictable. This led to potential situations where one request could take a device offline for servicing, changing tapes for instance, only to have the next request data from that device. Although no general solution to the problem was found, the programmers invested considerable effort in ensuring that all of the modules needed for a particular operation could be loaded in a single "clump".^[13]

The original 7090 had a single 32 kbyte bank of memory. In order to improve performance, the DAC-1 software was left in the core, isolated in one of two 16 kbyte logical banks. The other 16 kbytes held the batch monitor and an interrupt controller that drove it. With the introduction of the 7094, the two programs were separated into their own 32 kbyte physical stores.^[9] This left little room for user programs and data. After the DAC-1 was first installed, the original 7090 was relegated to other tasks and was replaced by an IBM 7094-II. In addition to being faster, this machine was equipped with two 32 kbyte core memory stores, an unusual arrangement. The two banks allowed DAC to have an entire 32 kbytes to itself.

Programming

Programming on the DAC system was in IBM's FORTRAN IV compiler, but it quickly became clear that a language with graphics primitives would be highly desirable. GM started with an existing ALGOL 58 derivative from the University of Michigan, MAD (Michigan Algorithm Decoder), adding to it and creating their own version, NOMAD. NOMAD also included the ability to allow code to run anywhere in memory, which was very important, especially on the earlier machine with limited memory. Over 90% of the DAC system was written in NOMAD.^[13]

A similar language was also developed for the special task of running on the channel controllers. The new language was named "Maybe", because it was not clear whether or not it would work. Maybe turned into a joint effort between GM and the University of Michigan, and was indeed used on the production system.^[13]

The DAC-1 system also included a custom language intended for the users, not the programmers. DGL, for descriptive geometry language" was a simple domain-specific language that contained a number of basic geometrical operators and variable assignment. Users could write programs in DGL and input them into DAC using punched cards. The result were new modules that the user could call within the interactive environment.^[13]

Terminals

DAC had been designed with a workflow in mind; paper and pencil sketching, digitizing on the reader, minor manipulation on the terminals, and then printing or modeling. In spite of it being the centerpiece of the operation, the graphics terminal was given little thought during the design process.^[14] Performance issues limited diagrams to about 1,000 vectors; at this point the refresh time became so slow the display would become difficult to use due to flickering.

The IBM design used a capacitance screen with a metal pencil for input, providing a directly read X and Y coordinate.^[14] The basic system was similar to modern touch screen systems like the iPhone, but not sensitive enough to detect a finger and instead required a wired conductor to complete the circuit. The pencil replaced the light pens because it was much faster to decode; a light pen had to wait for a pulse of light when a vector was being redrawn and then work its way through the list of vectors to find out which one was selected.

In use it was quickly discovered that holding the pen to the vertical monitor screen was extremely tiring, so the idea of using the terminal for input was abandoned. The GM team later visited Douglas Engelbart's lab where they saw the first computer mouse, and based future projects on this device instead.^[14]

All of the terminals were connected to a single controller, and in turn to the 7090 via its Channel C input. Channel A and B were used to control magnetic tape drives, and Channel D controlled the 1301 disk.

Notes

Bibliography

Further reading