To try to demystify CloudFoundry (CF) and Platform as a Service (PaaS) in general, in this three-part series, I’ll explain why the Cloud Foundry Platform as a Service is best viewed as a distributed operating system (OS) for clouds. By thinking of it this way, it’s easier to understand the various components of CF—both their reason for being and the way they’re evolving. Additionally, viewing PaaS in the prism of an OS gives PaaS developers a well understood conceptual framework, backed by years of research and development, from which to seek and find fertile grounds for innovations.

Image of punch-card technology

One common computing problem

Before we look at how PaaS is a modern-day distributed OS, let’s first understand the fundamental problem an OS solves and how that problem has evolved to the current era of cloud computing.

From the early days of computer science, in the 1940s, through today, the problem of software engineering (or computing) is very much the same. Fundamentally, software engineering must resolve how to:

  • Write software
  • Package that software
  • Distribute the packaged software to users

How history has approached this problem

Image of enormous 80s servers and computers

This problem has remained the same through various phases of the history of computer science. In the 1940s and 1950s, in the time of Alan Turing, writing software was about creating a complex single purpose computer with interconnected tubes that formed its circuitry and software. The packaging and distribution happened via the entire computing system.

In the next decade, the first general-purpose computing system was created with the IBM 360, which included a tape-based rewritable storage system and innovated on how to write and load software using punch cards. With this system, you distributed software via blocks of these punch cards, essentially a book, and physically moved the paper bits around cities and countries in trucks, boats, and planes.

The late 1970s was the dawn of the microcomputer revolution. Engineers began to build software on individual systems, packaging it onto disks (floppy disks), and loading it into the computing system’s hard drives. In the 1980s, the microcomputer revolution forged ahead to create personal computers, along with the advent of better storage devices and distribution to the home or office via CD-ROMs and then DVDs.

In the 1990s, the evolution concentrated primarily on networking, where large powerful servers centrally connected personal and office computers and created local area networks. At this point in history, creating and distributing software now meant using media disks and also loading server software via the network file transfer protocol (FTP).

The advent of the web was the next evolution of the solution to this computing problem we talked about earlier. With the web, the various LANs and WANs connect to a central common network (the Internet). In that model, the popularity of the World Wide Web (WWW) allowed for thinner, web-based user interfaces to software.

On the other hand, the graphical user interface (GUI) was a significant innovation for how to create software using integrated development environments (IDEs). The package and distribution of software did not evolve much with the web, except for a fundamental distinction: the client server model. In this model, applications consist of server components or services that you access through Web APIs and client interfaces and software executing on a browser.

Image of 90s technology

In the current decade, there’s been an evolution of both the server and client sides of application development and distribution. First on the client side, while web applications are still dominant, there is a huge shift toward mobile applications. These mobile apps still depend on server-side services, which increases the need for web services.

The other big change is that server-side computing is now completely homogenized with cloud computing. In light of that, it’s no longer necessary for enterprises to manage server hardware. The virtualized server-side environment means the server-side platform is now the cloud. So, applications built for the cloud make use of dedicated software frameworks designed to allow easy distribution and scaling of server-side components.

An evolving problem

As you can see from this brief escape into the history of computing, the problem of “writing, packaging, and distributing” software is fundamentally and centrally the reason computing systems are created.

In the current era of cloud and mobile computing, the problem has evolved to also include scaling these applications and deploying them in repeatable ways. So to summarize, the fundamental problem faced by a PaaS is to run and distribute access to applications in a scalable and efficient manner.

Part two of this three-part series dives into how a Platform as a Service, like Cloud Foundry (CF), is really a modern-day distributed OS. The article examines each part of a typical OS and relates it to a CF component. This will also help us explore not only the similarities but the contrasts as well. The overarching goal is to establish the rationale for using the OS conceptual framework for understanding PaaS.

Join The Discussion

Your email address will not be published. Required fields are marked *