Unix and Unix-like Operating Systems

Introduction

Unix is one of the most influential operating system families in computing history. It was originally developed at Bell Labs in 1969 by Ken Thompson and Dennis Ritchie. The first Unix system appeared in 1971 and was initially used for document processing and research computing.

A major turning point came with the introduction of the C programming language, which allowed Unix to be rewritten in 1973, making it portable across different hardware platforms—a revolutionary concept at the time.

Today, Unix itself is not widely used as a standalone system, but its influence continues through Unix-like systems, especially Linux, BSD variants, and macOS.

Evolution of Unix

Early Development

• 1969: Initial development at Bell Labs
• 1971: First operational version
• 1973: Rewritten in C (major milestone enabling portability)

Modern Impact

Unix principles influenced:

• Linux (Linus Torvalds, 1991)
• BSD systems (FreeBSD, OpenBSD, NetBSD)
• Apple macOS (built on Darwin, a Unix-certified system)

Modern enterprise systems, cloud infrastructure, and servers are predominantly Unix-like.

Unix Philosophy (Still Relevant Today)

The Unix philosophy remains foundational in modern computing:

• “Do one thing and do it well”
• Build small, modular tools
• Combine tools using pipelines
• Prefer simplicity and composability
• Use text-based interfaces for interoperability

Modern interpretation:

This philosophy is reflected in:

• Microservices architectures
• Containerization (Docker, Kubernetes)
• Cloud-native systems
• DevOps automation pipelines

Unix vs Linux Today

System

Description

Unix

Original commercial/academic OS family

Linux

Open-source Unix-like kernel (dominates servers/cloud)

BSD

Open-source Unix derivatives with permissive licensing

macOS

Apple’s Unix-certified desktop OS

Modern reality:

• Linux dominates servers, cloud computing, and supercomputers
• Windows dominates desktops but increasingly supports Linux via WSL (Windows Subsystem for Linux)
• macOS is widely used in development environments

User Interfaces in Unix Systems

1. Command-Line Interface (CLI)

The CLI remains one of the most powerful ways to interact with Unix systems.

Users interact through a shell, such as Bash or Zsh.

Example:

ls

Why CLI is still important:

• Automation (scripts)
• Remote server management (SSH)
• DevOps and cloud infrastructure
• Lightweight and fast operations

2. Graphical User Interfaces (GUI)

Modern Unix-like systems also provide full graphical environments:

• GNOME (Linux)
• KDE Plasma
• macOS Aqua interface

Additionally, modern development environments include:

• VS Code
• JetBrains IDEs
• Cloud-based IDEs (GitHub Codespaces)

Common Unix/Linux Commands (Modern Usage)

Command

Description

Modern Equivalent / Notes

ls

List files

Used with options like ls -la

cp

Copy files

cp file1 file2

rm

Remove files

rm -r for directories

cd

Change directory

Core navigation command

mkdir

Create directory

mkdir -p creates nested folders

man

Manual pages

man ls or tldr ls (modern alternative)

Modern additions:

• grep (search text)
• awk, sed (text processing)
• curl, wget (web requests)
• chmod, chown (permissions)
• systemctl (service management in Linux systems)

File Creation and Editors (Modern Tools)

Traditional Editors

vi / vim

• Powerful modal editor
• Still widely used in servers and DevOps environments

emacs

• Extensible and programmable editor
• Full development environment

nano (modern beginner-friendly choice)

• Simple CLI editor
• Default in many Linux distributions

Example:

nano myfile.txt

Modern Editors (Today’s Standard)

Most users now prefer:

• Visual Studio Code
• Vim/Neovim (advanced users)
• Cloud IDEs (GitHub Codespaces, AWS Cloud9)

Modern Vim/Vi Usage Overview

Vim remains widely used in server environments.

Core concepts:

• Command mode (navigation/edit commands)
• Insert mode (text input)
• Visual mode (selection)

Common commands:

• i → insert mode
• :w → save
• :q → quit
• :wq → save and quit
• dd → delete line
• u → undo

Modern note:

Neovim extends Vim with:

• Plugin ecosystem
• LSP support (language servers)
• Modern UI integration

Unix Architecture (Modern View)

Unix-like systems follow a layered architecture:

1. Hardware Layer

Physical components (CPU, memory, storage, network)

2. Kernel Layer

The core of the operating system:

• Manages memory
• Controls processes
• Handles device drivers
• Provides system calls

Examples:

• Linux kernel
• BSD kernel
• XNU (macOS kernel)

3. System Libraries

Provide APIs for applications (e.g., glibc)

4. Shell and User Applications

• Bash, Zsh, Fish shells
• User applications and utilities
• GUI desktops

System Calls

Applications interact with the kernel using system calls such as:

• open()
• read()
• write()
• fork()
• exec()

Unix Shells (Modern Landscape)

A shell is a command interpreter that allows users to interact with the operating system.

Popular modern shells:

Shell

Description

bash

Most common default shell in Linux

zsh

Advanced shell used in macOS and developers

fish

User-friendly interactive shell

sh

POSIX standard shell

ksh

Korn shell (enterprise environments)

Modern Trend

• Bash remains the default in most Linux distributions
• Zsh is default in macOS (since Catalina)
• Shell customization (Oh My Zsh, Powerlevel10k) is widely used
• Automation via shell scripts is essential in DevOps

Unix Family Today

Modern Unix-like systems include:

• Linux distributions (Ubuntu, Fedora, Debian, Red Hat)
• BSD systems (FreeBSD, OpenBSD, NetBSD)
• macOS (Darwin-based)
• Android (Linux kernel-based)

Modern Usage of Unix Systems

Unix-like systems dominate:

• Cloud computing (AWS, Azure, GCP)
• Web servers (Apache, Nginx)
• Supercomputing clusters
• Cybersecurity tools (Kali Linux)
• DevOps and container platforms (Docker, Kubernetes)

Modern Relevance

Unix systems remain foundational due to:

• Stability and performance
• Security and permission model
• Open-source ecosystem
• Scalability from embedded devices to supercomputers

Summary

Unix introduced a powerful design philosophy that continues to shape modern computing. Today, its legacy lives on through Linux, BSD, macOS, and cloud-based systems. Modern Unix-like environments are central to servers, development workflows, cybersecurity, and cloud infrastructure.

Despite its age, Unix remains one of the most important foundations of modern digital systems.