Browse Books

Reviewer: Fernando Berzal

As Martin Fowler once wrote, "any damn fool can write code that a computer can understand, the trick is to write code that humans can understand" [1]. Without this reason, we could still be writing code in assembly, and nobody would really complain. But, since maintenance, which obviously includes code reading, takes up a big chunk of the software development budget, it is not enough for code to work. It must also be clean. So, what exactly do professional programmers understand "clean code" to mean__?__ Martin conducted a small survey, asking some of the most renowned programmers for their thoughts on the subject. As you might expect, these experts mentioned elegance, efficiency, readability, modifiability, minimality, testability, simplicity, expressiveness, and abstraction. In this book's introduction, you will find their complete responses, along with Martin's commentary. Once the stage is set, the book proceeds in three complementary directions, which form the basis of its three constituent parts. The first part, chapters 2 to 13, covers the principles, patterns, and practices of writing clean code, from the point of view of Martin and six of his colleagues at Object Mentor Inc. Here, the authors deliberately "use the popular paperback model whereby the author is responsible for making himself clear and not the academic model where it is the scholar's job to dig the meaning out of the paper." These chapters, therefore, are written with an opinion column style. They are to be read more as informal blogging rants than as the final word on the topic. Written by seven different authors, you might find some general disorder, some lack of depth in many topics, and also many loose ends to be pondered. But, even when you might not agree with everything they say, you will still find many commonsense coding guidelines and some witty aphorisms, which are so dear to many agile zealots. The second part of the book, chapters 14 to 16, includes three particular case studies that illustrate how even well-written code can always be refactored and cleaned using test-driven development (TDD) [2]. The premise behind TDD is that code should be continually tested and refactored. Its motto is: first, make it work (pass the automated tests); then, make it right. This part of the book is particularly interesting for inexperienced programmers because it presents refactoring as an iterative process that is full of trial and error-far apart from the typical textbook examples, which are usually polished before publishing and provide the false impression of a perfect first draft. In this book, however, extensive code listings are provided as the author performs tiny steps to improve the code (keeping the tests passing between each pair of consecutive steps, of course). The final chapter of the book contains a list of 66 smells and heuristics that the author compiled by walking through different programs and refactoring them. Each time he changed anything, he asked himself why he had made that change, and then wrote the reason down. This resulted in a list that, even though it could hardly be said to be complete, implies "a value system"-the set of values at the heart of Object Mentor's "school of thought." Whether you find these kinds of expressions and analogies fortunate or not, you can always find some food for thought from Martin's incisiveness and insight. In short, this book makes common sense explicit in the form of coding guidelines, provides three interesting case studies that illustrate the iterative refactoring process needed to produce really maintainable code, and compiles, in a single chapter, many of the underlying heuristics that guide this process. It should be noted, however, that this book is virtually useless for novice programmers, since it assumes some knowledge of automated testing; refactoring; test-driven development; principles, patterns, and practices (PPP); and design patterns, not to mention the need to be able to appreciate the importance of writing clear and maintainable code, something you do not really understand until you have worked on actual projects (lip service in introductory programming classes is not enough). From my point of view, although this book is far inferior to Martin's excellent PPP book [3], it could still be beneficial as an instrument to spark interesting discussions within your own development team, polish your differences until you achieve a consensus, and, in agile terms, develop your own "value system." Online Computing Reviews Service

Reviewer: Ghita Mostéfaoui

If you have been involved in developing on top of legacy code, you have probably felt the pain of working with poorly designed code and a lack of documentation. This situation is simply a source of frustration and a definite cause of errors and project delays. Legacy code is not the only problem; our own code, when badly written, may lead to the same frustration, when used by others or even when extended or customized by the original developer. Writing elegant and maintainable code is, for many developers, an art, rather than a skill we can learn. This is probably due to the lack of training on the subject, as part of the developer's curriculum. However, we must all agree that some developers are more gifted than others in writing clean code, just by looking at the way they name variables and structure methods. Experience is definitely the best way to acquire this skill. Nevertheless, a more productive way is to gather all the tips and tricks in a pedagogical guide, so that budding developers can increase their experience with these best practices in mind. This is what this handbook is all about. Martin provides a synthesis of his experience in software development in the form of a very pedagogical manual for building clean code. The book is based on the Java language and is divided into 17 chapters. Chapter 1 is a general introduction to the book. The introduction is followed by specific advice on how to give meaningful names to variables and functions. Next is a description of best practices in documenting code with comments. The book also discusses code formatting, the only way to improve code readability. Three chapters list guidelines on organizing bigger chunks of code, focusing on data structures, error handling, and the use of third-party code, respectively. One chapter gathers best practices in writing unit tests. The book also discusses class organization and coarse-grained code, including systems and how to build them in a way that decreases complexity, making them easier to maintain. Chapter 12 provides a compact report that depicts simple design rules; these include continuous code refactoring and avoiding duplication. This is followed by an example case study that goes through a refinement process, in order to obtain cleaner code. Another case study is presented to expose bad code design. The final chapter gathers all code heuristics that expose code "smells" and shows how to correct them. While reading the book, I particularly enjoyed the ironic and confident style of the author. His extensive experience as a software developer is definitely the reason behind this confidence. The information is concise, clear, and exemplified with code samples. I also liked the illustrations at the beginning of each chapter, as they gracefully fill out the chapter material; they provide a summarized picture of the story that follows. The book is perfectly suitable for beginners with an elementary knowledge of the Java language. Most of the material is also applicable to any other object-oriented language. I highly recommend the book as a companion to any course on programming languages or software engineering, and even as a reference for more experienced developers. Online Computing Reviews Service