Refactoring: Improving the Design of Exi

Refactoring: Improving the Design of Existing Code is one of those amazing books that every professional developer should have on their book shelf. The bulk of this book is a catalog of refactorings, but there is more to it as I will explain below. In case you aren't aware of what refactoring is, I'll give you Fowlers definition. "Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure." For the most part this means cleaning up your existing - yet working - code. It involves anything from renaming a method to be more concise with the purpose of that method, to breaking up switch statements into a polymorphic structure. There are many different techniques used to refactor your code, which is what you learn in this book. Right off the bat Fowler throws you into a small sample application that is poorly designed. He then takes you through a few different refactoring techniques that improve the design of this simple application. Right from the start you see how effective refactoring can be. From there he goes into topics such as how to detect "bad smells" in code. This chapter is particularly informative and entertaining. You also learn a little bit about testing. After the introductory chapters you begin to dig into a deep catalog of refactorings. Each one is named. Like design patterns - naming the refactoring and building a vocabulary really helps in communicating thoughts and ideas. The catalog of refactorings is extremely useful. They are structured so that each refactoring has a name, a motivation, the mechanics and a simple example. This is very effective. As I said earlier, the name is useful because it helps build your programming vocabulary and it helps in communicating thoughts and ideas. The motivation explains why the refactoring should be done and when it should/shouldn't be used. The mechanics provide a step-by-step description of how to carry out the refactoring and the example shows a small example of the refactoring in use. All examples are written in Java 1.1. Although the examples are written in Java the book is still very good for any developer. Developers that have never written a line of code in Java, C++, C#, or anything similar may have a little bit of a tougher time working through this book. Luckily most examples are very small and simple so even if you fall into this category you shouldn't have too much of a learning curve. Some of the code is a bit outdated and can be done a bit better now-a-days but what do you expect? This book was written 8+ years ago! Times have changed. The ideas are still very relevant though, which is what makes this book so timeless. Martin Fowler books are always a joy to read. His writing style is humorous, yet often very blunt and to the point. Just like UML Distilled, he is able to communicate a lot of ideas into a very short amount of space - the book is a bit dense in other words, which is very good in my opinion. Martin Fowler does not beat around the bush and he has very strong opinions on certain topics. Unlike a lot of books you read, he actually writes with personality. I have a hard time putting his books down. Here is an example of the type of verbiage he uses... On how comments can be a "bad smell": "Don't worry; we aren't saying that people shouldn't write comments. In our olfactory analogy, comments aren't a bad smell; indeed they are a sweet smell. The reason we mention comments here is that comments often are used as a deodorant." - Martin Fowler. Here he is talking about how people use comments to hide bad code, or "bad smells". I highly recommend this book. If you are a professional developer or plan on becoming one then click the "Buy Now" button without second thought. This is one of those rare books worth its weight in gold - I would spend $100.00 on a book like this if I had to.

This book is replete with advanced knowledge of the situational logic of refactoring code in procedural and object oriented languages ... The point of view is that of a software engineer inclined to perfectionism ... Many typical kinds of bad code from a module or a function or a method or a class are outlined in Chapter 3 item by item 22 different situations are described and critiqued ... Much of the remainder of the book outlines what remedies the principal author and the other authors suggest as to how to refactor the code to meet this book's standards ... One doubt immediately comes to mind: what about the economics in industry of refactoring? Whilst I agree, say, that a car self parking system needs to be well nigh perfect in that this is the only way to assure safety for car drivers and nearby pedestrians, many an employer will say no just say no to refactoring exercises for perfection's sake! For example, many financial systems have the odd unimportant user interface bug that there's simply not the funds to get fixed. And every source code change involves risks: the risk that bugs are introduced; the risk that the unit and system testing will be inadequate; the risk of feature drift, the application semantics being misunderstood; and, the risk of loss of source code though related hardware failure. Source code control systems and people employed as change managers need to question whether the risk of some minor change should be countenanced, or rejected if too risky! It is possible that too many refactoring exercises might take a large system that works well and lead to it degenerating into an unholy mess, with added introduced bugs, the destruction of the original architect's vision, and changes that erode the system's integrity and purpose. This is a management problem. Quality code is not free. If a large system really needs extentive refactoring the real question is as to whether over the expected lifetime of the code it would be cheaper to refactor, or to throw the system away and start from scratch! It is overall more advisable to get the system right in the first place. A better design with a better architecture if put together for a hypothetical version 1 of a large system will reduce maintenance cost down the track ... Nevertheless an excellent book of practical advice on refactoring and code quality! An advanced reference work for third year university software engineering students, practising software engineers, and software engineering managers. Managers whose background is other than a career in programming would particularly benefit from this work.

This book is a bit old. It is the first, or among the first, which addresses the refactoring issue. However, everything in it is relevant today. At the beginning and at the end you will find articles by various authors (Fowler, Beck, Opdyke, Roberts and Brant): * Refactoring , first example. * Principles of refactoring . * Bad smells in code . * Building Tests. * Toward a Catalog of Refactorings . * Big Refactorings . * Refactoring , Reuse , and Reality . * Refactoring Tools. * Putting It All Together. In the middle will find a great catalog of small transformations that define the steps to do the refactoring. This catalog, though simple is very important as explained in the first chapters. Fowler clearly explains why refactoring, some clues to identify the most important issues (code smells) to refactor in order to improves the design, and the catalog of transformations that are commonly used to solve each code smells. Dependending your experience and knowledge of software craftsmanship, you will surely perceive it more or less as a simple topic, but that makes it no less important. It is a fantastic book. It is one of the books that every software developer in the industry should read. The only reason I'm not giving 5 stars is that it is not a truly revealing book. The items inside are all very basic and simple. You should not expect anything astonishing and the first impression is that all of it is obvious, but it is explained in an exceptional way and the catalog created by Fowler is really great.

The authors need to be congratulated and thanked for their humorous and engaging presentation of what could have been a long dry and dreary list of dos and don'ts. I just started reading this book and I was wondering if it is going to be too dry and difficult to read. Instead, I have been pleasantly surprised on how entertaining - along with being informative, educative and thorough - this book is.There are several interesting anecdotes - the narration of which is aimed at underscoring what is important and where we should focus our efforts on. The lead author engages in quite a bit of self deprecating humor while narrating these stories - while clearly having written this book - he is an authority on the topic and all the techniques being described. The point of the humor - as I understand is to help us adopt good practices and good coding habits. In addition to these anecdotes, the book is littered with witty and funny prose in order to drive home important points. Here is a sample from the text where the authors tell us why they included "Comments" as one of the code smells: "Don’t worry, we aren’t saying that people shouldn’t write comments. In our olfactory analogy, comments aren’t a bad smell; indeed they are a sweet smell. The reason we mention comments here is that comments often are used as a deodorant." I can't remember having seen humor being applied so effectively in a text/reference book of this stature to make a point. And the point being made here is that comments often tend to describe code which is hard to understand and good code should be self descriptive and hence comments should not really be needed if the code was indeed self-descriptive. I am happy that such a writing style makes it hard for me to put the book down and to continue reading!

This remarkable book is the next logical step after 'Design Patterns'. In fact, it would be fair to call this 'Re-Design Patterns'. It follows closely in the DP community's habit. For each way of improving a program, it systematically presents a name, set of conditions when it does or does not apply, and (unlike most DP books) clear, demonstrative examples and variations. As with design patterns, many of these recommendations have a sense about them of "I already knew that." That's a good thing - it means you bring familiarity to the reading, instead of starting cold. That lets Fowler get on with his real business, which is to systematize the knowledge and regularize the process of choosing a technique to use. I hope this follows another habit of the DP community, too: the public cataloging, collecting, and sharing of new techniques for refactoring. I could add bunches to the list, as I'm sure any other seasoned programmer could. One thing is distinctive about the refactorings: the number that come in matched, opposite pairs. This just emphasizes the context dependency of refactoring - each technique has its place, but is not appropriate in all places. Also, paired opposites effectively double the number of choices a practitioner has. Design patterns are very helpful, almost like power tools for programmers. Face it, though: initial design and implementation are only 1-10% of a large program's life. Maintenance, extension, and re-design are the other 90-99%. DP techniques get a program started, refactorings keep it going. If you started programming before most of your co-workers were born, you may not get the most out of this book. Get it anyway, and make sure the young pups read it. This knowledge needs to be spread.

Great book. I like this older revision as the newer ones switched to JavaScript which I don’t use. Great intro to refactoring and a great reference book on refactoring.

The book itself is good as it shows you the small steps of refactoring, and will show you how people came with those ideas a few decades ago. However now, for most of them we have automatic IDE refactorings so we never do such things as extract method manually anymore (though it's still a good thing to know how to do it properly without tool).

Regardless of whether you adopt each and every one of the recommended practices, this book clearly and concisely presents each concept with simple examples, UML diagrams, and good explanations of the pros and cons of performing each refactoring, as well as when to use them. These are great techniques to add to your toolset as an object-oriented programmer. Be aware that as defined by the book, refactoring means changing a program without altering the behavior of the program ("Improving the design of existing code.") Refactoring is essential for any software that must be maintained or upgraded, so this book can be a great aid to anyone who works with code. As a Gang of Four affiliated book, it uses the concept of patterns and a catalog to efficiently present material. It also uses the concept of "smells" of code to bridge intuition and best practices. Overall, a worthwhile read.