Episode 0's homework ── answering "Is Linux MINIX's child?" clearly
In Episode 0, we traced the chicken-and-egg loop backwards through "what compiled what." But the history of UNIX has another, entirely separate family tree ── the lineage of whose "source code" was inherited. The misunderstanding beginners always make ── "Linux is MINIX's child," "MINIX is BSD's child" ── arises from mixing this lineage tree and the reimplementation tree, which inherits only ideas, into a single tree. This time we carefully draw apart the two trees, and at the end we read the Tanenbaum–Torvalds debate through them.
When software "inherits" something from other software, what it inherits divides broadly into two kinds.
① Code lineage (genes): it inherits the actual lines of source code. It copies the parent's code, modifies it, and grows it. That is why copyright and licensing follow it around.
② Reimplementation of ideas (design/API): it takes not a single line of code; it only imitates "how it behaves (system calls, design philosophy)" and rewrites everything from a clean slate. It may be compatible, but the genes are unrelated.
These two are orthogonal. Just because one piece of software "behaves exactly like" another does not mean it inherited any code. Conversely, two things can look different yet have code inherited straight from the parent. In the UNIX family, these two trees intertwine into a forest.
First, the main current where real code flows. In 1969, Bell Labs' AT&T UNIX is the source (Multics, which came before it, was an ideological influence as a "cautionary example"; no code was inherited ── that's for a bonus episode). AT&T UNIX's source code was licensed and passed to various places, modified, and left descendants.
AT&T UNIX (1969) → two big branches:
Branch A: the Berkeley line (BSD)
A university (UC Berkeley's CSRG) obtained AT&T's source license and modified it → BSD (1978–) → 386BSD (1992) → NetBSD / FreeBSD (1993), and later OpenBSD.
Branch B: the AT&T commercial line
System III → System V (1983) → various companies' commercial UNIXes (Solaris and others).
The strongest evidence that this tree "really inherits code" is ── that it ended up in court. In 1992, AT&T (USL) sued Berkeley, claiming "BSD contains our UNIX code" (USL v. BSDi). The 1994 settlement revealed that, of BSD's 18,000 files, only 3 were removed and 70 modified. Put the other way, this tree carries so much real code that a court could trace the origin of the code line by line.
The other tree inherits not a single line of code. Things that "behave like UNIX but whose innards were written from a clean slate" ── the family called Unix-like.
MINIX (1987, Tanenbaum): for teaching, an OS written from a clean slate to behave compatibly with UNIX V7. No AT&T code included (so it could be handed out in class).
GNU (1983, Stallman): "GNU's Not Unix." Rebuilding UNIX's userland (gcc, bash, etc.) from a clean slate so it can be used freely.
Linux (1991, Torvalds): the kernel written from a clean slate. Developed on top of MINIX and influenced by it, but it did not inherit MINIX's code.
"Writing from a clean slate" sounds like an exceptional feat, but it isn't. As Tanenbaum himself later pointed out, plenty of people in history have written an OS from scratch ── himself (MINIX), Thompson (UNIX), Holt (Tunis), Comer (Xinu), Williams (Coherent)… Reimplementation is an "ordinary activity" of UNIX culture.
Now let's place both on the same picture. In the figure below, the horizontal axis is the year, the top half is the lineage tree (solid lines = code flows), and the bottom half is the reimplementation tree (dotted lines = ideas only). Use the buttons to switch trees, and confirm that Linux and MINIX hang on the dotted-line side, while NetBSD and FreeBSD hang on the solid-line side.
Linux is at the end of MINIX's dotted line. That is, it inherited the ideas (Unix-ness) but not the code (genes). "It was developed on top of MINIX (borrowed the delivery room)" from Episode 0 and "it is not MINIX's child (no blood tie)" are both true at once, because the delivery room and the lineage are separate matters.
On January 29, 1992, Tanenbaum posted "LINUX is obsolete" to comp.os.minix, and the famous debate began. What matters here is ── this was not, in any way, a dispute over code plagiarism. The point of contention was design philosophy.
Tanenbaum: the kernel should be small and split up (a microkernel). A monolithic (all-in-one) design like Linux's is "a giant step back into the 1970s." What's more, it's tightly coupled to the 386 and has no future.
Torvalds: monolithic is a perfectly sound design choice in practice. "linux is more portable than minix (in the API sense)." ── Linux was later ported to ARM, POWER, SPARC, and many others, and Tanenbaum's "the 386 will be obsolete" prediction proved wrong.
In other words, the two were debating "what makes a good design", not disputing "whose code it is." In the figure below, switch between the two kernel designs ── the "real substance" of the debate.
The roots are two separate trees, but at the top (the crowns) they exchange leaves. This is where it gets interesting.
• GNU + Linux: two leaves of the reimplementation tree (GNU's userland + Linux's kernel) combine to become the OS we casually call "Linux" every day (hence also "GNU/Linux").
• MINIX 3 ← NetBSD: the later MINIX 3 took in the userland of NetBSD, on the lineage tree side. This is the true identity of the "the arrow goes the other way and much later" we touched on in Episode 0. The reimplementation tree borrowed a leaf from the lineage tree.
So the "two trees," though strictly separate at the roots, lend and borrow each other's leaves at the crowns. Hold this image of separate roots, crossing at the crowns, and the "cluttered forest" of the UNIX family comes clearly into view.
The two trees are a model for organizing the story. Reality is more continuous. (1) Even the lineage tree isn't "pureblooded" ── early BSD contained AT&T code, which was gradually removed through the lawsuit until 4.4BSD-Lite became "effectively free." Lineage gets removed and added. (2) "Inheritance of ideas" is a matter of degree too; there are also standards that deliberately take on compatibility, like POSIX (a bonus episode). (3) We put Multics→UNIX under "ideas," but this is an influence, not a clear inheritance relationship.
The point is that the real substance is the perspective of asking separately "did code flow (genes)?" and "does the behavior resemble (ideas)?"; the shape of the trees themselves is just a rough guide.
The UNIX family has two trees. The lineage tree is the main current where real code flows: AT&T UNIX → BSD → NetBSD/FreeBSD, and → System V. The origin of the code is so real that the USL v. BSDi lawsuit could trace it line by line. The other, the reimplementation tree, inherits only ideas/API and writes the code from a clean slate ── MINIX, GNU, Linux. The two are orthogonal, and "behaving similarly" is a separate matter from "inheriting code."
So "Linux is MINIX's child" is inaccurate ── Linux is at the end of MINIX's dotted line (ideas), and it inherited no genes. The 1992 debate, read through the two trees, was a debate over design (micro vs. monolithic), not a dispute over plagiarism, and the 2004 "copy claim" was refuted even by MINIX's own author. Though the roots are separate, at the crowns they exchange leaves, as with GNU⊕Linux or MINIX 3←NetBSD. ── Genes, or ideas. Asking this one question separately is the key to reading a lineage.
Printing / making a PDF: ⌘+P (on Windows, Ctrl+P). On screen, use the buttons in Figure 1 to switch between the two trees, and Figure 2 to switch the point of contention (kernel design). "Show answer" opens each solution.