User's & Programmer's View MCQ 60 Practice Tests With Answers (2026)

Incorrect·D: Keeping multiple processes in main memory to maximize CPU utilization by switching execution whenever the active process waits for I/O

Multiprogramming keeps multiple processes active in RAM; when one process blocks for disk I/O, the OS schedules another process onto the CPU, ensuring the processor is never idle.

Incorrect·B: The user interacts via logical folder hierarchies and visual names; the programmer interacts via file descriptors, handles, and byte offsets

Users click named files in folders; programmers open files using kernel abstractions to receive file descriptors or handles, and interact using read/write loops and `lseek()` byte offsets.

Incorrect·B: The expensive computational overhead of saving the CPU registers and state of one process, and loading the state of another

A context switch is the heavily scrutinized overhead of swapping Process Control Blocks (PCBs) and TLBs. System programmers strive to minimize it because it consumes CPU cycles without doing actual work.

Incorrect·B: By implementing shared memory segments or utilizing kernel-managed message passing queues

Because processes are strictly isolated in memory, programmers must deliberately use OS-provided IPC primitives (like pipes, message queues, sockets, or SHM segments) to share data.

Incorrect·A: It creates a nearly identical duplicate of the calling process, establishing a parent-child relationship

The `fork()` call is fundamental in UNIX; it splits the current process into two identical but isolated address spaces (parent and child), returning different PIDs so each knows their role.

Incorrect·D: The user views a monolithic application performing a singular task; the programmer views discrete threads of execution concurrently sharing a common memory space

Users see an "application" (like a web browser). A system programmer sees that application as an isolated process containing dozens of concurrent threads (UI, network, disk) executing simultaneously and sharing memory.

Incorrect·C: A logical abstraction allowing processes to execute even if their entirety is not loaded in physical RAM, relying heavily on demand paging and swap space

Programmers view virtual memory as an abstraction giving each process the illusion of massive, contiguous RAM. The OS maps these logical pages to physical frames or disk swap using the MMU.

Incorrect·A: Implementing Access Control Lists (ACLs) and precisely defining privilege ring boundaries within the kernel

System programmers handle low-level security fundamentals: establishing strict Ring 0/Ring 3 separation, configuring hardware page table permissions (NX bits), and enforcing kernel DAC/MAC policies like ACLs.

Incorrect·A: The user sees a generic graphical failure notification; the programmer views a specific exception code, a core memory dump, or a detailed stack trace

Users receive safe, human-readable error dialogs. Programmers debug the underlying OS event: an unhandled SIGABRT, a stack trace revealing a null pointer, or a full core dump state.

Incorrect·B: By adjusting process nice values (priorities) or utilizing synchronization primitives (mutexes) to avoid race conditions

Programmers cannot force the scheduler, but they provide hints via scheduling APIs (like setting `nice` values or real-time priorities) and use primitives (locking mutexes) which cause the scheduler to block threads.

Incorrect·C: As crucial wrapper functions that prepare CPU registers and trigger the necessary software interrupts to request services from the kernel

The standard C library (libc) acts as the bridge layer: it provides wrapper functions (like `printf` or `open`) that marshal variables into the correct CPU registers required for specific architectural system calls.

Incorrect·A: It holds the specific memory addresses of Interrupt Service Routines (ISRs) used to handle distinct hardware and software signals

The IVT (or IDT in x86) is a critical array of function pointers. When an interrupt or CPU trap fires, hardware indexes into this table to jump to the exact OS function (ISR) designated to handle it.

Incorrect·B: By continuing to work seamlessly while a large document prints in the background, entirely unaware of the disk buffer managed by the OS

Spooling (Simultaneous Peripheral Operations On-Line) buffers slow peripheral I/O (like a printer queue) to a disk. This abstracts wait times, allowing the user workflow to seem immediate while the OS works in the background.

Incorrect·C: The OS guarantees standardized APIs and system call behaviors, ensuring the source-code can be ported across different UNIX-like systems without major rewrites

POSIX (IEEE 1003) is an API standard. A system programmer relies on POSIX compliance to know their C-code invoking `pthread_create()` or standard file I/O will securely compile and run on Linux, macOS, or FreeBSD unchanged.

Incorrect·B: A critical architectural flaw requiring complex algorithmic prevention (like the Banker's Algorithm) to stop processes from circular waiting for resources

Programmers view deadlocks as a fatal concurrency state where threads holds resources while waiting for each other in a circular chain. They necessitate deliberate hierarchy lock designs or detection algorithms to resolve.

Incorrect·D: The user often sees it as an obscure, difficult interface; the programmer sees it as a powerful, highly efficient conduit for direct system manipulation and scripting

End-users rely on GUIs due to their intuitive nature, whereas programmers lean heavily on CLIs (shells) pipelines, as they expose granular, automatable access directly to OS APIs and system logs.

Incorrect·B: It maps the contents of a file directly into a process's virtual address space, allowing extremely fast file I/O using standard memory pointers

Instead of slow `read()/write()` loops, `mmap()` attaches a disk file directly to the process virtual memory table. The programmer can then read/write the file exactly as if it were a massive C array.

Incorrect·A: As a matrix of access rights detailing exactly which operations a specific process can legally execute on specific system objects

Programmers view protection abstractly as a mathematical Access Matrix—where rows are domains (processes/users) and columns are objects (files, drivers), specifying read/write/execute rights enforced strictly by the kernel.

Incorrect·D: A normal, expected software exception handled efficiently by the OS to swap missing memory pages from the disk into physical RAM

A page fault is not an error; to a programmer, it is the normal, synchronous trap event generated by the hardware MMU to tell the OS to fetch a piece of program memory currently resting on the disk swap.

Incorrect·A: The user perceives true simultaneous execution; the programmer knows the CPU is rapidly interleaving time slices among processes to create an illusion

The user experiences applications running simultaneously (parallelism). A system architecture programmer knows the OS is context-switching among them so fast (concurrency) that it only appears simultaneous on single cores.

Incorrect·B: Microkernels isolate non-essential services in user space for maximum stability; monolithic kernels run all core services in a single privileged address space for maximum performance

Microkernels (stability) run only the bare minimum IPC and memory management in Ring 0, offloading services to user space. Monolithic kernels (performance) put file systems, net stacks, and drivers in Ring 0 to avoid IPC overhead.

Incorrect·A: Mapping specific, safe, read-only kernel routines directly into user space to completely bypass the heavy context-switching overhead of traditional system calls

vDSO exports read-only kernel variables (like `gettimeofday`) directly into process memory. This allows programs to retrieve system time instantly without making an expensive software interrupt and entering Ring 0.

Incorrect·C: To dynamically intercept, record, and analyze the exact system calls invoked by a running process for deep behavioral debugging

These tools hook into the OS (using `ptrace`) to log every single system call entering the kernel, giving programmers deep visibility into disk I/O, network sockets, and permission errors occurring within black-box binaries.

Incorrect·B: Hardware-enforced privilege levels where Ring 0 represents unrestricted kernel access and Ring 3 heavily restricts user-mode applications

Protection rings (x86 Ring 0-3) are a hardware feature utilized by the OS. Ring 0 grants full access to CPU instructions and memory. The OS restricts user processes to Ring 3, trapping attempts to execute privileged tasks.

Incorrect·C: To safely map device-visible virtual addresses to physical addresses and protect system memory from malicious or errant Direct Memory Access (DMA) attacks

Just as the MMU protects memory from applications, the IOMMU protects memory from hardware devices. It translates IO addresses, ensuring a device doing DMA cannot maliciously read or overwrite kernel memory outside its bounds.

Incorrect·C: By deliberately implementing synchronization primitives such as spinlocks, mutexes, and atomic operations

Because the kernel schedules threads preemptively and unpredictably, programmers must protect shared memory sections strictly using manually-implemented POSIX mutexes, atomic operations, or semaphores.

Incorrect·C: A critical, ultra-fast hardware cache inside the MMU that stores recent virtual-to-physical address translations to massively accelerate demand paging

System programmers know virtual memory requires a 2-4 tier page table walk. The TLB caches these translations completely in hardware. A context switch flushes it, representing a massive performance penalty programmers try to avoid.

Incorrect·B: A low-level synchronization lock where a thread continuously loops (busy-waits) checking for lock availability, utilized specifically for very short-duration waits in kernel space where sleeping is too costly

A spinlock burns CPU cycles (busy-waiting) expecting the lock to be released almost instantly. It is mandatory in kernel interrupt handlers where threads are forbidden from sleeping or context-switching.

Incorrect·D: To safely and efficiently run sandboxed programs directly inside the kernel for advanced performance profiling, tracing, and network filtering without ever modifying kernel source code

eBPF acts like a safe virtual machine nested inside the Linux kernel. Programmers write eBPF programs (in C, compiled to BPF bytecode) to trace syscalls or filter packets at incredibly high speeds without creating loadable kernel modules.

Incorrect·B: An essential optimization where the parent and child initially share the exact same physical memory pages; a new physical copy is only allocated when one process actually attempts to modify the data

Without CoW, `fork()` would stall the entire CPU copying gigabytes of RAM. CoW allows parent and child to instantly share read-only page pointers; the OS only clones a physical page when someone writes to it.

Incorrect·A: Modifying the scheduling priority hint, directly influencing how much relative CPU time the Completely Fair Scheduler (CFS) allocates to that process

The `nice` value (from -20 to 19) is a user-space hint mapped directly to the kernel CFS weight. It technically alters the virtual runtime decay rate, determining process scheduling priority.

Incorrect·C: It is object code that can be dynamically linked and unlinked from the running kernel at runtime, allowing the extension of OS capabilities (like new drivers) without requiring a system reboot

LKMs (`.ko` files on Linux) avoid the monolithic rigidity of recompiling the whole kernel to add a driver. The OS dynamic linker links the object code into kernel memory on the fly.

Incorrect·B: An architectural trap triggered by the MMU when a process attempts to access a restricted, read-only, or unmapped memory address, almost always indicating a severe pointer bug

SIGSEGV is the kernel's response to the MMU throwing a hardware page fault on an invalid logical address. Programmers understand this nearly guarantees an uninitialized pointer or buffer overrun in their C code.

Incorrect·A: A programmable endpoint for network communication utilizing file descriptors to transmit data streams across complex protocol stacks like TCP/IP

Sockets bridge IPC with networking. The OS intercepts socket file descriptor calls (`send`/`recv`) and processes them down the entire TCP/IP OSI stack—all hidden seamlessly from the application programmer.

Incorrect·A: It provides a mechanism to resolve uncontended locks entirely in user space, avoiding the heavy context-switching overhead of dropping into the kernel unless a thread actually needs to block or wait

`futex` optimizes mutexes: threads use atomic compare-and-swap instructions entirely in userspace. They only invoke the expensive `futex()` system call if the lock is already held and the thread must be put to sleep by the kernel.

Incorrect·B: A severe software performance collapse where the system spends significantly more time swapping memory pages between RAM and the disk than executing actual CPU instructions

Thrashing occurs when the working sets of active processes exceed physical RAM. The OS enters a feedback loop, endlessly paging out blocks only to immediately page them back in, destroying CPU throughput.

Incorrect·A: A mechanism to logically alter the apparent root directory or isolate system resources (PIDs, network) for a specific process, forming the foundational architecture of modern containerization (e.g., Docker)

`chroot` (and modern Linux namespaces) alters the logical reality presented by the OS to a process. It forms the backbone of security isolation jails and Docker containers.

Incorrect·C: It utilizes a red-black tree data structure to track virtual runtimes, continually striving to grant an equitable proportion of processor power to all runnable tasks

CFS ditches the classic OS time queues; instead, it uses an O(log N) red-black tree to track the "virtual runtime" of each process, always scheduling the process with the smallest accumulated time to ensure perfect fairness.

Incorrect·C: As a critical architectural requirement requiring protocols (like MESI) to ensure that when one CPU core alters a shared memory block in its local cache, all other cores are updated or invalidated to prevent processes from reading stale data

In SMP multicore systems, each CPU has its own L1/L2 cache. The OS/hardware must execute complex snooping protocols (MESI) so that if Core A writes a memory address, Core B's cached copy of that same address is instantly invalidated.

Incorrect·B: To define the low-level, architecture-specific conventions for how data structures, registers, and system calls must interact between compiled object code and the operating system kernel

While an API dictates source-code level rules, the ABI defines the rigorous machine-code rules: register allocation sizes, struct padding algorithms, and the exact stack frame formats the kernel expects from the binary execution.