Operating systems

From TechPedia
Revision as of 01:01, 21 October 2025 by LunaStev (talk | contribs) (→‎3. Modern OS Layer Model)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

Overview

Operating System (OS) is the core control software of a computer system, responsible for efficiently managing hardware resources and providing a standardized environment for applications and users. An operating system is not merely a “manager of programs,” but a software infrastructure that forms the foundation of the modern computing ecosystem.

The essence of an operating system lies in the “control and abstraction of resources.” Hardware resources such as the CPU, memory, storage devices, networks, and peripherals are inherently complex and asynchronous physical systems, but the operating system transforms them into a logically unified abstract layer so that users and applications can interact with them in a consistent manner. This abstraction serves as the foundational language of computing, and all modern application software exists solely upon this language.

An operating system is broadly composed of two main pillars:

  • Kernel — The core layer responsible for resource management and hardware control.
  • System Software Layer — Operates on top of the kernel and includes file systems, network stacks, drivers, process managers, and user interfaces.

The development of operating systems is closely tied to the history of computer science. Starting from batch systems for single tasks in the early 1950s, to time-sharing systems in the 1960s, portable OS architectures based on Unix and C (programming language) in the 1970s, the popularization of personal computer (PC) operating systems such as MS-DOS and Windows in the 1980s–1990s, and the open-source ecosystems of Linux and Android in the 2000s and beyond, operating systems have continually evolved alongside rapid hardware advancements.

Today’s operating systems are no longer just “hardware managers” but also serve as the backbone of security, virtualization, cloud computing, AI, and network infrastructure. Operating systems transcend the limitations of physical devices, providing abstract environments such as virtual machines and containers, thus forming the foundation of modern data centers and cloud platforms.

The design philosophy of an operating system varies depending on its implementation:

  • The Linux kernel and Unix-based systems adopt a monolithic kernel structure, where all core functions are integrated within the kernel.
  • Windows NT and the Darwin layer of macOS use a hybrid kernel structure, combining the stability of microkernels with the performance of monolithic kernels.
  • Systems like Minix and QNX employ a microkernel structure, retaining only minimal kernel functions and running the rest in user space to ensure high stability and isolation.

The core functionalities of an operating system can be summarized as follows:

  • Process and thread management — Creation, scheduling, synchronization, and termination of execution units.
  • Memory management — Virtual memory, page replacement, memory protection, and address space separation.
  • File system management — Logical storage structure of data and access control.
  • I/O system control — Device drivers, buffering, and interrupt handling.
  • Network management — TCP/IP stack, socket communication, routing, and protocol control.
  • Security and access control — User authentication, permission management, and sandboxing features.
  • Virtualization and container support — Technologies such as hypervisors, namespaces, and cgroups.

The design of modern operating systems extends beyond software engineering into philosophical and societal realms. An operating system serves as a digital constitution, deciding “what to permit and what to control.” Such decisions are not mere technical choices, but directly influence user freedom, privacy, data sovereignty, and the ethical boundaries of artificial intelligence.

Representative modern operating systems include:

Thus, the operating system is not a single program, but an “invisible platform” that supports the entirety of digital civilization.

Core Functions

The functions of an operating system go beyond simply “executing programs and managing resources”; they have evolved into a core mechanism that defines and controls the operating rules of the entire computer system. These functions are implemented around the Kernel, and include various layers that mediate between User Space and System Space. What follows are the main functions that the operating system carries out and their technical significance.

1. Process and Thread Management (Process and Thread Management)

One of the most important roles of the operating system is to manage CPU resources so that multiple programs can share them efficiently. A Process is an instance of a program in execution, and the operating system creates (Create), schedules (Schedule), synchronizes (Synchronize) and terminates (Terminate) it.

  • Scheduling — The mechanism that determines the order of CPU allocation among processes, divided into preemptive and non‑preemptive types. Modern operating systems use dynamic priority‑based algorithms such as CFS (Completely Fair Scheduler) or Windows’ MLFQ (Multilevel Feedback Queue).
  • Thread — The execution unit within a process, enabling lightweight parallel execution and resource sharing. With the advent of multi‑core CPUs, threads have become the core unit of OS schedulers; Linux supports POSIX threads based on `pthread`, Windows supports Win32 threads.
  • Synchronization — Techniques like semaphores, mutexes, spinlocks are used to prevent race conditions and deadlocks.

In modern systems, the process management layer has expanded beyond simple CPU control to structures based on namespaces and cgroups (Control Group) for running isolated execution environments such as containers (Container) or virtual machines (VM).

2. Memory Management (Memory Management)

Memory management aims for multiple processes to use a limited physical memory efficiently and safely. The operating system separates physical addresses (Physical Address) and virtual addresses (Virtual Address), so that each process acts as if it has an independent memory space.

  • Virtual Memory — Using page tables and the MMU (Memory Management Unit), the OS provides each process with an independent address space. This achieves both protection and isolation.
  • Paging and Swapping — When memory is insufficient, some pages are temporarily moved to disk so that more processes can run concurrently.
  • Cache and Buffer Management — Control of multi‑level memory hierarchies including CPU cache, file buffer, page cache, to maximize I/O efficiency.

Modern OS memory managers support various architectures such as NUMA (Non‑Uniform Memory Access), hardware virtualization (VT‑x, AMD‑V), and memory compression and sharing technologies (KSM, Memory Ballooning).

3. File System Management (File System Management)

The operating system abstracts data storage devices into logical structures, allowing users and applications to access them through the concept of “files”.

  • File Structuring — Through metadata structures such as directory, inode, FAT, B‑Tree, data is managed hierarchically.
  • Journaling — To prevent file system damage, changes are logged and then reflected to actual files. Examples include NTFS (Windows), ext4 (Linux), APFS (macOS).
  • Permission and Access Control — Via POSIX permissions, ACL (Access Control List), Security Context, user‑specific access is controlled.
  • File Cache and Buffering — To reduce disk I/O bottlenecks, read/write data are cached in memory to improve efficiency.

The file system has now evolved into more than simple storage structure, into extended layers including encrypted file systems (EFS), network file systems (NFS, SMB), and even cloud storage APIs.

4. I/O System and Device Management (I/O System and Device Management)

The I/O system is the physical boundary layer connecting hardware devices and the kernel. The operating system abstracts I/O requests so that applications can access standard APIs without knowing device specifics.

  • Device Driver (Device Driver) — Kernel modules that control specific hardware devices; each OS provides its own driver model (Windows Driver Model, Linux Device Model).
  • Interrupt Handling — An asynchronous signal handling system that allows the CPU to immediately detect external events.
  • Buffering and Spooling — Data is temporarily stored and processed sequentially to mitigate I/O bottlenecks.

In modern systems, the I/O layer has expanded beyond simple disks and printers to manage a wide range of devices such as GPU, sensors, network interfaces, USB, PCIe.

5. Network Management (Networking)

The operating system integrates a network protocol stack to support communication between local systems or over the Internet.

  • TCP/IP Stack Implementation — Provides a standardized network communication layer based on the socket API.
  • Routing and NAT Management — Network path control functions including packet forwarding, address translation, firewall policies.
  • Security Protocol Integration — Support system‑level encrypted communication such as TLS, IPSec, SSH.
  • Virtual Network (Virtual Network) — In container and virtual machine environments, manage bridges, tunnels, overlay networks.

Modern OS treat networking not as a simple data channel, but as an infrastructure of service, security, and virtualization.

6. Security and Access Control (Security and Access Control)

To maintain system consistency and reliability, the operating system must strictly control user permissions and data access.

  • Authentication — Verification of user identity (passwords, tokens, biometric, etc.).
  • Authorization — Granting access rights to specific resources.
  • Auditing — Tracking actions via system logs and security event records.
  • Sandboxing — Isolating the execution environment of applications to prevent malicious behavior from spreading across the system.
  • SELinux, AppArmor, Windows Defender are examples of implementations of these security policies.

Security operates at the kernel level in integration with hardware, and is combined with firmware‑based protection technologies such as TPM (Trusted Platform Module) and Secure Boot.

7. Virtualization and Resource Abstraction (Virtualization and Resource Abstraction)

In modern cloud environments, the operating system uses virtualization layers so that multiple logical systems can operate independently on a single physical device.

  • Hypervisor (Hypervisor) — Technologies such as KVM, Hyper‑V, Xen provide virtualization management functions at the OS level or hardware‑supported level.
  • Container (Containerization) — Technologies like Docker use OS kernel namespaces and cgroup features to implement process‑level isolation.
  • Resource Control — Dynamically allocate and limit CPU, memory, network, I/O bandwidth.

Virtualization is considered an “extended role” of the operating system, and functions as a core component of modern data center and cloud infrastructure.

Structure

The structure of an operating system is not defined in a single form. Its design varies according to philosophy, hardware architecture, performance priorities, security policies, and each structure is an answer to the fundamental question of “how far to include within the Kernel”.

The internal structure of an operating system can be broadly divided into the following three levels.

1. Layered Architecture

An operating system is generally composed of the following layers:

  • Hardware Layer — CPU, memory, storage devices, I/O devices and other actual physical resources.
  • Kernel Layer — The core part that performs resource management, system calls, process scheduling, memory protection, etc.
  • System Services Layer — Includes file systems, network stacks, device drivers, security, virtualization functions, etc.
  • User Space — The area where shells, graphical interfaces, libraries, applications, etc. are executed.

This hierarchical structure “abstracts the complexity of hardware step by step” so that applications can access hardware through standardized interfaces. Most modern operating systems such as Unix, Windows, Linux are designed based on this layer model.

2. Major Types of Kernel Architectures

The kernel structure of an operating system has evolved in various forms according to the balance of performance, stability, and scalability.

(1) Monolithic Kernel

A structure in which all core functions (process management, memory, file system, device drivers, etc.) are executed in a single large kernel space. Because all modules inside the kernel communicate directly, performance is high and system call overhead is low. However, a bug or crash can affect the entire kernel.

  • Representative examples: Unix, Linux Kernel, MS‑DOS, Xv6, FreeBSD
  • Advantages: fast execution speed, single address space, simplified system call path
  • Disadvantages: stability and security issues, maintenance complexity

Modern Linux kernel is classified as a complete monolithic kernel, but it has evolved into a “modular monolithic” form by introducing module concepts that support dynamic loading.

(2) Microkernel

A structure that leaves only the minimal functionality inside the kernel, and moves the remaining functions (file system, network, device drivers, etc.) into independent processes in user space. The kernel is responsible only for basic process scheduling, memory management, and IPC (Inter‑Process Communication).

  • Representative examples: Mach, Minix, QNX, L4, HURD
  • Advantages: high stability, error‑resilience due to module isolation, improved security
  • Disadvantages: performance degradation due to IPC overhead, implementation complexity

Microkernels are often used as the basic model in modern distributed systems, real‑time systems, and security‑enhanced OS designs.

(3) Hybrid Kernel

A form that combines the strengths of monolithic and microkernel architectures, keeping the message‑based communication of microkernels while integrating some core functions into kernel space to reduce performance loss. As a result, it can be described as a “partially monolithic microkernel” structure.

  • Representative examples: Windows NT Kernel, macOS’s XNU Kernel, ReactOS, Haiku
  • Advantages: compromise between microkernel stability and monolithic kernel performance
  • Disadvantages: structural complexity, difficulty in maintaining design consistency

Windows NT kernel is a representative example of a hybrid architecture, separating the Executive layer and the HAL (Hardware Abstraction Layer) in kernel mode, achieving both stability and portability.

(4) Exokernel

An experimental structure proposed in the 1990s at MIT, where the operating system model exposes hardware resources almost directly to applications. In other words, the kernel only acts as a “security arbiter”, and user‑space libraries implement actual resource management policies.

  • Representative examples: ExOS, Nemesis, MIT Exokernel Project
  • Characteristics: extreme minimalism, performance maximization, customizable resource policies
  • Disadvantages: complex user‑space management, cooperation needed between applications

Exokernels have indirectly influenced the design philosophy of high‑performance servers, hypervisors, and cloud nodes.

(5) Modular Kernel

A structure in which the kernel is divided into multiple independent modules, which can be dynamically loaded or unloaded when needed. This method maintains the performance of a monolithic kernel while securing maintainability and scalability.

  • Representative examples: Linux Kernel (Loadable Kernel Modules), Solaris’s DDI/DKI
  • Advantages: flexible feature extension, ability to add drivers without rebuilding the kernel
  • Disadvantages: complexity of module dependencies, possible impact on kernel stability

3. Modern OS Layer Model

Modern operating systems have evolved beyond kernel architecture, to multi‑layer structures including virtualization layers, user‑space services, and security isolation layers.

The common structure of a modern OS can be represented as follows: 

┌───────────────────────────────┐
│ User Space                                                   │
├───────────────────────────────┤
│ Applications / Shell / GUI                                   │
│ System Libraries (e.g., libc)                                │
├───────────────────────────────┤
│ System Call Interface                                        │
├───────────────────────────────┤
│ Kernel Space                                                 │
├───────────────────────────────┤
│ Process / Memory / I/O Management                            │
│ File System / Network Stack                                  │
│ Device Drivers / Security Modules                            │
├───────────────────────────────┤
│ Hardware Abstraction Layer (HAL)                             │
├───────────────────────────────┤
│ Hardware                                                     │
└───────────────────────────────┘

This model shows that an operating system acts not as a “single program” but as a hierarchical ecosystem. Each layer has a clear boundary, and communicates via system calls and interrupts.

4. Virtualized & Distributed Architectures

With the advent of cloud computing and container technologies, the structure of operating systems has expanded beyond physical boundaries into virtualization layers.

  • Hypervisor Architecture — Technologies such as KVM, Xen, Hyper‑V, VMware ESXi function as a “kernel on top of kernel” directly installed on hardware to manage multiple guest OSs.
  • Container Architecture — Technologies such as Docker, LXC, Kubernetes utilize OS kernel namespaces and cgroup features to provide virtualization at the user‑space level.
  • Distributed Kernel (Distributed Kernel) — Models such as Barrelfish, Amoeba, Plan 9 from Bell Labs treat multiple nodes as a single OS.

Such modern architectures have extended the operating system from a control program of a single machine to a distributed infrastructure layer controlling entire networks.

5. Summary

Structure Type Representative Example Core Philosophy Major Advantages Major Disadvantages
Monolithic Kernel Linux, Unix Integration and simplicity High performance, direct access Vulnerable stability
Microkernel Minix, QNX, Mach Minimization and isolation High stability, modularity IPC overhead
Hybrid Kernel Windows NT, XNU Compromise design Performance + stability Complex architecture
Exokernel ExOS Extreme minimization Performance maximization Complex management
Modular Kernel Linux, Solaris Flexible extension Dynamic feature management Dependency issues

Ultimately, the structure of an operating system is a compromise between “hardware constraints” and “human needs”. If monolithic kernels pursued simplicity, microkernels and hybrid kernels were compromises for stability and flexibility. And today’s operating systems have evolved into a multi‑layered, virtualized living entity that synthesizes all these philosophies.

History of Development

The history of operating systems is also the history of computer science. Advancements in hardware, changes in programming paradigms, and the evolution of human–machine interfaces have determined the structure and philosophy of operating systems. The development of operating systems has generally gone through the following major historical stages.

1. Early Days (1940s–1950s): The Era of Batch Processing

The first electronic computers (ENIAC, EDSAC) did not have operating systems. All programs were written directly in machine code, and hardware could handle only one task at a time.

Later, in the mid-1950s, the concept of the operating system began to emerge with the appearance of the Batch Processing System. This system, which grouped jobs into units and executed them all at once, was the first “automated interface” between the user and the hardware.

2. Time-Sharing and Multiprogramming (1960s–1970s)

As computers became more powerful, Time-Sharing Systems that allowed multiple users to use the system simultaneously emerged. The most innovative project of this period was Multics (Multiplexed Information and Computing Service). Multics implemented for the first time concepts that form the foundation of modern operating systems, such as security, hierarchical file systems, and virtual memory.

The result of simplifying and restructuring the complexity of Multics was Unix. Written in C (programming language), Unix dramatically improved portability and scalability, and with its philosophy of “everything is a file” as a single interface, set a new standard for operating system design.

The developments of this period marked a turning point in which “the operating system shifted from hardware control to human-centered interfaces.”

3. The Era of Personal Computers (1980s)

From the late 1970s, as microprocessors became widespread, operating systems moved from large mainframes to personal computers (PCs). CP/M, MS-DOS represented this environment.

Operating systems of this period were command-line based, single-user environments rather than graphical user interfaces (GUIs). However, with the release of the Apple Macintosh in 1984, GUI-based OSs became popular, and later the Windows 3.x series followed this trend, forming a new concept of “operating system = user experience.”

4. Expansion of Networking and Distributed Computing (1990s)

The 1990s, with the popularization of networking and the internet, was the period when operating systems began to internalize connectivity. The Windows NT kernel, based on a modular hybrid architecture, NTFS, and the Win32 API, provided stability and security in enterprise environments.

Meanwhile, Linux developed around the open-source community, inheriting and expanding the philosophy of Unix. This opened a new paradigm of “decentralization of operating systems.” Unix-based systems like FreeBSD and Solaris also laid the foundation for large-scale networks and server environments.

5. The Era of Mobile, Virtualization, and Cloud (2000s onward)

In the early 2000s, with the explosive growth of mobile devices, operating systems shifted from a PC-centered to a mobile-centered paradigm. Android and iOS efficiently handled multitasking, power management, and security policies even in hardware-constrained environments, establishing the concept of the “operating system in your hand.”

At the same time, in server and data center environments, virtualization technologies such as VMware, KVM, and Xen spread. Operating systems were no longer tied to a single system, evolving into “managers of virtualized resources.” This trend soon led to container-based operating system-level virtualization such as Docker and Kubernetes.

6. Modern Era (2010s onward): Dissolution of Boundaries

Modern operating systems are no longer limited to physical computers. In large-scale cloud infrastructures such as AWS, Azure, and Google Cloud, operating systems manage hundreds of thousands of virtual machines and containers simultaneously. Moreover, with the spread of the Internet of Things (IoT) and edge computing, operating systems have evolved into distributed intelligent structures that operate simultaneously across numerous heterogeneous devices such as sensors, vehicles, satellites, and wearable devices.

At this point, the operating system is no longer a single “program,” but functions as a global-scale software ecosystem.

Modern Role

In the 21st century, the operating system has evolved beyond the traditional definition of “software that controls hardware,” to become an entity responsible for the governance of the entire computing infrastructure. This expands its meaning on three levels: technological, social, and philosophical.

1. Technological Role: From Hardware Abstraction to Cloud Orchestration

The operating system still functions as an abstraction layer for hardware resources, but now extends its control beyond physical devices to virtual resources and cloud-native environments.

  • Container technologies (Docker, LXC) implement process-level virtualization using kernel namespaces and cgroups.
  • Hypervisors (KVM, Hyper-V, Xen) run multiple virtual operating systems on physical hardware.
  • Cloud orchestration (Kubernetes) automatically manages these virtual resources on a global scale.

Thus, the operating system has expanded from being a single system administrator to a “distributed operating system” controlling billions of nodes.

2. Social Role: Trust, Security, and Data Sovereignty

The operating system is like the “constitution” of digital society. Through user permissions, data access, encryption, and security policies, it determines who can control what. The security model of the Windows NT kernel, the policy-based access control of SELinux, and the sandbox structure of iOS are all expressions of such digital governance.

The security architecture of operating systems now extends beyond protecting individual systems to social domains such as national security, corporate ethics, and personal data protection.

3. Philosophical Role: The Boundary Between Control and Freedom

At its core, the operating system decides “who has the right to control the system.” Open-source models (Linux, FreeBSD) prioritize freedom and transparency, while closed models (Windows, iOS) prioritize stability and integrated ecosystems. The balance between the two is less a technical choice and more of a philosophical declaration.

In the end, the modern operating system is not merely a technical product, but a comprehensive embodiment of how human civilization manages digital space.

Types

Operating systems can be classified in many ways, depending on their purpose, hardware architecture, real-time requirements, distribution method, and more. Below are representative types of operating systems organized by major categories.

1. Desktop & Personal Operating Systems

Operating systems used by general users on personal computers with graphical user interfaces (GUI).

  • Windows series — Windows 1.0, 3.1, 95, 98, XP, 7, 10, 11, etc.
  • macOS — Apple’s desktop OS, formerly known as Mac OS X or OS X
  • Linux distributions — Ubuntu, Fedora, Debian, Arch Linux, openSUSE, Pop!_OS, Zorin OS, etc.
  • ChromeOS — Google’s lightweight Linux-based OS with a cloud-centric structure
  • Haiku — An open-source OS that inherits the philosophy of BeOS
  • ReactOS — An open-source OS aiming for Windows compatibility
  • AmigaOS — A classic multitasking OS designed for Amiga computers
  • MorphOS — A PowerPC-based Amiga-family OS
  • AROS — An open-source project compatible with the Amiga API

2. Server & Enterprise Operating Systems

Operating systems for systems providing large-scale computation, databases, and network services.

3. Mobile Operating Systems

Operating systems used in smartphones, tablets, wearables, and other mobile devices.

4. Real-Time Operating Systems (RTOS)

Operating systems used in systems where response delays can be fatal (aviation, medical, industrial control, etc.).

  • FreeRTOS — An open-source RTOS for microcontrollers
  • VxWorks — A commercial RTOS by Wind River Systems
  • QNX — A commercial microkernel-based RTOS (used in automotive, medical, industrial fields)
  • RTLinux — A real-time extension based on Linux
  • Zephyr OS — An open-source RTOS for IoT (led by the Linux Foundation)
  • ThreadX — A lightweight system integrated into Microsoft Azure RTOS
  • Integrity — A high-reliability RTOS by Green Hills Software
  • µC/OS-II / µC/OS-III — Embedded RTOS developed by Micrium
  • NuttX — A POSIX-compatible open-source RTOS (used in NASA's Ingenuity helicopter)
  • eCos — An open-source RTOS for embedded systems
  • T-Kernel — An RTOS based on Japan’s TRON project
  • ChibiOS — A small RTOS for microcontrollers like STM32

5. Embedded & IoT Operating Systems

Operating systems for systems with limited resources, such as sensors, appliances, and industrial devices.

  • Embedded Linux — Linux tailored with a lightweight kernel for embedded use
  • Android Things — Google’s OS for IoT devices
  • TinyOS — An ultra-light OS for sensor networks
  • RIOT OS — An open-source OS for IoT devices
  • Contiki — OS for low-power wireless networks
  • Mbed OS — IoT OS based on Arm Cortex-M
  • OpenWrt — A Linux distribution for network routers
  • uClinux — A Linux variant for processors without MMU
  • Fuchsia OS — Google’s next-generation microkernel-based OS
  • AliOS Things — Alibaba’s IoT operating system

6. Cloud & Virtualization Operating Systems

Operating systems that efficiently manage resources in virtual machines, containers, and data center environments.

7. Educational & Experimental Operating Systems

Operating systems designed for learning OS structure, theory, and research purposes.

  • Minix — Designed by Andrew S. Tanenbaum for educational use (Unix-based)
  • Xv6 — A modern Unix remake developed at MIT for education
  • Nachos — Simulator for university OS courses
  • Pintos — A learning OS framework based at Stanford
  • OS161 — An educational OS for hardware simulators
  • ToaruOS — An experimental OS based on C and x86
  • SerenityOS — A desktop-style experimental OS built by a solo developer

8. Mainframe & HPC Operating Systems

High-performance and high-reliability OSes used in mainframes and supercomputers.

  • z/OS — IBM’s operating system for mainframes
  • z/VSE, z/VM — IBM OSes for virtualization and partitioned environments
  • Cray OS / UNICOS — UNIX-family OSes for supercomputers
  • Compute Node Linux (CNL) — Linux for HPC nodes
  • Blue Gene OS — Lightweight kernel for IBM’s supercomputer
  • AIX — UNIX OS for IBM Power Systems
  • CNK — Kernel OS for IBM Blue Gene

9. Historical & Legacy Operating Systems

Classic systems that marked major turning points in computing history.

  • Multics — Prototype for modern operating system concepts
  • Unix — Established portability and the single-interface philosophy
  • MS-DOS — Popularized the personal PC operating system
  • CP/M — Early OS for microcomputers
  • OS/2 — Joint operating system by IBM and Microsoft
  • BeOS — Advanced OS optimized for multimedia
  • NeXTSTEP — Predecessor to macOS, GUI-based and object-oriented
  • Plan 9 from Bell Labs — Experimental OS with distributed filesystem philosophy
  • Inferno OS — Network-centric virtual machine OS
  • RISC OS — Early desktop OS for ARM-based systems
  • GEOS — Graphical OS for low-spec devices
  • OS/360 — A landmark system in the IBM mainframe era

10. Special-Purpose Operating Systems

Operating systems specialized for specific industries, devices, or environments.

11. Hypervisor & Virtual Machine Operating Systems

Operating systems that directly manage virtualization or operate as hypervisors.

12. Other Categories

Related Articles

References

  • Andrew S. Tanenbaum, Modern Operating Systems (Prentice Hall)
  • Silberschatz, Galvin, and Gagne, Operating System Concepts (Wiley)
  • William Stallings, Operating Systems: Internals and Design Principles (Pearson)
Retrieved from "https://en.techpedia.wiki/index.php?title=Operating_systems&oldid=26"