Without question, the biggest advantage of free software is that it allows information to be exchanged between developers, users, and anyone else who has an interest. Users can see how their favorite applications work, developers can peer into the workings of other applications to improve their own code, and so on and so on. By opening up the source, and giving the individual the freedoms to utilize what they find there, free software invariably leads to a more vibrant community and more agile software.
But of course, not everyone in the community has the programming knowledge required to look through the code of a modern open source program and truly understand how it works. Even for those who have the programming knowledge, many software projects are simply too complex for a new user to just dive into and fully grasp.
It’s this exact situation that “The Architecture of Open Source Applications” and this its sequel, “The Architecture of Open Source Applications Volume II”, look to address. By allowing the developers of dozens of well known free and open source software projects to give high level descriptions of their projects in plain English, “The Architecture of Open Source Applications” aims to be a sort of historical reference of open source.
Studying The Greats
From the introduction of “The Architecture of Open Source Applications”:
This book is our attempt to change that. Each chapter describes the architecture of an open source application: how it is structured, how its parts interact, why it’s built that way, and what lessons have been learned that can be applied to other big design problems. The descriptions are written by the people who know the software best, people with years or decades of experience designing and re-designing complex applications. The applications themselves range in scale from simple drawing programs and web-based spreadsheets to compiler toolkits and multi-million line visualization packages. Some are only a few years old, while others are approaching their thirtieth anniversary. What they have in common is that their creators have thought long and hard about their design, and are willing to share those thoughts with you. We hope you enjoy what they have written.
By separating the book into chapters that are each dedicated to a single software project, the book is very easy to navigate. The chapters are not arranged in any (obvious) order, and naturally there is no interconnection between them, so the reader can skip around however he or she pleases. Some programs will invariably be more interesting than others to each individual reader, but all have their lessons to teach and are well represented.
Each chapter is further divided into subsections, which allows for better organization of individual projects. Here, it’s obvious that individual contributors were given a considerable amount of freedom when laying out and writing their respective chapters; as some projects only have a few subsections, while others are nearly books within themselves. The length and complexity of each chapter can vary by a fairly large margin, with CMake coming in at only 3 subsections, while the Selenium WebDriver has 10.
Content wise, the vast majority of the book is plain text. There are a few code snippets here and there, and a healthy dose of diagrams and screenshots, but for the most part everything is laid out as in as much simple English as possible. The developers naturally have different writing styles, so some tend to be heavier on graphics than others, just as some are more anecdotal than others. The very different writing styles between chapters keeps things interesting, and what could have turned into little more than a reference text ends up being a genuinely interesting read.
Both volumes of “The Architecture of Open Source Applications” are identical in terms of format, the only difference being the projects which are featured. If you’re trying to decide which one you should read, you can simply look through the chapters and see which one includes more projects in which you are personally interested, though reading both certainly isn’t a bad idea either.
Licensing and Distribution
Both volumes of “The Architecture of Open Source Applications” have been released under the Creative Commons Attribution 3.0 Unported license, which of course means that you are free to view and copy the books however you see fit.
Accordingly, both books can be read in their entirety on the official Architecture of Open Source Applications website, free of charge. However, they’re also available in paperback form via Lulu and Amazon for $35. If you would rather a digital version, you can get DRM-free PDF or EPUB files from Lulu, or purchase it on your Kindle from the Amazon Marketplace for $10.
No matter which version you purchase, all sales are donated to Amnesty International, and organization dedicated to fighting for human rights. So even though you don’t need to spend any money on these books, the convenience of a proper digital edition and the fact that the sales will go to a very good cause make it easy to part with a few bucks for them.
A listing of all available purchase options, and their respective donations towards Amnesty International, is available on the site.
If there is anything negative to be said about “The Architecture of Open Source Applications”, it will surely be about the software projects which made the cut and the ones that didn’t. Not to say that there is anything wrong with the projects which have been featured, but the Internet is full of very opinionated users, and surely somebody out there is going to be put off by the fact that their favorite software isn’t mentioned.
Compiling a list of significant open source projects is perhaps a more difficult task than one might think initially. How do you determine who makes the list? What is the criteria for inclusion? Even when you have decided which programs you want to include in your book, there’s no telling if you can get anyone with sufficient knowledge of that software to write a chapter for it.
Considering the difficulties of the task, “The Architecture of Open Source Applications” does an excellent job of collecting up the first hand accounts of how some of the best known free software projects have evolved. As a reference for programmers, it offers a very rare glimpse into the development process and indeed the minds of other developers. For those who are merely interested in free software, the books are an excellent example of how open source software is developed, and how the free flow of information can help other developers and the community as a whole.