Learn more Download now Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Learn more Shop Fire Shop Kindle Learn More Shop now Shop now Learn more

on 29 September 2017
An absolute must-read for all software engineers and programmers and especially so if you work with Java or any such programming language. The first half of the book explains the concepts that make up clean code (naming, formatting, testing etc) and lays down the foundation. The second half of the book contains examples of the author working through and cleaning and refactoring code. It all comes together nicely and I've found it to be really impactful in influencing how I think about code.
0Comment| 2 people found this helpful. Was this review helpful to you? Report abuse
on 8 February 2018
This is a good book for beginner developers, or for whom who just want to review and refresh all the principles of the clean code. If you are an experienced programmer, I am sure that sometimes you will find this book obvious, and sometimes very illustrative.

Before reading this book, I recommend having a good understanding of Java and Object-Oriented programming. Don't forget Abstract classes, Interfaces, and Polymorphism.

In my opinion, it has more than 100 pages in excess.The appendixes and the chapter 14 (Refinement) don't contribute to anything. They are just boring. Also, I think that chapter 13 (Systems) could seem a little bit complex for beginners. It needs a very specific knowledge of Java, with concepts like EJB, JNDI, Proxies, and so on.

On the other hand, every concept is explained accurately with lots of examples. In addition, the "Smells and Heuristics" chapter summarizes the essence of this book very well.
0Comment| One person found this helpful. Was this review helpful to you? Report abuse
on 22 September 2011
I knew this was going to be an excellent book from the moment I heard Uncle Bod describing his ideas of Clean Code at his key note at an ACCU conference. I bought the book there and then, but didn't start reading it until a couple of years later. More recently I got it signed by Uncle Bob at Skillsmatter. After just a few pages it propelled itself into my top three books every programmer should read (behind Kent Beck's Test Driven Development and The Pragmatic Programmer by Andy Hunt & David Thomas) and at the end it's still there.

The chapter on comments is worth the price of the book alone. I have worked in places over the last few years, where comments have been encouraged to explain the code, rather than writing code that explains itself. Another great chapter is the one on functions and the advice to keep them small is especially good and compelling. As I look back over the table of contents now, every chapter that describes how to improve an aspect of code is an absolute mine of good advice.

The final few chapters contain a number of refactorings. One on an application from the ground up and the others on existing code written by other people. This is the only place where the book got gratuitous and I must admit I skipped most of the final refactoring.

The final chapter is a summary of the advice given in the rest of the book and something I will find myself referring to again and again.

If you've read Test Driven Development and The Pragmatic Programmer, make sure you read Clean Code next.
0Comment| 2 people found this helpful. Was this review helpful to you? Report 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? Report abuse
on 28 November 2008
This book is, believe it or not, a page turner! Yes, dear friends, you heard me. I know how boooorrriiing and dry can technical books of this sort be, but this one -- I actually read the whole of the Introduction chapter (which I do very rarely), then continued on to the first chapter, then the next, and next,... I read through the first 52 pages of the book in just a couple of hours!
The book is very reader-friendly, witty, interesting, and simply great!
I am now in the third year of a Software Engineering course and this book is certainly very helpful. With its help I hope to submit an extremely well readable and structured code to my final year project. I recommend this book to everyone!
11 Comment| 3 people found this helpful. Was this review helpful to you? Report abuse
on 20 May 2017
I'm very satisfied ​with the content, the book is suprisingly easy to read. It's packed with good, all-around tips which are applicable outside of Java too (my primary language is JavaScript). I'd recommend it to people who already know how to program and are looking at a way to improve their code organization and reasoning behind it.
0Comment| One person found this helpful. Was this review helpful to you? Report abuse
on 8 March 2017
This is an amazing book for all the developers, new or experienced, if everybody could follow the standard in the team, so much time and effort could have been saved analyzing what the code trying to achieve!
0Comment| One person found this helpful. Was this review helpful to you? Report abuse
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? Report abuse
on 4 April 2016
This book somehow manages to take a relatively dull subject and actually make it entertaining, and practical. The book starts off by explaining with good examples why certain practices can be misleading, it then goes on to explain possible suggestions - it is very clear that this is by no means the only good way to do things which I think is great. Then after explaining numerous bad practices to you as well as ways to tidy things up it provides numerous examples that allow you to actually try to pick up what you've learned. This is brilliant because at least in my case I cannot remember anything without practicing it.
0Comment|Was this review helpful to you? Report abuse
on 10 February 2014
Experience is the most important feature for a software engineer, but it might take years to build. This book gives you a practical approach on how to face every day problems, so your code is cleaner and easier to read. Cleaner code results in better, more concrete solutions, which are easier to test and maintain. Don't expect a revelation. It's just a nice book to make you put all those little things you've figured out or will figure out yourself in order.
0Comment|Was this review helpful to you? Report abuse

Sponsored Links

  (What is this?)