- Atlas
- Computer Science
- Cloud Computing
Cloud Computing
Cloud computing is the practice of renting computing—processors, storage, networks, and finished software—over a network, paying for what you use and letting someone else own and run the machines.
11 frameworks, from 1961 to today · Computer Systems · Computer Science
- Utility computing 1961-1985
- Cluster and Grid Computing 1994-2010
- Application Service Provisioning 1998-2010
- Virtualization 1998-Present
- Software as a Service 1999-Present
- Infrastructure as a service 2006-Present
- Platform as a Service 2008-Present
- Hybrid and Multi-Cloud 2010-Present
- Cloud-native computing 2013-Present
- Serverless Computing 2014-Present
- Edge Computing 2015-Present
Overview
Cloud computing is the practice of renting computing—processors, storage, networks, and finished software—over a network, paying for what you use and letting someone else own and run the machines12. Its central promise is that a program or a business can grow from a handful of users to millions without buying a single server, and shrink again when demand falls1. What is at stake is not just convenience but a shift in who bears the cost and risk of computing: the burden of buying, powering, cooling, patching, and replacing hardware moves from the user to a provider who spreads it across many customers1. That idea has roots going back to the 1960s, but it only became a mass phenomenon after the technical barriers of the 1990s and 2000s were knocked down one by one.
The computer utility and time-sharing
In the 1960s, computers were enormous and expensive, and almost nobody could justify owning one. The dominant model was batch processing: you handed a deck of punched cards to an operator, and hours later you got a printout. John McCarthy, at a 1961 MIT centennial celebration, proposed that "computing may someday be organized as a public utility," in the way that electricity and telephone service were. The analogy was exact: a utility owns the plant, and customers pay for what they draw from the socket.
The technical form this took was time-sharing, in which a single machine switches rapidly among many users so that each feels it has the computer to itself13. MIT's Compatible Time-Sharing System (CTSS), demonstrated in 1961, and later Multics, developed from 1964 by MIT, Bell Labs, and General Electric, made this real. Multics in particular was designed from the start as a utility: it treated memory as a hierarchy of segments paged in from disk, and it gave each user a private, protected address space. That last idea—isolating users from one another on shared hardware—is the ancestor of everything that follows.
The utility vision faded in the 1970s and 1980s as microprocessors made it cheap for organizations to own their own machines. Computing decentralized. But the problem Multics had solved—how to safely share one machine among many tenants—never went away; it just went dormant.
Virtualization: making one machine behave as many
The revival began with a problem of wasted capacity. By the late 1990s, large servers were often running at a small fraction of their capacity, because each application was installed on its own machine to keep it isolated from the others. The fix was virtualization: software called a hypervisor (or virtual machine monitor) presents the illusion of several independent computers on one physical machine, each running its own operating system45.
Virtualization was not new. IBM had built it into its mainframes in the 1960s—the VM/370 system let one mainframe host many virtual machines—but the technique had been largely forgotten in the commodity-server world, because the x86 processor architecture made it awkward. In 1998, Diane Greene, Mendel Rosenblum, Scott Devine, Edward Wang, and Edouard Bugnion founded VMware and produced a hypervisor for x86 that worked by binary translation, rewriting privileged instructions on the fly so that a guest operating system could not tell it was not running on bare metal. The result was that a data center could be consolidated: ten lightly used servers became one busy one, and each application kept its isolation4. Virtualization turned computing capacity into something fluid—a pool of resources that could be carved up and reassigned—and that fluidity is the precondition for everything cloud providers later sold.
Clusters and grids: aggregating many machines
While virtualization made single machines divisible, another line of work made many machines act as one. Cluster computing, developed through the 1990s, linked commodity PCs with fast local networks and software that distributed work across them. The Beowulf approach, a 1994 project at NASA's Goddard Space Flight Center led by Thomas Sterling and Donald Becker, built a parallel computer from off-the-shelf PCs running Linux—a demonstration that supercomputing performance need not require custom hardware.
Grid computing pushed the idea across institutions. The term was coined around 1998 by Ian Foster and Carl Kesselman, who envisioned sharing computing power the way the electrical grid shares power: many independent organizations contributing resources under common protocols. Projects such as SETI@home (1999), which let volunteers donate idle home computers to analyze radio-telescope data, and the EGEE and Open Science Grid infrastructures for physics, showed that vast computing could be assembled from scattered, independently owned pieces. Grids proved the demand for shared compute at scale, but they were built for batch scientific jobs among trusted partners, not for arbitrary customers with unpredictable needs. The missing ingredient was a business model and an interface simple enough for anyone to use.
The web makes software a service
The dot-com era supplied that interface. In the late 1990s, application service providers (ASPs) hosted software for client companies and delivered it over the web—an early attempt at what would later be called Software as a Service6. Salesforce, founded in 1999, sold customer-relationship management this way: customers logged into a website instead of installing software on their own servers. The model worked because the web browser had become a universal client, and because a single hosted copy could be updated for every customer at once.
The term "cloud computing" itself came into wide use around 2006, but the pieces were assembled by specific companies solving their own problems. Amazon, having built a large internal infrastructure for its retail business, realized it could rent out the spare capacity. In 2006 it launched Simple Storage Service (S3) for storing arbitrary data objects over the web, and Elastic Compute Cloud (EC2) for renting virtual machines by the hour. EC2 was the decisive move: it combined virtualization (so customers got isolated machines), a pay-as-you-go price, and a self-service web interface. A startup could now obtain in minutes, with a credit card, computing capacity that previously required a purchase order and weeks of waiting.
The three service layers
As providers competed, a vocabulary settled around three layers of service, each hiding more of the machine from the customer.
Infrastructure as a Service (IaaS) rents raw virtual machines, storage, and networks; the customer installs and manages the operating system and everything above it17. EC2 is the canonical example. Platform as a Service (PaaS) rents a runtime environment: the customer uploads application code and the provider handles the servers, operating system, and scaling18. Google App Engine, launched in 2008, was an early and influential PaaS, letting developers deploy a web application without touching a machine. Software as a Service (SaaS) rents the finished application itself, as Salesforce did. The layers are not a strict hierarchy but a spectrum of how much control the customer keeps versus how much operational burden the provider absorbs.
Cloud native: designing for the cloud
The first generation of cloud applications were ordinary programs lifted onto rented machines. But a rented machine can fail or be reclaimed at any moment, and a provider's network and storage behave differently from a data center's. A movement grew up around designing software that assumes this. "Cloud native" describes applications built as many small, independently deployable services (microservices), packaged with their dependencies into containers—a lightweight form of isolation, popularized by Docker from 2013—and orchestrated automatically. Kubernetes, released by Google in 2014 and donated to the Cloud Native Computing Foundation, became the standard system for scheduling containers across a pool of machines, restarting failed ones, and scaling the number of copies with demand. The point of these tools is to make the application itself resilient to the failures that are normal in a rented, shared environment.
Hybrid and multi-cloud
No single provider suits every workload. Regulated industries must keep some data on their own premises; others fear being locked into one vendor's proprietary services. Hybrid cloud describes an arrangement that combines private infrastructure with public cloud, with workloads moving between them. The technical enabler was the spread of the same virtualization and container interfaces on both sides, so that a workload packaged for one environment could run in the other. Multi-cloud—using several public providers at once—followed for similar reasons of resilience and bargaining power. These are less distinct technologies than deployment patterns, and their history is one of standards and interfaces catching up with the desire to avoid dependence on any single operator.
Edge computing: moving computation back toward the user
As cloud data centers centralized computation, a countervailing pressure appeared: some work cannot tolerate the round trip. A self-driving car, an augmented-reality headset, or a factory robot must respond in milliseconds, and sending data to a distant region and back adds latency that no amount of bandwidth removes. Edge computing pushes computation out of the central data center to smaller facilities near the user—cell towers, local exchanges, on-premises gateways9. It does not replace the cloud but extends it, with the central data center handling training, storage, and coordination while the edge handles the time-critical part. The idea echoes the earliest days of computing, when proximity to the machine was everything; the difference is that the edge and the center are now designed as one system.
Where cloud computing stands
Today the field is organized around a small number of hyperscale providers—Amazon Web Services, Microsoft Azure, and Google Cloud foremost—that operate data centers on a global scale, alongside many smaller and specialized providers. The dominant technical patterns are virtual machines for general workloads, containers and Kubernetes for new applications, managed databases and storage services, and a growing set of serverless offerings in which the customer writes a function and the provider runs it on demand, billing by the invocation. The layers of IaaS, PaaS, and SaaS remain the vocabulary in which services are sold.
The open questions are largely about the costs of success. Providers and customers alike confront the energy and water consumed by enormous data centers, and the siting of those facilities has become a public issue. Customers worry about lock-in to proprietary services and about the difficulty of predicting and controlling spend. Security and data residency—where data physically sits and whose laws govern it—remain contested1. And the boundary between cloud and edge, between what is centralized and what is distributed, is still being drawn, workload by workload. The utility that McCarthy imagined in 1961 exists; the question now is how it should be governed, priced, and powered.
References
- Cloud computing (introduction, Characteristics, Value proposition, History, Infrastructure as a service (IaaS), Platform as a service (PaaS), Challenges and limitations, Extraterritorial data access), Wikipedia
- Utility computing, Wikipedia
- Virtual machine (History), Wikipedia
- Virtualization (introduction, History), Wikipedia
- Hypervisor, Wikipedia
- Software as a service (History), Wikipedia
- Infrastructure as a service, Wikipedia
- Platform as a service, Wikipedia
- Edge computing, Wikipedia
The frameworks of Cloud Computing
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1961-1985
- 1994-2010
- 1998-2010
- 1998-Present
- 1999-Present
- 2006-Present
- 2008-Present
- 2010-Present
- 2013-Present
Cloud-native computing
How should software be built for rented machines?
- 2014-Present
- 2015-Present
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Software as a Service grew out of Application Service Provisioning
Software as a Service grew directly out of application service provisioning: ASPs hosted software for clients over the web, and Salesforce (1999) refined this into a multi-tenant, subscription model delivered through a browser. The term SaaS later replaced ASP for the same practice.
Carried by Salesforce (1999).
Infrastructure as a service influenced by Virtualization
Virtualization provided the technical precondition for infrastructure as a service: EC2 rented isolated virtual machines by the hour, which was only possible because hypervisors could carve a physical server into independent instances. Without the fluid pool of virtualized capacity, IaaS would be unthinkable.
Carried by VMware; Amazon EC2 (2006).
Platform as a Service grew out of Infrastructure as a service
Platform as a Service grew out of IaaS by hiding more of the machine: Google App Engine (2008) let developers deploy code without managing virtual machines, building on the rented infrastructure that IaaS had made available. PaaS is a refinement of the same rental model at a higher level of abstraction.
Carried by Google App Engine (2008).
Cluster and Grid Computing revived Utility computing
Grid computing explicitly revived the 1960s computer utility vision, with Ian Foster and Carl Kesselman framing grids as sharing computing power the way the electrical grid shares power. The Beowulf project (1994) and SETI@home (1999) carried the utility ideal into distributed systems.
Carried by Ian Foster; Carl Kesselman; Beowulf (1994).
Infrastructure as a service influenced by Cluster and Grid Computing
Grid computing demonstrated demand for shared compute at scale and supplied concepts of aggregating distributed resources, but its batch-oriented, trusted-partner model lacked a business model and simple interface. Amazon's EC2 (2006) combined these lessons with virtualization and pay-as-you-go pricing.
Carried by Ian Foster; Carl Kesselman.
Cloud-native computing influenced by Virtualization
Containerization, popularized by Docker from 2013, extended virtualization's isolation idea to the level of a single process, packaging an application with its dependencies. This lightweight isolation became a foundation of cloud-native design.
Carried by Docker (2013).
Hybrid and Multi-Cloud influenced by Infrastructure as a service
Hybrid and multi-cloud deployment patterns arose as customers of IaaS sought to avoid lock-in and meet regulatory constraints by combining public cloud with private infrastructure. The spread of common virtualization interfaces on both sides enabled workloads to move between environments.
Cloud-native computing influenced by Infrastructure as a service
Cloud-native computing emerged as a response to the failure modes of first-generation cloud applications lifted onto rented IaaS machines. Designers assumed that rented machines could fail or be reclaimed at any moment, and built microservices and containers to be resilient to those conditions.
Carried by Docker (2013); Kubernetes (2014).
Serverless Computing grew out of Cloud-native computing
Serverless computing grew out of cloud-native thinking: if applications are broken into small services and the platform handles scaling and restarts, the next step is to let the provider manage even the servers entirely. Function-as-a-service offerings abstracted away the container orchestration that Kubernetes had made standard.
Serverless Computing influenced by Infrastructure as a service
Serverless computing extended the IaaS pay-as-you-go model to fine-grained execution, billing only for the compute time actually consumed by a function. It relied on the same rented infrastructure but hid server management completely.
Edge Computing influenced by Infrastructure as a service
Edge computing arose as an extension of cloud infrastructure to locations closer to users, driven by the need for low latency that centralized IaaS data centers could not meet. It reused the virtualization and management techniques of the cloud.
Hybrid and Multi-Cloud influenced by Platform as a Service
PaaS platforms made it easier to package and deploy applications consistently, which in turn made it feasible to run the same workload across multiple cloud providers. Multi-cloud strategies relied on such portable deployment models.
Edge Computing influenced by Cloud-native computing
Edge computing took the cloud-native principles of containerized, orchestrated workloads and pushed them to the network edge to reduce latency. The same tools and patterns were applied to smaller, distributed locations.
Beyond the field
Where Cloud Computing's ideas came from in other fields, and what they led to there: the strongest 12 of 54 links.
Cluster and Grid Computing led to Cloud computing in Distributed Systems
Cloud computing grew directly out of cluster and grid computing, inheriting resource pooling, virtualization of distributed resources and on-demand provisioning. Commercial clouds generalized the grid and cluster model to elastic, pay-as-you-go infrastructure.
Virtualization influenced Cloud computing in Distributed Systems
Cloud computing depends on virtualization to pool and partition physical machines into elastic virtual resources. Virtual machine and hypervisor techniques were the enabling mechanism for multi-tenant cloud infrastructure.
Virtualization influenced by Hypervisor in Operating Systems
Modern virtualization revived the hypervisor concept from IBM's 1960s CP/CMS and VM systems, which first separated a control program from guest operating systems. The x86 hypervisors of the late 1990s and 2000s reimplemented that architecture on commodity hardware.
Carried by IBM CP/CMS.
Software as a Service influenced by Client–server model in Computer Systems
SaaS is delivered through the client-server model, with a thin browser client talking to centrally hosted servers. The web-based client-server architecture of the 1990s was the technical basis on which hosted software was offered.
Infrastructure as a service influenced by Hypervisor in Operating Systems
IaaS providers run hypervisors to create and manage the virtual machines they rent to customers. The hypervisor is the core enabling technology of infrastructure clouds.
Platform as a Service grew out of Cloud computing in Distributed Systems
Platform as a Service emerged as a layer of the cloud computing stack defined in the mid-2000s, with providers such as Google App Engine (2008) and Heroku building on the utility-computing model of cloud infrastructure. PaaS is a branch of cloud computing's service model rather than an independent tradition.
Carried by Google App Engine (2008); Heroku.
Hybrid and Multi-Cloud grew out of Cloud computing in Distributed Systems
Hybrid and multi-cloud is a direct extension of cloud computing: it generalises the single-provider model to combinations of public and private clouds. The idea grew out of enterprise adoption of cloud services in the late 2000s.
Cloud-native computing grew out of Cloud computing in Distributed Systems
Cloud-native computing grew directly out of cloud computing as a design philosophy for applications built to run on cloud infrastructure, crystallised in the Cloud Native Computing Foundation (2015). It refines cloud computing into an application-architecture doctrine.
Carried by Cloud Native Computing Foundation (2015).
Serverless Computing grew out of Cloud computing in Distributed Systems
Serverless computing is a direct outgrowth of cloud computing, extending the pay-per-use model from rented servers to event-driven functions. AWS Lambda (2014) generalised the cloud provider's managed infrastructure into on-demand execution.
Carried by AWS Lambda (2014).
Edge Computing reacted against Cloud computing in Distributed Systems
Edge computing arose as a corrective to centralised cloud computing, arguing that latency-sensitive and bandwidth-heavy workloads should run near users rather than in distant datacenters. It defined itself against the cloud's centralisation while still depending on cloud backends.
Utility computing influenced by Public Utility Regulation in Natural Resources And Energy Law
The computer-utility idea borrowed the regulatory and pricing framework of public utility regulation, treating computing as a metered service subject to similar rate and access questions. This analogy shaped how early utility-computing proposals framed their economics.
Utility computing influenced by Public Utility and Regulatory Economics in Energy Economics
The analogy of computing as a public utility was drawn directly from the regulated utility industries studied in public utility economics, including their rate structures and natural-monopoly arguments. Proponents of computer utilities borrowed this vocabulary to argue for metered, shared computing service.

Cloud Computing is a planet in Nousfarer
Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.
Land on Cloud ComputingRelated fields
Fields its ideas are linked to
- Distributed Systems 16 links
- Computer Systems 10 links
- Enterprise Systems 5 links
- Operating Systems 5 links
- Big Data Processing 4 links
- Parallel Computing 2 links
- Memory Hierarchy 1 link
- Energy Economics 1 link
- Natural Resources And Energy Law 1 link
- Ubiquitous Computing 1 link
- Imaging Informatics 1 link
- Network Architecture 1 link
More in Computer Systems
See where Cloud Computing sits on the Map of Human Knowledge