Last week, we looked at the transition from independent microcomputers to machines connected through local networks. Networking made it possible to share files, printers, and other resources between computers that had previously operated largely on their own. Connecting the computers was only the beginning. Once resources could cross the boundaries between individual machines, the role of the computers on the network could begin to change.

Earlier in this series, we looked at mainframes, minicomputers, and microcomputers as distinct approaches to computing. Mainframes provided shared computational resources to large numbers of users, while minicomputers brought many of those capabilities to departments and smaller organizations. The microcomputer changed that arrangement by placing the processor, memory, storage, applications, and peripherals directly in front of an individual user. Computing became increasingly personal and decentralized, but organizations still needed many of the shared resources that mainframes and minicomputers had provided.

Networking gave those functions a way to return on new hardware. Shared files could reside on one computer, printing could be handled by another, and applications or databases could be made available across the network. Instead of concentrating every shared function in one larger computer, a network of microcomputers could divide those responsibilities among several machines. Shared organizational computing was re-emerging, but its functions could now be distributed by role.

This is where the server begins to emerge as a role rather than another class of computer. A machine built from the same basic hardware as the personal computers around it could provide files, applications, databases, or other resources to the network. As those roles became more demanding, the machines performing them would gain more memory, storage, processing power, and eventually hardware designed specifically for reliability and continuous operation. The shared functions once associated with much larger computers had not disappeared. They were beginning to take new forms on descendants of the microcomputer.

The Roles That Never Disappeared

The move toward personal computing changed where computation happened, but it did not eliminate the problems shared computers had been solving. Organizations still needed common data, shared applications, centralized storage, access to expensive peripherals, and ways for multiple users to work with the same resources. Those requirements existed before the microcomputer and continued after computers began appearing on individual desks.

Mainframes and Centralized Resources

Mainframes addressed these needs by concentrating substantial computing resources in a central system shared by many users. Processing, storage, applications, and access to organizational data could all be managed in one place. Administration was concentrated there as well. Users might interact with the computer through terminals, but the important resources remained under the control of the central machine.

Minicomputers Bring the Model Downward

Minicomputers brought a similar model to a smaller scale. A department, laboratory, university group, or smaller organization could operate a shared computer without requiring the scale and expense of a mainframe installation. Multiple users could still share applications, files, processing capacity, and peripherals.

This placed the minicomputer particularly close to territory that network servers would later occupy. The hardware would change considerably, but the need for departmental and organizational resources shared among multiple users would remain.

The Older Systems Did Not Disappear Overnight

The arrival of the microcomputer did not cause organizations to immediately abandon their mainframes and minicomputers. Those systems already held applications and data they depended upon, and they continued to provide capabilities that early personal computers could not easily replace. For many organizations, the first step was connecting the new machines to the larger computers already in use.

A PC could take the place of a dedicated terminal while still accessing applications and data running on a mainframe or minicomputer. Terminal emulation and other connectivity software allowed the personal computer to perform its own local work while providing access to existing shared systems. Mainframes, minicomputers, and PCs could coexist in the same computing environment for years.

I saw this overlap firsthand in 1995, when I worked in a college computer lab. The college had two labs filled with PCs, but in the corner was still a VAX terminal used by the administrators. The PCs had clearly become the everyday computers for the students, but that did not mean every function of the older system had moved with them.

As networking among microcomputers matured, that relationship began to change. Local networks increasingly allowed PCs to share files, printers, applications, and other resources among themselves. Mainframes and minicomputers remained important, but some of the responsibilities that had kept them at the center of organizational computing could now move onto networks of smaller machines.

Mainframes and minicomputers represented recognizable classes of computer, but shared storage, multi-user applications, common data, and centralized administration were functions rather than properties of a particular kind of hardware. Those machines had been the practical way to provide them. As microcomputers and their networks became more capable, the functions could move to new hardware without disappearing.

The Microcomputer Pulls Computing Apart

The microcomputer gave individual users computing resources of their own. Instead of connecting to a larger shared system, a user could have a processor, memory, storage, applications, display, keyboard, and peripherals sitting on a desk. As these machines became more capable, more work could be performed locally without depending on a central computer.

Computing Becomes Personal

This independence was one of the great strengths of personal computing. A program running slowly or failing on one computer did not necessarily affect everyone else. Users could install different software, store their own files, and configure the machine for their own needs. Organizations could also add computers incrementally rather than concentrating all of their computing capacity in a single large system.

For the individual user, this represented a significant change. Processing and storage were no longer resources that had to be requested from a shared system. Much of the computing environment was sitting on the desk and belonged, at least operationally, to the person using it.

Independence Creates New Problems

Putting those resources on individual desks also scattered things that had previously been kept together. As personal computers spread through an organization:

• files could become scattered across many hard drives;
• printers and other peripherals could be attached to individual computers even when several people needed them;
• applications might have to be installed and maintained separately on many machines; and
• transferring information between computers could mean carrying it on floppy disks.

These were consequences of distributing resources that had previously been concentrated within shared systems. Personal computing provided independence, but that independence came with a new kind of isolation.

Local networks provided a way around some of that isolation. Once the machines were connected, resources distributed onto individual desks could begin to be shared again. The microcomputer had pulled computing apart; the network provided a way to put some of those pieces back together without giving up the individual computers themselves.

The Network Puts the Pieces Back Together

Once microcomputers were connected, a resource no longer had to reside on the computer that used it. Files stored on one machine could be accessed from another. A printer connected to one system could serve users throughout an office. Applications, databases, and other resources could likewise be placed on a machine where multiple users could reach them across the network.

This brought shared computing back into an environment built around personal computers. Mainframes and minicomputers had generally concentrated many shared functions within the same computer. A network of microcomputers allowed those functions to be separated.

Sharing Resources Across the Network

As shared resources moved onto networked computers, several recognizable server roles began to emerge:

• File server
• Print server
• Database server
• Application server
• Authentication server

A file server provided a common place to store files that could be accessed from other computers on the network. Instead of documents and other data existing only on individual hard drives, users could work with shared storage available to everyone who had permission to use it.

A print server managed access to one or more printers. This allowed a printer to be shared among many computers while print jobs could be queued and managed in one place.

A database server provided access to common data. Rather than maintaining separate copies on individual computers, applications and users could work with information stored and managed by a shared database system.

An application server moved some of the application workload away from the individual PC. Depending on the software, the server could provide an application itself, perform processing on behalf of clients, or provide services used by applications running on other computers.

An authentication server provided a common place to manage identities and access. Instead of every computer maintaining completely independent user accounts, authentication could become another shared network service.

These roles did not necessarily require five separate computers. A single machine could provide several services, particularly on a smaller network. The functions themselves no longer had to reside together.

Centralizing Functions Without Centralizing Everything

Users retained the processors, memory, applications, and storage available on their own computers while gaining access to resources provided elsewhere on the network. Local and shared computing could coexist.

This allowed organizations to centralize particular resources without centralizing the entire computing environment. Files might reside on a shared machine while processing remained on individual PCs. A database could be available throughout an organization without requiring every application to run on the same computer. Resources could be placed where sharing made sense while other work remained on the user’s machine.

As these shared resources became more important, particular machines could be given particular responsibilities. Instead of a user’s computer merely sharing a directory or printer when needed, an organization could dedicate a machine to providing that resource. Functions once concentrated within larger shared computers were becoming distinct roles distributed across the network.

The Server Becomes a Role

Once resources could be provided across the network, the distinction between a personal computer and a server was not necessarily a distinction between fundamentally different kinds of hardware. A server was defined primarily by what it provided to other systems.

A computer storing files for other machines was acting as a file server. The same computer might also manage printers or authenticate users. Another machine might request files from that server while providing a different service of its own.

Server and Client Describe What a Computer Is Doing

Server and client described roles rather than permanent categories. A computer could act as a client when requesting a resource from another system and as a server when providing a resource to others. A single computer could also perform several server roles at the same time.

This differed from the older mainframe, minicomputer, and microcomputer taxonomy. Those terms described recognizable classes of computer with meaningful differences in scale, construction, cost, and typical use. Calling a computer a server described what that computer was doing within the network.

The Hardware Could Still Be a PC

Early network servers could have a great deal in common with the personal computers around them. They used the same families of processors, memory, storage devices, expansion buses, network adapters, and other components found throughout the growing PC ecosystem.

A machine did not need to belong to a new hardware class before it could become a server. It might simply have a larger hard drive, more memory, a network adapter, and software configured to provide resources to other computers.

I’ve practiced system administration on plenty of “servers” built from discarded PCs over the years. They did not have redundant power supplies, error-correcting memory, hot-swappable drives, or many of the other features associated with dedicated server hardware. Once configured to provide files, web pages, or other network services to other computers, they were servers because of the role they performed.

The distinction was operational before it was necessarily physical.

An ordinary PC could therefore be a perfectly legitimate server. As more users began depending on a particular machine, there were increasingly good reasons to dedicate that computer to the role.

From Shared Role to Dedicated Machine

A computer did not have to be dedicated exclusively to a server role. A workstation could share files or a printer while still being used by the person sitting in front of it, and one machine could provide several services at the same time. For a small network, that might be entirely sufficient.

The situation changed as more people began depending on those services. A shared directory used occasionally by two or three people placed very different demands on a computer than storage used throughout an organization. The consequences of that computer being unavailable also became greater.

When a Shared PC Is No Longer Enough

Using someone’s workstation to provide a network service introduced some obvious problems. If the computer was turned off, the service disappeared with it. Maintenance, software problems, or hardware failures could affect everyone depending on the resource rather than only the person using the computer.

Server workloads could also compete with the person sitting at the machine for:

• processor time;
• memory;
• disk access; and
• network bandwidth.

At some point, dedicating a computer to the service became more practical than asking one machine to serve both as someone’s personal computer and as an important shared resource.

Giving Machines Specific Jobs

A machine could become the file server, while another became the database server or the mail server. Smaller networks might continue combining several roles on one computer, while larger environments could separate them as workloads and requirements increased.

An organization could centralize its files on one machine and its database on another while users continued running applications and performing much of their processing on individual PCs. Shared computing no longer required concentrating everything in one place.

The network was becoming a distributed environment assembled from computers with different responsibilities. Administrators could decide which machines should provide particular services rather than expecting one class of computer to provide all of an organization’s shared computing.

Once a computer supported many users or an important service, those responsibilities began influencing more than its configuration. Performance, capacity, reliability, and availability would increasingly shape the hardware itself.

The Role Begins to Change the Hardware

An ordinary PC could perform a server role, but a machine supporting many users faced different demands from one sitting on an individual desk. More users meant more simultaneous requests for files, applications, or data. Some workloads placed heavy demands on storage and networking, while others needed substantially more memory or processing power.

As those demands increased, the hardware began to change with them.

Capacity and Performance

Different server roles placed pressure on different parts of the system. A file server benefited from fast storage and greater disk capacity. A database server might need considerably more memory and processing power. A heavily used network service could require faster network interfaces and greater I/O capacity.

As workloads increased, servers could be equipped with:

• more memory;
• larger and faster storage;
• greater I/O capacity;
• faster network interfaces; and
• additional processing capacity.

A server could become considerably more powerful than the computers it served while still using processors, memory, storage, and expansion technologies from the same general hardware families. The PC hardware model provided plenty of room to grow before a server needed to look substantially different from the machines around it.

Reliability and Availability

Capacity and performance were not the only concerns. Once people depended on a server, keeping it running became increasingly important.

A failed desktop computer might interrupt one person’s work. A failed file server could prevent an entire department from reaching its files. Hardware features that prevented failures or reduced their consequences became more valuable as the number of people depending on the machine increased.

Server systems increasingly incorporated features such as:

• error-correcting memory;
• redundant disk arrays;
• redundant power supplies;
• improved cooling;
• hot-swappable drives; and
• components intended for continuous operation.

Some of these features helped keep a hardware failure from bringing down the entire system. Others made failed components easier to replace with less disruption to the people depending on the server.

Server Hardware Becomes Recognizable

Manufacturers eventually produced systems specifically designed for server workloads. Larger memory capacities, multiple processors, rackmount cases, remote-management hardware, redundant components, and greater expansion capabilities made these machines visibly different from the PCs sitting on users’ desks.

The relationship still worked in both directions. I once bought an old Pentium III-based server from my college. Later, when my PC died, I installed a desktop environment on the server and used it to do my homework. It had been built and sold as a server, but underneath the features intended for that role was still a computer closely related to the PCs of the same era.

By this point, it was easy to look at specialized server hardware and think of it as a different class of computer. In practical terms, it certainly was built for a different workload. The difference was not as fundamental as the older divisions between mainframes, minicomputers, and microcomputers.

Server hardware had become specialized because its role demanded greater capacity, reliability, and availability. Change the role, and even a purpose-built server could sometimes become a rather unusual desktop PC.

Old Functions on New Hardware

The rise of the microcomputer did more than move computing onto smaller hardware. It separated functions that mainframes and minicomputers had often provided together. Processing moved onto individual PCs. Files moved onto local disks. Applications ran on individual machines, and peripherals could belong to individual users.

LANs allowed those functions to be reorganized. Some remained on the personal computer, while others became shared resources provided across the network:

• processing could remain on individual PCs;
• files could move onto file servers;
• applications could be divided between clients and servers;
• databases could become shared network resources;
• printers could be managed centrally; and
• user accounts and authentication could be shared across many systems.

The functions were familiar, but their organization had changed. They could now be separated and recombined according to the needs of the network rather than being tied together by the class of computer providing them.

Minicomputer Functions Become Server Roles

The correspondence with the minicomputer was particularly easy to see. A minicomputer could provide a department, laboratory, university group, or smaller organization with shared storage, applications, databases, user accounts, peripherals, and processing resources.

A network of PCs and servers could provide many of those same functions, but they no longer had to reside on the same machine. Files might reside on one server, a database on another, and authentication on a third. Smaller organizations could combine several roles on one machine, while larger environments could separate them as workloads increased.

The users’ computers were different as well. Instead of terminals depending on the minicomputer for most of their computation, PCs could perform substantial amounts of work locally and reach across the network when they needed a shared resource.

This makes the minicomputer an especially useful comparison for the dedicated server. Both could provide shared resources to a group of users, but the server existed within an environment where many other functions had already moved elsewhere. What had once been bundled together in the departmental computer could now become several distinct server roles.

Mainframe Functions Become Distributed Services

The same reorganization happened at a larger scale with functions associated with mainframes. Organizational databases, applications, storage, authentication, processing, and other shared resources no longer had to reside within one central computer. Some could move onto separate servers, some could remain on a mainframe, and still others could move onto users’ PCs.

A collection of PC-derived servers was not automatically equivalent to a mainframe. Mainframes continued to serve workloads where their reliability, I/O capabilities, capacity, and architecture remained valuable. The change was that large-scale shared computing no longer required every function to reside within a computer belonging to a particular hardware class.

This also helps explain why the transition was gradual. Organizations could move individual functions without replacing their entire computing environment at once. An established application might remain on a mainframe while file storage moved elsewhere. A minicomputer might continue supporting another application while PCs handled everyday work. New server roles could be added as the need arose.

The mixture of mainframes, minicomputers, PCs, and servers was therefore more than an intermediate stage between generations of hardware. It allowed individual computing functions to migrate at different times.

The Functions Survive the Hardware Classes

By this point, the functions that had once helped define different classes of computer were becoming less closely tied to the hardware that provided them.

Shared storage could come from a server built on PC-derived hardware. Applications and databases could move to their own systems. Processing could remain on individual PCs or be performed elsewhere on the network. Mainframes and minicomputers could continue operating where their particular capabilities were still needed.

The functions survived even as their connection to particular classes of computer began to weaken.

For the network administrator, the practical question was increasingly not what historical class a computer belonged to, but what role it needed to perform.

Summary

The microcomputer changed computing by moving processing, storage, applications, and peripherals away from shared mainframe and minicomputer systems and onto individual machines. The need for shared resources remained. Older systems continued operating alongside PCs, and as networking matured, many of the functions they had provided could move onto microcomputer-derived hardware.

LANs allowed functions once bundled together inside mainframes and minicomputers to become separate network roles. Files could reside on one server, databases on another, and authentication somewhere else, while users continued performing much of their work on their own PCs. Shared computing had returned in a form that could coexist with personal computing.

A server therefore emerged primarily as a role rather than a new class of computer. At first, the hardware performing that role might differ very little from an ordinary PC. As more people and more important services depended on it, the demands of the role encouraged dedicated machines and eventually specialized server hardware designed for greater capacity, reliability, and availability.

The shared functions of the mainframe and minicomputer had survived the transition to personal computing. They had moved among different machines and been reorganized through the network. That leaves an important question for the old mainframe, minicomputer, microcomputer, and supercomputer taxonomy we have used throughout this series: what happens when the functions that once helped define those classes are no longer tied to the hardware that originally provided them?