|
|
Digital Cameras - Camcorders - Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)
|
List Price: $42.99
Our Price: $31.24
Your Save: $ 11.75 ( 27% )
Availability: Usually ships in 24 hours
Manufacturer: Prentice Hall PTR
|
Average Customer Rating:  
|
|
Binding: Paperback
Dewey Decimal Number: 005.1
EAN: 9780132350884
ISBN: 0132350882
Label: Prentice Hall PTR
Manufacturer: Prentice Hall PTR
Number Of Items: 1
Number Of Pages: 464
Publication Date: 2008-08-11
Publisher: Prentice Hall PTR
Studio: Prentice Hall PTR
|
|
|
|
|
|
Spotlight customer reviews:
|
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.
|
|
|
Editorial Reviews:
|
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 programmer—but only if you work at it.
What kind of work will you be doing? You’ll be reading code—lots 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 code—of 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.
|
|
|
|
|
|
|
|
|
