Table of Contents
If all goes well, The Architecture of Open Source Applications will be available for purchase by the beginning of May. As a teaser, there’s a table of contents below the fold–we think it’s going to be a great book, and hope you’ll think so too.
- Amy Brown & Greg Wilson: Introduction (15)
- Russell Bryant: Asterisk (21)
- Critical Architectural Concepts (21)
- Channels (21)
- Channel Bridging (22)
- Frames (23)
- Asterisk Component Abstractions (24)
- Channel Drivers (24)
- Dialplan Applications (26)
- Dialplan Functions (27)
- Codec Translators (27)
- Threads (28)
- Network Monitor Threads (28)
- Channel Threads (29)
- Call Scenarios (29)
- Checking Voicemail (29)
- Bridged Call (31)
- Final Comments (32)
- Critical Architectural Concepts (21)
- James Crook: Audacity (35)
- Build Systems (36)
- wxWidgets Library-GUI (38)
- ShuttleGui Layer (39)
- The TrackPanel (40)
- PortAudio Library: Recording and Playback (41)
- BlockFiles (43)
- Scripting (45)
- Real-Time Effects (46)
- Summary (46)
- Chet Ramey: The Bourne-Again Shell (49)
- Introduction (49)
- Bash (49)
- Shell Syntactic Units and Primitives (51)
- Shell Primitives (51)
- Variables and Parameters (51)
- The Shell Programming Language (52)
- A Further Note (52)
- Input Processing (53)
- Readline and Command Line Editing (53)
- Non-interactive Input Processing (54)
- Multibyte Characters (55)
- Parsing (55)
- Word Expansions (56)
- Parameter and Variable Expansions (57)
- And Many More (57)
- Word Splitting (57)
- Globbing (58)
- Implementation (58)
- Command Execution (58)
- Redirection (58)
- Builtin Commands (59)
- Simple Command Execution (60)
- Job Control (60)
- Compound Commands (61)
- Lessons Learned (61)
- What I've Found is Important (61)
- What I Would Have Done Differently (62)
- Conclusions (62)
- Introduction (49)
- Margo Seltzer & Keith Bostic: Berkeley DB (63)
- In the Beginning (63)
- Architectural Overview (65)
- The Access Methods: Btree, Hash, Recno, Queue (69)
- The Library Interface Layer (70)
- The Underlying Components (71)
- The Buffer Manager: Mpool (72)
- The Mpool File Abstraction (72)
- Write-ahead Logging (73)
- The Lock Manager:Lock (73)
- Lock Objects (74)
- The Conflict Matrix (74)
- Supporting Hierarchical Locking (75)
- The Log Manager: Log (76)
- Log Record Formatting (76)
- Breaking the Abstraction (77)
- The Transaction Manager: Txn (78)
- Checkpoint Processing (79)
- Recovery (79)
- Wrapping Up (81)
- Bill Hoffman & Ken Martin: CMake (83)
- CMake History and Requirements (83)
- How CMake is Implemented (85)
- The CMake process (86)
- CMake: The Code (87)
- Graphical Interfaces (90)
- Testing CMake (91)
- Lessons Learned (91)
- Backwards Compatibility (91)
- Language, language, language (92)
- Plugins Did Not Work (92)
- Reduce Exposed APIs (92)
- Kim Moir: The Evolution of Eclipse Architecture (93)
- Early Eclipse (94)
- Platform (94)
- Java Development Tools (JDT) (102)
- Plug-in Development Environment (PDE) (103)
- Eclipse 3.0: Runtime, RCP and Robots (103)
- Runtime (103)
- Rich Client Platform (RCP) (107)
- Eclipse 3.4: Brought to you by the letter p and the number 2 (108)
- p2 Concepts (111)
- Eclipse 4.0 (112)
- Modeled workbench (113)
- Cascading Style Sheets (CSS) Styling (113)
- Dependency Injection (115)
- Application Services (118)
- Conclusion (118)
- Early Eclipse (94)
- Chris Davis: Graphite (121)
- The Database Library—Storing Time-Series Data (121)
- The Back-end—A Simple Storage Service (122)
- The Front-end—Graphs On-Demand (123)
- Dashboards (124)
- An Obvious Bottleneck (124)
- Optimizing I/O (125)
- Keeping It Real-Time (126)
- Kernels, Caches, and Catastrophic Failures (126)
- Clustering (127)
- A Brief Analysis of Clustering Efficiency (128)
- Distributing Metrics in a Cluster (128)
- Design Reflections (129)
- Becoming Open Source (130)
- Robert Chansler, Sanjay Radia, & Suresh Srinivas: The Hadoop Distributed File System (131)
- Introduction and Related Work (131)
- Architecture (132)
- NameNode (132)
- Image and Journal (132)
- DataNodes (132)
- HDFS Client (133)
- CheckpointNode (134)
- BackupNode (135)
- Upgrades and File System Snapshots (135)
- File I/O Operations and Replica Management (136)
- File Read and Write (136)
- Block Placement (138)
- Replication management (139)
- Balancer (140)
- Block Scanner (140)
- Decommissioning (140)
- Inter-Cluster Data Copy (141)
- Practice at Yahoo! (141)
- Durability of Data (141)
- Caring for the Commons (142)
- Scaling and HDFS Federation (142)
- Lessons Learned (143)
- Acknowledgment (143)
- C. Titus Brown & Rosangela Canino-Koening: Continuous Integration (145)
- The Landscape (145)
- What Does Continuous Integration Software Do? (146)
- External Interactions (148)
- Architectures (150)
- Implementation Model: Buildbot (150)
- Implementation Model: CDash (151)
- Implementation Model: Jenkins (152)
- Implementation Model: Pony-Build (153)
- Build Recipes (155)
- Trust (155)
- Choosing a Model (155)
- The Future (156)
- Concluding Thoughts (156)
- Acknowledgements (157)
- The Landscape (145)
- Emil Ivov: Jitsi (159)
- Designing Jitsi (159)
- Jitsi and the OSGi Framework (160)
- Building and Running a Bundle (162)
- Protocol Provider Service (164)
- Operation Sets (165)
- Accounts, Factories and Provider Instances (165)
- Media Service (167)
- Capture, Streaming, and Playback (167)
- Codecs (167)
- Connecting with the Protocol Providers (168)
- UI Service (169)
- Lessons Learned (171)
- Java Sound vs. PortAudio (171)
- Video Capture and Rendering (172)
- Video Encoding and Decoding (172)
- Others (173)
- Acknowledgement (173)
- Chris Lattner: LLVM (175)
- A Quick Introduction to Classical Compiler Design (176)
- Implications of this Design (176)
- Existing Language Implementations (177)
- LLVM's Code Representation: LLVM IR (178)
- Writing an LLVM IR Optimization (179)
- LLVM's Implementation of the Three-Phase Design (181)
- LLVM IR is a Complete Code Representation (181)
- LLVM is a Collection of Libraries (182)
- Design of the Retargetable LLVM Code Generator (184)
- LLVM Target Description Files (184)
- Interesting Capabilities Provided by a Modular Design (186)
- Choosing When and Where Each Phase Runs (186)
- Unit Testing the Optimizer (187)
- Automatic Testcase Reduction with BugPoint (188)
- Retrospective and Future Directions (188)
- A Quick Introduction to Classical Compiler Design (176)
- Dirkjan Ochtman: Mercurial (191)
- A Short History of Version Control (191)
- Centralized Version Control (191)
- Distributed Version Control (193)
- Data Structures (194)
- Context (195)
- A Solution: Revlogs (196)
- The Three Revlogs (196)
- The Working Directory (198)
- Versioning Mechanics (198)
- Branches (198)
- Tags (199)
- General Structure (199)
- Extensibility (200)
- Writing Extensions (201)
- Hooks (201)
- Lessons Learned (202)
- A Short History of Version Control (191)
- Adam Marcus: The NoSQL Ecosystem (205)
- What's In a Name? (205)
- SQL and the Relational Model (205)
- NoSQL Inspirations (206)
- NoSQL (207)
- NoSQL Data and Query Models (208)
- Key-based NoSQL Data Models (208)
- Graph Storage (210)
- Complex Queries (210)
- Transactions (210)
- Schema-free Storage (211)
- Data Durability (211)
- Single-server Durability (211)
- Multi-server Durability (213)
- Scaling for Performance (213)
- Do not Shard Until You Have To (214)
- Sharding Through Coordinators (214)
- Consistent Hash Rings (215)
- Range Partitioning (217)
- Which Partitioning Scheme to Use? (219)
- Consistency (219)
- A little bit about CAP (220)
- Strong Consistency (220)
- Eventual Consistency (221)
- A Final Word (223)
- References (223)
- What's In a Name? (205)
- Tarek Ziadé: Python Packaging (225)
- Introduction (225)
- The Burden of the Python Developer (226)
- The Current Architecture of Packaging (227)
- Distutils Basics and Design Flaws (227)
- Metadata and PyPI (229)
- Architecture of PyPI (230)
- Architecture of a Python Installation (234)
- Setuptools, Pip and the Like (234)
- What About Data Files ? (235)
- Improved Standards (236)
- Metadata (236)
- What's Installed? (238)
- Architecture of Data Files (239)
- PyPI Improvements (242)
- Implementation Details (244)
- Conclusion (246)
- References and Contributions (246)
- Francesco Cesarini, Andy Gross, & Justin Sheehy: Riak and Erlang/OTP (247)
- An Abridged Introduction to Erlang (247)
- Process Skeletons (249)
- OTP Behaviors (250)
- Introduction (250)
- Generic Servers (251)
- Starting Your Server (252)
- Passing Messages (253)
- Stopping the Server (255)
- Other Worker Behaviors (255)
- Finite State Machines (255)
- Event Handlers (256)
- Supervisors (257)
- Supervisor Callback Functions (257)
- Applications (260)
- Replication and Communication in Riak (260)
- Conclusions and Lessons Learnt (261)
- Acknowledgments (261)
- Simon Stewart: Selenium WebDriver (263)
- History (263)
- A Digression About Jargon (265)
- Architectural Themes (265)
- Keep the Costs Down (266)
- Emulate the User (266)
- Prove the Drivers Work (266)
- You Shouldn't Need to Understand How Everything Works (266)
- Lower the Bus Factor (267)
- Have Sympathy for a Javascript Implementation (267)
- Every Call is an RPC Call (267)
- Final Thought: This is Open Source (267)
- Coping with Complexity (268)
- The WebDriver Design (269)
- Dealing with the Combinatorial Explosion (271)
- Flaws in the WebDriver Design (271)
- Layers and Javascript (272)
- The Remote Driver, and the Firefox Driver in Particular (275)
- The IE Driver (280)
- Selenium RC (284)
- Looking Back (286)
- Looking to the Future (287)
- Eric Allman: Sendmail (289)
- A Fertile Field (289)
- A Hodgepodge of Networks (289)
- A Paucity of Technology (290)
- A Plethora of Poorly Defined Standards (290)
- A Pot of Glue (290)
- Design Principles (291)
- Accept that One Programmer is Finite (291)
- Don't Redesign User Agents (291)
- Don't Redesign the Local Mail Store (291)
- Make Sendmail Adapt to the World, Not the Other Way Around (292)
- Change as Little as Possible (292)
- Think About Reliability Early On (292)
- Development Phases (292)
- Wave 1: delivermail (293)
- Wave 2: sendmail 3, 4, and 5 (293)
- Wave 3: the Chaos Years (294)
- Wave 4: sendmail 8 (294)
- Wave 5: the Commercial Years (295)
- Whatever Happened to sendmail 6 and 7? (295)
- Design Decisions (296)
- The Syntax of the Configuration File (296)
- Rewriting Rules (296)
- Using Rewriting to do Parsing (297)
- Embedding SMTP and Queueing in sendmail (297)
- The Implementation of the Queue (298)
- Accepting And Fixing Bogus Input (299)
- Configuration and the Use of M4 (299)
- Other Considerations (300)
- A Word About Optimizing Internet Scale Systems (300)
- Milter (300)
- Release Schedules (301)
- Security (301)
- Evolution of Design (302)
- Configuration Became More Verbose (302)
- More Connections with Other Subsystems: Greater Integration (303)
- Adaptation to a Hostile World (303)
- Incorporation of New Technologies (304)
- What If I Did It Today? (304)
- Things I Would Do Differently (304)
- Things I Would Do The Same (305)
- Conclusions (306)
- A Fertile Field (289)
- Roy Bryant & Andrés Lagar Cavilla: Snowflock (307)
- Introducing Snowflock (307)
- VM Cloning (308)
- SnowFlock's Approach (309)
- Architectural VM Descriptor (311)
- Parent-Side Components (311)
- Memserve Process (311)
- Multicasting with Mcdist (312)
- Virtual Disk (313)
- Clone-Side Components (313)
- Memtap Process (313)
- Clever Clones Avoid Unnecessary Fetches (314)
- VM Cloning Man Page (314)
- API Implementation (314)
- Necessary Mutations> (315)
- Conclusion (316)
- Audrey Tang: Social Calc (317)
- Introduction (317)
- WikiCalc (318)
- SocialCalc (321)
- Command Run-loop (323)
- Table Editor (325)
- Save Format (327)
- Rich-text Editing (328)
- Types and Formats (329)
- Rendering Wikitext (331)
- Real-time Collaboration (332)
- Cross-browser Transport (332)
- Conflict Resolution (335)
- Remote Cursors (336)
- Lessons Learned (337)
- A Chief Designer with a Clear Vision Worked Really Well (337)
- Wikis for Project Continuity (337)
- Embrace Time Zone Differences (338)
- Optimize for Fun (338)
- Drive development with Story Tests (338)
- Open Source With CPAL (339)
- Danielle Madeley: Telepathy (341)
- Components of the Telepathy framework (342)
- How Telepathy uses D-Bus (344)
- Handles (346)
- Discovering Telepathy Services (347)
- Reducing D-Bus Traffic (347)
- Connections, Channels and Clients (349)
- Connections (349)
- Channels (349)
- Requesting Channels, Channel Properties and Dispatching (350)
- Clients (352)
- The Role of Language Bindings (353)
- Asynchronous Programming (353)
- Object Readiness (354)
- Robustness (355)
- Extending Telepathy: Sidecars (356)
- A Brief Look Inside a Connection Manager (356)
- Lessons Learned (357)
- Alan Laudicina & Aaron Mavrinac: Thousand Parsec (359)
- Anatomy of a Star Empire (360)
- Objects (361)
- Orders (361)
- Resources (362)
- Designs (363)
- The Thousand Parsec Protocol (363)
- Basics (364)
- Players and Games (364)
- Objects, Orders, and Resources (366)
- Design Manipulation (366)
- Server Administration (368)
- Supporting Functionality (369)
- Server Persistence (369)
- Thousand Parsec Component Language (369)
- BattleXML (370)
- Metaserver (370)
- Single-Player Mode (370)
- Lessons Learned (372)
- What Worked (373)
- What Didn't Work (373)
- Conclusion (373)
- Anatomy of a Star Empire (360)
- Cay Horstmann: The Violet UML Editor (375)
- Introducing Violet (375)
- The Graph Framework (376)
- Use of JavaBeans Properties (380)
- Long-Term Persistence (382)
- Java WebStart (384)
- Java 2D (384)
- No Swing Application Framework (386)
- Undo/Redo (387)
- Plugin Architecture (388)
- Conclusion (389)
- Juliana Freire, David Koop, Emanuele Santos, Carlos Scheidegger, Claudio Silva, & Huy Vo: VisTrails (391)
- System Overview (392)
- Workflows and Workflow-Based Systems (392)
- Data and Workflow Provenance (393)
- User Interface and Basic Functionality (394)
- Project History (394)
- Inside VisTrails (395)
- The Version Tree: Change-Based Provenance (395)
- Workflow Execution and Caching (397)
- Data Serialization and Storage (397)
- Extensibility Through Packages (398)
- VisTrails Packages and Bundles (399)
- Passing Data as Modules (400)
- Components and Features (401)
- Visual Spreadsheet (401)
- Visual Differences and Analogies (403)
- Querying Provenance (403)
- Persistent Data (404)
- Upgrades (405)
- Sharing and Publishing Provenance-Rich Results (405)
- Lessons Learned (407)
- Acknowledgments (407)
- System Overview (392)
- Berk Geveci & Will Schroeder: VTK (409)
- What Is VTK? (410)
- Architectural Features (410)
- Core Features (410)
- Representing Data (412)
- Pipeline Architecture (413)
- Rendering Subsystem (417)
- Events and Interaction (419)
- Summary of Libraries (420)
- Looking Back/Looking Forward (420)
- Managing Growth (421)
- Technology Additions (421)
- Open Science (422)
- Lessons Learned (422)
- Richard Shimooka & David White: Battle For Wesnoth (425)
- Project Overview (426)
- Wesnoth Markup Language (427)
- Units in Wesnoth (430)
- Wesnoth's Multiplayer Implementation (431)
- Conclusion (432)