Beautiful Code: Leading Programmers Explain How They Think

Beautiful Code is a unique book. It is not bound by a particular system, or programming language, or methodology. Instead, it tries to straddle the entire field of programming with the ostensible aim of exploring beauty in computer code. What we get is a smorgasborg of essays that posits competing definitions of technical beauty in very different pieces of code. As such, the book becomes a dialectical argument between different conceptions of technical beauty. It may even serve as a rorsarch test to your sensibilities as a programmer. In the process, you may discover algorithms that are startling in their beauty and ingenuity. Given the broad sweep of the book, the quality of the essays is somewhat of a crap-shoot. What I found more interesting was working out why I found some of the essays elegantly persuasive, whilst others, I found to be a turgid sludge to wade through. In the end, it becomes almost impossible to separate the quality of the writing from the definition of beauty defined in the essay. Technical beauty is a very strange beast. It is different from the kind of beauty that resides in the curve of Scarlet Johanssen's lips. In physics and maths, there is a tradition of invoking beauty in certain equations. Einstein's equations for general relativity surely merits that description, as does Euler's formula. For me, technical beauty refers to that rare fusion of concision, efficiency and surprisingly deep connections between seemingly unrelated phenomena. I found that the essays that I liked were the ones that focused on very specific pieces of code. These essays would carefully explain the problem that the programmer was trying to solve, articulate the constraints, and show the straightforward (and usually less elegant) alternatives. They would then go through all the blind-alleys before unveiling the final solution, which would be as surprising as it was elegant. After all, the father of the essay, Montaigne, coined the term "essai", which means attempt in french. The essays that didn't work would try to describe how the software worked, and skip over the details. But these are technical essays, after all, and without a careful consideration of technique, all that is left is flabby writing. Surprisingly, there were quite a number of essays devoted to scientific programming, with contributions from the writers of BioPerl, Numpy, LAPACK, and the NASA Mars module. Most of these I found rather unsatisfactory, the kind of flabby essays that skipped over interesting technical details. They offered no fundamental insight to how the code was implemented other than the fact that these packages have stood the test of time. The exception was Trevor Oliphant's essay on Numpy, which showed how a powerful iterator implementation can dramatically simplify the organization of a linear algebra library. How detailed were the techniques? In Henry S. Warren Jr's essay, he describes how one might count bits in C. It's a marvelous essay because throu

Any experienced programmer can tell you that there is a huge difference between code, good code, and beautiful code. The ability to find the simple, elegant, clever, and most of the time, non-obvious solutions to daunting problems is what separates expert programmers from their peers. This book is really a collection of essays by famous names in the programming world, all describing how they solved a particular problem with a little bit of 'beautiful code'. With over thirty contributers, there is quite a bit of material here - and with names like Brian Kernighan and Karl Fogel, you know the material is worth reading. Firstly, I want to mention how impressed I am with the design of the book. This is the first O'Reilly publication, and really, first programming book, that I would describe as having a beautiful design. A lot of thought went into the book design, and it shows. Typeface, whitespace, layout, diagrams, organization - it all comes together to form a text as beautiful as the topic that it covers. This text has raised the bar regarding style, and I hope O'Reilly takes some of the successes of this style and includes them in future works. Because there are over thirty authors in the text, it is hard to talk about the writing itself. However, I will say that there wasn't a single essay that I found poorly written. Unlike most other programming texts, the authors in this book know both their material and how to communicate it effectively. The editors, Oram and Wilson, did a fantastic job putting the essays together and making sure they flow. Each essay is presented as a personal work of that particular author. Each one has a unique tone, writing style, and approach. The result is that each essay feels more like a one-on-one discussion with the programmer about how a certain problem was solved instead of a textbook chapter covering an particular programming lesson. Within each chapter, you will get little bits of insight into the author through the writing, and I found this almost as interesting as the topic itself. The pieces of humor and side notes that the authors spread through their writing add a fun flavor to the book, and you really get a sense that the authors enjoy what they are doing and are passionate about sharing it with others. I was also very happy with the liberal use of diagrams and code examples. Not including diagrams and images in textbooks is a pet-peeve of mine, and I was elated to find that nearly every essay in the text uses them extensively. The final topic that I want to talk about is the code itself. Unsurprisingly, the text is fantastic in this regard. The authors do an excellent job of only showing you the code that you need to see to follow what they are saying, and they try to keep it clean and simple. This isn't to say that there isn't a lot of code in the book - in fact, it is quite the opposite. There is a huge amount of code in the text, but it is presented and discussed in small bits to keep it from be

This is a collection of 33 articles, all new and commissioned for this book, dealing with aspects of beauty in software design and implementation. Most are brief case studies of particular systems, with a few instead dealing with solutions to particular problems. They cover a impressive variety of applications, platforms, and programming languages. The book is worth reading just to see what people are up to today. The examples come mostly from the United States, but all parts of the world are represented. All articles are well-written but not all will be interesting to a particular reader. My three favorites: "The Most Beautiful Code I Never Wrote" by Jon Bentley (clever title, clever article, about instrumenting Quicksort) "The Quest for an Accelerated Population Count" by Henry S. Warren, Jr. (a dozen different ways to count the one-bits in an array) "When a Button is all That Connects you to the World" by Arun Mehta (Stephen Hawking's only way to control his environment and communicate is through pressing a single button - this system is a great user interface study and shows many clever ways to anticipate what he wants to accomplish and cuts down the time it takes him to do things) As I was reading this book I was frequently reminded of the proverb "Beauty is in the eye of the beholder". In some cases it was a stretch to call the work beautiful, while others (notably Adam Kolawa's "The Long-Term Benefits of Beautiful Design") went to considerable trouble to identify and illustrate the types of beauty. One conspicuous omission in the book was the (mostly European) tradition of program proving and developing a program so its correctness can be verified by a short and elegant proof. An earlier "beauty" book, Beauty Is Our Business: A Birthday Salute to Edsger W. Dijkstra (Monographs in Computer Science), in many ways similar to this one, emphasizes program proving and correctness. In some ways the earlier book focuses on "formal beauty" while the present book focuses on "pragmatic beauty".

I am always looking to for new ways to look at programming problems. I love studying new programming languages in order to bend my mind in new, uncomfortable ways. Both of these are reasons I enjoyed Beautiful Code. Beautiful Code is a collection of essays from some well known software engineers. That said, I didn't immediately recognize many of their names (this is probably an indication of my lack of exposure in their fields of expertise). If you are like me, there is an alphabetical list of short biographical entries in the back of the book you can use to acquaint yourself with who wrote each chapter. There are chapters from people in the Perl, Python, Ruby, Google, Scheme, and Haskell communities (among others). I especially enjoyed reading about Google's MapReduce algorithm, Haskell's Software Transactional Memory, and Scheme's syntax-case macro system. These are subjects I have previously tried to tackle, but the explanations written in this book have helped me approach understanding far better than the academic papers on these subjects I have tried to read. You'll have to put forth effort to follow the explanations in the chapters as the authors walk you through how they tackle a given problem. This leads eventually to the solution, but may involve many twists and turns along the way. These twists and turns show how the authors think and grants us as the readers insight into how they approach the problems at hand. It's the journey to the desination that sometimes matters more than the destination. For example, I've long wondered abut the difference between hygenic and non-hygenic macros. Various descriptions on the web have given me some clue, but chapter 25 shows examples and explains the problem very clearly. It then goes about discussing various solutions that have been devised over the years before going into the details of the current solution that is in use today. I've seen the end result before, but knowing what motivated the solution gives me a much greater appreciation for and understanding of it. The effort required for some chapters may be over your head as they are for me, but those are the chapters where I find the rewards to be the greatest as they force me to look at things in new ways. Once I do achieve understanding I'm able to apply the new found ways of thinking about problems to the situations I face at work and elsewhere which has led to unique and compelling solutions that I would not have thought of before. I've long been on the search for beauty in the code I write. I have found that as I read and take the time to understand what others see as beautiful, even when I do not see beauty in it at first, I gain greater insights into my craft. I am glad that O'Reilly has taken the time to solicit responses from the authors in this book as it has given us a wealth of experience and expertise that we all can benefit from as we seek to gain greater insights into the various facets of beauty and elegance in code.

This book surveys the range of human invention and ingenuity in the development of computer systems. The elegance in each contributor's offering comes from the discovery of unique solutions, a discovery that comes from the authors' power to look beyond established boundaries, to see needs that have been overlooked by others, and to find innovative solutions to difficult problems. Many of the authors have confronted limitations in the physical environment, in resources, or in requirements that made it hard to believe that there were workable solutions that confronted and solved all problems, and then came up with those solutions. Still others already had a solution that worked, but came up with something new and innovative that worked even better. All the authors in this book have drawn lessons from their projects, but you can learn some even broader lessons after reading the entire book. 1. There are times when rules really do work and you don't have to abandon good technique in order to meet your design requirements. Often you just need to get away from the problem and then approach it again anew in order to see the solution. 2. Some chapters confirm that you must know the rules before you can break them. Some of the authors in this book had years of experience being masters of the various rules of software design before deciding to take an unconventional route toward solving a difficult problem, and this experience gave them the confidence they needed to break the rules in a constructive way. 3. Cross-disciplinary studies are championed by the lessons in this book. Many authors came into new domains and had to find their way in relative darkness. A particularly pure form of creativity and intelligence triumphed in a situation that required pioneers and free thinkers. 4.Finally, this book reveals that beautiful solutions don't last for all time. New circumstances will always require a new look. So, if you read this book and think that the authors' ideas and contributions are not relevant to your current problems, the situation could change in a few months or a few years. This is one of those books that should be useful to you for a long time to come since the lessons taught here don't go out of style as programming languages and technologies are born and eventually abandoned. Highly recommended.