**Author:** [[3. Resources/Authors/Chris DiBona, Sam Ockman (editors)|Chris DiBona, Sam Ockman (editors)]] # Book Overview ![[Open Sources Visual.excalidraw]] ## About the Editors and Contributors Chris DiBona was a Linux International board member and open source community organizer. Sam Ockman co-founded Penguin Computing. They assembled essays from the people who actually built the open source movement: Eric Raymond (hacker historian and "Open Source" coiner), Richard Stallman (GNU Project and Free Software Foundation founder), Linus Torvalds (Linux creator), Tim O'Reilly (publisher who saw the web as infoware), Bruce Perens (Debian leader and Open Source Definition author), Brian Behlendorf (Apache co-founder), Bob Young (Red Hat co-founder), Marshall Kirk McKusick (BSD developer), Scott Bradner (IETF Area Director), Michael Tiemann (Cygnus Solutions co-founder), Paul Vixie (BIND maintainer and software engineering critic), Larry Wall (Perl creator), and Jim Hamerly and Tom Paquin (Netscape engineers who opened Mozilla). The roster reads like a who's-who of late-1990s open source, and the book captures them at the exact moment the movement was crystallizing into something the business world couldn't ignore. ## Central Thesis There isn't one central thesis -- this is an anthology, and the contributors disagree with each other on fundamental questions. But the book's organizing claim is that open source software development isn't a curiosity or a counterculture hobby. It's a method that produces better software, and by 1999, it had enough real-world evidence (Linux, Apache, Perl, BIND, sendmail) to demand serious attention from business and technology leaders. The essays collectively argue that open access to source code, collaborative development across institutional boundaries, and community-driven quality control represent a genuine alternative to proprietary software development -- though the contributors can't agree on whether the argument is primarily moral (Stallman), economic (Young, Tiemann, Behlendorf), pragmatic (Torvalds, Raymond), or historical (McKusick, Bradner). ## Why This Book Matters This book is a primary source document. It captures the open source movement at its inflection point -- after Linux and Apache had proven the model worked, but before the dot-com bust tested whether open source businesses could survive. The essays were written by the principals, not by journalists or historians interpreting events after the fact. That makes it messy and contradictory in places, but it also makes it irreplaceable as a record of what these people were actually thinking in 1998-1999. The Stallman-Raymond philosophical split, the Torvalds-Tanenbaum technical debate, the tension between free software idealism and open source pragmatism -- all of it is here in the voices of the people who lived it. Two decades of open source history since then makes the predictions particularly interesting: some were prescient (O'Reilly on web-as-platform), some were wrong (Raymond's triumphalism about proprietary software's imminent collapse), and some are still being contested (Stallman's insistence that "free software" and "open source" are fundamentally different movements with different goals). --- # Chapter Summaries ## Introduction (Chris DiBona, Sam Ockman, Mark Stone) The introduction frames open source through an analogy to scientific research: just as science advances through open publication, peer review, and building on prior work, software development benefits from the same openness. The editors argue that proprietary software's closed-source model is the aberration, not open source. They sketch the landscape as of 1999 -- Linux running on millions of machines, Apache dominating web servers, Perl powering CGI everywhere -- and position the book as a collection of first-person accounts from the people who made it happen. The framing is deliberately inclusive: they want both the free software philosophical tradition and the open source business pragmatism represented. ## A Brief History of Hackerdom (Eric S. Raymond) Raymond traces hacker culture from its origins at MIT's AI Lab in the 1960s through the rise of Unix, the ARPAnet, Stallman's GNU Project, Linux, and the open source movement's public debut. The narrative is structured as a series of cultural crises and recoveries: the AT&T Unix licensing crackdown, the AI winter that scattered the MIT hackers, the proprietary software era of the 1980s that Stallman rebelled against, and the Linux explosion that proved a decentralized development model could work at scale. Raymond positions Linux as the synthesis that resolved decades of tension -- it combined Stallman's free software tools (GCC, GDB, Emacs) with Torvalds' pragmatic kernel development approach and the internet's ability to coordinate thousands of dispersed contributors. The essay is selective history with a clear arc: hackers are the heroes, and the story ends with their vindication. ## Twenty Years of Berkeley Unix: From AT&T-Owned to Freely Redistributable (Marshall Kirk McKusick) McKusick provides the most technically grounded history in the book. He traces BSD Unix from its origins in Bill Joy's work at Berkeley in the late 1970s through the AT&T lawsuit that nearly killed it in the early 1990s. The key narrative: Berkeley developers gradually replaced AT&T code with their own implementations, eventually producing a system (4.4BSD-Lite) that contained no AT&T proprietary code. But when they tried to release it freely, AT&T subsidiary USL sued. The lawsuit dragged on for years, and by the time it settled (mostly in Berkeley's favor), Linux had captured the momentum that BSD would otherwise have had. McKusick is candid: if the lawsuit had been resolved eighteen months earlier, Linux might never have gained its foothold. The chapter also details the networking code that made BSD essential -- the TCP/IP stack that essentially became the internet's foundation. ## The Internet Engineering Task Force (Scott Bradner) Bradner describes the IETF's operating philosophy -- "rough consensus and running code" -- as a model for how open processes produce standards that actually work. The IETF doesn't vote. It doesn't require unanimity. It requires working implementations before a standard can advance. Bradner contrasts this with the ITU and ISO, where standards are developed through political negotiation and often produce specifications that nobody implements correctly. The IETF's approach -- open participation, public mailing lists, freely available RFCs, decisions tested against working code -- is essentially the open source development model applied to standards-setting. The chapter argues that the internet's success is itself evidence that open processes work. ## The GNU Operating System and the Free Software Movement (Richard Stallman) Stallman's essay is the book's moral center and its most polarizing chapter. He doesn't argue that free software produces better code (though he believes it does). He argues that proprietary software is ethically wrong because it prevents users from helping each other. The GNU Project started in 1984 because Stallman couldn't accept a world where he couldn't share software with his neighbors and modify programs to fit his needs. He details the copyleft mechanism -- using copyright law to guarantee that software and all its derivatives remain free -- and the GPL as its legal implementation. Stallman is precise about his terms: "free as in freedom, not as in price." He's also blunt about his disagreements with the open source movement: he thinks rebranding free software as "open source" to make it palatable to business strips out the ethical argument that matters most. For Stallman, the goal isn't better software. It's a free society. ## Cygnus Solutions: Future of Cygnus Solutions -- An Entrepreneur's Account (Michael Tiemann) Tiemann tells the story of the first company built explicitly on an open source business model. Cygnus Solutions, founded in 1989, sold support and custom development for GNU tools -- GCC, GDB, the BFD binary file descriptor library. The company's insight was that businesses needed reliable, supported development tools and would pay for service even when the software itself was free. Tiemann walks through the company's growth from three founders to 150 employees, its development of GNUPro (a commercial-quality GNU toolchain) and eCos (an open source real-time operating system for embedded systems), and its eventual VC funding. The chapter is honest about the challenges: competing with free, explaining the model to investors who didn't understand how you make money giving away software, and the constant tension between community contributions and commercial product needs. Cygnus was proof of concept that open source could sustain a real business. ## Software Engineering (Paul Vixie) Vixie's essay is the most technically argumentative chapter. He compares traditional software engineering methodology -- with its emphasis on marketing requirements documents, functional specifications, design reviews, and formal testing plans -- against the open source development process, which largely skips all of those stages. His argument is nuanced: open source isn't doing the same thing faster. It's doing different things entirely. Open source projects skip the requirements-gathering phase because developers build what they themselves need, which eliminates the translation loss between users and developers. They skip formal design because the code is the design, and it's open for anyone to critique. Testing happens through massive field deployment rather than through formal test plans. Vixie isn't uncritical -- he notes that open source produces poor documentation and user interfaces because developers don't prioritize things they don't personally need. But he argues that for infrastructure software (operating systems, compilers, network services), the open source model produces higher-quality results than formal engineering processes. ## The Linux Edge (Linus Torvalds) Torvalds explains his design decisions for Linux with characteristic pragmatism. He chose a monolithic kernel design over the microkernel approach that was academically fashionable (and that Tanenbaum had criticized him for). His reasoning: microkernels are theoretically elegant but practically slow, and the modularity they promise can be achieved in other ways. Torvalds also explains why he chose to make Linux freely available under the GPL -- not primarily for ideological reasons (he's not Stallman), but because open access meant more developers, which meant more bug fixes and better code. The essay is short and direct, focused on technical tradeoffs rather than philosophy. Torvalds positions himself as a pragmatist who happened to create something revolutionary, not a revolutionary who set out to change the world. ## Giving It Away: How Red Hat Software Stumbled Across a New Economic Model for the Technology Industry (Bob Young) Young tells Red Hat's story through the lens of brand management and market economics. His central argument: in a commodity market where anyone can download and distribute Linux, the winning strategy isn't to lock up the product but to build the strongest brand. Red Hat gave away its software because holding it back was impossible anyway -- and by being the most generous distributor, they became the most trusted. Young draws analogies to Heinz ketchup (a commodity product differentiated by brand trust) and argues that open source creates a free market for software in the same way that published recipes create a free market for ketchup. The chapter is the book's most business-oriented essay, making the case that open source isn't anti-business -- it's a different business model that happens to benefit consumers more than the proprietary alternative. ## Diligence, Patience, and Humility (Larry Wall) Wall's essay is the book's philosophical outlier -- a wide-ranging meditation on the virtues of open source communities, written with Wall's trademark playfulness and literary references. He frames "diligence, patience, and humility" as the three virtues of the open source community (inverting his famous "laziness, impatience, and hubris" as the three virtues of the programmer). The essay wanders through linguistics, religion, Unicode character sets, and the nature of free speech before arriving at its central point: commercial and free software aren't enemies. They're more like tidally locked planets, each keeping the other in check. Wall argues that the open source movement needs commercial software to provide the competitive pressure that drives innovation, and commercial software needs open source to prevent monopolistic stagnation. It's the most nuanced take on the free-vs-proprietary debate in the book. ## Open Source as a Business Strategy (Brian Behlendorf) Behlendorf, co-founder of the Apache web server project, provides the most systematic analysis of where open source makes business sense and where it doesn't. He introduces a spectrum from infrastructure (where open source thrives) to end-user applications (where it struggles), arguing that the closer software is to a commodity -- operating systems, web servers, compilers, network protocols -- the more natural the open source model becomes. He details Apache's organizational structure: mailing lists, CVS repositories, bug tracking, a meritocratic commit hierarchy. The chapter includes a specific case study of Apache enforcing HTTP standards compliance -- when AOL's proxy servers were sending non-compliant requests that broke websites, Apache developers could simply refuse to accommodate the broken behavior because they had no commercial relationship with AOL to protect. That independence, Behlendorf argues, is open source's structural advantage for infrastructure software. ## The Open Source Definition (Bruce Perens) Perens traces the Open Source Definition from its origins in the Debian Free Software Guidelines, which he wrote in 1997. The chapter walks through each of the definition's criteria -- free redistribution, source code availability, derived works permitted, no discrimination against persons or fields of use -- and explains the reasoning behind each one. He then provides a detailed comparison of major licenses: GPL, LGPL, BSD, MIT, Artistic License, Mozilla Public License, and Qt's QPL. The chapter also covers the KDE/Qt controversy that drove the creation of the definition: KDE was built on Trolltech's Qt library, which wasn't truly free, creating a political crisis in the free software community that was only resolved when Trolltech released Qt under a free license. Perens is precise about licensing details in a way that the other essays aren't, making this chapter the book's most practical reference. ## Hardware, Software, and Infoware (Tim O'Reilly) O'Reilly's essay is the book's most forward-looking. He argues that the distinction between hardware and software is being supplemented by a third category: "infoware" -- the data, content, and dynamic information that powers web applications. Amazon isn't a software company; it's an infoware company that happens to use software. The web itself is an open source platform, built on open protocols and free software (Apache, Perl, sendmail, BIND), and the real value is in the information layer on top. O'Reilly positions Perl not as a programming language in the traditional sense but as the "duct tape of the internet" -- the tool that connects systems, transforms data, and makes the web actually work. The essay anticipated the "Web 2.0" and "platform" concepts that O'Reilly himself would popularize years later. ## Freeing the Source: The Story of Mozilla (Jim Hamerly, Tom Paquin, with Susan Walton) Hamerly and Paquin tell the inside story of Netscape's decision to release the Mozilla browser source code in 1998 -- the event that catalyzed the entire open source movement's mainstream visibility. They detail the internal debates, Frank Hecker's influential whitepaper arguing that open source was strategically necessary, and the enormous technical challenges of actually releasing the code: removing third-party licensed components (a process they call the "Java-ectomy"), cleaning up code that was never written for public scrutiny, and creating new licenses (the Netscape Public License and Mozilla Public License) that balanced open source principles with Netscape's business needs. The chapter is honest about the difficulties -- the mozilla.org team had to build entirely new development infrastructure (the Bonsai source-browsing tool, the Tinderbox automated build system) and convince Netscape's internal engineers that external contributions were worth the overhead. It's a case study in what it actually costs to open-source a large commercial codebase. ## The Revenge of the Hackers (Eric S. Raymond) Raymond's second essay picks up where his first left off, narrating the events of 1998 from his personal perspective. He describes the impact of "The Cathedral and the Bazaar" on Netscape's decision, the founding meeting at VA Research on February 3, 1998 where the term "Open Source" was coined (by Christine Peterson, credited here), and the deliberate marketing strategy he and others crafted to sell open source to the business world. The strategy was explicitly top-down: target Fortune 500 executives, get coverage in elite business media, frame open source in terms of reliability and cost rather than freedom and ideology. Raymond describes the "Halloween Documents" -- leaked Microsoft internal memos acknowledging Linux as a competitive threat -- as a turning point that validated the movement in the press. The essay is triumphalist in tone, predicting the imminent decline of proprietary software and the mainstreaming of open source development. Some of those predictions were right; the timeline was wrong. ## Appendix A: The Tanenbaum-Torvalds Debate The appendix reproduces the famous 1992 Usenet flame war between Andrew Tanenbaum (creator of MINIX) and Linus Torvalds over Linux's monolithic kernel design. Tanenbaum argued that monolithic kernels were a step backward, that Linux wasn't portable, and that microkernel architectures were the future. Torvalds responded that MINIX had its own design problems, that portability wasn't his priority (Linux was for the 386), and that practical performance mattered more than theoretical elegance. The exchange is historically significant because it captures the exact moment Linux could have been dismissed as a student project but wasn't. The most interesting intervention comes from Ken Thompson, who weighs in briefly to say that microkernels are theoretically right but practically unproven -- a characteristically pragmatic take from Unix's co-creator. --- # Key Themes and Highlights ## The Cathedral vs. the Bazaar (Development Models) The tension between centralized and decentralized development runs through almost every essay. Raymond's cathedral/bazaar framework (referenced but not fully developed here -- it's in his separate book) provides the vocabulary, but the actual case studies tell a more complex story. BSD was developed in a cathedral-like environment (Berkeley's CSRG) and produced excellent software. The IETF operates more like a bazaar but with strong process guardrails. Apache uses a meritocratic model with a small core of trusted committers. Linux combines Torvalds' centralized design authority with a bazaar of contributors. The book shows that there's no single "open source development model" -- there are multiple models, adapted to different contexts. ## Freedom vs. Pragmatism The book's deepest fault line runs between Stallman's ethical absolutism and Raymond's strategic pragmatism. Stallman insists that software freedom is a moral imperative -- you don't choose free software because it's more efficient; you choose it because proprietary software is wrong. Raymond (and most of the other contributors) argue that open source wins because it produces better results -- faster development, more reliable code, broader peer review. This isn't a minor disagreement. It's a fundamental split about what the movement is for. Stallman explicitly criticizes the "open source" rebranding in his essay; Raymond explicitly describes why they chose that rebranding. The book captures this tension honestly, without trying to resolve it. ## Business Models for Free Software Multiple essays tackle the question the suits always asked: how do you make money giving away software? Tiemann's answer (Cygnus): sell support and custom development. Young's answer (Red Hat): build brand trust in a commodity market. Behlendorf's answer (Apache): open source is best for infrastructure; build your business on the layers above. O'Reilly's answer: the value isn't in the software itself -- it's in the information and services powered by the software. These aren't competing answers. They're different strategies for different positions in the software stack. The book doesn't pretend there's one business model; it shows several that were working by 1999. ## Legal Infrastructure Matters Licenses aren't boring administrative details. They're the legal architecture that makes open source possible. Stallman's GPL uses copyright law to guarantee that free software stays free -- the copyleft hack that turned intellectual property law against itself. Perens' Open Source Definition created a standard for what counts as "open source." The Mozilla Public License was a compromise between Netscape's business needs and open source principles. The BSD license took a different approach entirely -- maximum freedom, including the freedom to make derivatives proprietary. The KDE/Qt controversy showed what happens when the licensing foundation is wrong. These legal frameworks determined which projects thrived and which got trapped in political fights. ## Open Source as Historical Inevitability (and the Limits of That Claim) Several contributors -- especially Raymond -- frame open source as historically inevitable, the natural conclusion of trends in networking, computing power, and developer culture. The internet made coordination cheap enough that distributed development could outcompete centralized teams. Hardware became powerful enough that operating systems could be given away. Developer culture selected for openness and sharing. This narrative is compelling but risks survivor bias. The book was written at the peak of open source enthusiasm, before the dot-com bust tested the business models and before cloud computing complicated the "freedom" question in ways none of these authors anticipated. --- # Analytical Reading ## Main Arguments 1. Open source software development is a viable alternative to proprietary development, backed by major real-world successes (Linux, Apache, Perl, BSD, BIND, sendmail). 2. The open source model works best for infrastructure software -- operating systems, compilers, web servers, protocols -- where the software is closer to a commodity. 3. Multiple sustainable business models exist for open source: support/services (Cygnus), brand trust in commodity markets (Red Hat), building value on top of free infrastructure (O'Reilly's infoware). 4. Open access to source code enables faster bug-fixing, broader peer review, and higher reliability for infrastructure software. 5. The free software movement has a moral dimension (Stallman) and a pragmatic dimension (Raymond), and these are in genuine tension. 6. Legal frameworks -- especially the GPL and the Open Source Definition -- are essential infrastructure for the movement, not administrative details. 7. Open processes (IETF's "rough consensus and running code," Apache's meritocratic governance) produce standards and software that proprietary processes often can't match. 8. The internet is both a product of and a platform for open source development, creating a virtuous cycle. ## Methodology This is a primary source anthology, not a systematic study. Each essay is a first-person account from someone who helped build the movement. There's no unified methodology -- Stallman argues from ethics, Torvalds from technical pragmatism, Young from market economics, McKusick from historical narrative, Vixie from engineering analysis. The persuasive method varies by author: case studies (Tiemann, Young, Hamerly/Paquin), historical narrative (Raymond, McKusick), technical argument (Torvalds, Vixie), philosophical reasoning (Stallman, Wall), and strategic analysis (Behlendorf, O'Reilly). There's no data analysis, no surveys, no controlled comparisons. The evidence is experiential and anecdotal -- powerful because it comes from the principals, but not systematic. ## Strengths The book's primary strength is authenticity. These aren't observers describing the movement from outside. They're the people who built it, writing at the moment of its mainstream breakthrough. The disagreements between contributors are left unresolved, which gives the book intellectual honesty that a single-author narrative would lack. McKusick's BSD history and Hamerly/Paquin's Mozilla story provide detailed technical and organizational case studies that go beyond slogans. Perens' license comparison is a practical reference. The Tanenbaum-Torvalds debate in the appendix is a priceless primary document. O'Reilly's "infoware" essay is genuinely prescient. The book captures a specific historical moment -- 1998-1999, when open source went from subculture to front page -- in the voices of the people who made it happen. ## Limitations The book is almost entirely written by white American men, reflecting the demographics of the 1990s open source community but not interrogating them. There's no discussion of the barriers that kept others out. The essays are uncritical of open source's failures -- poor documentation, hostile mailing list culture, user interface neglect -- except in passing (Vixie notes the documentation problem). Raymond's essays are triumphalist in a way that aged poorly; proprietary software didn't collapse on the timeline he predicted. The book was written before cloud computing, software-as-a-service, and platform economics complicated the "open source" question -- when the code is free but the platform is locked, what does "freedom" mean? Several essays repeat the same historical ground (Raymond's hacker history, the GNU/Linux creation story), which makes the book feel redundant in places. Stallman's and Raymond's essays are positioned as complementary, but they represent genuinely incompatible visions that the anthology format papers over. The business model discussions are optimistic in a way that the dot-com bust would test within two years. --- # Personal Reflection ## Key Takeaways The most valuable thing about this book is that it captures the open source movement before its own success story became settled history. Reading these essays, you can feel the uncertainty: will businesses actually adopt this? Can you really build companies on free software? Is this a movement or a moment? Two decades later, the answers are clear -- open source won the infrastructure layer and most of the development tooling. But the book also shows how many things the movement's leaders got wrong. Raymond predicted proprietary software's rapid decline; instead, it adapted. Stallman warned that "open source" without ethical commitment would become corporate-friendly window dressing; that's arguably what happened with cloud platforms that use open source but don't contribute back. The Behlendorf essay on infrastructure vs. applications is the most analytically useful framework. His argument that open source dominates where software is a commodity and struggles where it's a differentiator still holds. Linux dominates servers; proprietary software dominates most end-user applications. The infrastructure-to-application spectrum is a better predictor of where open source succeeds than any of the ideological arguments. ## Questions Raised - Has cloud computing (AWS, Azure, GCP) effectively recaptured the value that open source freed? The software is free, but the platform isn't. - Stallman's ethics-first argument was dismissed as impractical in 1999. Does the current state of surveillance capitalism, platform lock-in, and data monopolies vindicate him? - The book's contributors assumed that open source development would always attract enough volunteer developers. What happens when maintainer burnout becomes systemic, as it has with projects like OpenSSL and core-js? - Would the open source movement have developed differently if BSD hadn't been tied up in litigation during the critical 1991-1993 period? Linux filled a vacuum that the lawsuit created. - The book presents open source as a meritocracy. How much of the movement's demographic homogeneity is the result of self-selection vs. active exclusion? - O'Reilly's "infoware" prediction came true, but the companies that profited most from it (Google, Facebook, Amazon) aren't the open source companies the book imagined. What happened? ## Connections to Other Works - [[The Cathedral and the Bazaar]] by Eric Raymond -- Raymond's full development of the cathedral/bazaar framework that's only sketched in these essays. The book that convinced Netscape to open-source Mozilla. - [[Free Software, Free Society]] by Richard Stallman -- Stallman's collected essays expanding the ethical arguments compressed into his chapter here. - [[Just for Fun]] by Linus Torvalds -- Torvalds' autobiography, which expands his Linux origin story beyond the brief essay in this collection. - [[Hackers]] by Steven Levy -- The definitive history of the hacker culture that Raymond traces in his opening essay. Covers the MIT AI Lab, the Homebrew Computer Club, and the origins of the ethic that Stallman later codified. - [[The Innovator's Dilemma]] by Clayton Christensen -- The disruptive innovation framework helps explain why established software companies couldn't respond to open source: it entered at the low end (infrastructure) and moved up. - [[Working in Public]] by Nadia Eghbal -- A modern examination of open source maintenance and community that addresses questions this 1999 book couldn't anticipate: burnout, sustainability, and the economics of attention. --- # Reading Notes - The book was published in 1999 but most essays were written in 1998 -- the same year Netscape opened Mozilla's source and the term "Open Source" was coined. It's a snapshot of a movement in the act of naming itself. - The DiBona/Ockman introduction comparing open source to scientific research is the right analogy. Peer review, open publication, building on prior work, reproducibility -- the parallels are structural, not metaphorical. - McKusick's BSD history is the book's most underappreciated chapter. The AT&T lawsuit delayed BSD's free release by years and handed Linux the window it needed. Counterfactual history, but McKusick clearly believes BSD would have dominated without the lawsuit. - Stallman's essay is morally serious in a way the other essays aren't. Most contributors argue "open source works." Stallman argues "proprietary software is wrong." Those are different claims with different implications. - Tiemann's Cygnus chapter is the best early case study of an open source business model. Selling support for free software sounds obvious now; in 1989 it was genuinely novel. - Vixie's comparison of formal software engineering and open source development is the most technically nuanced essay in the book. His point about open source skipping the requirements phase because developers are their own users is sharp. - Torvalds' essay is characteristically short and practical. He doesn't do philosophy. He explains his design choices and moves on. - Young's Red Hat chapter is pure marketing thinking applied to software. The ketchup analogy is memorable: you can't lock up a commodity, so you compete on brand and trust. - Wall's essay will frustrate readers looking for direct arguments. It's a wandering, literary, philosophical piece -- very Larry Wall. But the "tidally locked planets" metaphor for the commercial/free software relationship is the most sophisticated take on that dynamic in the book. - Behlendorf's Apache essay contains the best specific case study: Apache enforcing HTTP standards by simply refusing to accommodate AOL's non-compliant proxy behavior. No commercial server vendor could have done that. - The Tanenbaum-Torvalds debate in the appendix is essential primary source material. Tanenbaum was technically right about the future (microkernels did become important in mobile operating systems), but Torvalds was practically right about what worked in 1992. - Raymond's "Revenge of the Hackers" is the most dated essay. His prediction that proprietary software was on the verge of collapse reads as wishful thinking twenty-five years later. But his description of the deliberate marketing strategy behind the "Open Source" branding -- targeting Fortune 500, working elite media, choosing pragmatic language over ideological language -- is a valuable insider account of a successful rebranding campaign. - Ken Thompson's brief appearance in the Tanenbaum-Torvalds debate, saying microkernels are unproven, is the most authoritative single comment in the entire book. Unix's co-creator siding with pragmatism over theory in two sentences. - The book's biggest gap: no essay from a woman. The editors apparently didn't notice or didn't prioritize this. It's a snapshot of the movement's demographics as much as its ideas. ## Readwise Highlights - [[3. Resources/Readwise/Books/Open Sources|Open Sources - Kindle Highlights]]