Abstraction

When we consider any type of computing technology, from low-level components through complete systems spread over multiple data centers, it is useful to be able to change our focus to consider different aspects of the system. For example, if we’re trying to determine how to design an environment that will utilize both cloud resources and company-owned equipment spread across different locations, it is usually counterproductive to spend a lot of time explaining the choice of CPU and RAM to be put into each system. At the other end of the problem, if we have a design for an environment and need to specify an individual system in an individual data center, we need to ignore unnecessary details about the rest of the environment and focus on that one system.

The ability to ignore the implementation details of something and instead focus on its external behavior is the art of abstraction. With abstraction, we can consider each component of a bigger system as an individual building block. As we put blocks together, we begin to look at combinations of blocks as their own units, ignoring the original blocks. This process continues until we can view the entire system as a single unit with a set of behaviors describing what it does, without really caring how it does whatever it does.

Video Lecture

Abstractions at the Hardware Level

At the level of individual computer systems and hardware components, abstractions are everywhere. Consider some pieces of a laptop, shown in Figure 1. If our job is to design the hard drive, we might care about what is inside it. However, if we’re building the laptop from components, we really do not care about the internals of the hard drive. Instead, we care that the hard drive is a storage device and that it fits in the appropriate bracket and has the correct electrical connectors to attach to the system.

Once we have the components of the laptop assembled, we get the final product. Most of the time, we just use this final product as a component – in this case, as a laptop computer. We don’t really care about all the small components that go inside the system. We just care that the system does what it is designed to do: power on, load some software, and allow us to surf the Internet.

We could have built this laptop using a wide variety of different components. Different manufacturers and models of CPU, RAM, and other devices could have been used. We could have used a different hard drive, or perhaps we could have installed a solid state drive instead. Either way, we would still have a laptop. We might have some performance differences based on component choices, but the end result would still behave the same way.

Moreover, we can abstract away the choice of the laptop and replace it with any computer, including a desktop, server, or even a small single-board device like a Raspberry Pi.¹ Any such device would enable us to surf the Internet, and we’re perfectly capable of carrying out that activity using any computer. Once again, at some level, our specific choice of computer might affect the speed or the specific software stack that is used. However, if the specification for what we need is a computer that can surf the Internet, any of those devices would work equally well.

Abstractions at the Software Level

Speaking of using computers to surf the Internet, the software we use for that purpose is full of abstractions. If we look at the software stack from the top down, we can start with the Web browser, which is the application we use to access Internet websites. These days, there are quite a few choices of Web browser, including Mozilla Firefox,² Google Chrome,³ Microsoft Edge,⁴ Apple Safari,⁵ Chromium,⁶ Falkon,⁷ and many others. While there may be small differences in terms of features, all these browser applications work the same way. We can easily access the same websites using any one of them, since the behavior of each one is predictable.

Abstractions continue as we move down the software stack. The Web browser runs inside some type of operating environment (Figure 2), which provides some standard mechanisms for using the computer’s input and output devices. For example, the computer monitor or screen gives us a way to see the Web browser, and the operating environment draws the browser onto the screen and decorates it with some controls that make it easier to use. The operating environment also provides a means for us to type on the keyboard or move the mouse pointer, permitting us to utilize the web page. While we might be more or less familiar with a given operating environment, such as a Linux distribution,⁸ Apple macOS,⁹ or Microsoft Windows,¹⁰ they all work in a similar enough way that we could use any one of them to surf the Internet without too much trouble.

At an even lower level of the software stack, we have the operating system, which is the component of the operating environment that abstracts away the details of the underlying hardware and permits multiple different pieces of software to share the same hardware. Examples of operating systems include the Linux kernel,¹¹ Apple XNU kernel,¹² and Microsoft Windows NT kernel. There are significant differences in the way these operating systems work, but they all hide the low-level details of the hardware from the user while simultaneously providing a high-level interface for higher levels of software to use.

Below the level of the operating system, there is firmware that runs at a low level on individual devices. The CPU, for example, may have its own firmware, often called microcode. Individual devices, such as the motherboard, wireless cards, video cards, and other peripherals, may also run their own low-level firmware. It is up to the operating system to load device firmware and then provide a uniform way to operate the device, without the higher levels knowing all the details of the individual component parts.

Multiple Computers as a Single System

In the examples above, we’ve explored some of the abstractions present in individual computer systems, and we’ve seen that the whole computer itself can be an abstraction in the sense that it is a device that lets us carry out some task. However, we can combine computer systems together to make larger systems, and then we can look at the behavior of the larger system as a single unit and abstract away the individual computers within it.

If we intentionally join a bunch of computers together to make an environment that works together in parallel to solve a bigger problem than any individual computer could handle, we create a compute cluster, also called a supercomputer. We can join multiple compute clusters together over the Internet to create a grid computing system that enables even larger, collaborative computing tasks to be undertaken.

We can also take individual computers or compute clusters and make them available for others to use over the Internet, letting them run either specific applications or virtual machines. This approach is called cloud computing, and it provides a way to scale computing resources beyond what we have available locally, without having to buy a bunch of extra computers. While cloud computing systems vary in the details, they still provide a service that can be described by what it does, without worrying about how it is implemented.

Data Centers

As a side note in our discussion of abstraction, we will encounter situations in IT where we need to describe resources in terms of where they are located. Examples of such scenarios include describing servers owned by our company, planning for low-latency access by customers in different areas, and preparing for disasters through geographic redundancy.

Figure 3 shows the main data center at Coastal Carolina University. This and similar data centers provide single locations where computer systems can be mounted in high-density racks to save space. Power distribution, cooling, network, and fire suppression systems supply the computers with the necessary physical environment for reliable operation. When discussing physical planning for computer systems, an individual data center is a type of abstraction in the sense that it is a facility providing a set of services for computing.

System Abstractions

At the top and final level of our discussion, we can consider entire computing systems as abstractions. At this level, we describe in broad terms what the system will do and how the system will interact with users and with other systems. When working at this level, we don’t care about all the details of the individual hardware components, software layers, computers, clusters, or even data centers. Instead, we focus on the “big picture” and treat the entire collection of computing equipment as one big tool to solve a problem for someone.

At this level, everything we do is conceptual. We describe the system using diagrams and documents written in such a way that we can communicate with the people who will use the system. It is up to us as IT professionals to figure out what components, at varying lower levels of abstraction, will be used to create the final environment. Therefore, we need to be able to “zoom in” and “zoom out” between different levels of abstraction as the need arises.

Abstraction is a powerful concept, but it does take some practice to be able to leave behind the concrete details of a specific piece of computing equipment and focus instead on its overall behavior. This process is a bit like learning that a place with a lot of trees can be viewed as a forest.

Practice Problems

Try doing the problems yourself before revealing the answers.

1. What computing abstraction is responsible for hiding the details of the underlying hardware and allowing multiple different pieces of software to share the same hardware?

2. On an Intel or AMD system, what is the firmware that runs inside the CPU called?

Notes and References

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.