Learn more Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Learn more Click Here Shop Kindle New Album - Foo Fighters Shop now Shop now



There was a problem filtering reviews right now. Please try again later.

on 11 September 2017
This book is really great. It's clearly written and every opinion expressed feels "right" and fits well with practical experience. It's definitely not a casual book and demands attention. I feel it's a book worth coming back to and re-reading every so often.
0Comment|Was this review helpful to you?YesNoReport abuse
on 13 September 2017
A must have book on any developer's shelf :)
0Comment|Was this review helpful to you?YesNoReport abuse
on 21 January 2009
This book has a great summary chapter - Chapter 17. I read this first and decided to read the rest of the book even though there wasn't much I hadn't come across before.

The book really is very readable and covers a lot of ground, generally at intermediate developer level. Advanced developers won't come across anything new, however there is a lot of good advice in one place. This is generally clearly explained with some examples that hint at the level of simplicity that can be achieved in production code with a bit of extra time and a lot of extra effort.

The Law of Demeter is explained with the usual lack of clarity, but there is enough supporting material that I finally understood what it is really about - everything within a scope should be at the same level of abstraction. It was a bit of a revelation when the implications started to sink in.

The Formatting chapter has some interesting insights into the rationale of some of the formatting techniques that I developed naturally over more than 20 years of writing code.

The sub-title reads "A Handbook of Agile Software Craftsmanship". There is the odd nod in the Agile direction, but the text is much more about software craftsmanship than it is about agile, and none the worse for it.

I've already lent the book to one of my colleagues, and I hope to get it back before too long.

Unusually for a Prentice Hall publication the editing is not as good as it should be, and the cover is cheap - it had a distinctive curl after the first reading stint. This is a shame as it's a book that needs to be passed around.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 11 March 2017
More of a reference/dip in that a cover to cover. Even long time programmers should be picking this up to remind them how they should be building software.
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on 19 January 2017
You're a self taught programmer who learned from stack overflow and a second hand beginner's guide to java. You've got an app on google play, and it works, but that's not enough any more because the bug reports are coming in and there are parts of your code where you fear to go. Classes with thousands of lines and nested indentations that stretch across to the margin line. Functions that don't make sense even with the comments you scattered throughout them. It's a mess and you know it. If this rings true for you, then Clean Code by Robert C Martin is going to help you, like it helped me. It's clearly written, easy to understand and provides code examples both good and bad to explain its practices. I just wish I had read it two years ago when I started programming.
0Comment| 4 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 3 May 2009
Every so often, a book comes along that codifies best practice in a way that manages to illuminate the path from where things are right now, to a better place that we'd rather be -- things like Fowler et al. Refactoring: Improving the Design of Existing Code (Object Technology Series) or the Gang of Four Design patterns : elements of reusable object-oriented software. This is one of those books. And if much of the material is the sort that seems obvious in hindsight -- well, that is the mark of a well written book, to make the concepts that clear.

Taking a series of real world examples -- open source projects with significant user bases, including FitNesse and JUnit -- a series of worked examples take us from good, or at least adequate, code, to a form which is better factored, and easier to read, with the steps along the way clearly marked. Yes, even some of Kent Beck's code is put under the microscope, and carefully polished that extra stage or two more.

The reader is cautioned that, without working long hours to follow these examples, this will be just another of those feel-good books. I don't quite agree -- spending just a little time to follow the transformations, and then reflecting on one's own outpourings should be enough to make this a feel-bad book. All the sins from obscurely named variables to sprawling functions that gaily mix abstraction levels, we've all done them (especially programming in FORTRAN on minicomputers with slow stacks and a rule of thumb that 1 call ~ 40 loc in terms of performance).

The maxim to take from the book is based on Baden-Powell's "Try and leave this world a little better than you found it", and owes to the same school of thought as "whenever you are in the garden, pull at least one weed". The meat of the book is in distinguishing what are the weeds from the intended crop.

So read it, understand the examples, and then refer to it often -- like the other titles mentioned, it is a reference work, and should join them as among the most thumbed on your bookshelf.
0Comment| 6 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 21 November 2016
Friggin Fernominal :-)
0Comment|Was this review helpful to you?YesNoReport abuse
on 11 May 2017
Thanks
0Comment|Was this review helpful to you?YesNoReport abuse
on 12 May 2017
Excellent book. Highly recommended for an experienced developer.
0Comment|Was this review helpful to you?YesNoReport abuse
on 22 May 2017
as described
0Comment|Was this review helpful to you?YesNoReport abuse

Sponsored Links

  (What is this?)