Question 1

Computer architecture – addressing modes In which addressing mode is the operand value given explicitly within the instruction itself?

Accepted Answer

Introduction / Context:Addressing modes define how instructions reference data. Recognizing these modes is vital for assembly programming, compiler backend work, and understanding how CPUs execute code efficiently. Given Data / Assumptions: The question asks for the mode where the operand value (a constant) is embedded in the instruction. Other modes provide addresses or perform address calculations rather than embedding the value. We consider conventional definitions used across many ISAs (e.g., x86, ARM, RISC-V). Concept / Approach: Immediate mode places the actual operand (a literal constant) directly in the instruction encoding. Absolute (or direct) mode places the memory address explicitly in the instruction. Indirect mode uses a pointer to find the address. Index mode adds an index register to a base to compute the address. Only immediate mode provides the value itself without a further memory fetch. Step-by-Step Solution: Define immediate mode: operand literal is part of the instruction.Contrast with absolute: instruction contains an address, not the value.Confirm indirect/index require additional address computation or dereference.Select “immediate mode.” Verification / Alternative check: Example: ADD R1, #5 uses an immediate literal 5. By contrast, ADD R1, [0x1000] (absolute) fetches from memory address 0x1000. Why Other Options Are Wrong: Absolute gives an address; indirect dereferences a pointer; index computes an address using base+offset. None embed the value itself like immediate mode does. Common Pitfalls: Confusing “explicit operand” (value) with “explicit address.” The question asks for the operand itself, not its location. Final Answer: immediate mode.

Question 2

Macro Processor Integration with Assembler Pass 1  What are the advantages of integrating the macro processor into Pass 1 of a two-pass assembler (instead of running a separate macro-expansion phase)?

Accepted Answer

Introduction / Context:Assemblers for systems programming often support macros—parameterized code templates that are expanded at translation time. Toolchains can run a standalone macro processor before assembly, or integrate macro expansion into Pass 1 of the assembler. Understanding the integration benefits helps explain why many practical assemblers collapse these stages for speed and simplicity. Given Data / Assumptions: A classic two-pass assembler performs symbol definition in Pass 1 and address resolution/code emission in Pass 2. Macros generate assembler source text at translation time; no runtime overhead is involved. We compare an integrated approach (macros inside Pass 1) with a separate, external macro-expansion pass. Concept / Approach:Integrating macro handling into Pass 1 means the assembler recognizes macro definitions and calls as it scans the source, expands them on the fly, and feeds the resulting tokens straight into its own symbol table and intermediate structures. This avoids extra I/O and duplicated logic while preserving full feature access (conditionals, local labels, and expressions) during macro expansion. Step-by-Step Solution:Identify macro definitions during Pass 1 and store them in a macro definition table.When a macro call appears, bind actual parameters to formals and expand inline.Immediately process expanded tokens for symbol collection, location counter updates, and diagnostics.Emit the internal intermediate representation directly for Pass 2—no temporary macro-expanded file required. Verification / Alternative check:Practical assemblers (for example, many IBM mainframe and embedded toolchains) integrate macros into Pass 1 to reduce disk I/O and ensure that conditional assembly and expressions are evaluated with the assembler’s own expression evaluator, not a separate tool’s simplified logic. Why Other Options Are Wrong:Options A, B, C each capture true but partial benefits; the comprehensive answer is the combination.Option E is incorrect because significant advantages do exist. Common Pitfalls: Confusing macro expansion (compile-time) with subroutine calls (run-time). Assuming separate macro passes are always faster; extra file I/O can dominate. Overlooking that integrated expansion improves diagnostics and symbol handling. Final Answer:All of the above.

Question 3

Operating Systems: Process State Transitions  Which transition is typically initiated by the process itself (i.e., caused by its own action) in a standard process state model?

Accepted Answer

Introduction / Context:Process scheduling models describe how processes move among states such as running, ready, and blocked (waiting). Recognizing which transitions are self-initiated by a process versus those triggered by the scheduler or devices is essential in operating systems theory and practice. Given Data / Assumptions: States considered: running, ready, and blocked (waiting). Typical triggers: system calls, I/O operations, timer interrupts, and device completions. We focus on who triggers the transition: the process itself, the scheduler, or an external event. Concept / Approach:A process moves to the blocked (waiting) state by performing an operation that cannot complete immediately—commonly a synchronous I/O request, a sleep call, or waiting on a synchronization primitive. By contrast, dispatch, wake-up, and timer-driven preemption are not initiated by the process itself. Step-by-Step Solution:From running, the process issues a blocking call (e.g., read on a slow device or wait on a semaphore).The kernel places the process into the blocked queue associated with that event.Later, an external event (I/O completion or signal) triggers the wake-up, moving it to ready.The scheduler will eventually dispatch it back to running. Verification / Alternative check:Trace a system call like read on a disk file: the process cannot proceed until data arrives, so it voluntarily blocks. It does not self-dispatch, self-wake, or generate its own timer expiration. Why Other Options Are Wrong:Dispatch: performed by the scheduler, not by the process.Wake up: triggered by an external event or the kernel on behalf of a device.Timer run out: caused by a clock interrupt that preempts the process. Common Pitfalls: Confusing voluntary blocking with preemption. Assuming a process controls its dispatching; it does not. Thinking wake-up is initiated internally; it is event-driven. Final Answer:block.

Question 4

Thrashing in Virtual Memory  Which factors most significantly influence whether a system experiences thrashing (excessive paging) under demand-paged virtual memory?

Accepted Answer

Introduction / Context:Thrashing occurs when a system spends most of its time servicing page faults rather than executing useful work. Understanding the causes helps administrators and developers prevent severe performance collapse on multitasking systems. Given Data / Assumptions: Demand-paged virtual memory is in use. Multiple processes may compete for limited physical frames. Locality of reference varies by program structure and phase. Concept / Approach:Thrashing is governed by the working-set sizes of active processes versus the total available frames. Code/data structure (program structure), total footprint (program size), and physical memory capacity collectively determine whether working sets fit in RAM with acceptable fault rates. Step-by-Step Solution:Assess program structure: tight loops and cache-friendly access improve locality.Evaluate program size: larger footprints need more frames to avoid constant eviction.Examine RAM: insufficient frames force frequent page replacement, amplifying faults.Adjust multiprogramming level or allocate more frames to stabilize working sets. Verification / Alternative check:Monitoring page fault rates and residency per process typically reveals that increasing frames or reducing active processes drops fault rates sharply, confirming the interplay among structure, size, and RAM. Why Other Options Are Wrong:Selecting only one factor ignores the combined effect; all listed aspects materially contribute to thrashing risk. Common Pitfalls: Attributing thrashing solely to “insufficient RAM” while ignoring poor locality. Failing to consider phase changes in a program’s working set. Overcommitting memory by raising the degree of multiprogramming too high. Final Answer:All of the above.

Question 5

Mainframe Storage Formats: Partitioned Data Set (PDS)  On IBM mainframe-style systems, a Partitioned Data Set (PDS) is most commonly used for which purpose?

Accepted Answer

Introduction / Context:Legacy and modern IBM mainframe environments (such as MVS and z/OS) use several dataset types. The Partitioned Data Set (PDS) stores multiple related “members” under one cataloged dataset, making it ideal for source and load libraries. Given Data / Assumptions: PDS consists of a directory plus multiple members, each addressable by name. Common use cases include macro libraries, JCL libraries, and object/load libraries (PDS/E for extended features). Alternate dataset types handle sequential data or indexed access differently. Concept / Approach:PDS is optimized for storing many small related files (members) within a single dataset. Developers and system programmers use it for maintaining source code, macros, and executable modules that benefit from directory-based member access. Step-by-Step Solution:Identify the content to be stored (e.g., source members, macros, JCL).Create a PDS with a directory area sized for anticipated members.Add members and reference them by dataset(member) notation.Use utilities or ISPF/PDF to maintain members efficiently. Verification / Alternative check:Operational practices on z/OS store assembler macros in SYS1.MACLIB and procedures in SYS1.PROCLIB—both PDS or PDS/E libraries—confirming the “program/source library” role. Why Other Options Are Wrong:Option B: Large sequential runtime data typically uses PS or VSAM, not PDS.Option C: Backups use tape or specialized datasets, not PDS libraries.Option D: ISAM/VSAM provide indexed access; they are different structures. Common Pitfalls: Confusing PDS with VSAM datasets. Under-provisioning directory blocks, which later limits member additions. Final Answer:A program or source library containing many members.

Question 6

System Startup Loaders  When a computer is powered on or restarted, which special loader is executed automatically to bring the operating system into memory?

Accepted Answer

Introduction / Context:Bootstrapping is the process by which a bare machine starts executing the operating system. A small, non-volatile program—commonly in firmware—initializes hardware and loads the initial OS components. Given Data / Assumptions: On reset, the CPU begins at a predefined address in firmware (e.g., ROM/flash). This minimal program must locate and load the OS loader or kernel image from disk, flash, or network. Concept / Approach:The bootstrap loader (often shortened to “boot loader”) contains just enough logic to discover the boot device, read the next-stage loader or kernel, and transfer control. Classic examples include BIOS + MBR code, UEFI firmware, and boot managers like GRUB. Step-by-Step Solution:CPU resets and executes firmware entry point.Bootstrap initializes minimal hardware and locates a bootable volume.It loads the OS loader or kernel into RAM.Control transfers to the loaded image, which continues the startup sequence. Verification / Alternative check:Inspecting BIOS/UEFI settings shows boot order and confirms a tiny stage runs first to fetch the larger OS components. Why Other Options Are Wrong:“Compile and Go” is a development-time mechanism, not a startup loader.“Relocating loader” adjusts addresses when loading programs but is not inherently the power-on loader.Option B (Boot loader) is colloquially correct, but the traditional term in curricula is “Bootstrap loader.” Common Pitfalls: Confusing boot managers with the firmware’s initial bootstrap. Assuming the kernel is burned into ROM; many systems load it from storage. Final Answer:Bootstrap loader.

Question 7

Software Layers: Aids for Using Systems Software  Which type of software primarily simplifies a user’s interaction with systems software (for example, providing a graphical shell over the operating system)?

Accepted Answer

Introduction / Context:Systems software (operating systems, utilities, device drivers) can be complex. An intermediate layer—often called an operating environment—provides friendlier interfaces, shells, and tools that make system capabilities easier to access. Given Data / Assumptions: Users interact with the OS through command shells, GUIs, and frameworks. Productivity applications (e.g., spreadsheets) sit above this layer. Concept / Approach:An operating environment packages UI components, file managers, and configuration tools that mediate between users/apps and core OS services. Classic examples include early Windows versions over MS-DOS or graphical desktops atop Unix-like systems. Step-by-Step Solution:Identify the role: simplify and standardize access to OS functions.Recognize components: window managers, desktop shells, control panels.Differentiate from applications (spreadsheets) and OS features (timesharing, multitasking). Verification / Alternative check:Historical environments (e.g., Windows 3.x on DOS) confirm that an environment can sit atop a lower-level OS, adding usability without replacing kernel services. Why Other Options Are Wrong:Spreadsheet: an application, not a mediator to systems software.Timesharing/Multitasking: OS scheduling features, not user-facing environments. Common Pitfalls: Equating the operating environment with the kernel itself. Assuming all usability features reside in applications rather than the environment. Final Answer:Operating environment.

Question 8

CPU Scheduling Fundamentals  In operating systems, what is scheduling?

Accepted Answer

Introduction / Context:Scheduling is the heart of CPU resource management. It decides which ready process gets the CPU and for how long, directly affecting throughput, response time, and fairness. Given Data / Assumptions: There may be more ready processes than available CPUs. Scheduling policies reflect goals (interactive responsiveness, batch throughput, or deadlines). Concept / Approach:Scheduling selects the next process/thread to run from the ready queue. Policies range from simple round-robin to priority-based, multilevel feedback queues, or real-time algorithms (rate-monotonic, earliest-deadline-first). The chosen policy shapes performance and user experience. Step-by-Step Solution:Maintain a ready queue of runnable entities.Choose a candidate based on the policy (e.g., highest priority).Dispatch it to the CPU; on preemption or blocking, repeat. Verification / Alternative check:Metrics such as average waiting time, turnaround time, and response time change noticeably as policies change, confirming scheduling’s performance impact. Why Other Options Are Wrong:Unrelated to performance: false—policy choice dramatically affects performance.Not required in uniprocessors: false—even one CPU must decide which process runs next.Always identical: false—policies differ with system purpose (interactive vs. batch vs. real-time). Common Pitfalls: Assuming one “best” policy fits all workloads. Ignoring priority inversion and starvation without safeguards. Final Answer:Allowing jobs or processes to use the processor according to a defined policy.

Question 9

MS-DOS File Types: Object Files and Load Modules  In MS-DOS toolchains, what are the common extensions for relocatable object files and for load modules (executable images)?

Accepted Answer

Introduction / Context:Classic DOS development uses a compile–link workflow. Compilers/assemblers produce relocatable object files that a linker converts into loadable executables. Recognizing standard filename extensions helps identify build artifacts and deployment outputs. Given Data / Assumptions: Relocatable objects contain fixups and symbol information for the linker. Executable load modules are images the OS loader can run (.COM or .EXE under DOS). Concept / Approach:Assemblers/compilers emit .OBJ files. Linkers resolve symbols and relocations to produce .EXE (segmented) or .COM (simple, flat 64 KB) executables, both load modules for DOS. Step-by-Step Solution:Write source → assemble/compile → generate .OBJ.Link .OBJ plus libraries → produce .EXE or .COM.Run via DOS loader (COMMAND.COM) or shell. Verification / Alternative check:Tool manuals and historical DOS conventions document .OBJ as object and .EXE/.COM as executables, widely recognized across vendors (MASM, TASM, Microsoft C, Borland C, etc.). Why Other Options Are Wrong:B/C swap roles incorrectly.D uses a nonstandard .DAS extension. Common Pitfalls: Assuming .COM and .EXE are interchangeable—.COM is limited and lacks headers. Confusing object files (.OBJ) with libraries (.LIB) or debug symbol files (.MAP). Final Answer:.OBJ and .COM or .EXE, respectively.

Question 10

File Addressing Techniques  Which computational technique is commonly used to compute the storage address of a record in a direct-access file?

Accepted Answer

Introduction / Context:Direct-access file organizations and many database indexes use a transformation from a record key to a storage location. The core idea is to quickly compute where a record should reside without scanning the file sequentially. Given Data / Assumptions: A key value (e.g., account number) exists for each record. We desire average constant-time access to insert/find operations. Collisions may occur and must be resolved. Concept / Approach:Hashing applies a deterministic hash function to the key to produce a bucket or slot address. Techniques such as modulo arithmetic, multiplicative hashing, or stronger hash functions map the key space to storage locations. Collision resolution uses chaining or open addressing (linear/quadratic probing, double hashing). Step-by-Step Solution:Choose a hash function h(key) that distributes keys uniformly.Compute address = h(key) mod table_size (or bucket index).If occupied, apply collision strategy; otherwise place/find the record. Verification / Alternative check:Performance analysis shows average O(1) expected access with well-chosen hash functions and load factors, validating hashing as the standard technique for direct addressing in many systems. Why Other Options Are Wrong:Bubble memory: a storage technology, not an addressing technique.Key fielding: vague term; not the computational mapping method itself.Dynamic reallocation: concerns memory management, not computing addresses. Common Pitfalls: Poor hash function choice causing clustering. Ignoring load factor, which degrades performance. Final Answer:Hashing.

Question 11

Compiler Phases: “Creation of a More Optimal Matrix”  In the classical compilation pipeline for a PL/I program, the activity described as “creation of a more optimal matrix” is associated with which phase?

Accepted Answer

Introduction / Context:Compilers often translate source into an intermediate representation (IR) such as a graph or matrix-like structure (e.g., three-address code, quadruples). Improving this IR prior to target-specific steps is the domain of machine-independent optimizations. Given Data / Assumptions: Compilation stages include scanning, parsing (syntax analysis), semantic analysis, IR generation, optimization, and code generation. “More optimal matrix” refers to refining the IR (eliminating redundancies, improving data flow) before final code emission. Concept / Approach:Machine-independent optimization applies algebraic simplification, constant folding, common subexpression elimination, dead-code elimination, loop optimizations, and data-flow improvements on the IR. These changes are target-agnostic and aim to reduce work regardless of the eventual machine. Step-by-Step Solution:Generate IR from the parsed PL/I program.Analyze data/control flow to identify redundancies and opportunities.Apply optimizations (CSE, DCE, loop-invariant code motion, strength reduction).Produce a refined IR (the “more optimal matrix”) for the backend. Verification / Alternative check:Comparing pre- and post-optimization IR typically shows fewer operations and improved locality, and later code generation emits shorter, faster target code without altering program semantics. Why Other Options Are Wrong:Assembly/output and code generation are target-dependent phases following optimization.Syntax analysis builds parse trees; it does not optimize the IR. Common Pitfalls: Confusing machine-independent optimizations with machine-dependent peephole optimizations done after instruction selection. Believing optimization changes semantics; it must preserve behavior. Final Answer:Machine-independent optimization.

Question 12

Mainframe Job Control Language (JCL): Which function do JCL statements primarily serve in batch processing on IBM-style operating systems—specifically, what do they tell the operating system about the start and end of a job and its steps?

Accepted Answer

Introduction / Context:Job Control Language (JCL) is the command language used on IBM mainframe systems (such as MVS, z/OS) to describe batch jobs. Understanding what JCL statements actually do is essential for operations, scheduling, and batch troubleshooting in enterprise computing environments. Given Data / Assumptions: The context is batch processing on IBM-style systems. JCL statements accompany programs but are not the programs themselves. We are distinguishing between job description (JCL) and resource management (handled by OS subsystems). Concept / Approach:JCL does not execute business logic; it instructs the operating system how to run programs: when the job begins, where it ends, which job steps run, what datasets are allocated, and which parameters or procedures apply. While JCL can request resources, it does not itself “allocate the CPU”—the scheduler does that. Nor is JCL merely an input copy tool; it is a control script for batch execution. Step-by-Step Solution: Identify the core role of JCL: describe job boundaries and steps.Map to options: the statement about specifying beginning and end of a job matches JCL’s purpose.Eliminate CPU allocation (scheduler responsibility) and simple I/O copying (a job step task, not JCL’s primary role).Choose the option that reflects batch job demarcation and control. Verification / Alternative check:Basic JCL cards like JOB, EXEC, and DD define job start, program steps, and dataset usage, confirming that the language’s essential function is job specification and control. Why Other Options Are Wrong:Reading from card readers or disks is an application/utility function, not JCL’s essence. CPU allocation is an OS scheduling function. “All of the above” overstates JCL’s role. Common Pitfalls:Confusing JCL with the programs it invokes; assuming JCL “does” I/O or computation rather than directs them. Final Answer:Specify, to the operating system, the beginning and end of a job in a batch

Question 13

MS-DOS basics: After booting a DOS-based system, which command reports the operating system version currently running?

Accepted Answer

Introduction / Context:Identifying the precise operating system version is a first step in DOS troubleshooting and software compatibility checks. MS-DOS provides simple, built-in commands to reveal this information without third-party tools. Given Data / Assumptions: The user is at a DOS prompt after boot. They need the OS version, not disk layout or directory contents. Standard DOS internal commands are available. Concept / Approach:The DOS internal command VER (short for “version”) displays the current DOS version string. Other common commands serve unrelated purposes: DIR lists files, FORMAT prepares a disk, and DISK is not a standard DOS internal command for reporting OS version. Step-by-Step Solution: At the DOS prompt, type: VERPress Enter to display the version information (for example, “MS-DOS Version 6.22”).Confirm that the output matches the OS currently loaded.Use this version data for compatibility or configuration decisions. Verification / Alternative check:In some DOS derivatives or Windows command prompts, ver similarly returns the version of the environment. This cross-check reinforces the correctness of using VER. Why Other Options Are Wrong:FORMAT alters disks and does not report OS version. DIR lists directory contents only. DISK is not the correct command for this task. “None of the above” is invalid because VER is correct. Common Pitfalls:Running commands that change media (FORMAT) when you only need information; confusing DOS with Windows version reporting tools. Final Answer:VER

Question 14

System software vs. application software: Which of the following is not an applications (end-user) software category?

Accepted Answer

Introduction / Context:Differentiating system software from application software is foundational in computer science. Applications solve user tasks; system software manages and abstracts hardware and provides services for applications. Given Data / Assumptions: Word processors, spreadsheets, and DTP tools are classic end-user applications. UNIX is an operating system (system software), not an application. The question asks for the item that is not applications software. Concept / Approach:Applications are programs designed for users (document creation, calculations, publishing). Operating systems like UNIX (and Linux, Windows, macOS) are system software: they manage processes, memory, filesystems, and devices, enabling applications to run. Step-by-Step Solution: Classify each option by purpose: end-user task vs. system control.Word processing, spreadsheets, and desktop publishing clearly target end users.UNIX provides core services and is not an application.Select the non-application item: UNIX. Verification / Alternative check:Vendor and academic definitions consistently place operating systems under system software; application suites depend on the OS to execute. Why Other Options Are Wrong:Word processing, spreadsheets, and DTP are definitive examples of applications used for productivity. Common Pitfalls:Confusing terminal programs or shells with the OS; mistaking a distribution’s bundled apps for the OS itself. Final Answer:UNIX

Question 15

Classical mutual exclusion: Dekker’s algorithm guarantees mutual exclusion for how many processes that share a common critical section?

Accepted Answer

Introduction / Context:Dekker’s algorithm is a landmark software-only solution to mutual exclusion on a single processor with shared memory and no special atomic instructions. Knowing its scope and limitations is part of understanding concurrency primitives and their evolution. Given Data / Assumptions: No modern hardware atomic instructions (like test-and-set) are assumed. We are protecting a single critical section accessed by multiple processes. Dekker’s original algorithm targets two processes specifically. Concept / Approach:Dekker’s algorithm uses intent flags and a turn variable to ensure mutual exclusion, progress, and bounded waiting for exactly two processes. Extensions and other algorithms (Peterson’s, Lamport’s bakery algorithm) address two or many processes differently, but Dekker’s classic form is for two. Step-by-Step Solution: Recall the structure: two boolean flags desire[i] and turn variable.Both processes coordinate by setting desire flags and yielding based on the turn.The proof of correctness holds for two participants; it does not generalize as-is to three or more.Therefore, the answer is two processes. Verification / Alternative check:Standard operating systems and distributed computing texts categorize Dekker’s algorithm as the first two-process mutual exclusion algorithm; multi-process solutions use other techniques. Why Other Options Are Wrong:1 is trivial and does not describe mutual exclusion. 3 or 4 require different algorithms or significant redesign. “None of the above” is incorrect because two is correct. Common Pitfalls:Confusing Dekker’s with Peterson’s algorithm (also two-process) or Lamport’s bakery algorithm (many processes). Final Answer:2

Question 16

IBM System/370 assembler concepts: Which statement best describes a key assembler function related to base registers on System/370?

Accepted Answer

Introduction / Context:IBM System/360/370 assemblers use a base-displacement addressing model. Understanding how assemblers manage base registers is critical for writing and maintaining low-level code that addresses memory efficiently and relocatably. Given Data / Assumptions: The assembler supports USING/DROP directives to assign base registers to address ranges. Programmers use base-displacement forms in instructions. The question asks about the assembler’s role in tracking base registers. Concept / Approach:While programmers specify addressing forms, the assembler maintains a base register table derived from USING statements. This table records which general-purpose registers act as bases and the corresponding base addresses, enabling translation of symbolic references into correct displacements. Multitasking or multiple-program residence is an OS feature, not an assembler language property, and “control programs” refers to OS components, not the assembler itself. Step-by-Step Solution: Recognize that base register management is an assembler bookkeeping task.Associate USING directives with internal tables: register → base address.Identify the statement that describes this tracking responsibility.Exclude unrelated OS features (multiple programs in memory) and terminological confusion about control programs. Verification / Alternative check:Assembler manuals document the base register table and relocation assistance provided during assembly based on USING/DROP. Why Other Options Are Wrong:Explicit syntax (option A) is true in practice, but the distinctive assembler function is the tracking of base registers (option B). Options C and D concern operating system behavior, not assembler responsibilities. Common Pitfalls:Assuming the OS, not the assembler, resolves addressability issues; or conflating base management with runtime register contents. Final Answer:Keeps track of which general-purpose registers are available as base registers and what base addresses they contain.

Question 17

Language translation pipeline: A program that converts a high-level language source program into executable machine instructions is called what?

Accepted Answer

Introduction / Context:Software development involves editing code, compiling it, linking, and testing. Distinguishing the roles of a compiler, debugger, and editor is essential for understanding the toolchain and diagnosing build problems. Given Data / Assumptions: Source code is written in a high-level language (C, C++, Java, etc.). The target is machine instructions or an intermediate form executable by the system. We need the tool that performs translation from source to target code. Concept / Approach:A compiler translates high-level language into machine code or an intermediate representation, possibly producing object files for later linking. A debugger inspects and controls program execution to find defects. An editor enables creation and modification of text source files but does not translate them. Step-by-Step Solution: Identify the translation task: high-level → machine instructions.Map to the tool named “compiler.”Eliminate debugger and editor, which perform different roles.Reject “All of the above.” Verification / Alternative check:Build systems call compilers (and assemblers/linkers) to produce executables; debuggers attach after the program is built. Why Other Options Are Wrong:Debugger inspects runtime behavior; editor edits text; “all” is incorrect because only the compiler does translation. Common Pitfalls:Confusing integrated IDE actions with individual tool responsibilities. Final Answer:Compiler

Question 18

Compiler phases (PL/I example): In the compilation process, the step described as “resolving symbolic addresses (labels) and generating machine language” corresponds to which phase?

Accepted Answer

Introduction / Context:Compilers proceed through well-defined phases, from lexical and syntax analysis to code generation and assembly. Understanding which phase resolves symbolic labels and emits final machine code clarifies how human-readable names become concrete addresses. Given Data / Assumptions: We are compiling a high-level language (PL/I) down to executable code. Symbolic labels (procedure and branch targets) must be mapped to addresses. Final machine instructions are emitted after address resolution. Concept / Approach:Code generation emits target instruction templates and symbolic references. The assembly/output stage then resolves remaining symbolic addresses (labels) and encodes final opcodes, displacements, and addresses, producing object code suitable for linking and loading. Storage assignment concerns layout of variables; syntax analysis builds parse trees but does not produce machine code. Step-by-Step Solution: Recognize that “resolving labels” is traditionally an assembler function.Map “generating machine language” to the final emission step.Identify the combined phase as “assembly and output.”Exclude code generation alone, which may still reference symbols to be fixed later. Verification / Alternative check:Toolchains often split codegen and assembly; many modern compilers still emit assembly or object with relocations resolved by an assembler/linker. Why Other Options Are Wrong:Code generation templates instructions but may not resolve all symbols. Storage assignment handles memory layout. Syntax analysis parses grammar only. Common Pitfalls:Conflating code generation with final address resolution; forgetting that link-time or assembly-time fixups complete the mapping. Final Answer:Assembly and output

Question 19

Operating system capability: If you want to run more than one program seemingly at the same time on a single system, which systems software capability is required?

Accepted Answer

Introduction / Context:Modern operating systems allow users to run multiple programs concurrently. Recognizing the OS feature that enables this behavior is essential for understanding scheduling, responsiveness, and system throughput. Given Data / Assumptions: Single machine running multiple processes. Time-sharing of CPU among tasks. We are not focusing on memory extension techniques or compilers. Concept / Approach:Multitasking allows the OS scheduler to interleave CPU time across processes or threads, giving the illusion of simultaneous execution on single-CPU systems (or true parallelism on multi-core systems). Virtual memory extends address space; compiling transforms code; word processing is an application, not a system capability. Step-by-Step Solution: Identify the requirement: multiple programs at once.Map to OS functionality: task creation, context switching, scheduling.Select “multitasking.”Reject unrelated options (applications or memory abstraction alone). Verification / Alternative check:Process lists (e.g., Task Manager, ps/top) show many tasks running—evidence of multitasking. Why Other Options Are Wrong:Virtual memory addresses space limits; compiling builds programs; word processing is just an app. Common Pitfalls:Assuming virtual memory implies multitasking; they address different OS concerns. Final Answer:multitasking

Question 20

Memory management truths: Identify the statement that is not correct about common memory-management schemes (virtual memory, paging, segmentation).

Accepted Answer

Introduction / Context:Operating systems use paging, segmentation, and virtual memory to manage limited physical RAM. Recognizing which statements are valid helps clarify performance trade-offs and design choices in OS memory subsystems. Given Data / Assumptions: Virtual memory abstracts large address spaces; it is used widely. Paging splits memory into fixed-size pages/frames. Segmentation splits memory into variable-sized logical segments. Concept / Approach:Segmentation experiences external fragmentation because variable-sized segments leave gaps between allocations. Paging can have internal fragmentation because the last page of a process may be partially unused. Virtual memory is not limited to multi-user systems; it is common in single-user desktops and mobile devices. Systems can combine segmentation and paging (e.g., segmented virtual memory paged to frames). Step-by-Step Solution: Evaluate each statement against OS theory.Confirm B (true): segmentation → external fragmentation.Confirm C (true): paging → internal fragmentation within pages.Confirm D (true): some designs page segmented spaces.Identify A as false: virtual memory also exists in single-user systems, so “only in multi-user” is incorrect. Verification / Alternative check:Consumer OSes (Windows, macOS, Linux) use virtual memory regardless of single vs. multi-user usage. Why Other Options Are Wrong:Options B, C, and D are standard textbook truths; marking them false contradicts established OS behavior. Common Pitfalls:Assuming “multi-user” implies the necessity for virtual memory; in reality, it addresses address-space abstraction and overcommit independent of user count. Final Answer:virtual memory is used only in multi-user systems

Operating Systems Concepts Questions

Questions

Practice smarter