NCEAC Syllabus Operating System Concepts

1. History and evolution of operating systems.

2. Types of operating systems.
3. Case histories of significant operating systems.
4. Processes, inter-process communication, process co-ordination and synchronization.
5. Process scheduling.
6. Memory management.
7. File systems.
8. Security and protection.
9. Case operating systems.

Introduction: Operating System is system software that works as an interface between

user and hardware.

If there will be no Operating System, then if user wants to access a particular hardware, he
always has to write a program to access that hardware. He has to write different programs for
different devices again and again.

1. History and evolution of operating systems:

The history and evolution of operating systems (OS) is a fascinating journey that reflects the
development of computer technology and user needs over time. Here’s a brief overview of key
phases in their evolution:
1. Early Days: Single-Tasking and Batch Processing (1950s-1960s)

 Mainframes and Early Computers: The first computers didn’t have operating systems
as we know them today. Operators had to physically manage hardware using such as
punched cards.
 Batch Systems: Early operating systems were simple batch processing systems where
jobs (programs) were executed sequentially. The system would load a program, run it,
and then load the next program. Early OS examples include IBM's FORTRAN Monitor
System (FMS) and Input/ Output Control System (IOCS).
 Key Development: The transition to batch processing automated the job switching
process and improved efficiency.

2. Multi-Programming and Time-Sharing Systems (1960s-1970s)

 Multi-Programming: Allowed multiple jobs to be loaded in memory and managed by

the OS, improving resource utilization. The system could switch between programs,
enabling better CPU efficiency.
 Time-Sharing: Systems like Compatible Time-Sharing System (CTSS) and
MULTICS allowed multiple users to interact with the computer simultaneously by
sharing processor time. This led to the development of terminals and command-line
interfaces.
 UNIX (1969): Developed at AT&T Bell Labs, UNIX was a powerful, multi-user
operating system. It introduced key concepts like hierarchical file systems, multi-tasking,
and portability across hardware. It also laid the foundation for many modern OS.

3. Personal Computing Era (1970s-1980s)

 CP/M (Control Program for Microcomputers, 1974): One of the first OS for personal
computers. It was designed for Intel 8080/8085 microprocessor-based systems.
 MS-DOS (1981): Created by Microsoft for IBM PCs, MS-DOS became highly popular
as personal computers started gaining widespread use. It was a simple command-line OS
that laid the foundation for future Microsoft OS.
 Macintosh System Software (1984): Apple’s Macintosh computers introduced a
graphical user interface (GUI) with the Mac OS. It was user-friendly, with windows,
icons, and menus.

4. The Rise of GUIs (1980s-1990s)

 Microsoft Windows: To compete with Apple, Microsoft developed Windows, initially

as a GUI for MS-DOS. By Windows 95, it became a full-fledged operating system with a
user-friendly interface.
 AmigaOS and Atari TOS: These OS for home computers also contributed to the growth
of GUIs during this period.
 Linux (1991): A UNIX-like operating system, Linux, was developed by Linus Torvalds.
It became popular due to its open-source nature, flexibility, and the large community-
driven development model.
5. Networking and Internet Era (1990s-Present)

 Windows NT (1993): Microsoft introduced Windows NT for businesses, with a more

stable architecture suited for networked environments.
 Mac OS X (2001): Apple released Mac OS X, based on UNIX, combining a strong core
with a sleek GUI. It became the foundation for all modern macOS versions.
 Modern Linux Distributions: Linux became more user-friendly with distributions like
Ubuntu, and is used widely in servers, embedded systems, and desktops.
 Mobile OS: The rise of smartphones led to specialized operating systems like iOS (2007)
and Android (2008), both of which dominate the mobile space today.

6. Cloud and Virtualization (2000s-Present)

 Virtualization: Modern systems can run multiple OSes on the same hardware through
virtualization software like VMware, Hyper-V, and KVM.
 Cloud-Based OS: As cloud computing grew, cloud-based OSes like Google’s Chrome
OS emerged, emphasizing lightweight, web-based interactions.

7. Modern Trends

 Security and Privacy: Modern OSes focus heavily on security, with features like built-in
encryption (e.g., BitLocker in Windows), biometric authentication, and sandboxing.
 AI and Automation: Integration of AI, voice assistants (e.g., Cortana, Siri), and
automated workflows is a key trend in operating systems today.
 Containerization: Technologies like Docker and Kubernetes represent a shift toward
lightweight OS instances that run isolated applications, crucial for modern cloud and
DevOps environments.

Summary

Operating systems have evolved from simple batch processing systems to complex, multi-user,
networked environments that power everything from personal computers to mobile devices and
large-scale cloud infrastructures. Key milestones like UNIX, MS-DOS, Windows, and Linux
have shaped the OS landscape, with modern systems focusing on security, flexibility, and
integration with the web and AI-driven technologies.

2. Types of operating systems:

Operating systems (OS) come in various types based on their functionality, design, and use
cases. Below are the major types of operating systems:

1. Batch Processing System

 Functionality: Batch Processing System does not interact with the user directly. Instead,
the user prepares a job (a program or task), submits it to the computer, and waits for the
 output. Multiple jobs are batched together and executed sequentially, without user
intervention during execution.
 Examples: Early IBM systems (like IBM 1401) used batch processing systems.
 Use Case: Suitable for tasks that do not require immediate feedback, such as large-scale
data processing (e.g., payroll processing).

2. Time-Sharing Operating System

 Functionality: A time-sharing OS allows multiple users to use the system simultaneously

by providing each user with a slice of time on the CPU. It creates the illusion of
parallelism by switching between tasks very quickly.
 Examples: UNIX, MULTICS, and CTSS (Compatible Time-Sharing System).
 Use Case: Used in environments where multiple users need to access resources at the
same time, such as educational institutions, research centers, and public computer
terminals.

3. Distributed Operating System

 Functionality: A distributed OS manages a group of independent computers and makes

them appear as a single system to the user. It distributes tasks among multiple machines,
sharing the workload to improve performance and reliability.
 Examples: Plan 9 from Bell Labs, Amoeba, and some versions of Linux configured for
distributed computing.
 Use Case: Ideal for networked environments where multiple computers are linked to
share processing power, such as cloud computing environments and large server farms.

4. Real-Time Operating System (RTOS)

 Functionality: An RTOS is designed to handle tasks with strict timing constraints. It

guarantees that critical operations will be completed within a defined time period, making
it suitable for systems where timely responses are crucial.
 Types:
o Hard RTOS: Systems that must meet strict deadlines (e.g., aerospace, medical
devices).
o Soft RTOS: Systems where timing is important but not critical (e.g., multimedia
systems).
 Examples: VxWorks, RTLinux, QNX, FreeRTOS.
 Use Case: Used in embedded systems, medical devices, robotics, and industrial control
systems where reliability and precision are critical.

5. Network Operating System (NOS)

 Functionality: A network operating system provides services to computers connected

over a network. It enables file sharing, printer access, communication, and data security
across a network.
  Examples: Novell NetWare, Windows Server, Linux-based NOS (e.g., Samba on
Linux).
 Use Case: Common in local area networks (LANs) and larger organizational
infrastructures where shared resources are managed and accessed via a network.

6. Embedded Operating System

 Functionality: An embedded OS is designed to run on small devices with limited

hardware resources. It is often found in specialized systems and is optimized for
efficiency, with minimal user interaction.
 Examples: Embedded Linux, FreeRTOS, eCos, VxWorks.
 Use Case: Embedded OSes are used in devices like smartwatches, washing machines,
ATMs, GPS systems, and other appliances where computing is required but on a limited
scale.

7. Mobile Operating System

 Functionality: A mobile OS is specifically designed for mobile devices such as

smartphones, tablets, and wearable devices. These systems are optimized for touch
interfaces, power efficiency, and connectivity.
 Examples: iOS, Android, Windows Phone, BlackBerry OS.
 Use Case: Used in smartphones, tablets, and other portable computing devices.

8. Multiprocessing Operating System

 Functionality: A multiprocessing OS supports multiple CPUs (central processing units)

and can execute multiple processes simultaneously. This increases processing power and
speed for complex tasks.
 Examples: Linux, Windows, IBM AIX.
 Use Case: Often used in high-performance computing, servers, and data centers where
large volumes of data need to be processed concurrently.

9. Multitasking Operating System

 Functionality: A multitasking OS allows more than one task (program) to be executed

concurrently by dividing CPU time between processes. There are two types:
o Preemptive Multitasking: The OS controls the CPU and decides when to switch
between tasks (e.g., Windows, Linux).
o Cooperative Multitasking: The running program controls the CPU and must
voluntarily yield control to other programs (e.g., older versions of Mac OS).
 Examples: Windows, macOS, Linux, UNIX.
 Use Case: Commonly used in general-purpose computing where users run multiple
applications simultaneously.

10. Single-User Operating System

  Functionality: A single-user OS is designed to manage one user at a time, although it can
still handle multiple applications or processes. It focuses on serving a single user’s
computing needs.
 Examples: MS-DOS, Windows 98, Mac OS Classic.
 Use Case: Primarily used in personal computing environments where only one user
interacts with the system at a time.

11. Multi-User Operating System

 Functionality: A multi-user OS allows multiple users to access the system

simultaneously. It manages the resources (CPU, memory, and storage) to ensure that
multiple users can run programs concurrently without conflict.
 Examples: UNIX, Linux, Windows Server, VMS (Virtual Memory System).
 Use Case: Found in environments like mainframes, servers, and supercomputers where
many users access the system simultaneously.

12. Graphical User Interface (GUI) vs. Command-Line Interface (CLI)

 GUI OS: Systems that provide a graphical interface where users interact with the OS
using windows, icons, and menus (e.g., Windows, macOS).
 CLI OS: Systems where users interact using text-based commands (e.g., MS-DOS,
Linux command-line).

Summary

Operating systems can be broadly classified based on how they handle tasks (e.g., multitasking,
multiprocessing), their target platform (e.g., embedded, mobile), and the type of interface they
provide (e.g., GUI vs. CLI). Each type of OS is tailored to specific use cases, ranging from
personal computing to real-time industrial systems.