To understand the present status of the field of information technology, and the current development trends, it will be necessary to review its past history. It is short but packed with events and interesting people—so much that it will be impossible to recount the fascinating detail of the last 50 years here. We will therefore have to contend with an outlining of what seem to be the main events.

Routine calculations have always been regarded a drudgery, and much work has been done up through the centuries to lessen the strain. As mentioned earlier, the first mechanical calculator was made by the German professor Wilhelm Schickard in 1623. Another (and much more famous) one was constructed by Blaise Pascal circa 1645 (Augarten 1984). Readers born before 1960 may remember the modern mechanical or even electromechanical desk calculators (with a motor instead of a crank), those thundering monsters of the preelectronic office. They were all designed to do simple arithmetic and were considered advanced if they could multiply and divide. For more specialized computational applications, various types of large mechanical calculators were devised and built right up to the 1950s. There were even machines that could solve differential equations—but they were cumbersome to set up, required highly skilled operators, and were painfully slow by our standards.

The birth of what is usually acknowledged as the world’s first electronic computer, the ENIAC, illustrates the intimate relationship between our material needs, our creation of tools, and the tools’ subsequent feedback on our creativity, spurring new branches of both science and business.

ENIAC was product of wartime urgency in developing new guns. As the American war effort accelerated, the number of new guns increased, as did the number of gun platforms—from ships to aircraft. To make gunsights, or elevation tables for the big guns, you have to calculate the trajectories of the projectiles, and, if you want to fire on moving targets, you must calculate how far in front of the targets you must point your gun. Those calculations were the job of the Ballistic Research Laboratory (BRL) of the Army’s Ordnance Department. In 1943 BRL was falling behind the development of new guns and weapons platforms. They were depending on college graduates with mechanical desk calculators, and they were no longer able to provide all the new tables required. In their desperation they provided the funding for a speculative new project: the construction of ENIAC, an electronic calculator built explicitly to calculate ballistic firing tables for guns. When the machine was finished, however, the war was over—and ENIAC’s most important contribution to the military effort came to be the basic calculations needed to design the hydrogen bomb (Augarten 1984, p. 131).

ENIAC was a speed marvel when it was first put into service. A skillful employee of the BRL (equipped with a mechanical desk calculator) needed three days to calculate a single trajectory for a typical piece of heavy artillery. BRL did have more advanced equipment, however. It had one of the most advanced analog, mechanical calculators of the day (a differential analyzer), which used 15 to 30 minutes for the same job—but it required a set-up time of about two hours. ENIAC did the job in 20 seconds, which was 10 seconds less than the shell itself needed to complete the trajectory when fired. And the calculations needed to build the hydrogen bomb were so complex that they probably would not have been possible without the aid of ENIAC. It was no midget, though—ENIAC weighed in around 30 tons, was 25 meters long and 2 meters high, and its 18,000 vacuum tubes consumed 174,000 watts of electrical power. It could add 5000 ten-digit decimal numbers or multiply 333 such numbers in one second. In contrast, a reasonably powerful portable PC of today (1997) weighs 1.5 to 4 kilos, consumes a few watts of power and is more than 10,000 times as fast. The most powerful supercomputers (not counting special-purpose, parallel designs) are tens of millions times as fast as ENIAC.

Although ENIAC was programmable, it was very awkward to use as a general-purpose machine. To program the ENIAC, you had to know the machine almost as well as its designers, and a complicated program could take months to work out. Once you had written it down, you set up the machine by plugging cords (there were hundreds of them) into plugging boards which looked very much like old telephone switchboards, and flipped the larger part of several thousand small switches on the consoles. Data was provided by punch cards running through a card reader. This was not too bad as long as you calculated firing tables, which involved long series of calculations varying only one parameter. Other tasks, however, were extremely arduous—it usually took two days to set up ENIAC for a specific problem. Error correction, in particular, was a maddening task.

Let us pause here briefly to consider the concept of the stored-program computer, an innovation that was absolutely crucial to the further development of the computer. ENIAC, more a calculator than a real computer in the modern sense, was programmed by physically wiring it, and data was fed through punch cards. Even as the first of its kind, it already approached the practical limits of complexity—as previously mentioned, programming it was extremely difficult and laborious. It was hard to imagine computers, designed in the same way, that could be orders of magnitude larger and more complex—the resulting amounts of wiring and switch throwing would make them completely unwieldy. It was a dead end.

The Manchester Mark I and the American EDVAC therefore represented a fresh start in computing, and set a course still followed by mainstream computers. Their tour de force was the abolition of the need for physical rewiring. Instead of being embodied in the positions of wires and switches, the Mark I program was set up as a pattern in electronic storage devices. The pattern was created as the machine read punch cards or tape, and it could therefore be changed in a very short time. The long setup time of ENIAC was thus eliminated, and the machine could even modify its own program while running. Because of its limited memory and computational capacity, the Mark I was a humble machine compared to modern ones, but it embodied all the principles of that new species: the universal machine. The essence of the stored-program computer is really its general nature—it is a logical engine, able to process all information that can be represented, directly or indirectly, by numerical values, and able to perform any operation on that data that can be represented, directly or indirectly, by logical statements. As such, it is not only able to solve equations, but to process text, sound, and pictures; control physical machines and production processes; and even simulate physical processes, if they can be represented numerically and logically. The same physical machine can do it all.

A Binary World

But even if computers came to be stored-program computers, they were still very difficult to program, as they did not understand any other "language" than the 0s and 1s of the binary number system they relied on. And we may just as well confront this basic issue here and now—a lot of the finer points about computers are much easier to understand if one gets a grasp on the two fundamental pillars of computer number crunching.

The first is the number representation. Digital computers cannot operate with decimal numbers or letters directly, as did their mechanical forebears. Decimal (or base 10) math is very well suited for gears and axles, but not for the electronic switches that computers rely on. All they can do is discern the difference between a low voltage (or none) and a sufficiently higher voltage. Computers therefore depend on a binary (base 2) number system, where a lower voltage represents 0 and a higher voltage represents 1. This, by the way, is the ubiquitous "bit" of the digital computer world—a 0 or a 1 represents one "bit" of information. By using enough positions, or bits, it is perfectly possible to represent any decimal number with 0s and 1s, and numbers can again represent letters: The first position in a binary number signifies either 0 or 1 decimal. A 1 in the next position means 2 decimal, in the next again means 4, and so on (positions are counted from right to left). The decimal numbers from 0 to 15 will look like this:

0 = 0

1 = 1

2 = 10

3 = 11

4 = 100

5 = 101

6 = 110

7 = 111

8 = 1000

9 = 1001

10 = 1010

11 = 1011

12 = 1100

13 = 1101

14 = 1110

15 = 1111

The other pillar of computation is the logical system invented by the British mathematician George Boole (1815–1864). Boole, who did not have computing machines in his thoughts at all, actually devised a system that proved to be perfect for electronic computers relying on binary mathematics.

Boolean logic has three basic operations called AND, OR, and NOT. Being binary in nature, they are only able to process two different entities. In the computer world, those two entities are 0s and 1s. The operations are often called gates, and that is really the way they function. An AND gate has two inputs, and if each of them is a 1, the operation will yield a 1 to the next gate. Any other combination (10, 01, 00) will result in a 0. The OR gate will pass on a 1 if at least one of the incoming bits is a 1, giving a 0 only when both are 0. The NOT gate will simply reverse the incoming signal, turning a 1 into 0 and a 0 into 1.

The computer business did not really get off the ground until the second half of the 1950s. The first commercial machines went to government institutions, military research establishments, and a few private corporations with large files to take care of—notably banks and insurance companies. Computers were a very exclusive commodity, and few needs could warrant one.

That changed rather abruptly with the IBM 650, introduced in 1953 and first delivered in December 1954. It could be rented (IBM did not sell its machines at that time) for as low as $3250 a month. (In contrast, IBM’s first computer, the 701, rented for $15,000 a month.) A year later, in December 1955, 120 of the machines were installed and another 750 on order. At that point the dam broke, and IBM in particular supplied the water—the resistance in IBM’s planning department was obliterated, the company accelerated, and several more machines were developed. In the meantime the company had also been chosen as the main contractor for the manufacturing of the world’s first computer-controlled, radar-based early warning and air combat control system. Lead by MIT, the SAGE project was massive in every way—it was initiated in the wake of the first Soviet A-bomb test, and cost was no concern. The SAGE computers were the first serious real-time, interactive machines with screens; they showed that computers could be used to control complex machinery (in this case, a large network of radar stations). The project gave IBM invaluable experience and access to the latest technology. On the basis of its SAGE experience, IBM was commissioned by American Airlines to develop SABRE—a computer-based seat-reservation system. The work started in 1954, but the system did not enter into full operation until late in 1964. It had then cost $300 million, and with its 1200 teletype terminals, it was the largest real-time data-processing network in the world—a position it has held until recently, when it has found itself vying with two other reservation systems—Amadeus and Galileo—for that title. SABRE started to sell its services to airlines other than American in 1986; it was organized as a separate company several years ago; and became a public company listed on the New York Stock Exchange in 1996. It has an annual turnover in the region of $1.6 billion (1996).

Amadeus (owned by European carriers such as Lufthansa, Air France, and Iberia) is, with its 180,000 terminals, arguably the largest reservation system in operation today. It contains the schedules of more than 700 airlines and performs bookings on more than 430 airlines, 40,000 hotels, and 51 car rental agencies. It probably processes over 6000 transactions per second in peak hours.

While SAGE and SABRE showed the world that computers could do more than solve equations and do batch-oriented records processing, the vacuum tubes were replaced by transistors (the transistor was invented in 1947, but was initially very difficult to manufacture). The first transistorized computer was released by UNIVAC in 1957, and Philco followed suit the year after. The transistor-based machines were smaller, faster, cheaper, and more reliable than their predecessors, and they started a new turn in the upward spiral of the computer business.

In 1964 IBM, also converting to transistors, introduced the 360—another watershed in commercial computing. Designed to be the first universal computer, equally suitable for business and scientific purposes, it was named after the 360 degrees of the compass (Piore and Sabel 1984). The 360 was also the first computer family: A customer could mix and match processors of various capacities with different tape drives, printers, card readers, and other peripheral units without worrying about compatibility. And, most significant of all, all the processors in the 360 series could run the same software without modifications. This fact alone was something of a revolution at a time when different computers, even from the same manufacturer, were completely different and could not share a single piece of software or hardware. The 360 was an immense success, with orders coming in at the rate of 1000 a month. The delivery time of course increased rapidly, and customers started to buy and sell places on the waiting lists!

All of the first-generation commercial computers were large and expensive—even the 650 cost a lot of money. Their processing capacity, although impressive by contemporary standards, was in fact very limited, and, for economic reasons, they had to be kept working as efficiently as possible—preferably, around the clock. Because of the cost and complexity of the computer, every routine in an organization that interfaced with a computer system in some way or another was designed primarily to allow the computer to run at maximum efficiency—to get the maximum out of the processing unit, the true heart and soul of the machine. Interactive computing, where the user interacted directly with the machine, was not even contemplated, and screens were few and far between (SAGE and SABRE were rare exceptions). The "jobs," consisting of decks of cards, paper tape, or magnetic tape, were fed to the computer, which did its work and printed out the result on paper; all the while it was being tended by a large staff of operators and system programmers. Both the hardware and the software of the early computers were pretty "raw"; there was a need for a lot of operator intervention, and the operating system (the basic software directing the internal processes in the computer and the peripheral equipment) required constant tuning and tinkering.

Today’s big mainframe computers are the direct descendants of this first generation of computers, and, even if much has changed, they still retain many of the old characteristics. They are still big, they are expensive, and they still require a sizable, highly competent staff to tend their exceedingly complex operating systems and related basic software. There are yet application areas where large mainframes are the only solution, but their exclusive domain is rapidly shrinking, and today they represent only a small fraction of the total computing power available in the world. (This remains true even if we include the specialized high-performance mainframes called supercomputers.)

As we noted earlier, even stored-program computers were hard to program at first. But the incremental improvements have continued, and the development of more efficient programming techniques has undergone four distinct phases (we are still in the fourth one). The first phase was machine language programming—the direct writing of 0s and 1s. Needless to say, programmers did not exactly relish their work after a while, painstakingly spelling out every minute detail of the computer’s operations in 0s and 1s. And, as programming rapidly became the bottleneck in computer utilization, improvements in programmer productivity became an important issue for the computer manufacturers (which it still is).

At first, as always in pioneering work, several solutions were tried, but they all had a common denominator: The goal was to express programs in more high-level symbols, which the machine itself could translate into the actual 0s and 1s it needed for its operation. The first "languages" of code developed for this purpose were simple and only covered discrete machine instructions—it was in many ways just a mnemonic shorthand, eliminating the need to write strings of 0s and 1s, but still requiring the programmers to describe all operations in painstaking detail. Today, such code schemes are called assembly languages. They are still used for special purposes, especially when compactness and speed is very important.

As computer use took off in the 1950s, assembly languages did not suffice to alleviate the programming bottleneck. Writing in assembly was still slow, there was a specialized assembly language for every machine (it was very close to the hardware, since it directly reflected the instruction set of the processor), and to use it the programmer needed a thorough knowledge of the hardware. Work on more advanced coding schemes continued in several places, most notably IBM and Remington Rand. The idea was to automate common subroutines such as calculations, indexing, and reading and writing to files. Automating both standard computational and housekeeping functions would free the programmer to use his time on the more creative aspects of programming—the actual tasks to be carried out. The first compiler—as the internal, translating program was called—was created by a team at Remington Rand. The compiler took the statements in the high-level language and translated them into the strings of single instructions the processor needed. The product was a modest success, and it spawned other efforts. In 1957 IBM released the first version of FORTRAN (FORmula TRANslation), the first full-fledged high-level programming language that was commercially viable. Because FORTRAN was optimized for scientific and engineering purposes, other languages soon followed, such as COBOL (COmmon, Business-Oriented Language) and BASIC (Beginner’s All-purpose Symbolic Instruction Code).

The high-level languages (or, as we now call them, third-generation languages) brought about a great increase in programmer productivity. Just as important, compilers for FORTRAN, COBOL, and other languages were implemented on more and more machines, and within the space of a few years, all computers on the market had compilers for the most widely used languages. This meant that programmers no longer needed to know the innards of the machines they worked with, nor did they have to learn a new language every time they confronted a new computer. The dream of portable programs was not totally fulfilled, however, since the instruction sets of the different computers were not sufficiently similar to allow programs written for one to run unmodified on another. But, whereas it had been totally impossible to transfer an assembly program from one type of computer to another, a high-level program could often be transferred at a cost that was considerably smaller than the expenditure needed for rewriting the program from scratch.

The Birth of the Mini

As noted earlier, the transistor entered the scene in the late 1950s, making computers much more reliable and powerful. It also contained in it the possibility of making smaller and cheaper computers. But the concept of the mainframe persevered and continued to keep the ownership of a computer out of reach for all but the biggest or richest organizations.

In 1957, however, a new company was founded, headed by an engineer with a bent toward small computers. His name was Ken Olsen, and he headed his Digital Equipment Corporation (DEC) until 1993. Although has been in serious trouble the last few years DEC is still among the largest computer companies in the world (the ninth largest by revenue in 1996).

Olsen was convinced that there was a market for affordable computers, and DEC’s first one, PDP-1, appeared in 1961 at a cost of $120,000. It did not make much of an impact, but for those who cared to look, it showed that there was an alternative route to computing: by means of small, inexpensive machines that were easier to program and run and did not require the multitude of operators and system programmers that were the hallmark of a mainframe installation. The new minicomputers were also designed as interactive machines from the very start, allowing direct interaction with the user through keyboards and screens.

The big surprise for the industry came two years later, when DEC introduced its PDP-8, a machine the size of a refrigerator and costing only $18,000. It was not as powerful as the mainframes, it could not support a large number of users, and it could run only one program at a time. But it was cheap, and most organizations could afford one. Soon PDP-8s were analyzing lab data, controlling machine tools, running payrolls, and keeping track of warehouse inventories. It became the first computer installed in a submarine. From then on, it was the minicomputer that carried the torch of the computer revolution, and scores of new companies sprang up to capitalize on the new development.

In 1958 an event just as important as the invention of the transistor took place: the first integrated circuit (IC) was produced by an engineer at Texas Instruments. The news of the feat spread fast, and others soon came up with more practical designs. The one that proved to be the right one for mass production of more complex circuits was developed at Fairchild Semiconductor during the first six months of 1959.

At first the IC developed fairly slowly, and the computer application that was most amenable to early IC technology was memory. The first computers with ICs in them were the medium-sized B2500 and B3500 from Burroughs, introduced in 1966. In 1968 Control Data introduced the first computer composed entirely of ICs. But ICs were still hard to make, and prices were high. Only top-of-the-line computers—wherein speed advantages were more important than cost—could use ICs. But as the technology matured, things began to change. The number of circuit elements (transistors, resistors, and capacitors) on one chip increased from a few to a few tens, then to hundreds, and in 1970 the start-up company Intel startled the computer world by introducing a 1-kilobit memory chip, capable of storing 1024 bits of information.

The transition from magnetic core memory began, and, because the elements on a chip now numbered in the thousands, the development accelerated beyond belief. Memory and logic chips proliferated, more and more circuit elements were packed onto one chip, and prices went down. Since 1970, the capacity of memory chips has increased by 60% per year. Meanwhile, costs have gone down to the effect that the price for one bit of semiconductor memory has decreased on the average by 35% every year since 1970. Based on advertised prices in Byte and PC-Magazine, the leading microcomputer journals, the end-user price for one megabyte of memory has been reduced from $20,480 in 1975 to $5 in the fall of 1997. The complexity and price of logic chips have followed the same trajectories.

As the cost of ICs fell and the complexity increased, even smaller and cheaper computers than the PDP-8 could be built, and the minicomputer companies got another large boost. Their heydays lasted from the middle of the 1970s until about 1985. In the meantime, however, another revolution was in store for the industry.

The Microprocessor and the PC Enter the Fray

Even while it was working to bring out the 1kb memory chip, another revolution was brewing at Intel. Busicom, a now defunct Japanese calculator maker, placed an order with Intel for a custom chip set for a new series of calculators. Busicom’s design called for dedicated logic chips for each calculator in the series, but Intel’s engineers concluded that the best solution would be to build a general processor chip able to do the job in all the calculators Busicom wanted to make. The result was the Intel 4004, the world’s first microprocessor—delivered late in 1970. The year after, Intel obtained the rights to sell the 4004 to others, and within another year a more powerful chip, the 8008, was brought to market. Sales started to pick up as electronic engineers around the globe slowly figured out how they could use the new marvels. The real success, however, did not come until the far superior Intel 8080 was launched in 1974. The 8080 was the first microprocessor that was powerful enough for a real computer, and it was the brain of the first useful microcomputer—the Altair 8800, described and advertised in Popular Electronics in January 1975. Fully assembled, the Altair cost $650; as a kit, $395. That was for the bare computer—it had no screen and no input device except a set of toggle switches on the front. Two rows of lights were all the computer had for communication with the outside world. Terminals, printers, paper tape readers and the like cost extra and did not become available until the end of the year.

The Altair was a success anyway, and thousands of kits were ordered, even if the machine did not have any high-level programming language. One of the many computer enthusiasts reading the article in Popular Electronics, however, was Paul Allen, a friend of Harvard freshman William Gates. They telephoned Mike Roberts, Altair’s creator, and offered to write a BASIC interpreter for his machine. Roberts agreed, and the interpreter was delivered six weeks later. Allen and Gates subsequently founded Microsoft Corporation, now arguably the most influential company in the computer business and the world’s largest software company (with sales of more than $8.6 billion in 1996, Microsoft occupied the number ten spot on the list over the world’s largest computer companies overall).

The Altair fired the imagination of a lot of young electronics people, and a host of microcomputer companies sprang up. One of them was Apple Computer, started by two college dropouts, Stephen Wozniak and Steven Jobs. They sold 175 of their first product, the Apple I computer (really only a board), through a San Francisco computer retailer. They then came into contact with one of the "veterans" from Intel, who had retired as a millionaire at the ripe old age of 32. He immediately saw the company’s potential, bought one third of it, and arranged for the necessary additional funding. The company’s next product, the Apple II, became a runaway success, and Apple grew at record speed—going from $775,000 to $983 million in sales in just six years. Sales received a major kick after two other college students, Dan Bricklin and Bob Frankstone, came up with VisiCalc—the first spreadsheet, and the program that made the business community take the microcomputer seriously. VisiCalc was in fact just as important for the phenomenal growth of the microcomputer business as the hardware itself. The year 1979 also saw the first useful word-processing programs and the first database program for the new machines. When IBM introduced its own microcomputer in 1981, the IBM PC, it was as if the product received its official blessing—and microcomputer sales took off on an even steeper curve. Today, PCs provide most of the computational power available in the world, their importance is still growing, and the trend toward networked PCs and workstations becoming the dominant computer architecture is firmly established.

After that time, the computing power of the mass-produced microprocessors started to catch up with the proprietary (and much more expensive) minimachine processors, leading to three simultaneous developments that threw most of the traditional mini makers into serious trouble toward the end of the decade: the maturing of the PC networks; the emergence of cheap, microprocessor-based servers and minis; and a drive toward more or less standardized operating systems, fueled by the users’ growing concern about the disadvantages of vendor lock-in.

The PC’s main attractions were user control and low price—it had a price/performance ratio far superior to minis and mainframes, once again confirming a peculiar fact of the computer business: that the familiar notion of economy of scale is inverted. A unit of processing power (however one chooses to define it) is most expensive on the biggest machines, and cheapest on the smallest. And the difference is far more than marginal, it is of one to two orders of magnitude—the price of one MIPS is about 100 times higher for a conventional top-of-the-line mainframe as for the PCs and workstations with the best price/performance ratio. A typical mini falls somewhere in between. The difference is compounded by the fact that not only processing power, but also memory, disk storage, graphic capabilities, and frequently even software is cheapest on the smallest machines. However, networked PCs is by far the most expensive system architecture to maintain and support, because of the great complexity involved. Some of the most annoying and difficult problems arise from a fact that is also a great strength: the enormous wealth of equipment and software that is available. Although it allows the user to find a product for almost any conceivable purpose, the use of equipment and software from a large number of independent vendors also produce innumerable compatibility problems, which cost a lot of time and money.

A natural question is then why manufacturers could still sell mainframes and minis—why those markets did not collapse with the advent of the PC. The main reason is simply that most of the backbone applications for any organization require shared data: People at various places in the organization must be able to use the same systems to enter and retrieve information from the same databases, and isolated PCs are simply not viable platforms for such applications. But the stand-alone PC is the perfect platform for such personal and processor-intensive applications as word processing, spreadsheets, and graphics, and they invaded organizations in droves. With the increasing sophistication of networking software, combined with the powerful, low-cost servers built with the new microprocessors, they were also increasingly able to attack the rest of the application base of the minis, and PC networks ate into the traditional mini market at a rapidly increasing rate.

At the same time, the stronghold of the traditional mini—the shared application—was also attacked by new vendors (and some of the old) with cheap, new machines built with PC technology and based on standard microprocessors bought in volume from the chip companies—notably Intel and Motorola. To reduce their development costs further, these vendors almost without exception opted for a de facto standardized operating system (UNIX), which further increased their appeal to the users. Because of an initial lack of application software, the new machines did not wipe out the old ones directly, but the pressure on prices mounted, and many of the traditional vendors found themselves in the red for the first time in two decades. A few years later, most of them were gone—they either went bankrupt or were bought by more resourceful competitors. Only the largest vendors had the necessary production volume to put their own processor architectures onto chips and achieve a cost level approaching that of the vendors using standard chips.

What is left of the minimachine market today is increasingly dominated by cheap, powerful computers built with the new generations of standard microprocessors. They offer the lowest price per terminal of any system category today, but even they fall behind PC-based networks as soon as users demand the functionality and power of dedicated PCs, especially when they want graphical user interfaces such as Microsoft Windows.

The Workstation

The early development of the PC was really driven by the interest and enthusiasm of computer hobbyists, finally provided with an affordable computing platform by the evolving microprocessor. The history of the personal workstation is older, however. Some would even describe the Manchester Mark I as the first personal workstation, a notion that is correct insofar as it had a display and only one person could run his or her program on it at a time. Some would peg the honor on the display units of Whirlwind, a precursor to the SAGE. It might be more appropriate to name DEC’s PDP-1 and/or MIT’s LINC (completed in 1962) the first personal workstations. Scientists and engineers of most denominations yearned for the power and convenience of a dedicated computer for their personal use, so the need for personal workstations was already identified. The limiting factor was their price—to become practical in economic terms, even the scientific workstation had to await the birth of the microprocessor.

The forerunner of modern workstations (and machines such as Apple’s Lisa and MacIntosh) was the NLS (oN-Line System), built by Douglas Engelbarth and his colleagues at Stanford Research Institute in 1968. It incorporated the first mouse. Later versions pioneered windowing, graphical user interfaces, compound text/graphical documents, and electronic mail. The concept of the graphical user interface was further refined through the design of the Alto, developed at Xerox Palo Alto Research Laboratories (Xerox PARC) in 1972–73. All window-based graphical user interfaces of today (Apple’s MacIntosh environment, Microsoft Windows, OSF/Motif, etc.) descend from the NLS and the Alto—the reason why the data processing-community perceived Apple’s lawsuits to protect the "look and feel" of its windowing system to be both ludicrous and an affront to the spirit of the community’s pioneers.

Around 1980 microprocessors became powerful enough for scientific and engineering workstations, and first Apollo and then the start-up Sun began to deliver affordable machines. Very quickly, a lot of other companies entered the fray, not the least established vendors such as DEC and Hewlett-Packard, and the highly varied requirements of the scientific/engineering community rapidly resulted in an impressive array of offerings—workstations with an enormous range in capacity. The low end today can be compared to medium-to-high capacity PCs (the dividing line is becoming increasingly blurred), the high-end models have a computational power in excess of anything but the largest mainframes and supercomputers.

Miniaturization Continues

Continued miniaturization, not only of processors and memory circuits, but also of support chips and connective circuitry, hard disks, and floppy disks, has allowed for a totally new class of computers: portables. It started in April 1981, when Adam Osborne unveiled his Osborne 1—the first complete computer with a handle. Its most significant feature, however, was its price—at $1795, complete with monitor (albeit only 5"), two floppy drives, and an impressive bundle of software (with a total list price higher then the price of the machine itself), it was a bargain system at the time. In a workstation context it is interesting to note that Xerox introduced its Star workstation just one month later, carrying the legacy of the Alto to the marketplace, and for the first time introducing the general (computer) public to the concept of windows, icons, and mice. With a price tag of $50,000 for a minimum configuration, however, the Star remained a star of the trade shows, whereas the humble Osborne 1 achieved commercial star status, and Osborne Computer’s growth made even Apple’s first years look dull.

The new niche quickly drew more contenders, and portability and stowability (what do you do with that home computer when you are not using it?) soon became the main selling point, especially after Compaq entered the race with an IBM compatible portable in November 1982. Looking back, we would more describe them as "luggables," as they weighed in at ten kilos or more. The first "modern" portable was the DG One from Data General, introduced in October 1984. It opened like a clamshell, had a full-screen LCD display (although hard to read), was IBM-compatible, and could run on batteries. The price was $2895.

Portable computers today cover a wide specter, from quarter-kilo "palm-tops" to eight-kilo "luggables" with workstation power, with the main interest concentrated on the "notebook" class. A notebook computer should adhere to the A4 (or American equivalent) form factor when closed and weigh less than three kilos—preferably less than two. It should have a full-size screen, a good keyboard, a large mass storage, a floppy drive, and perhaps a CD-ROM drive. This class of machines holds the promise of becoming true "notebooks" in the sense that we will carry them everywhere and use them as a replacement for our yellow pads and calendars. With digital, cellular telephones now becoming mature products (with the concomitant low prices), we are already seeing the combination of such phones with light, portable computers—providing a workstation-on-the-go, complete with wireless network connection to the corporate database.

In the 1960s computers proliferated—mainframe sales were soaring, IBM 360 was an enormous success—and from 1963 on, the minicomputer brought computing to "the rest of us." The third generation programming languages, now well established, provided a stable platform for the development of the myriad of application programs the new computer owners needed to put their machines to good use. But several development trends combined to put a renewed pressure on the software side, once again turning it into a bottleneck.

First, even if program development in COBOL or FORTRAN was much more efficient than writing in assembly, it was still labor-intensive work. A large application program could take scores of programmers and years of work to complete, and even small programs would take months. Almost all computer-using organizations quickly built up a large backlog of unfulfilled development requests. Compounding the issue was problem number two: the scarceness of programmers. The demand grew much faster than the supply. The labor intensity of programming also meant that programs were expensive, and the short supply of programmers drove up salaries and increased cost even more. Especially for minicomputers, this was a problem. Even if it was faster to develop on minis than on mainframes (due to the interactive nature of the minis), it was not that much faster, and the cost of developing even small- and medium-sized programs loomed high in the context of $18,000 computers. For scientific and technical purposes the problem was not so severe, since many of the users themselves quickly learned to program. But for administrative purposes the cost and trouble of software development became a definite restriction on computer use. Clearly, the industry was ripe for another innovation, the standard package—a ready-made program for a specific application, for instance, general ledger, payroll, or inventory control.

The standard application package did not spring complete from the forehead of some super programmer, however. It started as growing libraries of subroutines and modules for doing specific operations in particular application areas. Slowly, the concept of the complete package grew, and toward the end of the 1960s the concept was more or less established. A landmark event was a court ruling in the United States, which on the basis of antitrust law demanded that IBM "unbundled" the software from its computers. Until then, software had come with the computer, included in the price. The court ruled that IBM would have to put a separate price on the software, making the purchase optional. This opened the vast IBM market to third-party software vendors, and several of the largest software houses today were founded about then. A couple of years later, IBM launched a highly successful small business computer (a rudimentary mini), the S/32, together with ready-made software for everyday business needs. Many other vendors had similar offerings, and the sales of small systems accelerated.

The 1980s became the decade of the stand-alone PC. In the office environment it was used mainly for word processing, spreadsheets, and record keeping; in scientific and engineering environments, CAD, statistics, and acquisition of lab data were important application areas. For the users it represented a final liberation from the time-sharing environment of the larger computers, where they had to contend with other users for access to the computer’s resources. The low price of the PC meant that it could fit into almost any budget, and the proliferation of PC-based software packages (with a correspondingly low price) for the first time gave the users an alternative to lining up in the computer department’s backlog queue. A PC also turned out to be so much cheaper than a terminal on a large system (if we count the terminal’s part of the host computer with all its associated resources) that the number of users who could justify taking advantage of computers increased significantly.

The stand-alone PC still left unanswered the need many organizations had to tie their users into organization-wide systems, however. One possible answer was to let the PC function as a terminal as well, a solution that has met with some success in mainframe environments. The PC then emulates a terminal, allowing access to the mainframe-based systems, whereas local, computationally intensive tasks such as word processing and spreadsheets can be done locally. The sharing of data between local and mainframe-based systems is not seamless, however, and in many cases, the mainframe-related functionality of the PC is not on par with the normal terminal (due to factors such as keyboard differences).

But another, more epochal development was already underway: the evolvement of the local area network (LAN). The origin of the LAN is a matter of discussion, but most people would agree that the first operational network was the net connecting the Alto workstations at Xerox PARC in 1975. The first commercial network was released by Datapoint a couple of years later, but did not catch on with others. It was Xerox’s release of Ethernet in 1981 that really got things rolling. Networks as a concept took form much earlier, however—actually, the 27 SAGE centers were all linked together.

The mother of large networks (and the germ of Internet) was the ARPA network, established in 1970. It linked computers at universities and research facilities throughout the United States, allowing data sharing, remote processing and mail. It grew rapidly from four nodes in December 1969 to hundreds of nodes 15 years later. Today, we have lost count—but the Internet nodes number in the millions and multiply furiously all over the world.

In the PC world, LANs were at first a welcome method of sharing expensive peripherals such as disks and printers. That was indeed also the purpose of the first LAN servers—a print server and a file server supporting the Altos on the PARC network in the last half of the 1970s. But as the power of PCs and servers grew and the networks became more sophisticated, software also evolved to take account of the new possibilities. At first, applications and data were just downloaded to the PC, and the file server acted merely as a remote storage device (disk). For some applications, such as spreadsheets and word processing, that was (and is) just fine in most cases, but, for any application involving the shared use of a database of some kind, it is not a viable solution. If the database is large, it will be impractical to download, and if many users download their own separate copies of the database and update them locally, data integrity is quickly lost—since the local versions are not revised by the input from other users. Chaos will result when a large number of such individually altered versions are stored back to the central file.

Increasingly, however, products involving shared data are now adapted to the new environment. Database products, for instance, have been split in two, with the database engine proper residing on the server and the application "front end" running locally in the PC. Several companies can offer reliability and security approaching the level of mainframes, and great strides have been made in server technology. We are witnessing a period of transition, where older, centralized computer architecture is being superseded by a distributed one, with multi-processor servers and powerful workstations/PCs connected by high-capacity networks. By the year 2000 the traditional mini and mainframe will probably have largely disappeared, relegated to a few specialized niches and otherwise only found in very conservative organizations.

Even if packaged software came to dominate the computer scene during the 1980s, custom programming did not disappear. There are always applications that are too rare to create a viable market for a package, and there are also applications so important for the competitive edge of a company that managers are willing to spend large amounts of money to provide systems that are better than the competitors.’ In addition, there is the fact that any two companies of the same size engaged in the very same business never organize their activities in exactly the same way. Often, companies will therefore find that available packages are incompatible with their usual way of conducting business, and they are often loath to change their ways. Modification of standard packages is complicated work, and, as a rule of thumb, it is generally acknowledged that if the necessary changes involve more than 20% of the code, one may as well write a new program from scratch.

Even as the number of standard packages took off, a mounting pressure was building to make software development more efficient. And, whereas some developers started to fashion application-specific, package-like products from their modules and subroutines, others accumulated libraries of routines and modules that covered the general aspects of most commercial software applications—the definition of screens, for instance, or of reports culling data from databases. Many simple applications do indeed mainly consist of a number of screens for data entry and maintenance, a database, and a few reports to tabulate the data. What they eventually had on their hands were more or less general tools for application building, relieving them of much of the drudgery of detailed programming.

Over the years, many such application builders, or "fourth generation languages" (4GL) as they were commonly called (today we speak of development tools), were put on the market—especially the first half of the 1980s saw a flurry of announcements. Today, competition has already removed many of them, and the market is rapidly maturing. Although most of these tools were at first tied to particular database products, those that survive now increasingly separate themselves from any such dependence, allowing several of the most widely used databases to serve as platforms for their programming engine. Experience shows that dramatic increases in productivity are possible with the right use of such tools; in some cases it has been demonstrated that even for major applications, a custom-made system can be developed for less money than it takes to buy a standard package and give it the necessary local color. A further advantage is that the same lead in productivity is true for maintenance and modifications, making a program developed with a sophisticated development tool inherently more flexible.