UGC NET Computer Science System Software and Operating System Syllabus

System Software and Operating System syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for System Software and Operating System in UGC NET Computer Science, not a summary of it.

1. 1

   System Software

   4 topics

   • Machine, Assembly and High-Level Languages
   • Compilers and Interpreters
   • Loading, Linking and Relocation
   • Macros, Debuggers
2. 2

   Basics of Operating Systems

   5 topics

   • Operating System Structure
   • Operations and Services
   • System Calls
   • Operating-System Design and Implementation
   • System Boot
3. 3

   Process Management

   8 topics

   • Process Scheduling and Operations
   • Interprocess Communication
   • Communication in Client–Server Systems
   • Process Synchronization
   • Critical-Section Problem
   • Peterson’s Solution
   • Semaphores
   • Synchronization
4. 4

   Threads

   5 topics

   • Multicore Programming
   • Multithreading Models
   • Thread Libraries
   • Implicit Threading
   • Threading Issues
5. 5

   CPU Scheduling

   4 topics

   • Scheduling Criteria and Algorithms
   • Thread Scheduling
   • Multiple-Processor Scheduling
   • Real-Time CPU Scheduling
6. 6

   Deadlocks

   5 topics

   • Deadlock Characterization
   • Methods for Handling Deadlocks
   • Deadlock Prevention
   • Avoidance and Detection
   • Recovery from Deadlock
7. 7

   Memory Management

   9 topics

   • Contiguous Memory Allocation
   • Swapping
   • Paging
   • Segmentation
   • Demand Paging
   • Page Replacement
   • Allocation of Frames
   • Thrashing
   • Memory-Mapped Files
8. 8

   Storage Management

   4 topics

   • Mass-Storage Structure
   • Disk Structure
   • Scheduling and Management
   • RAID Structure
9. 9

   File and Input/Output Systems

   14 topics

   • Access Methods
   • Directory and Disk Structure
   • File-System Mounting
   • File Sharing
   • File-System Structure and Implementation
   • Directory Implementation
   • Allocation Methods
   • Free-Space Management
   • Efficiency and Performance
   • Recovery
   • I/O Hardware
   • Application I/O Interface
   • Kernel I/O Subsystem
   • Transforming I/O Requests to Hardware Operations
10. 10

    Security

    9 topics

    • Protection
    • Access Matrix
    • Access Control
    • Revocation of Access Rights
    • Program Threats
    • System and Network Threats
    • Cryptography as a Security Tool
    • User Authentication
    • Implementing Security Defenses
11. 11

    Virtual Machines

    2 topics

    • Types of Virtual Machines and Implementations
    • Virtualization
12. 12

    Linux Operating Systems

    9 topics

    • Design Principles
    • Kernel Modules
    • Process Management
    • Scheduling
    • Memory Management
    • File Systems
    • Input and Output
    • Interprocess Communication
    • Network Structure
13. 13

    Windows Operating Systems

    5 topics

    • Design Principles
    • System Components
    • Terminal Services and Fast User Switching
    • File System
    • Networking
14. 14

    Distributed Systems

    6 topics

    • Types of Network based Operating Systems
    • Network Structure
    • Communication Structure and Protocols
    • Robustness
    • Design Issues
    • Distributed File Systems

System Software and Operating System flashcards for UGC NET Computer Science

20 of 51 cards from the System Software and Operating System deck — real questions with worked answers.

1. What is the difference between a compiler and an interpreter?

   A compiler translates the entire source program into machine/object code in one pass before execution, producing a separate executable; an interpreter translates and executes the source program statement-by-statement at runtime without producing a separate object file. Compilers give faster execution; interpreters give easier debugging and portability.

2. What is an assembler, and what is the difference between a one-pass and a two-pass assembler?

   An assembler translates assembly language into machine code. A one-pass assembler processes the source once and handles forward references with back-patching; a two-pass assembler uses pass 1 to build the symbol table (assigning addresses) and pass 2 to generate the object code.

3. In system software, distinguish loading, linking, and relocation.

   Loading places a program's object code into memory for execution. Linking combines multiple object modules and resolves external symbol references into one executable. Relocation adjusts address-dependent locations (code/data references) so the program runs correctly at its actual load address.

4. What is the difference between static linking and dynamic linking?

   Static linking copies all referenced library code into the executable at link time, producing a larger self-contained file. Dynamic linking defers resolution to load/run time, sharing one copy of the library (e.g., DLL/.so) among processes, saving memory and allowing library updates without relinking.

5. What is a macro, and how does macro expansion differ from a subroutine call?

   A macro is a named sequence of instructions that the macro processor textually expands inline wherever the macro is invoked (before assembly/compilation). Unlike a subroutine call, there is no transfer of control or stack overhead at runtime—the code is duplicated at each invocation site.

6. List the major phases of a compiler in order.

   Lexical analysis (scanner), syntax analysis (parser), semantic analysis, intermediate code generation, code optimization, and code generation. Symbol-table management and error handling span all phases.

7. What is a system call, and how does it transfer control to the OS?

   A system call is the programmatic interface through which a user process requests a service from the OS kernel (e.g., read, write, fork). It triggers a software interrupt/trap that switches the CPU from user mode to kernel mode, runs the kernel routine, then returns to user mode.

8. Name the main categories of services an operating system provides.

   User-helpful services: program execution, I/O operations, file-system manipulation, communication, error detection, and user interface. System-efficiency services: resource allocation, accounting, and protection and security.

9. Describe what happens during system boot.

   On power-up, firmware (BIOS/UEFI) runs POST and executes the bootstrap program stored in firmware/boot block. The bootstrap (or a boot loader like GRUB) locates the OS kernel on disk, loads it into memory, and transfers control to it; the kernel then initializes devices and starts the first process (init/systemd).

10. Define the five process states in the standard process state model.

    New (being created), Ready (waiting for CPU), Running (instructions being executed), Waiting/Blocked (waiting for an event/I/O), and Terminated (finished execution).

11. What information does a Process Control Block (PCB) contain?

    Process state, program counter, CPU registers, CPU-scheduling info (priority), memory-management info (page/segment tables), accounting info, I/O status info, and the process ID.

12. Compare the two fundamental models of interprocess communication (IPC).

    Shared memory: processes share a region of memory; fast after setup, communication handled by the processes themselves; risk of synchronization issues. Message passing: processes exchange messages via send/receive primitives; easier in distributed systems, slower due to kernel involvement, no shared address space needed.

13. In client–server communication, what are sockets, RPC, and pipes?

    A socket is an endpoint for communication identified by IP address + port. RPC (Remote Procedure Call) lets a program invoke a procedure on a remote host as if local, using stubs and marshalling. Pipes provide a conduit for communication (ordinary/named pipes) typically between processes on the same machine.

14. State the three requirements that any solution to the critical-section problem must satisfy.

    Mutual exclusion (only one process in its critical section at a time), Progress (only processes not in their remainder section participate in deciding who enters next, and the decision is not postponed indefinitely), and Bounded waiting (a limit exists on how many times others enter before a waiting process is granted entry).

15. Explain Peterson's solution to the critical-section problem.

    A software solution for two processes using two shared variables: flag[2] (intent to enter) and turn (whose turn it is). A process sets its flag true and turn to the other, then waits while the other's flag is true and it is the other's turn. It guarantees mutual exclusion, progress, and bounded waiting (assuming no instruction reordering).

16. What is a semaphore, and what are its two atomic operations?

    A semaphore is an integer synchronization variable accessed only through two atomic operations: wait() / P() / down() (decrements; blocks if value < 0) and signal() / V() / up() (increments; wakes a waiting process). A counting semaphore ranges over an unrestricted domain; a binary semaphore (mutex) is restricted to 0/1.

17. Differentiate a binary semaphore (mutex) from a counting semaphore.

    A binary semaphore takes only values 0 and 1 and is used for mutual exclusion over a single resource. A counting semaphore can take any non-negative integer and is used to control access to a resource with multiple identical instances (its value reflects the number available).

18. What is multicore programming and what challenge does it address?

    Multicore programming is designing software to use multiple processing cores on a single chip for true parallel execution. Challenges include identifying parallel tasks, balancing load, splitting data, handling data dependencies, and testing/debugging concurrent code (per Amdahl's law, speedup is limited by the serial fraction).

19. Compare the many-to-one, one-to-one, and many-to-many multithreading models.

    Many-to-one: many user threads mapped to one kernel thread (no true parallelism; one blocking call blocks all). One-to-one: each user thread maps to a kernel thread (true concurrency but overhead per thread). Many-to-many: many user threads multiplexed onto a smaller-or-equal number of kernel threads (flexible, concurrent, scalable).

20. What is a thread library, and name common examples.

    A thread library provides the API for creating and managing threads. Examples: POSIX Pthreads (user- or kernel-level), Windows threads (kernel-level), and Java threads (managed by the JVM). It can be implemented entirely in user space or with kernel support.

See more System Software and Operating System flashcards →

Planning System Software and Operating System for UGC NET Computer Science

System Software and Operating System (UGC NET Computer Science) FAQ