Linux Fundamentals TCA 100

How Linux Works: What Every Superuser Should Know

At first glance, a modern operating system such as Linux is very complicated, with a dizzying number of
pieces simultaneously running and communicating. For example, a web server can talk to a database server,
which could in turn use a shared library that many other programs use. But how does it all work?
The most effective way to understand how an operating system works is through abstraction—a fancy way of saying that you can ignore most of the details. For example, when you ride in a car, you normally don’t need to think about details such as the mounting bolts that hold the motor inside the car or the people who build
and maintain the road upon which the car drives. If you’re a passenger in a car, all you really need to know is what the car does (transports you somewhere else) and a few basics about how to use it (how to operate the door and seat belt). But if you’re driving a car, you need to know more. You need to learn how to operate the controls (such as the steering wheel and accelerator pedal) and what to do when something goes wrong. For example, let’s say that the car ride is rough. Now you can break up the abstraction of “a car that rolls on a road” into three parts: a car, a road, and the way that you’re driving. This helps isolate the problem: If the road
is bumpy, you don’t blame the car or the way that you’re driving it. Instead, you may want to find out why the
road has deteriorated or, if the road is new, why the construction workers did a lousy job.
Software developers use abstraction as a tool when building an operating system and its applications. There
are many terms for an abstracted subdivision in computer software, including subsystem, module, and
package—but we’ll use the term component in this chapter because it’s simple. When building a software
component, developers typically don’t think much about the internal structure of other components, but they
do care about what other components they can use and how to use them.
This chapter provides a high-level overview of the components that make up a Linux system. Although each
one has a tremendous number of technical details in its internal makeup, we’re going to ignore these details
and concentrate on what the components do in relation to the whole system.