Operating Systems: History, UNIX/Linux, and Modern Architecture

History of Operating Systems

• Overview: OS history traces evolution from no OS to modern multitasking, multiuser, networked, and distributed systems. Key milestones include batch processing, timesharing, multiprogramming, real-time needs, personal computers, and open vs closed architectures.

• Early history (1940s–1950s)

  • 1940s: Early computers did not include operating systems. Projects ran programs directly on hardware.
  • 1950s: Execution of one job at a time. Technologies were developed to smooth transitions from one job to the next. Emergence of single-stream batch-processing systems.
  • Programs and data submitted consecutively on tape.

• The 1960s

  • Predominantly batch-processing systems; turnaround time reduced to minutes or seconds.
  • Multiprogramming: run multiple jobs at once; one job could use the processor while others used peripheral devices.
  • Timesharing: developed to service multiple interactive users.
  • Real-time systems: aimed to respond within a bounded time period.
  • 1964: IBM announced the System/360 family of mainframe computers.
  • 1960s projects: CTSS (Compatible Time-Sharing System) at MIT introduced time sharing.

• CTSS and Multics (1960s)

  • CTSS: one of the first time-sharing OSs, demonstrated in 1961, operated at MIT until 1973.
  • CTSS used a modified IBM 7094 mainframe.
  • Louis Pouzin created RUNCOM for CTSS to execute a list of commands from a file.
  • 1964: MIT, GE, Bell Labs started the Multics project; Multics was a commercial OS based on CTSS; last working copy shut down on 31 Oct 2000.

• The 1970s

  • Primarily multimode timesharing systems supporting batch, timesharing, and real-time apps.
  • Personal computing began to emerge due to microprocessor tech.
  • Networking developments: DoD develops TCP/IP (standard protocol); PARC (Xerox) develops Ethernet.
  • Security concerns rise with growing information over vulnerable networks; encryption starts to play a role.

• The 1980s

  • Rise of personal computers and workstations; computing distributed to the sites where needed.
  • IBM PC released in $1981$.
  • GUIs popularized: mouse-driven interfaces; GUI concepts developed at PARC for the Xerox Alto.
  • Apple releases the Macintosh in $1984$; GUI embedded in OS.
  • Networking becomes economical and practical for data transfer between machines.
  • Client/server computing model becomes widespread; clients request services, servers provide them.
  • Software engineering emphasizes code reusability, abstraction, and multi-threading.

• The 1990s

  • Hardware performance grows exponentially; inexpensive processing power enables large, complex programs on PCs.
  • Shift toward distributed computing: multiple independent computers perform a common task.
  • OSs become standard for networking tasks: file sharing, client-server architectures.
  • Notable OS examples: Windows NT, Solaris, Linux.
  • Windows 3.0 released in $1990$; many concepts from early MacOS influence Windows.
  • Object technology rises: C++, Java; OOOS concepts emerge where OS components use objects, inheritance, and interfaces to improve modularity.

• Open source and software practices (1990s)

  • Most commercial software sold as object code; source code often not included.
  • Free and open-source software grows in prominence; Open Source Initiative (OSI) founded to promote open-source benefits.
  • Richard Stallman launches the GNU project (1980s) to recreate and extend tools for AT&T UNIX; advocates free software and permissive licensing.

• User friendliness and plug-and-play (1990s)

  • GUIs become mainstream; plug-and-play capabilities allow dynamic hardware changes without manual OS reconfiguration.

• UNIX and UNIX-like systems: origins and lineage

UNIX: Origins and early evolution

• 1964–1969: Multics project at Bell Labs, GE, and MIT aimed to provide “all things to all people” but was large, expensive, and complex.

• 1969: Bell Labs withdraws from Multics; Ken Thompson and team begin a lean OS for Bell Labs’ machines.

• Original name: UNICS, a joke on Multics; later renamed UNIX.

• UNIX was rewritten in Thompson’s B language and then in Dennis Ritchie’s C.

• AT&T could not sell UNIX; source code distributed to universities for a fee.

• BSD UNIX: University of California, Berkeley group edited UNIX source to create BSD UNIX, led by Bill Joy (Sun Microsystems co-founder).

• UNIX family evolution

  • SunOS: Sun Microsystems“基于 BSD UNIX”
  • Solaris: SunOS combined with AT&T System V Release 4 UNIX
  • OSF/1: Open Software Foundation’s alternative UNIX variant created in response to AT&T/Sun collaboration
  • Multics influence remains in early thinking about secure, multiuser systems, though UNIX diverged.

• Key takeaways

  • UNIX established modular, portable design with C as a primary language, enabling widespread adaptation.
  • BSD UNIX introduced licensing and distribution that fostered research and teaching environments.

Linux: History, distributions, and open-source movement

• Origins and linking to UNIX

  • 1969–1983: UNIX laid the groundwork for Linux; GNU project (1983) promoted free software, tools like GCC, Bash, and core utilities, and a philosophy of sharing.

• Creation of the Linux kernel

  • 1991: Linus Torvalds announced on Usenet: "I’m doing a (free) operating system (just a hobby, won’t be big and professional like GNU)." Kernel development started; combined with GNU tools to form a complete OS.

• Early Linux distributions (1992–1994)

  • SLS (Softlanding Linux System): one of the first complete distributions.
  • Slackware (1993): emphasized simplicity and stability.
  • Debian (1993): community-driven, focus on package management.

• Growth and commercial interest (1995–2000)

  • Linux gains popularity for servers and academic use; companies provide support and commercial distros.
  • Red Hat Linux (1995): enterprise focus.
  • SuSE Linux (1994): popular in Europe.
  • Linux becomes known for server stability and strong networking.

• Desktop and enterprise adoption (2000–2010)

  • Desktop GUIs (KDE, GNOME) improve usability; Linux becomes a major server OS and gains presence in web hosting and supercomputing.
  • Enterprise distributions expand: Red Hat Enterprise Linux (RHEL); Ubuntu (2004) becomes popular for desktop and server use.

• Modern Linux (2010–present)

  • Linux powers servers, supercomputers, Android devices, and embedded systems (IoT).
  • Distributions evolve with security, cloud integration, containerization (Docker, Kubernetes).
  • Open-source community and corporate support (IBM, Google, Red Hat) drive ongoing innovation.

• Flavors and distributions (diversity of Linux)

  • Different flavors arise because source code is freely distributed; each distribution offers its own installation, administration procedures, software packages, and configurations.
  • Examples of notable distributions include Mandrake/Mandriva, Red Hat, openSUSE, Debian, Gentoo, Slackware, Lycoris, BeOS-inspired Beehive (Behlve), Caldera OpenLinux, Turbolinux, etc.
  • The core functions are similar; differences lie in packaging, toolchains, and defaults.

• Why Linux is advantageous (summary of pros)

  • Low cost due to GNU General Public License; no licensing fees for the OS or many components.
  • Stability and long uptimes; rarely require reboots for performance.
  • Performance and scalability across networks; strong multi-user and multi-tasking capabilities.
  • Networking: robust client/server capabilities; efficient backups and network services.
  • Flexibility: modular, install only required components; can tailor for servers, desktops, or embedded systems.
  • Compatibility: runs most common UNIX software packages; broad hardware support.
  • Wide distribution ecosystem: multiple choices for different needs; fast and easy installation in many cases.
  • Open source: source code is available, enabling customization and auditability.
  • Security emphasis: strong permission and ownership models; community-driven security practices.
  • Broad deployment: from embedded devices to mega clusters and space missions.

• Linux today: scope and impact

  • Used worldwide, including in space (NASA) and by major companies (IBM, Boeing, NASA) for a variety of roles.
  • Supports multiple hardware platforms: xSeries (Intel), pSeries and iSeries (PowerPC).
  • Continues to evolve with cloud-native tech and virtualization support.

Organization and File System of Linux OS

Linux architecture and the three core layers

• Linux is organized in layers that interact to provide a functional OS:
  • 1) Kernel: core of the OS; manages hardware resources (CPU, memory, I/O), handles process management, device drivers, system calls, and security. Types include monolithic kernel (all services in one) with loadable modules.
  • 2) Shell: command interpreter providing interface between user and kernel; examples include Bash, Zsh, Ksh; accepts commands and executes scripts.
  • 3) System libraries: provide standard functions for applications; example: glibc (GNU C Library) allows programs to interact with the kernel.
• Additional layers:
  • 4) System utilities and daemons: programs for file management, networking, process management; daemons run in the background (e.g., cron, syslog).
  • 5) User applications: apps installed on top of Linux (e.g., LibreOffice, Firefox); communicate with the kernel via libraries and system calls.

Organization and File System (structure)

• Linux OS is functionally organized into three main levels (conceptual view): kernel, shell, and user programs, with libraries in between.
• File system is the portion of a disk that stores information related to files; all files are stored on secondary storage.

Kernel: core duties

• Main core of the OS; typically written in C; communicates with hardware directly.
• In multi-user systems, terminals are assigned numbers; users work on terminals connected to the host.
• Important tasks include:
  • Check user authorization; ensure only permitted users access resources.
  • Manage scheduling; allocate CPU time to each running program.
  • Allocate storage for files; manage file systems and spaces.
  • Run the shell; provide user command execution environment.
  • Manage I/O transfer between computer and terminals.

Shell and text interfaces

• Shell: translates keyboard input into commands for the kernel; acts as an interpreter and text-based interface.
• Examples of shells include: bash, zsh, ksh, sh, tcsh.
• Five common Linux shells:
  • bash (Bourne Again SHell)
  • csh (C Shell)
  • ksh (Korn Shell)
  • sh (standard shell)
  • tcsh (enhanced C Shell)

System libraries and utilities

• glibc: GNU C Library; provides standard interfaces for user-space programs to interact with the kernel.
• Utilities and daemons provide essential system services and background tasks.
• Applications (LibreOffice, Firefox, etc.) are installed on top and rely on libraries and system calls.

Linux processes and file system concepts

• Linux treats all data (including devices) as files and uses a hierarchical directory structure starting at root "/".
• Common directories include:
  • /bin: essential user binaries (commands like ls, cp)
  • /sbin: system binaries (admin commands like ifconfig)
  • /etc: configuration files
  • /home: user home directories
  • /var: variable data (logs, mail, spool files)
  • /usr: user programs and libraries
  • /lib: essential shared libraries
  • /tmp: temporary files
  • /boot: boot loader files and kernel
  • /dev: device files (e.g., /dev/sda)

Filesystem types in Linux

• ext4: most common default filesystem
• ext3/ext2: older versions
• XFS: high-performance journaling filesystem
• Btrfs: modern filesystem with snapshots and self-healing
• FAT32/NTFS: cross-platform compatibility
• ISO9660: filesystem for CD/DVD images

Text processing, editors, and development tools

• Text processing capabilities are built into the OS; editors are essential for software development.
• Text editors commonly used in Linux:
  • vi: a powerful modal editor; can edit text and binary files.
  • ed: line editor; later variants like sed (stream editor) edit files non-interactively; supports command-line editing commands.
  • emacs: powerful editor with features for C code formatting, pattern matching, and mail reading.

Command-line editing and editors overview

• ed (line editor): edits by line; can be used non-interactively.
• sed: stream editor; can apply commands to streams of data; accepts command-line arguments that specify editing commands.
• emacs: expansive editor with programmable features and integrated tools.

Common editor features and examples

• bash, sh, and other shells provide command-line editing capabilities and scripting support.
• Editors enable development workflows: coding, compiling, and debugging within the OS environment.

Windows OS family (historical overview)

• Windows history is presented in terms of bit-architecture progressions and major releases:
  • 16-bit era: Windows 1.0 (1985), Windows 2.0 (1989), Windows/286 hybrid (16/32-bit) – occasionally shown as 16-bit/32-bit hybrid in early versions.
  • 16/32-bit era: Windows 3.1 (1992).
  • Hybrid 16/32-bit era: Windows 95 (1995); Windows 95 SE (1996); Windows 98 (1998); Windows 98 SE (1999); Windows Me (2000).
  • 32-bit era: Windows NT line begins with NT 3.1 (1993) through NT 4.0 (1996); Windows 2000 (2000); Windows XP (2001); Windows CE (2005).
  • Hybrid 32/64-bit era: Windows XP Pro (2005); Windows Server 2003 (2005); Windows Vista (2006); Windows Server 2007; Windows 7 (2008).
  • Windows 8, Windows 10, Windows 11 are subsequent modern releases.
• Windows market dominance: roughly $95\%$ personal computer market share at peak times (varies by source and time).
• OS concepts mirrored from early Macintosh and UNIX ideas; Windows built on a rich set of integrated features spanning GUI, networking, file systems, and software ecosystems.

UNIX and Linux: a quick comparative view

• UNIX family built around core concepts of portability, multiuser support, and a C-language port.
• Linux emerged as a free/open-source alternative, built to be compatible with UNIX-like paradigms while embracing open licensing and community development.
• Linux distributions provide different installation experiences, package management systems, and defaults; however, the kernel, core utilities, and many libraries share common ancestry with UNIX and BSD traditions.

Linux distributions: flavors and ecosystem

• Diversity of distributions arises from free software principles; each distribution packages the kernel with a set of tools, libraries, and configuration defaults.
• Notable distributions mentioned:
  • Mandrake Linux / Mandriva
  • Red Hat Linux / Red Hat Enterprise Linux (RHEL)
  • openSUSE / SuSE
  • Debian GNU/Linux
  • Gentoo
  • Slackware
  • Lycoris Desktop/LX
  • Behlve Linux (likely Beehive/Behlve typo in source)
  • Caldera OpenLinux
  • Turbolinux
• Each distribution targets different audiences (servers, desktops, enterprises) and provides different packaging ecosystems.

Practical implications and takeaways

• Open source vs proprietary licensing
  • Linux and GNU tools exemplify open-source philosophy: access to source code, modification, and redistribution.
  • Proprietary OSs (historically) protected source and required licenses for commercialization; OSI and GNU projects formalized open-source benefits.
• Security and stability considerations
  • Linux emphasizes strong permissions, modularity, and rapid patch cycles through community and vendor collaboration.
  • Breadth of hardware support and configurability can improve security when properly managed.
• Real-world relevance
  • Linux dominates servers, cloud infrastructure, and embedded systems; Windows dominates many desktop environments; macOS emphasizes GUI with UNIX foundations.
  • Modern OS features: virtualization, containers (Docker, Kubernetes), cloud integration, and mobile platforms showcase evolving OS roles beyond single devices.

Summary of key concepts and terms

• CTSS: early time-sharing OS at MIT enabling multiple users to interact with a computer simultaneously.
• RUNCOM: CTSS command file executor; automated command sequences.
• Multics: early ambitious OS project; influenced later OS design; last copy shut down in $2000$.
• System/360: IBM mainframe family introduced in $1964$; symbolized an era of standardized hardware and software platforms.
• TCP/IP: standard networking protocol suite developed for DoD and later widely adopted.
• PARC Ethernet: early LAN technology enabling network communication between computers.
• BSD UNIX: Berkeley-derived UNIX variant that spurred further UNIX-like implementations.
• Minix: teaching-oriented UNIX-like OS by Andrew Tanenbaum; inspired Linus Torvalds to develop Linux.
• GNU: project promoting free software; essential tools used with Linux kernel to form a complete OS.
• OOOS: object-oriented operating systems concept; modularity via objects, inheritance, and interfaces.
• Open-source ecosystems: OSI, GNU, and a broad set of licenses enabling collaboration and distribution.
• Virtualization and containerization: modern OS features enabling cloud, multi-tenant environments, and isolation.

Note: This note consolidates content from the provided transcript, organizing historical milestones, UNIX/Linux evolution, Windows timelines, Linux architecture, distributions, and practical implications into a structured study guide. Where years and numbers appear, they are presented in the form $<number>$ to reflect the LaTeX-style requirement for numerical references.