Customer Rating:  
Summary: Clean Code
Comment: Good set of rules for keeping your code up to high standards. But to be honest, most of the rules are common sense and not likely to surprise anyone who cares enough about his code to bother reading this book. Even so, the author's arguments are often not so convincing (i.e. based on anecdotal evidence and personal opinion). This is fine with rules with which you happen to agree, but don't expect this book to change your opinion in the few cases where you don't agree. Then there is also the issue that most bad code isn't bad because the programmers didn't know the proper rules, but because following the rules can be difficult. Most examples in the book are a bit simplistic, but in the second-to-last chapter the author walks us through a complete refactoring where he applies his rules to real code. This is a great idea, though the chapter ends up being a bit tedious. The last chapter contains a concise set of rules -- read this if all you have is five minutes.
Customer Rating:
Summary: Excellent Code Review Resource
Comment: This is a really excellent handbook for use in Design and Code Reviews. After reading this very well written book it is much easier to be effective during code development and in code reviews by providing concise suggestions and being able to back them up with good rationale. The disappointment comes in finding out how poorly written the existing software base is when compared against this Clean Code standard. Even worse is developing new code which cannot meet the clean code standards for one reason or another.
I highly recommend this book for everyone involved in software development. The very pragmatic and disciplined approach takes practice and skill but the rewards are well worth it.
Customer Rating:
Summary: Your Coding Mentor in a Book
Comment: I knew I was going to like this book after I read the Foreword and Introduction. I know not many people read those and as an author myself this bothers me, but it gives insight to why the author has written the book, which is a very important thing to understand. I was hooked by the affirmation that details are important and that the only meaningful metric is the number of "wtfs" per minute in a code review. For a long time I have kept my "profanities per test session" metric as a way to measure software usability.
Long before I was a software testing guy, I was a coder. Back in those days it was common for rookie coders to sit next to guys with gray hair and bad breath (or if lucky next to ladies with better appearance and who smelled better) to learn the craft of writing code. Yes, coding was a craft before the attempt to make it an engineering discipline. Although there was a lot of bad code, there were plenty of people who took pride in how they coded. This book reminds me of what it was like to sit next to these intelligent
people as mentors.
I have often lamented that today's young coders don't have this mentor/apprentice relationship. A reasonable facsimile would be to read this book and practice these very sensible and helpful lessons in coding. As a testing guy who has been through those 30 wtf/hour code reviews, my bulletin to developers is that: Your code can be better! This book can show you how!
Here's one example: Have meaningful names. Instead of a function named "int d", how about "int ElapsedTimeInDays;"? There's a whole chapter about naming things. It reminds me of the coder I knew that liked to label COBOL paragraphs after towns and cities in Kansas. Why? So he could write GOTOs that read "GOTO Topeka." He thought that was cute but the rest of us found it confusing and not-so-cute.
I also appreciated the chapter on Unit Testing. As a tester, I love it when testing is mentioned, but Martin actually has specific guidance on what makes for good Test Driven Development and Unit Testing.
This book is very readable, makes a lot of sense and would make most coders better. For testers that sit in on code reviews, this would be a great read for understanding how good code should be. I wish every coder in college or tech school would read this book before unleashing their creations upon the world.
Customer Rating:
Summary: Excellent resource
Comment: Clean Code provides a good approach for refactoring existing code and provides systematic thinking for the design of new code.
Customer Rating:
Summary: Robert Is Amazing!
Comment: 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.
|
|
