Operating-System Foundations and Evolution

Introduction

An operating system (OS) is the fundamental software layer that coordinates computer hardware, provides common services to application programs, and gives users a usable environment for computation. Although users often interact with applications rather than the operating system itself, every modern computing activity—loading a web page, training a machine-learning model, saving a file, connecting to a network, or running a mobile application—depends on operating-system mechanisms.

The OS occupies a position between hardware and application software. It hides unnecessary hardware details through abstractions, manages scarce resources, enforces protection boundaries, and provides standardized interfaces. This role becomes more important as systems become concurrent, networked, heterogeneous, virtualized, and distributed across cloud infrastructure.

Historically, operating systems developed in response to practical problems. Early computers required manual setup and were used by one program at a time. Batch systems improved utilization by grouping jobs. Multiprogramming allowed several jobs to reside in memory, while time-sharing made interactive computing possible. Later systems supported personal computers, mobile devices, virtual machines, containers, and cloud services. Understanding this evolution explains why current operating systems contain mechanisms for scheduling, memory management, files, security, networking, virtualization, and power control.

Learning Objectives

By the end of this chapter, you should be able to:

1. Define an operating system and distinguish its major roles.

2. Explain common OS terminology, abstractions, services, and interfaces.

3. Describe kernel responsibilities and the relationship between software and hardware.

4. Explain system calls, user mode, kernel mode, interrupts, and device drivers.

5. Outline the boot process from power-on to an operational system.

6. Trace the evolution from batch processing to multiprogramming, time-sharing, desktop, mobile, and cloud systems.

7. Analyze how OS design choices affect performance, security, reliability, usability, and energy consumption.

8. Apply OS concepts to a realistic computing scenario.

1. The Operating System as an Interface and Resource Manager

Two complementary definitions are useful. First, an operating system is an extended machine: it provides convenient abstractions over difficult hardware operations. A file, for example, is a persistent named abstraction rather than a collection of disk sectors. A process is an abstraction of a running program rather than merely a sequence of processor instructions.

Second, an operating system is a resource manager. It allocates and controls processors, main memory, storage, input/output devices, network interfaces, and energy. Because resources are limited and applications may compete for them, the OS must decide who receives a resource, for how long, and under what conditions.

These roles can conflict. A highly abstract interface may be easy to use but hide performance-relevant details. Aggressive sharing can improve utilization but increase interference or security risk. A system optimized for maximum throughput may respond poorly to interactive users. OS design therefore involves trade-offs rather than a single universally optimal policy.

1.1 Hardware, system software, and applications

A simplified software hierarchy is:

• Hardware: processors, memory, storage, buses, controllers, and peripheral devices.
• Firmware: low-level software stored in nonvolatile memory, such as UEFI firmware.
• Operating system: kernel and system programs that control hardware and provide services.
• Middleware and runtime systems: libraries, virtual machines, container engines, and service frameworks.
• Applications: programs that deliver user or organizational functionality.

The boundaries are not absolute. For example, a network protocol may be implemented partly in the kernel and partly in a user-space library. A hypervisor may manage hardware directly while hosting complete guest operating systems. Nevertheless, the hierarchy is useful for understanding responsibility and privilege.

1.2 Core OS goals

Typical operating-system goals include:

• Convenience: make computers easier to use.
• Efficiency: use hardware effectively.
• Responsiveness: provide timely interaction.
• Reliability: continue operating correctly despite faults.
• Security: protect data, programs, and system resources.
• Fairness: allocate resources according to defined policies.
• Scalability: support growth in users, processors, data, or workload.
• Portability: enable software to run across different hardware platforms.
• Maintainability: permit updates, debugging, and extension.
• Energy efficiency: reduce power use, especially in mobile and embedded systems.

These goals may compete. For instance, encryption can improve confidentiality while adding computational overhead. Isolation improves security but may increase communication cost. A design must therefore reflect the intended environment.

2. Fundamental Terminology and Abstractions

A program is a passive set of instructions and data stored on a medium. A process is a program in execution, including its current instruction, registers, address space, stack, open resources, and operating-system-managed state. Multiple processes may be created from the same program, and one process may execute multiple threads.

A thread is a unit of execution within a process. Threads in the same process normally share its address space and many resources, whereas separate processes normally have stronger isolation. Multithreading can improve responsiveness and exploit multiple processor cores, but shared data introduces synchronization and race-condition risks.

A processor core executes instructions. A central processing unit may contain several cores, and the OS schedules runnable threads onto those cores. Multiprocessing refers broadly to using multiple processing units. Concurrency means that multiple activities make progress during overlapping periods; parallelism means that activities execute simultaneously on different processing resources. A single-core system can support concurrency through rapid switching but cannot execute two instructions simultaneously on that core.

Main memory, or RAM, holds actively used instructions and data. Secondary storage, such as solid-state drives and hard disks, retains data when power is removed. Virtual memory gives processes the appearance of a large, private address space, commonly using paging and storage as a backing medium. The terms virtual address and physical address must be distinguished: the former is generated by a process, while the latter identifies a location in physical memory.

A file is a named, persistent collection of data managed by a file system. A directory organizes file names and related metadata. A file descriptor is a process-specific handle used by many Unix-like systems to refer to an open file, socket, pipe, or device. Windows uses related handle abstractions.

A device driver is software that translates OS requests into operations understood by a particular device or controller. A system call is a controlled request by a user program for a kernel service. The kernel is the privileged core of the OS. User space is the environment in which ordinary applications execute; kernel space is the protected environment in which core OS code executes.

3. Services and Interfaces

An operating system commonly provides the following services:

1. Program execution: loading a program, creating a process, scheduling it, and terminating it.

2. Input/output: offering standardized operations for devices.

3. File-system manipulation: creating, opening, reading, writing, renaming, and deleting files and directories.

4. Communication: supporting pipes, shared memory, message passing, sockets, and remote communication.

5. Error detection: identifying hardware, memory, storage, and program errors.

6. Resource allocation: assigning CPU time, memory, devices, and storage.

7. Accounting and monitoring: recording resource use for diagnosis, capacity planning, or billing.

8. Protection and security: controlling access and isolating activities.

Applications normally access these services through application programming interfaces (APIs), libraries, and system calls. An API is a programming interface specifying operations and data conventions. A system call is the mechanism by which execution crosses from user mode into kernel-controlled service code. A library function may perform validation and then invoke one or more system calls; therefore, an API call and a system call are related but not identical.

For example, a program that saves data may call a library function such as `write`. The library prepares arguments and invokes the corresponding system-call mechanism. The kernel validates the process’s permissions and memory addresses, identifies the open file, passes data to a file-system layer, and eventually communicates with a storage driver. The application is not required to know the details of the storage controller.

3.1 System programs and shells

Not all OS functionality is inside the kernel. System programs provide utilities such as shells, compilers, file-management tools, service managers, logging systems, and configuration tools. A shell interprets commands and starts programs. It is usually a user-space program, although it relies heavily on kernel services.

Graphical desktop environments provide window management, menus, accessibility functions, and visual application launching. Their presence does not change the fundamental role of the kernel; rather, they offer a different user interface to OS services.

4. Kernel Responsibilities and Hardware Interaction

The kernel coordinates privileged operations that applications should not perform directly. Its responsibilities typically include process and thread management, CPU scheduling, memory management, file systems, device management, networking, security enforcement, and interprocess communication.

4.1 Privilege and protection

Modern processors commonly provide at least two execution privilege levels: a restricted user mode and a privileged kernel mode. User-mode programs cannot freely execute instructions that could compromise other programs or the machine. Operations such as changing memory mappings, configuring devices, or disabling interrupts are restricted.

A system call, exception, or interrupt transfers control to a kernel entry point. The processor changes execution state, preserves relevant context, and begins executing trusted code. After checking arguments and permissions, the kernel performs the operation and returns to user mode. This transition is essential for protection, but it has a cost, so systems optimize frequent paths carefully.

4.2 Interrupts and exceptions

An interrupt is an event that causes the processor to temporarily suspend its current execution and run a designated handler. Hardware devices generate interrupts to signal events such as completed input/output. A timer interrupt allows the OS to regain control periodically and implement preemptive scheduling.

An exception is a processor-detected event associated with the current instruction, such as division by zero, an invalid instruction, or a page fault. Some exceptions are caused by programming errors; others, such as page faults, are normal components of virtual-memory operation. A system call is often implemented using a controlled trap or special instruction.

4.3 Direct memory access and device control

For large data transfers, a device may use direct memory access (DMA). A DMA controller transfers data between a device and main memory with limited processor involvement. The OS configures the transfer, ensures that buffers are valid and protected, and handles completion notification. DMA improves efficiency but requires careful security and memory-coherence management.

Device drivers hide hardware-specific protocols. A storage driver may issue commands to an NVMe controller, while a network driver manages packet buffers and interface queues. The kernel commonly presents a more uniform interface above these drivers, allowing applications to use files or sockets without knowing device-specific details.

5. Process Management and Resource Allocation

The OS maintains process-control information, including process state, scheduling information, memory mappings, credentials, and open resources. A process may be new, ready, running, blocked or waiting, or terminated. A running process can become blocked while waiting for input/output; another runnable process can then use the processor.

A context switch changes the processor from one thread or process to another. The OS saves the current execution context and restores another. Context switching supports multitasking but consumes time and may disturb processor caches and translation-lookaside buffers. Consequently, excessive switching can reduce performance.

Scheduling policies express system priorities. First-come, first-served is simple but can produce poor response when a long job precedes short interactive jobs. Round-robin scheduling assigns each runnable task a time quantum and is suitable for interactive sharing, although the quantum must balance responsiveness against switching overhead. Priority scheduling favors selected tasks but requires safeguards against starvation. Real-time systems use policies designed around timing constraints rather than general-purpose fairness.

The appropriate policy depends on workload. A batch analytics server may value throughput, while a mobile interface may value responsiveness and energy conservation. Cloud platforms may additionally consider fairness among tenants and service-level objectives.

6. Memory, Storage, and File-System Abstractions

Memory management tracks which regions are allocated, translates virtual addresses, enforces protection, and may move pages between RAM and storage. Paging divides virtual memory and physical memory into fixed-size blocks called pages and frames. A page table records mappings from virtual pages to physical frames. Hardware translation support, commonly a translation lookaside buffer, caches recent mappings.

Virtual memory provides isolation and allows programs to use an address space that is larger or differently organized than immediately available physical memory. However, excessive paging can cause thrashing, in which the system spends more time moving pages than executing useful work. This illustrates a general principle: an abstraction improves programmability but does not eliminate underlying resource limits.

A file system manages naming, metadata, allocation, protection, and persistence. Metadata may include file size, ownership, timestamps, permissions, and storage locations. File systems also address consistency after failures. Journaling records intended metadata changes so that recovery can restore a structurally consistent state. Modern systems may use copy-on-write techniques, checksums, snapshots, or distributed replication.

The phrase “stored successfully” can have different meanings. Data may have been copied into an application buffer, a kernel buffer, a device cache, or stable nonvolatile storage. Reliability-sensitive software must understand durability guarantees and use appropriate synchronization operations.

7. The Boot Process

Booting is the sequence that transforms a powered-off machine into an executing operating system. The exact sequence varies by platform, but a modern general-purpose system commonly follows these stages:

1. Power-on and hardware initialization: the processor begins execution at a firmware-defined location.

2. Firmware execution: BIOS or UEFI performs hardware checks and initializes essential devices.

3. Boot selection: firmware identifies a configured boot device or network source.

4. Bootloader execution: a bootloader is loaded and may present operating-system choices.

5. Kernel loading: the bootloader places the kernel and often an initial RAM file system into memory.

6. Kernel initialization: the kernel establishes memory management, interrupt handling, device discovery, scheduling, and core subsystems.

7. Initial user-space process: the kernel starts a first system process, such as an init or service manager.

8. Service startup and login: networking, storage services, security mechanisms, and user interfaces are launched.

The initial RAM file system, often called an initramfs, contains temporary tools and drivers needed to discover storage and mount the final root file system. Secure Boot can require cryptographic verification of boot components, helping prevent unauthorized modification before the OS security mechanisms are active.

Boot failures can occur at several layers. Firmware may fail to detect hardware; a bootloader may be misconfigured; the kernel may lack a required driver; or a user-space service may fail after the kernel has started. Diagnosing the layer is more effective than treating every failure as a generic “OS problem.”

8. Evolution of Operating Systems

8.1 Early and batch systems

The earliest electronic computers were operated manually. Programmers loaded instructions, initiated execution, and collected results. This process left expensive hardware idle during setup and output handling.

Batch systems addressed this inefficiency by collecting jobs and running them sequentially without interactive user involvement. A resident monitor automatically loaded jobs and directed execution. Batch processing improved operator efficiency and reduced setup time, but users experienced long delays and received little feedback while jobs ran. Jobs requiring input or encountering errors could disrupt the batch sequence.

8.2 Multiprogramming

Multiprogramming placed several jobs in memory. When one job waited for slow input/output, the processor could execute another. This improved processor utilization and overall throughput. Multiprogramming required memory protection, job scheduling, device management, and mechanisms for switching among programs.

Multiprogramming is not identical to parallel execution. On a single processor, jobs overlap in time but execute one at a time. On a multicore system, some tasks may execute simultaneously as well.

8.3 Time-sharing

Time-sharing extended multiprogramming to interactive use. The processor rapidly switches among users or processes, giving each a time slice. If the switching interval and system load are controlled, users perceive a responsive machine.

Time-sharing introduced strong requirements for preemption, protection, interactive scheduling, terminals, and user authentication. It also encouraged the development of general-purpose multiuser systems such as Unix and its descendants.

8.4 Personal computers and desktop systems

Early personal computers emphasized affordability and single-user convenience. As hardware became more capable, desktop operating systems added graphical interfaces, multitasking, networking, multimedia, plug-and-play device support, and stronger security. Desktop systems must balance usability with compatibility because they run diverse applications and support many hardware configurations.

8.5 Mobile and embedded systems

Mobile operating systems operate under constraints that are less dominant on desktop systems: limited battery energy, wireless connectivity, sensors, variable hardware, and touch-oriented interfaces. They often restrict background execution, suspend inactive applications, and isolate applications using permission models and sandboxing. Mobile security must address lost devices, untrusted applications, location data, cameras, microphones, and application marketplaces.

Embedded operating systems may be designed for appliances, vehicles, industrial controllers, or medical devices. Some require deterministic response times, small memory footprints, long maintenance lifetimes, or safety certification. A general-purpose OS may be inappropriate where missing a deadline creates physical danger.

8.6 Networked, distributed, and cloud systems

Networked operating systems provide communication and resource access across connected machines. Distributed systems go further: several computers cooperate, often presenting a unified service despite failures and network delays. Unlike local hardware, a network is not instantaneous or perfectly reliable. Distributed OS-related designs must address latency, partial failure, naming, replication, consistency, and trust.

Cloud computing commonly uses virtualization, containers, orchestration, software-defined networking, and automated provisioning. A cloud workload may run inside a virtual machine managed by a hypervisor, inside a container isolated by kernel mechanisms, or across many nodes. Cloud operating environments emphasize elasticity, tenant isolation, observability, automation, and availability.

A virtual machine emulates or exposes a complete machine interface so that a guest OS can run in isolation from other guests. A container generally shares the host kernel while isolating processes, file-system views, users, and resource limits. Containers often start faster and use fewer resources than full virtual machines, but they do not provide exactly the same isolation boundary.

9. Operating Systems in AI and Machine Learning

AI and machine-learning workloads place distinctive demands on operating systems. Training may require large memory allocations, high-throughput storage, multiple CPU cores, GPUs or other accelerators, and efficient data pipelines. The OS and device drivers manage accelerator access, memory mapping, process isolation, and communication between host and device.

A training job can be computationally intensive, storage-intensive, or limited by data movement. OS-level scheduling affects whether multiple experiments interfere with one another. Containerization supports reproducible environments, while orchestration systems allocate accelerators across users. Monitoring tools expose processor utilization, memory pressure, storage throughput, and thermal conditions.

AI systems also raise governance concerns. Logs may contain sensitive data; model checkpoints may be proprietary; shared accelerators require tenant isolation; and automated resource allocation can disadvantage certain users if policies are opaque. Least privilege, encryption, access logging, retention controls, and reproducible deployment practices are therefore relevant to both OS administration and responsible AI engineering.

10. Illustrative Case: Deploying a Shared Machine-Learning Platform

Background

Consider an illustrative university platform used by students and researchers to train machine-learning models. The platform contains multicore servers, GPUs, high-speed storage, and a networked authentication service. Several users may run experiments simultaneously.

Problem

Initially, users execute programs directly on a shared system account. One experiment consumes most of the memory, another fills the storage volume with checkpoints, and a third accesses files belonging to other users. GPU allocation is informal, so jobs interfere and results are difficult to reproduce.

Analysis

The problem is not simply insufficient hardware. It involves protection, resource allocation, accountability, and reproducibility. Processes require separate identities and access permissions. CPU, memory, storage, and GPU resources require limits or scheduling. Software dependencies require controlled environments. Administrators also need logs to investigate failures and measure usage.

Approach and solution

The platform introduces individual authentication and group-based permissions. Users run experiments in containers with approved images. Kernel namespaces provide isolated views of processes and file systems, while control groups impose CPU, memory, and process limits. A scheduler queues GPU jobs according to stated priorities and fair-use policies. Storage quotas prevent one account from exhausting shared capacity. Checkpoints are stored in a protected object-storage service, and sensitive datasets are mounted only for authorized jobs.

Monitoring records resource consumption without exposing unnecessary personal data. Images are scanned for known vulnerabilities, and containers are not treated as a substitute for all security controls. The host kernel is patched regularly, and administrative access is restricted.

Outcome

The platform becomes more predictable and auditable. Users can reproduce environments, jobs no longer routinely exhaust shared resources, and access to datasets is easier to review. Some overhead and administrative complexity are introduced, and poorly configured containers can still create risks. The solution therefore combines OS mechanisms with policies, maintenance, and user education.

Learning points

This case demonstrates that operating systems are socio-technical foundations. Kernel features such as isolation and resource control are necessary, but effective operation also requires identity management, governance, monitoring, patching, and clearly communicated allocation policies.

11. Challenges, Limitations, and Best Practices

Operating-system design faces persistent challenges. Concurrency creates races, deadlocks, and difficult-to-reproduce failures. Hardware diversity complicates driver development. Security vulnerabilities may occur in kernels, drivers, libraries, firmware, or configuration. Performance optimization can reduce portability or maintainability. Virtualization and containerization improve deployment but add layers that complicate diagnosis.

Best practices include applying least privilege, separating user and kernel responsibilities, keeping systems and drivers updated, using strong authentication, encrypting sensitive data, maintaining reliable backups, monitoring resource and security events, testing recovery procedures, and documenting configuration. Administrators should avoid assuming that a successful command guarantees durable storage or that a container automatically provides complete security isolation.

Organizations should define service-level objectives appropriate to their workload. A safety controller may prioritize deterministic timing; a public web service may prioritize availability and scalability; a research cluster may prioritize throughput and fair allocation. Good OS decisions begin with explicit requirements rather than fashionable technologies.

Contemporary Developments

Current operating systems increasingly support heterogeneous processors, confidential computing, memory expansion technologies, edge devices, and specialized accelerators. Security engineering emphasizes hardware-backed roots of trust, measured boot, sandboxing, memory-safe components, and rapid vulnerability response. Cloud-native systems rely on automated scheduling and declarative management, while edge computing moves processing closer to sensors and users to reduce latency and bandwidth use.

Energy-aware scheduling is important for mobile devices, data centers, and AI infrastructure. Sustainability considerations include power consumption, cooling, hardware lifespan, and the environmental cost of data movement. These concerns broaden OS evaluation beyond speed alone.

Chapter Summary

An operating system is both an extended machine that provides useful abstractions and a resource manager that allocates and protects hardware. Its major services include program execution, input/output, file management, communication, error handling, resource allocation, accounting, and security. The kernel performs privileged functions involving processes, memory, devices, storage, networking, and protection, while applications use APIs and system calls to request services.

User mode, kernel mode, interrupts, exceptions, drivers, and DMA explain how software interacts safely and efficiently with hardware. The boot process moves from firmware through a bootloader and kernel initialization to user-space services. Operating systems evolved from manual operation and batch processing to multiprogramming, time-sharing, desktop, mobile, distributed, and cloud environments. Each stage responded to new requirements for utilization, interaction, portability, isolation, scalability, or energy efficiency.

For AI and ML systems, OS mechanisms manage accelerators, memory, storage, containers, scheduling, and tenant isolation. Effective OS administration combines technical mechanisms with security governance, monitoring, maintenance, and fair resource policies.

Key Terms

Operating system: System software that manages hardware and provides services to applications.

Kernel: Privileged core of an operating system.

Process: A program in execution together with its managed execution state.

Thread: A unit of execution within a process.

System call: A controlled request from a user program to the kernel.

API: A defined programming interface for using software functionality.

User mode: Restricted processor execution mode for ordinary programs.

Kernel mode: Privileged execution mode for trusted OS code.

Interrupt: An event that causes the processor to invoke a handler.

Exception: A processor-detected event associated with an instruction.

Device driver: Software that controls or communicates with a hardware device.

DMA: Direct memory access, allowing device data transfer with limited CPU involvement.

Virtual memory: An abstraction that maps process addresses to physical memory and possibly storage.

File system: OS component that manages files, directories, metadata, and persistence.

Multiprogramming: Keeping multiple jobs available so the processor can switch when one waits.

Time-sharing: Interactive resource sharing through rapid, usually preemptive, task switching.

Virtual machine: An isolated software environment that presents a machine interface to guest software.

Container: An isolated process environment that generally shares the host kernel.

Hypervisor: Software or firmware that manages virtual machines.

DMA: A mechanism for transferring data between devices and memory with reduced processor intervention.

Review Questions

Short Answer Questions

1. What are the two complementary ways of defining an operating system?

2. Distinguish a process from a program.

3. What is the purpose of a system call?

4. Why are interrupts important to operating-system operation?

5. Identify the major stages of a typical boot process.

Long Answer Questions

1. Explain how the kernel protects applications from one another and from hardware misuse.

2. Compare batch processing, multiprogramming, and time-sharing in terms of goals and user interaction.

3. Describe virtual memory and explain both its benefits and its performance limitation under thrashing.

4. Compare virtual machines and containers, including their relationship to the host kernel.

5. Discuss how operating-system priorities differ among desktop, mobile, real-time, and cloud systems.

Analytical / Application Questions

1. A shared ML server experiences memory exhaustion and unauthorized access to datasets. Identify the relevant OS mechanisms and policies that should be introduced.

2. A user reports that a computer fails before the login screen appears. Analyze the boot stages to identify possible fault locations and diagnostic actions.

3. A system designer must choose between maximizing batch throughput and minimizing interactive response time. Explain which scheduling and resource-management trade-offs should be evaluated.

Multiple Choice Questions with Answers

Question 1

Which statement best describes an operating system as a resource manager?

A. It converts all source code into machine code.

B. It allocates and controls resources such as CPU time, memory, and devices.

C. It permanently stores every application instruction.

D. It replaces all hardware components with software.

Correct Answer: B. It allocates and controls resources such as CPU time, memory, and devices.

Question 2

What is the main distinction between a program and a process?

A. A program is passive, whereas a process is a program in execution.

B. A program always runs in kernel mode, whereas a process runs in user mode.

C. A process is stored only on secondary storage, whereas a program is stored only in RAM.

D. There is no distinction between them.

Correct Answer: A. A program is passive, whereas a process is a program in execution.

Question 3

Which event normally transfers control to an operating-system interrupt handler?

A. A user changing a file name

B. A device signaling that an input/output operation has completed

C. A compiler allocating a local variable

D. A directory displaying its contents

Correct Answer: B. A device signaling that an input/output operation has completed

Question 4

Why does a system use user mode and kernel mode?

A. To increase the screen resolution

B. To distinguish text files from binary files

C. To restrict ordinary programs from directly performing privileged operations

D. To ensure that every process runs on a separate physical processor

Correct Answer: C. To restrict ordinary programs from directly performing privileged operations

Question 5

What is the primary purpose of a device driver?

A. To translate operating-system requests into device-specific operations

B. To compile application source code

C. To replace the system scheduler

D. To create user passwords automatically

Correct Answer: A. To translate operating-system requests into device-specific operations

Question 6

Which stage normally occurs after a bootloader has loaded the kernel?

A. The kernel initializes core subsystems and starts early user space.

B. The machine returns to firmware configuration immediately.

C. All applications are deleted from storage.

D. The processor is permanently disabled.

Correct Answer: A. The kernel initializes core subsystems and starts early user space.

Question 7

What problem does multiprogramming primarily address?

A. It eliminates the need for secondary storage.

B. It allows another job to use the processor while one job waits for input/output.

C. It guarantees that every program executes simultaneously on one core.

D. It prevents all software errors.

Correct Answer: B. It allows another job to use the processor while one job waits for input/output.

Question 8

Which statement about containers is generally correct?

A. They always include a completely independent kernel.

B. They generally isolate processes while sharing the host kernel.

C. They can run only on mobile devices.

D. They eliminate the need for access control.

Correct Answer: B. They generally isolate processes while sharing the host kernel.

Question 9

A mobile operating system commonly restricts background activity mainly to improve which combination?

A. Battery life, responsiveness, and security

B. Printer resolution, keyboard size, and file naming

C. Compiler syntax, disk geometry, and screen color

D. Bootloader compatibility only

Correct Answer: A. Battery life, responsiveness, and security

Question 10

Which resource-control mechanism is especially useful for limiting a container's CPU and memory consumption?

A. Control groups

B. A shell alias

C. A file extension

D. A display driver alone

Correct Answer: A. Control groups