Top 100 Robert C. Martin Quotes (2024 Update)
Page 2 of 3

51. “For example, class names including weasel words like Processor or Manager or Super often hint at unfortunate aggregation of responsibilities.”

— Robert C. Martin

52. “Every system is built from a domain-specific language designed by the programmers to describe that system. Functions are the verbs of that language, and classes are the nouns.”

— Robert C. Martin

53. “A use case is a description of the way that an automated system is used. It specifies the input to be provided by the user, the output to be returned to the user, and the processing steps involved in producing that output. A use case describes application-specific business rules as opposed to the Critical Business Rules within the Entities.”

— Robert C. Martin

54. “Science does not work by proving statements true, but rather by proving statements false.”

— Robert C. Martin

55. “Yet attentiveness to detail is an even more critical foundation of professionalism than is any grand vision. First, it is through practice in the small that professionals gain proficiency and trust for practice in the large. Second, the smallest bit of sloppy construction, of the door that does not close tightly or the slightly crooked tile on the floor, or even the messy desk, completely dispels the charm of the larger whole. That is what clean code is about.”

— Robert C. Martin

56. “The primary cost of maintenance is in spelunking and risk. Spelunking is the cost of digging through the existing software, trying to determine the best place and the best strategy to add a new feature or to repair a defect.”

— Robert C. Martin

57. “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. This is the essence of iterative and incremental agility. Test-driven development, refactoring, and the clean code they produce make this work at the code level.”

— Robert C. Martin

58. “An estimate is not a number. An estimate is a distribution.”

— Robert C. Martin

59. “Providing too much detail can be an invitation for micro-management.”

— Robert C. Martin

60. “Just as the Hare was overconfident in its speed, so the developers are overconfident in their ability to remain productive.”

— Robert C. Martin

61. “Whatever else a TODO might be, it is not an excuse to leave bad code in the system.”

— Robert C. Martin

62. “You see, programmers tend to be arrogant, self-absorbed introverts. We didn’t get into this business because we like people.”

— Robert C. Martin

63. “Database schemas are notoriously volatile, extremely concrete, and highly depended on. This is one reason why the interface between OO applications and databases is so difficult to manage, and why schema updates are generally painful.”

— Robert C. Martin

64. “The fundamental assumption underlying all software projects is that software is easy to change. If you violate this assumption by creating inflexible structures, then you undercut the economic model that the entire industry is based on. In.”

— Robert C. Martin

65. “All race conditions, deadlock conditions, and concurrent update problems are due to mutable variables.”

— Robert C. Martin

66. “If you can develop the high-level policy without committing to the details that surround it, you can delay and defer decisions about those details for a long time. And the longer you wait to make those decisions, the more information you have with which to make them properly.”

— Robert C. Martin

67. “On the other hand, a system being developed by five different teams, each of which includes seven developers, cannot make progress unless the system is divided into well-defined components with reliably stable interfaces. If no other factors are considered, the architecture of that system will likely evolve into five components – one for each team.”

— Robert C. Martin

68. “Consider, for example, the truly hideous practice of creating a variable named klass just because the name class was used for something else.”

— Robert C. Martin

69. “SRP is one of the more important concept in OO design. It’s also one of the simpler concepts to understand and adhere to. Yet oddly, SRP is often the most abused class design principle.”

— Robert C. Martin

70. “The problem that Dijkstra recognized, early on, was that programming is hard, and that programmers don’t do it very well.”

— Robert C. Martin

71. “Another problem with service-level decoupling is that it is expensive, both in development time and in system resources. Dealing with service boundaries where none are needed is a waste of effort, memory, and cycles. And, yes, I know that the last two are cheap – but the first is not.”

— Robert C. Martin

72. “Programmers must avoid leaving false clues that obscure the meaning of code.”

— Robert C. Martin

73. “The folks who think that code will one day disappear are like mathematicians who hope one day to discover a mathematics that does not have to be formal. They are hoping that one day we will discover a way to create machines that can do what we want rather than what we say. These machines will have to be able to understand us so well that they can translate vaguely specified needs into perfectly executing programs that precisely meet those needs. This will never happen.”

— Robert C. Martin

74. “Say what you mean. Mean what you say.”

— Robert C. Martin

75. “This is the philosophy of YAGNI: “You aren’t going to need it.” There is wisdom in this message, since over-engineering is often much worse than under-engineering. On the other hand, when you discover that you truly do need an architectural boundary where none exists, the costs and risks can be very high to add such a boundary.”

— Robert C. Martin

76. “If the discipline of requirements specification has taught us anything, it is that well-specified requirements are as formal as code and can act as executable tests of that code!”

— Robert C. Martin

77. “Design and programming are human activities; forget that and all is lost. – Bjarne Stroustrup, 1991.”

— Robert C. Martin

78. “Perhaps you thought that “getting it working” was the first order of business for a professional developer. I hope by now, however, that this book has disabused you of that idea. The functionality that you create today has a good chance of changing in the next release, but the readability of your code will have a profound effect on all the changes that will ever be made.”

— Robert C. Martin

79. “We are confidently commanding, in precise detail, the behaviors of a machine that could otherwise do incalculable damage. And so, programming is an act of supreme arrogance.”

— Robert C. Martin

80. “Programmers can practice in a similar fashion using a game known as ping-pong. The two partners choose a kata, or a simple problem. One programmer writes a unit test, and then the other must make it pass. Then they reverse roles.”

— Robert C. Martin

81. “Factories are a complexity that can often be avoided, especially in the early phases of an evolving design.”

— Robert C. Martin

82. “If a test in the same package needs to call a function or access a variable, we’ll make it protected or package scope.”

— Robert C. Martin

83. “The fact that we did not have a database running for 18 months of development meant that, for 18 months, we did not have schema issues, query issues, database server issues, password issues, connection time issues, and all the other nasty issues that raise their ugly heads when you fire up a database. It also meant that all our tests ran fast, because there was no database to slow them down.”

— Robert C. Martin

84. “You are reading this book for two reasons. First, you are a programmer. Second, you want to be a better programmer. Good. We need better programmers.”

— Robert C. Martin

85. “Architecting for the enterprise, when all you really need is a cute little desktop tool, is a recipe for failure.”

— Robert C. Martin

86. “But there are different kinds of duplication. There is true duplication, in which every change to one instance necessitates the same change to every duplicate of that instance. Then there is false or accidental duplication. If two apparently duplicated sections of code evolve along different paths – if they change at different rates, and for different reasons – then they are not true duplicates. Return to them in a few years, and you’ll find that they are very different from each other.”

— Robert C. Martin

87. “Building a project should be a single trivial operation.”

— Robert C. Martin

88. “Programming is an act of creation. When we write code we are creating something out of nothing. We are boldly imposing order upon chaos. We are confidently commanding, in precise detail, the behaviors of a machine that could otherwise do incalculable damage. And so, programming is an act of supreme arrogance. Professionals.”

— Robert C. Martin

89. “Without tests every change is a possible bug. No.”

— Robert C. Martin

90. “We programmers simply do not know how long things will take. This isn’t because we are incompetent or lazy; it’s because there is simply no way to know how complicated a task is going to be until that task is engaged and finished. But, as we’ll see, all is not lost.”

— Robert C. Martin

91. “Good software designs accommodate change without huge investments and rework. When we use code that is out of our control, special care must be taken to protect our investment and make sure future change is not too costly.”

— Robert C. Martin

92. “If you let the tests rot, then your code will rot too. Keep your tests clean.”

— Robert C. Martin

93. “This is the monstrosity in love, lady, that the will is infinite, and the execution confined; that the desire is boundless, and the act a slave to limit. – William Shakespeare.”

— Robert C. Martin

94. “These comments are so noisy that we learn to ignore them. As we read through code, our eyes simply skip over them. Eventually the comments begin to lie as the code around them changes.”

— Robert C. Martin

95. “It is unit tests that keep our code flexible, maintainable, and reusable. The reason is simple. If you have tests, you do not fear making changes to the code! Without tests every change is a possible bug.”

— Robert C. Martin

96. “We want our code to be a quick skim, not an intense study.”

— Robert C. Martin

97. “One of the more common motivations for writing comments is bad code.”

— Robert C. Martin

98. “A system that is comprehensively tested and passes all of its tests all of the time is a testable system. That’s an obvious statement, but an important one. Systems that aren’t testable aren’t verifiable. Arguably, a system that cannot be verified should never be deployed.”

— Robert C. Martin

99. “Indeed, many of the recommendations in this book are controversial. You will probably not agree with all of them.”

— Robert C. Martin

100. “What this team did not realize was that having dirty tests is equivalent to, if not worse than, having no tests.”

— Robert C. Martin