Quotes from Robert C. Martin

As they added more and more features, the code got worse and worse until they simply could not manage it any longer. It was the bad code that brought the company down.

In a globalized economy, where corporations are held to the almighty dollar and raising the stock price involves layoffs, overworked staffs, and offshoring, this strategy I've shown you of cutting developer costs is making good code obsolete. As developers, we're going to be asked/told/conned into writing twice the code in half the time if we're not careful.

Programming is so hard, in fact, that it is beyond the capability of one person to do it well. No matter how skilled you are, you will certainly benefit from another programmer's thoughts and ideas.

Notice how well those three align with the three big concerns of architecture: function, separation of components, and data management.

Code formatting is about communication, and communication is the professional developer's first order of business.

highway through the middle of a small town that anticipates growth? Who would want such a road through their town? It is a myth that we can get systems "right the first time." Instead, we should implement only today's stories, then refactor and expand the system to implement new stories tomorrow.

I told you those two stories because they describe two very different kinds of mentoring, neither of which are the kind that the word usually implies. In the first case I learned from the authors of a very well-written manual. In the second case I learned by observing people who were actively trying to ignore me. In both cases the knowledge gained was profound and foundational.

Premature Precision Both business and programmers are tempted to fall into the trap of premature precision. Business people want to know exactly what they are going to get before they authorize a project. Developers want to know exactly what they are supposed to deliver before they estimate the project. Both sides want a precision that simply cannot be achieved, and are often willing to waste a fortune trying to attain it.

Professionals are often heroes, but not because they try to be. Professionals become heroes when they get a job done well, on time, and on budget.

There was a time, back in the sixties, when commenting-out code might have been useful. But we've had good source code control systems for a very long time now. Those systems will remember the code for us. We don't have to comment it out any more. Just delete the code. We won't lose it. Promise.

there is always the chance that some experiment will show that those laws of motion and gravity are incorrect. That is the nature of scientific theories and laws: They are falsifiable but not provable.

As useful as services are to the scalability and develop-ability of a system, they are not, in and of themselves, architecturally significant elements. The architecture of a system is defined by the boundaries drawn within that system, and by the dependencies that cross those boundaries.

Making the code read like a top-down set of TO paragraphs is an effective technique for keeping the abstraction level consistent.

What do we talk about when we talk about architecture?

Science does not work by proving statements true, but rather by proving statements false. Those statements that we cannot prove false, after much effort, we deem to be true enough for our purposes.

Don't depend on volatile things. GUIs are volatile.

Ultimately, we can say that mathematics is the discipline of proving provable statements true. Science, in contrast, is the discipline of proving provable statements false.

When software is done right, it requires a fraction of the human resources to create and maintain. Changes are simple and rapid. Defects are few and far between. Effort is minimized, and functionality and flexibility are maximized.

Refactoring is a lot like solving a Rubik's cube. There are lots of little steps required to achieve a large goal. Each step enables the next.

Structured programming forces us to recursively decompose a program into a set of small provable functions. We can then use tests to try to prove those small provable functions incorrect. If such tests fail to prove incorrectness, then we deem the functions to be correct enough for our purposes.

Remember that the people who read your code will be programmers.

You must understand that when you marry a framework to your application, you will be stuck with that framework for the rest of the life cycle of that application. For better or for worse, in sickness and in health, for richer, for poorer, forsaking all others, you will be using that framework. This is not a commitment to be entered into lightly.

The company held a little contest to select a name for the new system. One of the most creative of the names suggested was SAM CARP. This stood for "Still Another Manifestation of Capitalist Avarice Repressing the Proletariat." Needless to say, that wasn't selected. Another was the Teradyne Interactive Test System. That one was also not selected. Still another was Service Area Test Access Network. That, too, was not selected.

Programming is an act of creation. When we write code we are creating something out of nothing. We are boldly imposing order upon chaos.