BCS401 Operating System Semester IV · AY 2025-26 onward
Unit 1 · Introduction & OS Structure

Lecture 2: OS services: user view vs system view

Back to contents ← Previous Next →

Learning outcomes

  • Differentiate between the user perspective and system perspective of operating system services.

Prerequisites

-- What an Operating System (OS) is and why it exists (basic idea: OS sits between user/apps and hardware). -- Basic computer resources: CPU, memory, storage, and input/output (I/O) devices. -- Basic idea of a “program” and a “process” (a program running).

Lecture Notes

Main content

Lecture 2: Operating-System Services — User View vs System View

In OS study, the same system can be described from two angles: (1) user view and (2) system view. These views help us understand why an OS provides certain services and how it actually delivers them.

1) What “User View” Means

From the user’s perspective, the OS is mainly judged by: ease of use (simple interface, quick response), plus reasonable performance and security. Typical single-user PCs/laptops focus on maximizing the user’s work (or play). Mobile devices often use touch and even voice interfaces.

Key idea (User View)

  • “Make it convenient.” Give me a friendly interface and predictable behavior.
  • “Help me run apps.” Let me open, save, print, share, and connect without thinking about hardware details.

2) What “System View” Means

From the system’s perspective, the OS is the software closest to hardware. In this view, the OS is: a resource allocator (decides how CPU time, memory, storage, and devices are allocated) and also a control program (controls execution to prevent errors and improper use, especially around I/O devices).

Key idea (System View)

  • “Share resources efficiently and fairly.”
  • “Control access.” Keep the system correct, consistent, and protected.

3) Operating-System Services: The Big Picture

An operating system provides an environment to execute programs and makes services available to programs and users. We can study OS structure from multiple vantage points: services provided, interfaces for users/programmers, and internal components.

A common “service view” includes the following major OS service classes:

  • User interface (CLI / GUI / touch)
  • Program execution
  • I/O operations
  • File-system manipulation
  • Communications (between processes)
  • Error detection
  • Resource allocation
  • Accounting / logging
  • Protection and security

4) User View vs System View of OS Services (Service-by-Service)

OS Service User View (What you experience) System View (What OS must do internally)
User Interface You interact through a command-line (shell), GUI (windows/icons/menus), or touch interface. OS supports interface programs (shell/desktop), accepts input events, and converts requests into system calls that trigger kernel services.
Program Execution “I clicked an app / ran a command — it starts and later exits.” OS must load the program into memory, run it, and handle normal/abnormal termination.
I/O Operations You read keyboard input, write to screen, print documents, use USB/network—everything “just works.” Users can’t usually control devices directly (for efficiency/protection), so OS provides controlled I/O through drivers, buffering, and safe interfaces.
File-System Manipulation Create/open/read/write/delete files & folders; view file info; set permissions. OS manages file structures, directories, metadata, and enforces access rules (ownership/permissions).
Communications Apps “talk” locally (browser ↔ server process) or over network (chat, web, cloud). OS supports process communication using shared memory or message passing, including networking support.
Error Detection You expect stable behavior: meaningful error messages, retries, or safe shutdowns (not random crashes). OS must detect and respond to errors in CPU/memory, I/O devices, and programs; may terminate a process, return error codes, retry, or halt if necessary.
Resource Allocation You expect fairness: multiple apps run together without one “hogging” everything. OS decides allocation of CPU cycles, memory, storage, and devices; scheduling routines consider CPU speed, workload, number of cores, etc.
Accounting / Logging You can see usage: battery/app usage, storage usage, CPU/memory stats, per-user limits in labs/servers. OS tracks which programs/users consume which resources; records may be used for billing or for usage statistics to improve system configuration.
Protection & Security Login, permissions, privacy, app isolation—your data should remain safe from other users/apps. OS enforces isolation and access control so programs/users cannot improperly access others’ resources; supports safe sharing and controlled privilege.

5) Mini-focus: “User Interface” as a Service (CLI vs GUI vs Touch)

Command-Line Interface (CLI) / Shell

In many systems, a command interpreter (shell) reads user commands and executes them. For example, a delete command like rm file.txt works by locating the program rm, loading it into memory, and executing it with the parameter file.txt.

Graphical User Interface (GUI)

In a GUI, users interact using windows, icons, and menus (desktop metaphor). Clicking an icon can invoke a program; selecting a file/folder triggers OS services behind the scenes.

Touch / Mobile Interfaces

Touch screens and voice interfaces are common on mobile devices, where interaction happens via taps, swipes, and speech—yet the same OS service idea remains: user actions become OS requests.

6) Quick Differentiation (Exam-friendly)

  • User view asks: “What services do I get, and how easy is it to use?”
  • System view asks: “How are CPU/memory/devices controlled and shared safely and efficiently?”
  • Same service, two meanings: User sees “Open file”; system sees file metadata + permissions + disk I/O + caching + error handling.

Worked Example

Worked Example: Deleting a File using CLI — User View vs System View

A) User View

  1. You open a terminal.
  2. You type: rm file.txt and press Enter.
  3. The file disappears from the directory listing.

B) System View (What the OS must do)

  1. Command interpreter (shell) reads your command and identifies the program to run (rm).
  2. The OS loads and executes the rm program, passing file.txt as an argument.
  3. rm requests file deletion via OS mechanisms (system calls).
  4. The OS checks permissions (are you allowed to delete it?).
  5. The file system updates directory entries/metadata and reclaims storage (free space management).
  6. If something goes wrong (file not found, permission denied, disk error), OS returns an error and the command prints a message.

One-Page Summary

One-Page Summary: OS Services — User View vs System View

Core Definitions

  • User View: OS is designed for ease of use, with attention to performance and security; often not focused on resource utilization (especially single-user systems).
  • System View: OS is a resource allocator and control program that manages CPU, memory, storage, and I/O devices efficiently and fairly.

Standard OS Service Classes

  • User interface (CLI/GUI/touch)
  • Program execution
  • I/O operations
  • File-system manipulation
  • Communications
  • Error detection
  • Resource allocation
  • Accounting / logging
  • Protection and security

Fast Recall (1 line each)

  • User interface: how humans/apps request OS work.
  • Program execution: load → run → terminate.
  • I/O: safe controlled access to devices.
  • Files: create/read/write/delete + permissions.
  • Communication: shared memory or message passing.
  • Error detection: detect + correct/contain failures.
  • Allocation: decide who gets CPU/memory/devices.
  • Logging/accounting: record resource usage for stats/billing/tuning.
  • Protection/security: isolation + access control.

Important

User view emphasizes convenience and interface, while system view emphasizes resource allocation and control to ensure correct, efficient, and fair operation.