View on GitHub
Prefer a developer-friendly format? You can find the raw markdown files and track all updates for this article directly inside the GitHub repository.
Link:
🔔 Connect & Stay Updated
Follow avidflick_tech across our social handles to get instant notifications, micro-learning clips, and real-time alerts whenever a new module, YouTube masterclass, or blog architectural update drops!
Prior to Linux — Unix Origins
1. Unix, Invented by Whom and When?
The creation of Unix was not a sudden corporate mandate; it was a grassroots “rebellion” by a small group of brilliant computer scientists at AT&T Bell Labs in Murray Hill, New Jersey.
The primary architects were:
- Ken Thompson: A brilliant programmer who loved system design and video games.
- Dennis Ritchie: The genius logician who went on to invent the C programming language specifically to make Unix portable.
- Douglas McIlroy: The head of the Computing Techniques Research Department who invented the concept of “Pipes” (
|). - Joe Ossanna: A crucial contributor who helped secure funding for hardware by adapting Unix for text processing.
The Timeline of Birth (1969–1971):
- Summer 1969 (The Prototype): Ken Thompson wrote the very first version of Unix in just four weeks on a discarded, obsolete PDP-7 minicomputer. He wrote it entirely in assembly language.
- 1970 (The Official Name): The system was officially named UNICS (Uniplexed Information and Computing Service), which was a cheeky, sarcastic pun on an older operating system we will discuss next. The spelling was later streamlined to Unix.
- November 3, 1971 (The Manifest): The first edition of the Unix Programmer’s Manual was published by Thompson and Ritchie. This date marks the official public standardization of Unix Version 1.
- URL for Unix first version Manual released on Nov 3, 1971: Unix Manual, first edition
The Multics Disappointment
Before Unix, AT&T Bell Labs, General Electric, and MIT were collaborating on a massive, highly ambitious operating system called Multics (Multiplexed Information and Computing Service).
- The Vision: Multics was designed to be a massive commercial utility, allowing hundreds of people to share a single mainframe simultaneously (like a power grid for computing).
- The Reality: The project became an over-engineered, slow, bureaucratic nightmare. It required massive computing power and felt incredibly sluggish.
- The Pullout (April 1969): Bell Labs management decided the project was a money pit and officially withdrew funding. They pulled their engineers off the project and banned them from spending money on building any more operating systems.
When Bell Labs pulled out of Multics, Ken Thompson and Dennis Ritchie suddenly lost access to the powerful GE-645 mainframe.
- Thompson had written a space simulation game called Space Travel, where the player piloted a spaceship across a model of the solar system.
- Without the mainframe, running the game on other Bell Labs hardware cost about $75 per run in corporate computing time—an astronomical expense for a hobby.
Thompson found an old, neglected Digital Equipment Corporation (DEC) PDP-7 computer in a hallway. It had a primitive display terminal but excellent graphics capabilities for its time. However, it lacked an operating system.
The Birth of the “Unix Philosophy”
To play his game on the PDP-7, Thompson didn’t just port the game; he decided to write a completely fresh, lightweight operating system from scratch.
Because of the bad taste Multics left in their mouths, Thompson and Ritchie designed Unix to be the exact opposite of Multics. Where Multics was huge, complex, and bureaucratic, Unix would be small, simple, and elegant.
This birthed the legendary Unix Philosophy that still governs Linux architecture today:
“Write programs that do one thing and do it well. Write programs to work together (using text streams). Treat everything as a file.”
3. Famous Commands from Unix V1/V2 that are Deprecated or Obsolete Today
In the early 1970s, storage was measured in kilobytes, and computers didn’t use monitors; they printed their output onto physical paper using noisy mechanical typewriters called Teletypes (TTY). Because of this, several commands existed purely to deal with the extreme limitations of physical paper and primitive hardware.
A. dbw (Database Write)
- What it did: This was a highly specialized, low-level system command used to directly alter the structure of the filesystem on the disk.
- Why it’s obsolete: It was incredibly dangerous. A tiny typo could wipe out the entire operating system instantly. In modern Linux, we use safer, abstract filesystem tools (like
tune2fs,parted, orfsck) that prevent users from accidentally corrupting raw disk sectors directly.
B. form (Form Letter Generator)
- What it did: One of the main ways Bell Labs programmers secured funding for their computers was by promising management they could use Unix for office secretarial work.
formwas a tool that took a template letter and a list of names/addresses and merged them together to print mass mailings. - Why it’s obsolete: This functionality moved completely out of the operating system layer and into office software suites (like Microsoft Word or Google Docs Mail Merge) and script libraries.
C. opr (Off-line Printer)
- What it did: Since computers were slow, you didn’t want a program blocking the terminal while a mechanical printer slowly spit out paper.
oprtook a text file and queued it up to be printed “off-line” by a background system. - Why it’s obsolete: It was completely replaced in later versions of Unix and Linux by the standard
lp(Line Printer) andlprcommands, alongside modern print spooling subsystems like CUPS (Common UNIX Printing System).
D. tap (Tape Drive Manipulator)
- What it did: Early PDP-11 systems relied heavily on magnetic tape reels for storing data files and system backups.
tapwas the direct CLI tool to wind, rewind, read, and write to these physical tape drives.
- Why it’s obsolete: Magnetic tape drives became highly niche enterprise backup hardware. Linux completely phased out
tapin favor of the universaltar(Tape Archive) command and standard block device file management.
4. Famous Commands from Unix V1/V2 that are Still in Daily Use
The longevity of these commands is mind-blowing. If Ken Thompson walked up to your modern Ubuntu machine or AWS EC2 instance today, he could open the terminal and run these exact commands, and they would behave exactly the same way they did in 1971.
A. ls (List Segments / Directory Contents)
- Then: It stood for “List Segments” because early Unix filesystems referred to file allocations as segments. It printed a flat list of files in the current directory onto the teletype paper.
- Now: It is the foundational command to list directory contents. While it now supports colors, icons, and human-readable sizes (
ls -lh), the core execution is identical.
B. cp, mv, and rm (Copy, Move, Remove)
- Then: Written as ultra-short, 2-letter commands because the physical keys on a Teletype were incredibly stiff to type on. Programmers wanted to minimize keystrokes to prevent finger fatigue.
- Now: They remain the absolute, unshakeable standard commands for file manipulation across every cloud server, container, and local Linux machine on Earth.
C. cat (Catenate / Concatenate)
- Then: It was designed strictly to link multiple text files together end-to-end and output the combined stream to a file or printer.
- Now: While it is still used for concatenation, millions of DevOps engineers use it daily as a quick shortcut just to dump the contents of a configuration file straight onto their screen (
cat /etc/resolv.conf).
D. chmod (Change Mode)
- Then: Unix introduced the revolutionary concept of file permissions—owner, group, and others, with Read, Write, and Execute rights.
chmodwas created in Version 1 to change these bits. - Now: Linux still uses the exact same security architecture. Running
chmod 755 script.shworks today exactly how it worked over 50 years ago at Bell Labs.
E. wc (Word Count)
- Then: A simple utility designed to count lines, words, and characters in a text block, crucial for authors writing documentation.
- Now: It is an invaluable pipeline tool for DevOps engineers. For example, piping a process list into
wc -l(ps -ef | wc -l) is the standard way to count exactly how many application processes are currently running on a production server. - Now we step into the late 1980s. To understand why Linux exists, you must understand MINIX. MINIX is the missing link between the corporate giant Unix and the open-source revolution of Linux. It was both Linus Torvalds’ launchpad and his primary limitation.
MINIX — The Catalyst
1. Invented by Whom and When?
MINIX was created by Andrew S. Tanenbaum, an American Dutch professor of computer science at the Vrije Universiteit Amsterdam in the Netherlands.
- The Release Date: MINIX 1.0 was released in January 1987.
- The Format: It was released alongside Tanenbaum’s legendary textbook, Operating Systems: Design and Implementation. The operating system’s source code was literally printed in the back of the book so students could read it.
2. The Deeper Reason Behind Inventing MINIX
To understand why Tanenbaum wrote MINIX, you have to look at the legal and financial corporate wars surrounding Unix in the 1980s.
The Death of Academic Unix
In the 1970s, AT&T gave Unix source code to universities for practically free because a government antitrust decree blocked AT&T from selling software commercially. Professors used it to show students how a real operating system worked line by line.
However, in 1984, the US government broke up the AT&T monopoly. Free to enter the computer business, AT&T realized Unix was a goldmine. They commercialized it and strictly updated their license:
- The Cost: Unix licenses skyrocketed to thousands of dollars.
- The Lockdown: AT&T legally forbade universities from showing the Unix source code to students in class. Teaching operating systems suddenly became completely theoretical and professors could talk about algorithms, and students weren’t allowed to see real code.
The Birth of an Academic Clone
Frustrated that he could no longer teach his students using real code, Professor Tanenbaum decided to write a completely clean, fresh clone of Unix from scratch that didn’t contain a single line of AT&T’s copyrighted code.
He designed it to run on the widely available and affordable IBM PC (Intel 8088 processors) so that any student could run it at home on cheap hardware, rather than needing an expensive corporate minicomputer. He named it MINIX (Mini-Unix).
- The Microkernel Architectural Shift
Tanenbaum didn’t just clone Unix; he wanted to improve its core computer science architecture. He built MINIX using a Microkernel architecture.
How traditional Unix worked (Monolithic): Everything—the filesystem, process management, network drivers, and hardware interaction—ran inside one giant block of high-privileged memory (the Kernel space). If a single display driver crashed, the entire computer crashed (Kernel Panic).
How MINIX worked (Microkernel): The core kernel was kept incredibly tiny (only a few thousand lines of code). It handled only the absolute bare essentials: memory allocation and passing messages. Everything else—like the filesystem and device drivers—ran as separate, isolated, low-privilege user processes outside the kernel. If a driver crashed, it just restarted automatically without taking down the computer. It was highly secure and mathematically elegant.
The Linux Invention
1. Linux, Invented by Whom and When?
Linux was invented by Linus Benedict Torvalds, a 21-year-old Finnish computer science student at the University of Helsinki, Finland.
- The Timeline of Birth (1991):
- January 1991: Linus bought a brand new, powerful IBM-compatible 386 PC. It had a cutting-edge Intel 80386 processor, 4 Megabytes of RAM, and a 40 Megabyte hard drive. He installed MINIX on it to study Unix-like systems.
- April–July 1991: Frustrated by MINIX’s limitations and bugs in its terminal emulation software, Linus began writing a raw, low-level program that could switch between two threads: one to read from his keyboard and one to read from his modem. This primitive terminal emulation program slowly evolved into a task switcher, which then evolved into a filesystem handler, and eventually, an operating system kernel.
What It Means in This Context:
For Linus, the modem was his only bridge to the outside world. He needed his computer to communicate with the University of Helsinki’s powerful Unix servers to read student discussion boards (Usenet), download files, and check emails.
Because he was writing his program from scratch to learn his computer’s hardware, he had to handle the data flow manually:
[ Your Hands ] ----> ( Keyboard Input ) ----\
===> [ Linus' Task Switcher ] ===> ( Out to University via MODEM )
[ Your Eyes ] <---- ( Screen Output ) ----/
To make his home computer act like a terminal connected to the university, his primitive code had to handle two tasks at the exact same time:
Task A: Listen for keys pressed on the physical keyboard and send those characters out through the modem to the university server.
Task B: Listen for responses coming back through the modem from the university server and print them on his physical monitor.
The “task switcher” he built to bounce back and forth between handling the keyboard and handling the modem became the foundational design for how the Linux kernel manages multiple programs today
- August 25, 1991 (The Legendary Announcement): Linus posted a historic message to the
comp.os.minixUsenet newsgroup. This is the official “soft launch” date of Linux.
- September 17, 1991: Linus uploaded Linux Version 0.01 to an FTP server hosted by the Helsinki University of Technology. The source code was roughly 10,000 lines of code compressed into a tiny file.
2. Was Linux a Copy of Unix or MINIX?
The Source Code Reality:
Linux was written entirely from scratch. It did not contain a single line of copyrighted code from AT&T’s Unix or Andrew Tanenbaum’s MINIX.
How they are related (The Distinction):
- The Relationship with MINIX: MINIX was the scaffolding. Linus used MINIX to write the first versions of Linux. He used the MINIX filesystem layout inside his early kernel so that his new OS could read the files on his hard drive. However, he threw away MINIX’s microkernel design completely.
- The Relationship with Unix: Unix was the design blueprint. Linux was designed to be a clone in behavior, but not in code. Linus looked at the POSIX standards (the official rules governing how Unix commands and programs should interact) and wrote his own code to mimic those exact behaviors.
Therefore, Linux is classified as a Unix-like operating system, not a direct descendant of Unix.
3. The Deeper Reason Behind Inventing Linux
Linus did not set out to change the world, defeat Microsoft, or build cloud infrastructure. His reasons were highly personal, practical, and casual:
A. The Intellectual Challenge of the 386 Processor
The Intel 80386 processor inside Linus’s new computer featured a revolutionary mode called Task Switching / Protected Mode. MINIX was designed to remain backward compatible with older, weaker processors, so it intentionally ignored this advanced hardware power. Linus wanted to learn exactly how the 386 processor handled task switching at a hardware level. His kernel started strictly as a personal engineering experiment to push his computer to its physical limits.
B. Financial Desperation
Linus loved Unix from his university labs, but a commercial Unix license for a personal computer cost thousands of dollars. He couldn’t afford it. MINIX was cheap ($79), but it was heavily restricted. He built Linux because he wanted a full-featured, powerful Unix system for his personal machine without breaking the bank.
C. The Academic Gridlock of MINIX
As mentioned earlier when Linus requested basic features for MINIX (like supporting a hard drive partition instead of just floppies, or implementing better memory management), Professor Tanenbaum refused to merge them. Linus felt trapped by an educational operating system that was intentionally kept “crippled” for classroom clarity.
4. Important Points to Note on Linux (The Spark of Open Source)
The Licensing Pivot: GNU GPL License
When Linus released Version 0.01, he applied a restrictive, custom license that banned any commercial distribution. You could download it and use it, but you couldn’t sell it or bundle it into a commercial product.
However, in January 1992, for Version 0.12, Linus made the most important executive decision of his life: he adopted the GNU General Public License (GPLv2).
Why this was revolutionary:
- The Copyleft Rule: The GPLv2 states that anyone can modify your code, share it, or even sell it. However, there is a massive catch: any modifications you make and distribute must also be made fully open-source under the exact same GPLv2 license.
- The Anti-Hoarding Mechanism: If a massive tech company took Linus’s kernel and added a brilliant feature to make it run faster, they were legally required to share that code back to Linus and the rest of the world. They couldn’t hoard it as a corporate secret.
- The Collaborative Explosion: This license made other global hackers feel safe contributing to Linux. They knew their hard work wouldn’t be stolen by a corporation. Within months, hundreds of developers around the globe began writing drivers, fixing bugs, and optimizing the kernel, completely hyper-accelerating its development speed.
Leave a Reply