|
Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series) | 
 enlarge | Author: Robert C. Martin
Publisher: Prentice Hall PTR
Category: Book
List Price: $42.99
Buy New: $30.85
You Save: $12.14 (28%)
New (35) Used (7) from $30.85
Avg. Customer Rating:  20 reviews
Sales Rank: 5591
Media: Paperback
Edition: 1
Number Of Items: 1
Pages: 464
Shipping Weight (lbs): 1.5
Dimensions (in): 9 x 6.9 x 1.1
ISBN: 0132350882
Dewey Decimal Number: 005.1
EAN: 9780132350884
ASIN: 0132350882
Publication Date: August 11, 2008
Availability: Usually ships in 1-2 business days
Shipping: International shipping available
Condition: Brand New, Perfect Condition, Please allow 4-14 business days for delivery. 100% Money Back Guarantee, Over 1,000,000 customers served.
|
| Also Available In:
|
| Similar Items:
|
| Editorial Reviews:
Product Description
Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way.
Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmerabut only if you work at it.
What kind of work will you be doing? You’ll be reading codealots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft.
Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up codeaof transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code.
Readers will come away from this book understanding
- How to tell the difference between good and bad code
- How to write good code and how to transform bad code into good code
- How to create good names, good functions, good objects, and good classes
- How to format code for maximum readability
- How to implement complete error handling without obscuring code logic
- How to unit test and practice test-driven development
This book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.
|
| Customer Reviews: Read 15 more reviews...
 Robert Is Amazing! November 29, 2008
Robert C. Martin, or Uncle Bob as he is called, is probably the most impressive coder I have read a book from ever! Right from the word go Robert is filling you with tons of information, skill, and knowledge about what is good code. He doesn't mix any words, letting you know immediately that you will spend some time with this book, it took me almost two weeks to work my way through with a great understanding of the concepts in this book.
I don't want to scare anyone, this book is really important for any coder to read. I will be suggesting it to my employers from now on as a required reading for our developers. The concepts are sound, solid, and make sense. There is no voodoo in this book, and nothing that doesn't come from a great deal of working with code.
Clean Code has the ability to turn any good coder into a great coder, and build teams into better coding machines.
Robert explains the best techniques if factoring code so that it will be easiest to read, and refactor. If the tips, tricks, and suggestions are followed then any coder would be able to follow in your footsteps and enjoy maintaining your code.
There is nothing too outrageous in Clean Code, but instead is a good explanation of why you should code the way we were taught. If you weren't taught to code well, then you really owe it to the coders in your wake to come and read this book.
A Keeper That I Highly Recommend November 26, 2008
1 out of 1 found this review helpful
The software development industry is always maturing. The craft of coding is always advancing.
The book starts with a great manifesto-ish cry for clean code and carries the reader through things to consider. Just reading 2 chapters got me to change the way I code. A book club got started where I work due to this book. It's that good.
This book provides an up-to-date view of what works really well when coding / creating software solutions. This view is supported by a foundation of experience and best practices that have evolved over the years.
What used to be great in the past is now refined and sometimes even backwards of what was once done. In those mind-jarring moments, an explanation is given in the book which really helps one see why they suggest what they do.
The authors clearly have experience which they share in a clear and easy to understand manner.
I highly recommend the book.
 Software Engineering is a Craft! Thank you! November 18, 2008
Before I even read the book, I liked the fact that the title contained the words "software" and "craftsmanship" next to each other! This alone is a good reason for many programmers to keep this book where they can see it - every day. The book is well structured, it is well and thoughtfully written - something you would expect from a book of this kind. I am happy to see a book that - in clear and simple terms - promotes what the great Edsger Dijkstra (considered the Father of the Computing Science by many) had been advocating all his life: elegance, simplicity, and intellectual manageability of software. There have been many articles popping up here and there, addressing various aspects of coding standards and general quality of code. Such articles usually would result in heated discussions, mostly fueled by personal preferences, pride, unwillingness of some people to admit that they hadn't been doing things right always... A book like this was needed..
It's good to see a serious book from a serious author who, for example, finally is not afraid to state: "Use unchecked exceptions. The debate is over". This is music to my ears. Surprisingly, however, the author uses checked exceptions in many of his examples! That seems like a really strange oversight. Any plans to fix that in the 2nd edition, Robert? Also, I think the author only scratches the surface explaining why checked exceptions are "not necessary". What is missing is the explanation why checked exceptions are not safe, in the first place. Most of us know that they result in bad and convoluted code. The bigger problem, however, is that they usually result in incorrect error handling in general. And there is quite a bit of confusion and misunderstanding when it comes to error handling among Java programmers - to this day. So, I am afraid, this particularly important advice from the book will be ignored by many programmers raised on checked exceptions - simply due to the lack of clear explanation and the confusing code examples that use checked exceptions.
While I think it is a very good book, I generally agree with one of the earlier reviewers that some topics are covered without the depth necessary to fully illustrate the practice or issue in question.
As one would reasonably expect, some recommendations may have to be taken with a grain of salt. For example, should we really never use HTML in javadocs? Most of us use IDEs that have excellent support for javadoc viewing via key-shortcuts - by simply pointing to the class or method's name anywhere in the code. I never pull up the method's source to read the in-line Javadoc for it as is. I place the cursor on the method name right where the method is referenced, and do Ctrl-Q in IntelliJ. The nicely formatted Javadoc appears in a pop-up window, so I actually like taking full advantage of any HTML formatting. Eclipse or NetBeans users use similar ways. So, I'd say, use common sense, and make sure the comments are informative, and neat. Which is pretty much what the book says anyway.
By the way, speaking of comments, most code examples in the book contain none of those at all! How come? Another strange oversight... I certainly understand that the author assumes that there is no need for javadocs and comments in the sample code since he explains everything in the text of the chapter. However, consistency is another important rule that the author advocates, and I would prefer to see the sample code follow all the same rules the author is promoting in his book.
One of my favorite parts of the book is Chapter 17 - "Smells and Heuristics". This is a great reference guide for any beginner or anyone who only now starts to show interest in writing quality code. Fortunately, most common IDEs today can be configured to inspect your code and look for each of the anomalies listed in that chapter. Turn those inspections on and never ignore them!
The bottom line is that Software Engineering is a CRAFT, indeed. At the end of the day, a programmer should be able to look at his/her work and be proud of it. Those who don't care should probably find a different occupation. For everyone else, this book is a must-read.
(Disclaimer: This review is based on the electronic copy of the book; the hard copy is still on its way from amazon.com at the time of this writing.)
Excellent book November 18, 2008
Robert C. Martin is one of the most experienced developers in the world and tries to share his wisdom with the reader, and he does so in a very clear and well articulated way. He says clearly that the book is not THE answer, but rather a summary of his own opinions.
The book focuses on making easily maintainable code.
Clean Code Belongs on Every Coder's Shelf November 13, 2008
Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)
First Impressions
I began reading this book with a couple of concerns. First, all the code examples were written in Java, and I haven't written much Java in the last couple of years. Secondly, the books seventeen chapters were written by seven different authors. In my experience, most books with this many authors are at best a collection of uneven chapters, or even worse a morass of redundancy and contradictions. In the end, neither of these concerns proved to be a problem. Instead they demonstrated the authors' point - that clean code is readable code.
The book's main premise is that clean code results from paying attention to the small details (details that are often overlooked in an effort to meet a deadline, or simply get the code working). This overriding theme allows for a seamless blending of each author's contribution into a cohesive readable whole. Where contradictions did occur, the authors not only acknowledged them, but successfully argued that they resulted not from conflicting ideas or approaches, but from differences in priority. Even the high quality of the editing, and typesetting silently reinforce this attention to detail and professionalism. Most computer books have several technical, typographical and grammatical errors in every chapter. I found only a single one in this book (several hundred pages in). This attention to detail silent reinforces the lessons presented in this book.
What's Inside
The book is divided into three parts. Part I (chapters 1-13) demonstrate what makes up clean code, what it looks like, and how to begin creating it (by picking better names, properly using comments, properly structuring your code etc.). By organizing this section into a series of small chapters the reader is able to begin applying these lessons from day one.
Part II (chapters 14-16) contains a series of case studies demonstrating how to apply the rules and guidelines from part I. These case studies show that like refactoring, cleaning code is an iterative process. One that should be undertaken at every opportunity, because all code no matter how good can be improved.
Part III (chapter 17) is a knowledge base. This section documents the rationale behind every change made to the code in the case studies. This final chapter shows that clean code requires both the ability to make the changes, and to know why they were needed.
Final Impression
No book alone can make you a better programmer, anymore than a screwdriver can make you a better carpenter. However, if you have the discipline to go beyond simply getting your code to work, and begin writing clean code, then this book can help you to become a better more professional programmer. If correctly applied over time, it can even serve as a bulwark against an increasingly fragile code base comprised of hacks, kludges and quick fixes. This book not only taught me how to improve my code, but demonstrated that its principals are both timeless, and language agnostic. I would recommend this book to anyone who writes code.
Clean Code A Handbook of Agile Software Craftsmanship
By Robert C. Martin
Published by: Prentice Hall
isbn: 0-13-235088-2
|
|
|
Powered by Associate-O-Matic
| |
