Quotes About Software

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

abstraction is evil. Code is anti-evil, and clean code is perhaps divine.

Complexity kills. It sucks the life out of developers, it makes products difficult to plan, build, and test." —Ray Ozzie, CTO, Microsoft Corporation

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

Lots of very funny code is written because people don't take the time to understand the algorithm.

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.

Software has two types of value: the value of its behavior and the value of its structure. The second of these is the greater of the two because it is this value that makes software soft.

The way you keep software soft is to leave as many options open as possible, for as long as possible. What are the options that we need to leave open? They are the details that don't matter.

What makes a clean test? Three things. Readability, readability, and readability.

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

The goal of software architecture is to minimize the human resources required to build and maintain the required system.

Good software systems begin with clean code. On the one hand, if the bricks aren't well made, the architecture of the building doesn't matter much. On the other hand, you can make a substantial mess with well-made bricks. This is where the SOLID principles come in.

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

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

The only way to prove that your software is easy to change is to make easy changes to it. And when you find that the changes aren't as easy as you thought, you refine the design so that the next change is easier. When do you make these easy changes? All the time! Every time you look at a module you make small, lightweight changes to it to improve its structure.

OO imposes discipline on indirect transfer of control.

Don't override concrete functions. Concrete functions often require source code dependencies. When you override those functions, you do not eliminate those dependencies—indeed, you inherit them. To manage those dependencies, you should make the function abstract and create multiple implementations.

Woe to the poor developer who buckles under pressure and agrees to try to make the deadline. That developer will start taking shortcuts and working extra hours in the vain hope of working a miracle.

The majority of the cost of a software project is in long-term maintenance.

It is far more common to fight your way through terrible software designs than it is to enjoy the pleasure of working with a good one.

Software architecture is the art of drawing lines that I call boundaries. Those boundaries separate software elements from one another, and restrict those on one side from knowing about those on the other.

is not the language that makes programs appear simple. It is the programmer that make the language appear simple!

Cuteness in code often appears in the form of colloquialisms or slang. For example, don't use the name whack() to mean kill(). Don't tell little culture-dependent jokes like eatMyShorts() to mean abort(). Say what you mean. Mean what you say.

Few practices are as odious as commenting-out code. Don't do this!