Martin Fowler Quotes

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

I’m not a great programmer; I’m just a good programmer with great habits.

Whenever I have to think to understand what the code is doing, I ask myself if I can refactor the code to make that understanding more immediately apparent.

If you can get today’s work done today, but you do it in such a way that you can’t possibly get tomorrow’s work done tomorrow, then you lose.

... parts of classic MVC don't really make sense for rich clients these days.

A heuristic we follow is that whenever we feel the need to comment something, we write a method instead.

When you find you have to add a feature to a program, and the program's code is not structured in a convenient way to add the feature, first refactor the program to make it easy to add the feature, then add the feature.

Poorly designed code usually takes more code to do the same things, often because the code quite literally does the same thing in several places.

I've learned to always avoid saying "always".

You can Change Your Organization or Change Your Organization

In almost all cases, I’m opposed to setting aside time for refactoring. In my view refactoring is not an activity you set aside time to do. Refactoring is something you do all the time in little bursts.

Now I'm a pretty lazy person and am prepared to work quite hard in order to avoid work.

William Pearson said that really what they were talking about at the end of the day was Martin Fowler constantly parking like a cunt.

Parallel inheritance hierarchies is really a special case of shotgun surgery. In this case, every time you make a subclass of one class, you also have to make a subclass of another.

I’ve found that refactoring helps me write fast software. It slows the software in the short term while I’m refactoring, but it makes the software easier to tune during optimization. I end up well ahead.

Other than when you are very close to a deadline, however, you should not put off refactoring because you haven’t got time. Experience with several projects has shown that a bout of refactoring results in increased productivity. Not having enough time usually is a sign that you need to do some refactoring.

It's more than a little ironic that many of us preach safety first to our children, nieces, and nephews but in our roles as programmers scream for freedom, a hybrid of the Wild West gunslinger and teenage driver. Give us freedom, give us the resources, and watch us fly.

[...in interaction diagrams], comprehensiveness is the enemy of comprehensibility.

If someone were to come up to you in a dark alley and say, "Psst, wanna see a UML diagram?" that diagram would probably be a class diagram.

Architectural refactoring is hard, and we’re still ignorant of its full costs, but it isn’t impossible. Here the best

First Law of Distributed Object Design: Don’t distribute your objects!

A statement Kent Beck often makes about himself, "I'm not a great programmer; I'm just a good programmer with great habits.

If you have to spend effort looking at a fragment of code and figuring out what it's doing, then you should extract it into a function and name the function after the "what".

Life being what it is, you won't get your names right the first time. In this situation you may well be tempted to leave it—after all it's only a name. That is the work of the evil demon Obfuscatis; don't listen to him. If you see a badly named method, it is imperative that you change it. Remember your code is for a human first and a computer second. Humans need good names.

It reminds me of a statement Kent Beck often makes about himself: “I’m not a great programmer; I’m just a good programmer with great habits.” Refactoring helps me be much more effective at writing robust code.

People sometimes ask me what length I look for in a method. To me length is not the issue. The key is the semantic distance between the method name and the method body. If extracting improves clarity, do it, even if the name is longer than the code you have extracted.

I write them to improve my productivity as a programmer. Making the quality assurance department happy is just a side effect. Unit tests are highly localized. Each test class works within a single package. It tests the interfaces to other packages, but beyond that it assumes the rest just works. Functional tests are a different animal. They are written to ensure the software as a whole works. They provide quality assurance to the customer and don't care about programmer productivity. They should be developed by a different team, one who delights in finding bugs.

Code should be obvious: When someone needs to make a change, they should be able to find the code to be changed easily and to make the change quickly without introducing any errors. A healthy code base maximizes our productivity, allowing us to build more features for our users both faster and more cheaply. To keep code healthy, pay attention to what is getting between the programming team and that ideal, then refactor to get closer to the ideal. But the most important thing to learn from this example is the rhythm of refactoring. Whenever I’ve shown people how I refactor, they are surprised by how small my steps are, each step leaving the code in a working state that compiles and passes its tests. I was just as surprised myself when Kent Beck showed me how to do this in a hotel room in Detroit two decades ago. The key to effective refactoring is recognizing that you go faster when you take tiny steps, the code is never broken, and you can compose those small steps into substantial changes. Remember that—and the rest is silence.

WARNING: Before commencing any program of sustained physical inactivity, consult your physician. Sedentary living doubles the likelihood of stroke and coronary artery disease, making it as risky as smoking, high cholesterol, or high blood pressure. If unaccustomed to sitting for extended periods, you may experience weak muscles, low bone density, high cholesterol, hyperglycaemia, a rapid resting heart rate, mental decline, mood disorders, and obesity. Start slowly and increase inactivity gradually. If you experience drowsiness, difficulty in concentration, or craving for stimulation, discontinue inactivity immediately.:-)

in Solitude; also James Martin’s introduction to Merton and others, Becoming Who You Are), Henri Nouwen (The Inner Voice of Love), Gregory Mayers (Listen to the Desert), Rowan Williams (Tokens of Trust), J. Keith Miller (Compelled to Control) and David Benner (Spirituality and the Awakening Self). Let me also include here Frederica Matthews-Green (The Jesus Prayer and At the Corner of East and Now) for gentle and compelling introductions to Eastern Orthodoxy, a direction to which I never once nodded throughout my entire seminary career, and James Fowler’s classic Stages of Faith. Others I want to mention are M. Holmes Hartshorne (The Faith to Doubt) and Daniel Taylor (The Myth of Certainty and The Skeptical Believer). I could go on, but each of these were one ah-ha moment after another, encouraging in me a different perspective on what the life of faith can look like, which I found both unsettling and also healing and freeing. These books have become old friends.

Don’t worry about design, if you listen to your code a good design will appear...Listen to the technical people. If they are complaining about the difficulty of making changes, then take such complaints seriously and give them time to fix things. -Martin Fowler, Chief Scientist, ThoughtWorks (from Is Design Dead?) If

When I talk about refactoring, I’m often asked about how it should be scheduled. Should we allocate two weeks every couple of months to refactoring? In almost all cases, I’m opposed to setting aside time for refactoring. In my view refactoring is not an activity you set aside time to do. Refactoring is something you do all the time in little bursts. You don’t decide to refactor, you refactor because you want to do something else, and refactoring helps you do that other thing.

Even so the program works. Is this not just an aesthetic judgment, a dislike of ugly code?

Code that communicates its purpose is very important. I often refactor just when I'm reading some code. That way as I gain understanding about the program, I embed that understanding into the code for later so I don't forget what I learned.

The Addison-Wesley Signature Series: Martin Fowler' google it

Martin Fowler sobre refactorings

Es todo un clásico el libro de Martin Fowler titulado ‹‹Refactoring: improving the design of existing code››; este libro me ha ayudado como ningún otro a mejorar en la calidad del código que escribo y debería estar en la estantería de cualquier programador profesional. El

Moving state and behavior between classes is the very essence of refactoring. As the system develops, you find the need for new classes and the need to shuffle responsibilities around. A design decision that is reasonable and correct one week can become incorrect in another. That is not a problem; the only problem is not to do something about it.

Hay ocasiones en las que el código existente es tan confuso que, aunque podrías refactorizarlo, es más fácil empezar desde el principio. Martin Fowler

This pattern — of implementing a reader able to ignore changes we don’t care about — is what Martin Fowler calls a Tolerant Reader.

It Takes Awhile to Create Nothing

The more you produce, the more you have to read. Automated code generation only makes matters worse. As Martin Fowler writes about low code quality: “Even small changes require programmers to understand large areas of code, code that’s difficult to understand.” [32] Code that’s difficult to understand slows you down. On the other hand, every minute you invest in making the code easier to understand pays itself back tenfold.

When you feel the need to write a comment, first try to refactor the code so that any comment becomes superfluous.” ― Martin Fowler

For diagrams comprehensiveness is the enemy of comprehensibility.

Martin Fowler NoSQL Distilled: "In general, with remote communication you want to reduce the number of round trips involved in the interaction, so it’s useful to be able to put a rich structure of information into a single request or response." Patterns of Enterprise Application Architecture" "Due to the latency costs of remote calls, it's better to err on the side of sending too much data than have to make multiple calls.

One of the problems with Domain Model is the interface with relational databases. In many ways this approach treats the relational database like a crazy aunt who’s shut up in an attic and whom nobody wants to talk about.

Patterns are useful starting points, but they are not destinations.

Accept finite disappointment but never lose infinite hope—Martin Luther King Jr.

Although in different circumstances, Martin Luther King Jr. in 1965 spoke also about the results of remaining low profile, as he said, History will have to record the greatest tragedy of this period of social transition was not the vitriolic words and other violent actions of the bad people but the appalling silence and indifference of the good people. Our generation will have to repent not only the words and acts of the children of darkness but also for the fears and apathy of the children of light.

As I suggested before, temporary variables can be a problem. They are only useful within their own routine, and therefore they encourage long, complex routines.

Most programmers, even experienced ones, are poor judges of how code actually performs.

So, my overall advice on performance with refactoring is: Most of the time you should ignore it. If your refactoring introduces performance slow-downs, finish refactoring first and do performance tuning afterwards.

Use this advice to prod your thinking, but don't use it as a replacement for your thinking. In the end you have to make, and live with, the decisions yourself.

It’s hard to figure out what the right amount of hiding is. Fortunately, with Hide Delegate (189) and Remove Middle Man, it doesn’t matter so much. I can adjust my code as time goes on. As the system changes, the basis for how much I hide also changes. A good encapsulation six months ago may be awkward now. Refactoring means I never have to say I’m sorry—I just fix it.

The lesson is: Even if you know exactly what is going on in your system, measure performance, don't speculate. You'll learn something, and nine times out of ten, it won't be that you were right!

Notice how I'm playing the part of an enemy to code. I'm actively thinking about how I can break it. I find that state of mind to be both productive and fun. It indulges the mean-spirited part of my psyche. When you are doing tests, don't forget to check that expected errors occur properly.

Repetition is the root of all software evil

Leaving nots in a conditional like that twists my mind around at a painful angle

An intuitive definition is that a safe refactoring is one that doesn't break a program. Because a refactoring is intended to restructure a program without changing its behavior, a program should perform the same way after a refactoring as it does before.

If you can’t fly,” Martin Luther King once said, “then run. If you can’t run, then walk. If you can’t walk, then crawl. But whatever you do, you have to keep moving forward.

If oy have to spend effort looking at a fragment of code and figuring out what it's doing, then you should extract it into a function and name the function after the "what".

Most of all I found myself listening- listening in the acutely active way that makes dialogue a truly hermeneutical act. Hermeneutics is the science of the interpretation of texts. Hermeneutics helps bring the meanings in texts to expression. Conversation as a hermeneutical enterprise helps persons bring their own meanings to expression. With sensitive, active listening we "hear out of" each other things we needed to bring to word but could not, without an other. This is Martin Buber's "I Thou" relationship with its dialogical transcendence; this is Reuel Howe's "miracle of dialogue.