Refactoring: Improving the Design of Existing Code (2nd Edition) (Addison-Wesley Signature Series (Fowler)) 2nd Edition
Use the Amazon App to scan ISBNs and compare prices.
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Frequently bought together
Customers who viewed this item also viewed
About the Author
Martin Fowler is Chief Scientist at ThoughtWorks. He describes himself as “an author, speaker, consultant and general loud-mouth on software development.” Fowler concentrates on designing enterprise software: exploring what makes a good design and what practices are needed to create one.
There was a problem filtering reviews right now. Please try again later.
"this is just common sense, what a waste of money"
"I wish he would have used typescript at least"
Developers like this:
a) are not truly reading the book
b) are egoistical devs who do not need to be in our profession and who influence our profession in the worst ways possible
With that stated, I have to say that you can tell this book was carefully written, and Martin makes sure to explain WHY you aren't seeing stuff like typescript as well as I love this line in the book "Some of the refactorings, such as Extract Method or Move Field, may seem obvious. But don't be fooled. Understanding the mechanics of such refactorings is the key to refactoring in a disciplined way".
For those of you who are here to bash the book because you're all knowing, know that there are many young developers in front of us who are still trying to learn and mold their young careers. In fact there are old devs still doing the same. It's called Software Craftsmanship. If you think this book is beneath you, please leave our profession, I beg you.
Disappointing, could have been better. No worthy of a $50+ price tag.
Chapter 3- Bad Smells in Code would be easier to understand after understanding the later chapters.
The examples and concepts that are introduced are informative and make you want to run back to your code.
I would use this book to skim relevant topics before refactoring a block of code instead of reading cover to cover.
The books is mostly examples and only the first couple of chapters are on theory. It's great if you are already bought into the idea and just need to learn how to do it as opposed to convincing someone that refactoring should be done.
Top international reviews
The book was bound upside down. Even if that had been correct, the paper is of the cheapest possible quality which means you can see the text of the next page through the page you are reading, something that makes reading source code, where punctuation really matters, much more difficult.
My only gripe is that book looked half the size of the original! This isn't due to an extensive refactoring, but the rather thin, poor quality paper. "Bible paper" as one colleague quipped when they saw it. The thin pages are easily creased or torn, and the ink from the other side of each page shows through slightly. Very disappointing to see this with an Addison Wesley book, especially given the price and the fact the hard cover is the usual robust and high quality binding. I've deducted a star for this, although I nearly deducted two!
In the 20 years since the first edition this has become an uncontroversial point and "refactoring" has entered the daily lexicon of the software engineering discipline. Surely time for an update to the classic text on the subject to bring it up to date with all the learning that 20 years of widespread practise have revealed!
Unfortunately it seems that there isn't much new to say. The refactoring techniques have been shuffled around a bit, sometimes consolidated or split, but they all seem very familiar. They are now so familiar that they seem trivial in fact, so obvious they barely need mentioning. Whilst there is value in establishing a common lexicon for these common operations, the detailed step by step examples become a chore to read through because they are so obvious.
Most of the examples boil down to making small, incremental changes and then running your comprehensive set of tests (which take a few seconds to run) to make sure you didn't make a mistake. Fine if you're working on some small, isolated piece of code with unit tests accessible at a keystroke... Less helpful when you're working with part of a legacy system that takes 15 minutes to build and 30 to run through its tests (if they exist). Unfortunately the latter are where refactoring is probably most needed.
The book is worth adding to your library and at least skimming to pick up some patterns and terminology if you're new to programming. You might occasionally even find yourself consulting it as a reference for how to do a refactoring, though the answer is probably "in the obvious way".
The author should rightly be proud of the fact that his original text was so influential that 20 years later it is hard to imagine that there was a time when it needed to be written ;-)
The content of this book is second to none - it’s a goldmine of useful techniques to help keep code in the best shape possible. Fowler goes into excruciating detail with regard to the steps taken for each refactoring. I found the reinforcement of ‘smaller steps’ incredibly useful when applying the techniques on my own later - I moved incrementally with the confidence of knowing which exact step in the process may have triggered a test failure.
On the subject of testing, the book hammers home it’s importance in being able to actually refactor, which I can only see as a good thing.
Returning to the topic of physical quality, the book is hardbacked, the pages are printed with some colour (rare for a programming book), in addition to having a ribbon in the spine. These attributes only add to the positive experience of reading this book.
Si no has leído la primera edición, recomiendo leerlo de principio a fin y asimilar la filosofía de desarrollo que propone. Si la has leído, entonces la segunda te va a encantar.
El papel del libro físico es ultra-fino (aunque no problemático), el código que muestra es con una tipografía condensada muy fina, aunque en negro se lee (no bien, se lee), el problema es que os cambios de código son escritos en un color rojo que parece que se les ha acabado la tinta, imposible de leer en la cama con luz tenue.
No conozco el formato kindle, espero que sea mejor
Ce livre contient énormement de blabla autour des test unitaires donc si vous êtes adepte c'est très très long à lire.
Sinon les pattern de refactoring son intéressant. Il faudra les adapter et pas mes utiliser bêtement.
Mais dans l'enssemble il y a de très bon conseil.
À lire absolument si vous ne faites pas de test unitaire.