LT   EN   RU  
Friday 29 March 2024 Straipsniai.lt - Independent and informative portal
Home
Phorum
Contacts
Login
Register   Login
News subscribe
Subscribe   Unsubscribe
Partners
www.slaptai.lt www.gamezone.lt
www.penki.lt www.hakeriai.lt
   
   
Advertising
Statistic
Visits since 2002 09 12 - 70582236
Pages in Straipsniai.lt: 40735
  
  Computers
Lankomumo reitingas Print version Print version
The History Of Computers During My Lifetime - The 1980's

by Jason Patterson
(jason@pattosoft.com.au)

The Commodore VIC-20

Riding on the success of the PET, Commodore drove its engineers to make computers that anyone could afford. The 6502 based VIC-20, introduced in 1981, was the first color computer that cost under $300. It was also the first computer to sell one million units. VIC-20 production hit 9000 units per day - a rate that was absolutely phenomenal back then. While shortsighted critics kept asking what these machines were good for, Commodore was the first company to introduce millions of people to personal computing.

The First Portable Computer - The Osborne 1

Adam Osborne sold Osborne Books to McGraw-Hill and started Osborne Computer. Its first product, the 24 pound Osborne 1 "portable", cost $1795. The Osborne 1 was easily identified by its tiny built-in screen. Osborne also started the practice of bundling software with the computer - the Osborne 1 came with nearly $1500 worth of programs! Unfortunately Osborne went bankrupt when it preannounced its next computer while still trying to sell the Osborne 1.

The IBM PC

In 1981, the landmark announcement of the IBM PC stunned the computing world. People had always thought of IBM as a high end mainframe player. Even the chairman of IBM is supposed to have looked at the original PC and said that it would never fly - that mainframes would dominate forever.

Despite its weaknesses, IBM did get one critical thing right with the PC - it was based on an open architecture so that it could grow into the future. This strategy, combined with IBM's huge influence and the release of Lotus 1-2-3 a year later, made business people sit up and take notice. The PC and its descendants went on to dominate the computing industry.

The original PC cost $3000, and came with 64 Kb of RAM, a floppy disk drive and monochrome graphics. It also came with DOS, an operating system based on CP/M. In an effort to save time so that it could catch the early personal computer market, IBM chose to license DOS from the then tiny Microsoft instead of writing its own operating system. For many years to come IBM would regret the decision not to write its own PC operating system. Eventually it did do so - OS/2.

The IBM PC was based on Intel's 8088 processor, which was released in 1980. The 8088 was a 16-bit processor which had 8 registers, about 100 instructions, and an unusual (some would say brain damaged) segmented 20-bit memory architecture capable of addressing 1 Mb of memory. It ran at a clock speed of 4.77 MHz in the original IBM PC. The 8088 was actually the second x86 processor. Its predecessor, the 8086 (released in 1978), used 16-bit external busses, whereas the 8088 used 8-bit busses. This made the 8088 about 20% slower than the 8086, but 8-bit busses were critical to keeping down the total system cost.

IBM's decision to use the x86 architecture was widely criticized, and lead to the PC and its descendants facing many problems that other machines didn't face, mainly because of the x86's segmented memory model. So why did IBM chose the 8086 series when alternatives such as the Motorola 68000 were so much better? Apparently IBM's own engineers wanted to use the 68000, but IBM had already obtained the rights to manufacture the 8086 (for use in its Displaywriter intelligent typewriter), in exchange for giving Intel the rights to its bubble memory technology. Another factor was that the 8088 could use existing low cost 8-bit components, whereas 68000 components were more expensive and not widely available at that time. In any case, thanks to the PC's open design, the Intel x86 architecture went on to completely dominate the computing industry - proof that technical superiority sometimes doesn't matter.

Graphical User Interfaces Arrive - The Xerox Alto

In the late 1970's and early 80's, the Xerox Alto started the graphical user interface revolution which would sweep through the computer industry over the following decade. The desk-sized Alto, and its commercialized descendant the Xerox Star, were the first GUI-based computers. Researchers at Xerox PARC (Palo Alto Research Center) developed the basic ideas of a graphical user interface along with all the associated innovations - the mouse, the desktop metaphor, icons, windows, menus etc. Although the ideas in the Xerox Star were revolutionary, it was a huge failure commercially. This was due mainly to the price tag of $50,000.

When Steve Jobs took a tour of Xerox PARC in 1979, he saw the Alto and realized it was the future of computing. He quickly began to work towards bringing the technology to market. Many of the ideas in the Alto showed up two years later in the Apple Lisa, and finally made it to market in the Apple Macintosh. Several Xerox researchers also left to join Apple.

The Commodore 64

In 1982, a year after the huge success of the VIC-20, Commodore introduced the Commodore 64. This was the machine that brought computers to the masses.

The Commodore 64 reached an altogether new level of popularity. A decade later it still held the record as the best-selling single computer model of all time. An estimated 22 million units were sold. That's almost as many as all the Macintosh models put together, and it dwarfs IBM's top-selling systems, the PC and the AT. For the first time ever, millions and millions of people all over the world went and bought a computer - a Commodore 64 - from their local department store!

The Commodore 64 set a number of technical firsts too. It was the first cheap computer to have a whopping 64 Kb of RAM, it was the first personal computer with an audio synthesizer chip, and the portable version, the SX-64 (1983), was the first color portable.

More than that, the Commodore 64 was a fun machine. Although it was only based on the MOS 6510 processor (a slightly modified version of the 6502 used to power the Apple II five years earlier), the 64 had fast color graphics with hardware sprites. Compared to the Apple II's slower color graphics and the IBM PC's monochrome display, it was way ahead. It had enough memory to make really good software, so the 64 software market boomed, especially the games market. And, as possibly its most important feature, the price was right - the Commodore 64 cost around $400.

As with the Apple II, software for the 64 was distributed on audio tapes, or on floppy disks for those who bought the optional floppy disk drive (which cost almost as much as the machine itself). In rare cases plug-in cartridges were also used. Like the VIC-20, the 64 used a TV set as its display device (which is part of the reason it was able to be so cheap).

For most of my generation, myself included, the Commodore 64 was the first computer they ever owned or used.

Lotus 1-2-3

VisiCalc on the Apple II may have sold Wall Street on the idea of electronic spreadsheets, but Lotus 1-2-3 was the spreadsheet that Wall Street adopted. When the IBM PC took over the business world in the early 1980's, Lotus 1-2-3's simple but elegant grid was without question the best spreadsheet available. It added simple chart style graphics and data retrieval functions to the paradigm established by VisiCalc. By the early 1990's, Lotus could brag that Lotus 1-2-3 was the best-selling application of all time. Lotus's period of dominance finally ended when Microsoft Excel came out with a graphical user interface for Microsoft Windows.

COMPAQ - The First PC Clone

COMPAQ's "portable" almost single handedly created the PC clone market. It weighed a ton (20 pounds), but nonetheless it was the first successful PC clone. Columbia Data Products just preceded COMPAQ that year with the first true IBM PC clone, but they didn't survive for long. It was COMPAQ's quickly gained reputation for quality and its essentially 100% IBM compatibility (reverse engineered, of course) that really created the clone market.

Radio Shack's TRS-80 Model 100

Years before mainstream notebook computers, Radio Shack came out with a book sized portable with an unbeatable combination of features, battery life, weight, and price. The $800 TRS-80 Model 100 had an 8-row by 40-column reflective LCD screen, supplied ROM based applications including a text editor and a communications program, and it had a built-in modem, nonvolatile RAM, and a keyboard. Weighing under 4 lb, and with a battery life measured in weeks (it used four AA batteries), the TRS-80 Model 100 became the first popular laptop, especially among journalists. With its battery-backed RAM, the Model 100 was always in standby mode, ready to take notes, write a report, or go on-line. NEC's PC 8201 was essentially the same Kyocera-manufactured system.

dBase

Wayne Ratliff's dBase was originally intended to manage a company football pool, but ended up being the first serious database system for personal computers. dBase II, running on DOS, was a massive success. It provided just the right combination of features for a small business database, plus it was relatively easy to learn, and it ran on cheap PC's. As a result, lots of small businesses which had previously been surviving without a database system decided dBase running on a PC was cheap enough and offered enough benefits to be worth buying. Ashton-Tate acquired dBase from Ratliff when dBase was at its peak (dBase III), but let their users down badly by releasing the bug-ridden dBase IV in 1988. dBase for Windows didn't arrive until 1994, by which time its market share was gone.

The Apple Macintosh

In January 1984 the introduction of Apple's Macintosh computer, with its graphical user interface, generated even more excitement than the IBM PC had three years earlier. Apple's R&D people were inspired by the critical ideas developed at Xerox PARC (and practiced on the Apple Lisa) but Apple programmers also added many of their own ideas to create the final polished Macintosh product. It was this polished product that changed the way people used computers.

The Macintosh (lovingly called simply the Mac) was introduced in the famous "1984" TV commercial broadcast during the SuperBowl. It featured a small built-in high resolution monochrome display, the wonderful Macintosh operating system with its graphical user interface, and a klunky looking single button mouse. It sold for $2495. With only 128 Kb of RAM, the Mac was memory starved at first, but later models quickly corrected this.

Apple included several key applications that made the Macintosh immediately useful. MacPaint showed people what a mouse was good for, and MacWrite demonstrated that WYSIWYG (What You See Is What You Get) word processing really worked. The Macintosh redefined what we meant when we said that a program was easy to use. The Mac also had a floppy disk drive that used 3.5" disks, which were physically smaller than their 5.25" PC counterparts, but were sturdier and could hold more data (400k).

A couple of years later, Aldus PageMaker allowed high end desktop publishing to be performed on a Macintosh. PageMaker's paste-up metaphor made sense to people who had worked in traditional design and production departments. A Mac became the tool of choice on which to run a publishing business, and the combination of a Macintosh, PageMaker and the PostScript based Apple LaserWriter laser printer went on to dominate the desktop publishing industry.

The Macintosh was powered by Motorola's 68000 processor, a powerful 32-bit processor which had been around since 1979. The 68000 contained about 60,000 transistors, and had 16 registers and a large instruction set which used 13 addressing modes. Future versions of the 68000 architecture would further extend this so that by the end of the 68000 line over a thousand different combinations of instructions and addressing modes were possible!

Word Perfect

In 1984, Satellite Software International introduced Word Perfect, a powerful new word processor for the IBM PC. Despite having a relatively bland and unfriendly character cell user interface, Word Perfect soon became the dominant word processor for the PC market, especially in the business/secretarial world. The ability to use Word Perfect became an essential skill for most secretaries, and remained so until the early 90's and the introduction of Microsoft Windows. A graphical user interface version of Word Perfect was introduced for Windows, along with versions for the Macintosh and the Amiga (and the Atari ST ?), but Microsoft Word managed to grab most of the GUI word processing market.

The IBM PC/AT

Building on the strength of the PC (1981) and PC/XT (1983), the PC/AT was a major increase in performance and storage capacity. Although it looked like the original PC, Intel's fast 80286 processor running at 6 MHz, combined with 16-bit busses, made the AT several times faster than the original PC. AT systems also came with much more RAM, usually 512 or 640 Kb, and new high-density 1.2 Mb floppy disk drives.

Hard disks of up to 20 Mb became available, and you could even install two if you wanted. New 16-bit expansion slots allowed for faster expansion cards but maintained backward compatibility with the old 8-bit cards. The hardware changes meant a new version of DOS (the dreaded 3.0).

The price for an AT with 512 Kb of RAM, a serial/parallel adapter, a high-density floppy drive, and a 20 Mb hard disk was over $5000, but at the time this was less than everyone expected.

The Commodore Amiga

In 1985 the Amiga introduced the world to multimedia. The talented engineers who designed the Amiga (and it wasn't Commodore) happened to hit on a basic configuration that all personal computers would eventually move towards. Unfortunately, the Amiga was so far ahead of its time that almost nobody - including Commodore - really understood what it was. Today it is obvious that the Amiga was the first multimedia computer, but in those days it was viewed largely as a games machine because few people grasped the importance of advanced graphics and sound combined with a multitasking operating system with a graphical user interface.

Like the Macintosh, the Amiga was based on the Motorola 68000 processor. The initial model, the Amiga 1000, had 256 Kb of RAM. It was soon phased out by the lower cost Amiga 500 at the low end (shown in the picture), and the Amiga 2000 at the high end. Both offered 512 Kb of RAM standard, expandable to 1 Mb on the Amiga 500 and a whopping 8 Mb on the Amiga 2000.

Unlike previous personal computers, the Amiga used three custom chips (Agnes, Denise & Paula) to do advanced graphics and sound. The graphics in particular was amazing by the standards of those days. At a time when PC users thought 16 color low resolution EGA was hot stuff, the Amiga could display 4096 colors, could reach the extremely high resolution of 640x400, and had custom chips such as a blitter for accelerated graphics. It even had built-in video outputs for TV's and VCR's (a decade later this was still a pricey extra cost option for most systems). The Amiga's audio system was also impressive. Building on the audio capabilities of the Commodore 64, the Amiga had four voice sampled stereo sound and was the first computer with built-in speech synthesis. Although it only cost $1200, the Amiga did graphics, sound, and video well enough that many broadcast professionals adopted it for special effects. With a small investment, even a home user could do reasonable quality desktop video production (I remember doing quite a few videos myself for high school and university presentations).

The Amiga's operating system, designed by Carl Sassenrath, was just as amazing. From the outset it had preemptive multitasking, a graphical user interface, shared libraries, messaging, scripting, and multiple simultaneous command line consoles. Ten years later, PC and Macintosh users were still waiting for some of those features. Thanks to the custom chips and an efficient operating system, the Amiga even felt fast. The user interface was really quite snappy, much faster than a Macintosh. Five years later, Microsoft Windows running on a much faster 80386 based PC still felt slower.

The Amiga was also the first platform to make major use of emulation of other operating systems. Emulators for the IBM PC and the Apple Macintosh became quite widely used, often in an attempt to make the Amiga more useful for business purposes (it didn't have a lot of business software). The technology of emulation went on to become very important in the next decade.

The X Window System - UNIX gets a GUI

The X Window System (known as just X, or sometimes [incorrectly] as X Windows), first appeared in the mid 1980's running on DEC VAX based UNIX workstations. X was developed at MIT (with support from Digital) as part of MIT's Project Athena distributed workstation environment. Many of the core ideas of X (as well as the X name) were derived from an earlier Stanford windowing system named W. Other ideas came from Sun's SunView environment which ran on the 68000 based Sun-3 workstations. The early versions of X were developed primarily by Robert Scheifler, Ron Newman and Jim Gettys. X went on to become the basic graphics system of all the RISC based UNIX workstations.

Aside from providing UNIX with a graphical user interface, X's main contribution to the computing world was the idea of displaying an application remotely over a network (ie: running an application on one machine but displaying its user interface on another, much like telnet already provided for command line UNIX users). The implementation was a client-server approach, where an X window system server ran on the displaying machine, and the client programs communicated with it using a network protocol. The X server and its client programs could be running on the same machine, or on different machines, it didn't matter.

X had an unusual career. In somewhat of an odd decision, its designers decided that X should only provide mechanism, not policy. So X did not provide any particular look an feel, but instead only provided the basic mechanisms on top of which several different user interface styles were later implemented. At least three major user interface look & feel styles were widely used on X - MIT's own Athena style, Sun and AT&T's OpenLook, and OSF's Motif (supported primarily by HP and IBM). Other less significant styles included Digital's DECwindows, Silicon Graphics' 4Sight and several public domain styles. None of the styles interacted particularly well with the others, and as a result X was plagued by inconsistencies between applications.

The Atari ST

Known primarily as a maker of games machines, the Atari ST was Atari's first major foray into the world of personal computing. Like the Macintosh and Amiga, the Atari ST was based on the Motorola 68000 processor. It offered medium resolution color graphics and high quality stereo sound, and its GEM operating system featured a graphical user interface.

Unfortunately, for mainstream business uses the ST couldn't compete with the PC and Macintosh, and for graphics and games it couldn't compete with the Amiga. As a result, the ST struggled to find its place in the market. Eventually it managed to carve out a niche in the music and audio editing market, where many music professionals used it as an advanced sound mixing and sound effects machine.

MIPS - The First Commercial RISC

The MIPS R2000, introduced in June 1986, was [arguably] the first commercial RISC processor. It was a descendant of the Stanford MIPS project led by John Hennessy, one of the three pioneering RISC research projects of the early 1980's. In stark contrast to the complicated CISC architectures of the 1980's, the MIPS architecture only had about 50 instructions and was a load store architecture with just a single addressing mode. Instead of achieving high performance through complexity, the MIPS design had 64 registers (32 int + 32 fp) and used an efficient pipelined design to achieve almost one instruction per cycle. The original R2000 contained just 110,000 transistors (compared to almost 300,000 for the Intel 386), ran at 12 MHz and clocked in at an impressive 9 MIPS (six times the speed of the 386). It powered the first RISC based workstations - Digital's DECstations.

MIPS stood for Microprocessor without Interlocked Pipeline Stages. In somewhat of an irony, however, pipeline interlocks had to be added back into the architecture five years later (1991) for the third generation MIPS processor, the R4000 (actually, even the R2000 had interlocks for the HI/LO register pair used by the multi-cycle multiply and divide instructions).

The Intel 80386 Processor - x86 goes 32-bit

The 80386 heralded the beginning of a new age for the IBM PC. The 386 was the first 32-bit x86 processor. As such, it was capable of breaking the 640 Kb memory barrier and running software written for graphical user interfaces. The 386 introduced a 32-bit architecture while maintaining full backward compatibility with earlier x86 processors. This was accomplished by using two operating modes: "real" mode, which mirrored the segmented memory of the older x86's, and "protected" mode which took full advantage of the 386's 32-bit enhancements.

The 386 began shipping in August 1986, but unfortunately it was several years before PC operating systems could make use of its 32-bit capabilities. IBM's OS/2 and Microsoft's Windows '95 were really the first 32-bit mainstream PC operating systems, and even on them most applications were still 16-bit!

Compaq's Deskpro 386

While IBM was busy developing its proprietary MicroChannel based PS/2 systems, clone vendors ALR and Compaq grabbed control of the x86 market by introducing the first 386-based PC's, the Access 386 and the Deskpro 386, just a couple of months after Intel began shipping the 80386 processor. This marked the end of IBM's dominance of the IBM PC market. Both 386 clone systems maintained backward compatibility with the 286-based PC/AT. Compaq's Deskpro 386 had a further performance innovation in its bus architecture - it split the x86 external bus into two separate buses: a fast local bus to support memory chips fast enough for a 16 MHz 386, and a slower I/O bus that supported existing expansion cards.

The Sun SPARC Architecture

In July 1987, Sun announced a RISC architecture called SPARC, which stood for Scalable Processor ARChitecture. Like MIPS, SPARC was the descendant of one of the three pioneering RISC projects, in this case the Berkeley RISC project led by David Patterson. Like MIPS, SPARC was a sleek pipelined design - a radical departure from the complex CISC architectures which held sway at the time. It had about 60 instructions and was a load store architecture with two addressing modes. The instruction set didn't even include integer multiply or divide! SPARC also had one interesting feature which even the MIPS architecture did not have - register windows - which allowed for up to a whopping 520 integer registers (the first implementation had 120), 32 of which were accessible at any given instant. There were also 32 floating point registers.

From the beginning, SPARC was an open RISC architecture (ie: a specification to which anyone could build compatible chips). The idea was to make the architecture open to encourage multiple sourcing and lively competition which would hopefully spur performance and spread the SPARC standard far and wide. This strategy worked well, and by 1995 over a dozen different processors had been built implementing the SPARC architecture, outstripping even the x86 line in terms of the number of different implementations. Holding true to its name, the SPARC architecture scaled very well, ranging from low power notebooks and portables to huge million dollar Cray supercomputers. SPARC based systems went on to dominate the UNIX workstation and server markets.

Rapid time to market was an important goal of the SPARC architecture, so Sun selected a gate-array technology for the first SPARC implementation. It was a 20,000 gate chip running at 16 MHz, with a performance of about 10 MIPS. Fujitsu delivered the first chips in April 1986, a year before the SPARC architecture was officially announced! Sun waited until July 1987 to announce the SPARC architecture so that it could announce the first complete SPARC systems at the same time - the Sun-4/200 family.

HP's Precision Architecture

Hewlett-Packard's Precision Architecture (PA-RISC) was another early commercial RISC. It was a relatively conservative design, with a load store architecture and 64 registers (32 int + 32 fp). PA-RISC had an unusually large instruction set for a RISC, partly because the initial design took place before the RISC philosophy was popular. Despite this, it was a simple design and the first implementation only had 115,000 transistors. PA-RISC processors were used in HP's UNIX workstations, which became quite popular and reached a 25% share of the workstation market.

The C++ Programming Language

Back at AT&T Bell Labs, things hadn't stood still. Several new versions of UNIX had been written, and the C language had been undergoing ANSI standardization. But by far the most interesting thing to happen at Bell Labs in the late 1980's was the emergence of the C++ language as the refined, object oriented successor to C.

Early versions of the C++ language, collectively known as C with Classes, had been in use within Bell Labs since as far back as 1980. The language was originally invented because its creator, Bjarne Stroustrup, wanted to write some event driven simulations for which the Simula language would have been ideal except for speed. So he wrote a front end preprocessor which allowed Simula style classes to be implemented efficiently in C. This was similar in concept to how RATFOR added structured programming to FORTAN, but in this case Stroustrup was adding object oriented features to C. Stroustrup's CFront preprocessor gradually evolved into the first C++ compiler.

C++ was first used outside Stroustrup's research group in 1983, but at that time it lacked many of its final features. Between 1983 and 1991, the language acquired operator overloading, multiple inheritance, templates and exception handling (among other things). Most of these features were driven by experience, and resulted in an efficient and practical, down to earth object oriented language (unlike other OO languages which tended to be slow and were based on abstract methodologies rather than practical experience). Its efficiency, backward compatibility with C, and down to earth approach resulted in C++ gradually succeeding C as the dominant programming language of the computer industry.

The name C++ came from the C increment syntax. Hence C++ was an incremented C (whereas C+ would have been a syntax error).

A Color Mac - The Apple Macintosh II

Although there had been several new Macintosh models since the original Macintosh, the Macintosh II, released in March 1987, was a real leap. It was the first color Macintosh computer. In the normal configuration the color was 8 bitplanes deep - able to display 256 colors at a time from a palette of 16 million! For the power graphics user there was even a 24-bit graphics card available as an expensive extra cost option. The awesome graphics capabilities of the Mac II inspired Adobe to produce a feature packed high end photo editing package called Photoshop, which went on to dominate the photo editing market.

In moving to color Apple also did away with the built-in 9 inch screen, moving instead to a more conventional (and expandable) desktop chassis with a separate 14" color monitor. The screen resolution was increased to 640x480, and RAM was expandable up to a whopping 68 Mb. The only thing missing was a custom chip for graphics - the CPU still did all the drawing on the Mac II, which made the graphics a little slow.

The processor was upgraded to a powerful Motorola 68020 with a 68881 FPU, and a new version of the Macintosh operating system was also released which incorporated color capabilities and cooperative multitasking. The Mac II was quite expensive, costing $5498 in a standard configuration with 1 Mb of RAM and a 40 Mb hard disk. Nevertheless, the verdict was unanimous. This was the ultimate Mac - a colorful, multitasking, all-singing, all-dancing high performance machine. Unfortunately, most applications still treated the machine as if it were black and white, at least for a while.

The Acorn Archimedes

The Archimedes (lovingly called the Arc) was the first RISC based personal computer. Introduced in 1987, the Archimedes was based on Acorn's ARM architecture (ARM stood for Advanced RISC Machine). The ARM was a simple RISC architecture with 16 registers and no floating point support. The initial ARM implementations concentrated on low cost by using a short 3-stage pipeline. A unique feature of the ARM was that every instruction had a set of condition codes which indicated under what conditions it should be executed. This enabled simple conditional execution, which eliminated many branches and improved performance.

For a home computer, the Archimedes packed quite a punch. The original Archimedes A305 only had 512 Kb of RAM and monochrome graphics, but its 4 MIPS ARM2 processor offered much better performance than a 68020 based Macintosh II or an 80386 based PC. Later models used the even faster ARM3 processor and added fast Amiga-like color graphics, more memory (up to 4 Mb), and a floating point co-processor. The Archimedes' RISC-OS operating system featured multitasking and a graphical user interface.

The Archimedes sold quite well in the British educational market, which had been Acorn's primary market for its earlier 6502 based BBC machines. Unfortunately, the Archimedes was not a success in the wider marketplace, due mainly to the lower price and larger software market of the Amiga (with which it directly competed), and the Microsoft Windows phenomenon of the early 1990's.

HyperCard

In August 1987, an Apple engineer named Bill Atkinson (also the developer of MacPaint) introduced a new type of software development tool - HyperCard. HyperCard was unlike any previous software development tool in two key respects: it was interactive rather than language based, and it was geared towards the construction of user interfaces rather than the processing of data. As such, HyperCard made an ideal tool for rapid prototyping and the development of in-house applications.

HyperCard was loosely based on the hypertext idea of links between pages (in this case screens called cards). Building HyperCard applications (called stacks) required almost no programming skills, so even end users could produce useful and interesting applications. A simple language called HyperTalk was available "behind the scenes" to build more complex stacks. HyperCard was a godsend to researchers in the field of Human Computer Interfaces, since it made experimentation with new user interface styles exceptionally quick and easy.

Apple distributed HyperCard free of charge with every Macintosh sold (until 1992, when it became an extra cost product). Similar tools became available for other platforms over the following decade.

The Sun SPARCstation

The Sun SPARCstation 1 was the machine that brought RISC performance to the masses. It wasn't the first RISC workstation. It wasn't even the first SPARC based Sun system. But the SPARCstation 1 set a new standard for price/performance. It churned out a whopping 12.5 MIPS at a starting price of only $8995 - about the cost of a fully configured Macintosh.

The SPARCstation 1 was introduced in 1989. It was based on a SPARC processor running at 20 MHz, and a typical configuration included 16 Mb of RAM, a couple of hundred Mb of hard disk, and a fast and extremely high resolution (1152x900) color graphics system displayed on a huge 19" color monitor. The SPARCstation 1 also had an optical mouse rather than a mechanical one, and built-in ethernet networking. The operating system was SunOS, Sun's version of BSD UNIX. This was later replaced with Solaris, Sun's version of SVR4 UNIX.

Sun sold lots of SPARCstation systems and made the words SPARCstation and workstation synonymous in many people's minds. Engineers and scientists loved them and looked no further for a very long time. A whole range of bigger and better SPARCstation models, including clones, appeared on the market over the next few years, making SPARC the second major platform to use cloning to keep prices down (the IBM PC was the first, of course).

Silicon Graphics IRIS - The Birth of 3D Graphics

In 1989, Silicon Graphics introduced what was [arguably] the first 3D graphics workstation, the IRIS 4D Superworkstation. It was based on the MIPS RISC architecture, but its real innovation was its high end 3D graphics system, including a 24-bit double buffered extremely high resolution (1280x1024) display, with Z buffering and Gouraud shading in hardware!

The high end GTX graphics system had 5 custom 3D geometry processors and 5 pixel rendering processors which ran in parallel. It could render over 100,000 3D shaded triangles per second, which made it fast enough for interactive 3D solid modeling. And all the 3D graphics hardware was at a programmers disposal through the IRIS's wonderful GL 3D graphics library.

The only problem was the price - the IRIS 4D was really, really expensive! Responding to requests for a lower cost version, Silicon Graphics brought out a Personal IRIS which had cut-down features but was still capable of interactive 3D wireframe and limited solids modeling. The Personal IRIS still wasn't cheap, but for many graphics professionals it was reachable.

The IRIS series and its descendants, together with the GL graphics library and its OpenGL descendant, went on to dominate the 3D graphics market.

The NeXT

The NeXT was Steve Jobs' first major computer after leaving Apple. It was released in late 1989, and featured a Motorola 68040 processor (early NeXT's used a 68030), greyscale graphics (color was added later), 8 Mb of RAM, a built-in DSP (digital signal processor) and the first commercial magneto-optical drive (256 Mb capacity). Its NeXTstep operating system was a version of UNIX with a friendly and consistent GUI wrapped around it. The NeXT cost just under $10,000.

Unfortunately, the NeXT had a few critical flaws. The primary programming style for the NeXT was correctly chosen to be object oriented, but the primary language chosen for the machine was Objective-C, a hybrid mix of C and SmallTalk. It should have been C++. Objective-C went on to become a dismal failure in terms of wide spread use, whereas C++ went on to supersede C as the dominant language for the entire computing industry. The NeXT was also based on the aging Motorola 68000 CISC architecture. It should have been based on a RISC architecture such as MIPS or SPARC. And finally, the user interface relied heavily on PostScript for its text rendering, which made it slow.

These flaws, plus the fact that it was priced slightly too high, meant that the NeXT never really caught on. The NeXTstep operating system was eventually ported to other platforms including x86 and SPARC, but it still failed to capture any significant market share. Nevertheless, it served as an inspiration for future workstations. It took several years before mainstream UNIX workstations came with a decent GUI, for example.

      
Lankomumo reitingas

Diskusijos - Discusions

Print version - Print version

Atgal
Random tags:    Pubic Hair Fashion (15)    Energetics (2)    Aquariums (28)    Cinema (20)    Architecture (2)    Wedding (10)    Dolphins (6)    Photography (3)    Modems (2)    Vampire (6)    Intercourse (265)    History (4)    Prose (11)    Education (174)    Hunting (3)    Geology (4)    SSL certificates (10)    Egypt (43)    Gymnastics (9)    Dragons (13)    Eurointegration (4)    Health (20)    Law (11)    Printers (12)    Telecomunication (40)    Cats (14)    Cryptography (10)    Mother and child (17)    Fishing (14)    Astrology (10)    Buddhism (10)    Nursing (4)    Style (3)    S.Valiulis (2)    Animals (65)    Dogs (17)    Philately (8)    Tourism (46)    PHP (3)    Chess (10)    People (56)    Economics2 (2)    Physics (5)    Monitors (10)    Aviculture (2)    Mobile communication (9)    Sport (81)    Countries (43)    Agrobusiness (2)    Ecology (10)
1. The History Of Computers During My Lifetime - The 1970's
2. The History Of Computers During My Lifetime - The 1990's
3. AMD Mobilizes Against Centrino
4. FireWire Groups Converge
5. All Chips Great and Small for AMD
6. HyperTransport Broadens Its HPC Scope
7. Japan: Making 3G Look As Slow As Smoke Signals
8. Sony reveals some specs for PSP handheld
9. Basic Computer Troubleshooting & Repair
1. Sony reveals some specs for PSP handheld
2. The History Of Computers During My Lifetime - The 1990's
3. The History Of Computers During My Lifetime - The 1970's
4. AMD Mobilizes Against Centrino
5. HyperTransport Broadens Its HPC Scope
6. All Chips Great and Small for AMD
7. FireWire Groups Converge
8. Japan: Making 3G Look As Slow As Smoke Signals
9. Basic Computer Troubleshooting & Repair
Map