5.0 out of 5 stars I've received in perfect conditions

A. · May 25, 2025

(function() { P.when('cr-A', 'ready').execute(function(A) { if(typeof A.toggleExpanderAriaLabel === 'function') { A.toggleExpanderAriaLabel('review_text_read_more', 'Read more of this review', 'Read less of this review'); } }); })(); .review-text-read-more-expander:focus-visible { outline: 2px solid #2162a1; outline-offset: 2px; border-radius: 5px; } Perfecto

5.0 out of 5 stars I love this book.

K.G. · April 10, 2025

Great author.

5.0 out of 5 stars Very useful even for experienced programmers and well designed

V.C. · October 6, 2024

This is a great book!I'm a Java dev with 6yoe and I still learn from this book. There are some things I knew, some I forgotten or thought about but didn't know a proper name of and some I have never thought of. The language used is Javascript but it's syntax shouldn't be hard to follow.Also, the book quality is high and there are lots of pretty diagrams if it matters for you (it certainly does for me).

4.0 out of 5 stars If you have the right 'why', you can bear almost any 'how'

N.M. · October 27, 2023

Code is written by humans, executed by machines. Live code is also read by (other) humans for about 10x more than the time it took to write it. This is where "refactoring" comes to play. It is sort of making continuous improvement to code so it is more readable. It is cleaning up cobwebs from the corners.One of the most popular CS papers ever ("Hints for Computer System Design", 1983) suggests 3-step process about writing code - first, make it work; second, make it right; finally, make it fast". This book, a succinct second edition of a very popular first, is an excellent "show and tell" for the second part.It has a catalog of "code smells" and an inventory of "refactoring tricks" mapped to each. The first edition had working Java examples. The present one shows JavaScript ones. The examples are real-life but simple enough to not distract from the core - how to simplify the "first version" of code. Apart from the content, the insights that pops out can only be gleaned from years of deep experience. One example, say, most developers encode a "phone number" attribute as string in the first attempt of modeling. Soon enough, one needs to add "spam rules", "blocking number", "area code" etc. That necessitates phone number to be 'refactored' from string (i.e., a primitive type) to its own object model (say, a class called PhoneNumber). The author cheekily refers to the former type of behavior as "stringly typed" variables. Word play is a hallmark of many good engineers I'd worked with, but it is also a phenomenal way to remember things. Humor shortens the retrieval curve.What I liked most about the book is a broad adoption of "Paracelsus' Maxim" - the difference between a poison and something benign is the dose. Most of the refactoring pattens come in pairs. You can "extract function" from a big one, or "inline function code" if it is short, obvious and singularly used, say. You can "replace parameter with query" or "replace query with a parameter". The only unpaired pattern shows up with large/complex conditionals (say, a switch, or a multiway nested conditional with 'guard clause) - most/all of them are pain to read and should ideally be refactored, say, with "replace conditional with polymorphism". Live book site has 4 more patterns beyond the book.I found the refactoring patterns could be of three principal dimensions - one, structure -- variable, method, class, conditional; two, usage and locality -- depending on how much they're used and if they are used within/outside the module (class); three, data and mutation -- there is a clear separation between refactoring a data (or, value) object/data passed as value- or reference; separating data (query) from command etc. On top of that, some of the refactoring could be thought of as "helping the original developer" (say, to modularize or DRY better) vs. "helping others who may read the code later".When I read the first edition years ago, IDEs were not as robust nor opinionated enough about refactoring. These days, majority if not all the refactoring is done by default - one just needs to click to accept, say, extracting a method. It has been a huge time saving and long-term benefit for collaborative work and fits very well within the philosophy of "continuous integration"/Kaizen etc. One could argue that lowers the importance of such book. While the IDE may do the grunt work, key decisioning remains with humans, for now. Especially since most refactoring could appear in polar opposites it is therefore even more important to understand the context - the "why" - which this book brilliantly lays out.

5.0 out of 5 stars Absolute must have book for every developer’s library!

J.O. · January 3, 2023

Fantastic book and one that should be in every developers personal library. The depth of knowledge and technical precision the author has in regards to refactoring is immense. This book is not a quick read but should be read in its entirety to really take in all that refactoring has to offer. Refactoring has now become part of my everyday programming and development process.There is only one thing I would change about the book and that is for the author to add the completed refactored code for some of the more complex methodologies to the end of each refactoring. Some of the refactoring methodologies can be quite extensive and by adding the completed refactored code to the end may help give a clearer picture of the information the author is imparting to the reader. Other than that this book has taught me so much about refactoring and will be a go to book for the rest of my software development career.

5.0 out of 5 stars Refactoring Software

A.C. · September 17, 2023

One of the best software developer books, If you have the challenge of redesign a software application this is the book you need to read but before buy it, make sure the application you are going to refactor has unit-tests, if not as the book mentioned first you need to read: Working Effectively with Legacy Code of Michael Feathers, read this book first and later read this one.Thank you so much to Martin Fowler.

5.0 out of 5 stars great Book

g. · August 18, 2024

This is a comprehensive review of refactoring.

5.0 out of 5 stars The hype is real.

J.S. · July 7, 2024

Very solid pattern-oriented book. Must have for every software engineer.

Best buy

F.C. · May 9, 2025

(function() { P.when('cr-A', 'ready').execute(function(A) { if(typeof A.toggleExpanderAriaLabel === 'function') { A.toggleExpanderAriaLabel('review_text_read_more', 'Read more of this review', 'Read less of this review'); } }); })(); .review-text-read-more-expander:focus-visible { outline: 2px solid #2162a1; outline-offset: 2px; border-radius: 5px; } Cercavo qualcosa che mi aiutasse a gestire meglio il processo di destrutturazione del codice, questo libro mi ha aiutato

Excelente libro

R. · January 26, 2023

Muy buen libro, desde las primeras páginas me dio tips para realizar refactor en mis proyectos.

Muy útil

A. · January 30, 2023

Me ha gustado el estilo, es muy ameno y práctico.Todo tiene su lógica y lo estoy aplicando en mi código y en las reviews que hago. Puede que cambie para siempre la forma en la que programo.No puedo dejar de leer y releer. Me ofrece ideas de cómo escribir, probar y revisar código y también propone una nomenclatura para cada tipo de refactor que es un estandar para discutir con otros desarrolladores.

Well worth having

A.カ. · June 6, 2021

Be careful with the paper, as it’s quite thin. Overjoyed with the contents of the book though, it’s going to serve me well for many years I’m sure.

good read

A.C. · December 30, 2020

quality is fantastic.