#complexity quotes

There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.

Organizations that design systems are constrained to produce copies of the communication structures of these organizations

Complexity is a sign of technical immaturity. Simplicity of use is the real sign of a well design product whether it is an ATM or a Patriot missile.

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

It's OK to figure out murder mysteries, but you shouldn't need to figure out code. You should be able to read it.

Beauty is more important in computing than anywhere else in technology because software is so complicated. Beauty is the ultimate defense against complexity.

Inside every well-written large program is a well-written small program.

A complex system that works is invariably found to have evolved from a simple system that worked…A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.

There's an old story about the person who wished his computer were as easy to use as his telephone. That wish has come true, since I no longer know how to use my telephone.

Perfection is reached, not when there is no longer anything to add, but when there is no longer anything to take away.

Simplicity is prerequisite for reliability.

Controlling complexity is the essence of computer programming.

UNIX is simple. But It just needs a genius to understand its simplicity.

The purpose of software engineering is to control complexity, not to create it.

People seem to misinterpret complexity as sophistication.

Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it.

You do not really understand something unless you can explain it to your grandmother.

Make everything as simple as possible, but not simpler.

The trick is to fix the problem you have, rather than the problem you want.

Easy is not to be underestimated. Easy taps the pool of talent and ideas out there that were turned off by hard.

The central enemy of reliability is complexity.

The art of programming is the art of organizing complexity, of mastering multitude and avoiding its bastard chaos as effectively as possible.

The function of good software is to make the complex appear to be simple.

Treat your code like poetry and take it to the edge of the bare minimum.

I hate code, and I want as little of it as possible in our product.

Ugly programs are like ugly suspension bridges: they're much more liable to collapse than pretty ones, because the way humans (especially engineer-humans) perceive beauty is intimately related to our ability to process and understand complexity. A language that makes it hard to write elegant code makes it hard to write good code.

Don't waste your time typing up that long visionary tome; no one's going to read it. Take consolation in the fact that if you give your product enough room to grow itself, in the end it won't resemble anything you wrote about anyway.

It's important to remember that when you start from scratch there is absolutely no reason to believe that you are going to do a better job than you did the first time. First of all, you probably don't even have the same programming team that worked on version one, so you don't actually have “more experience”. You're just going to make most of the old mistakes again, and introduce some new problems that weren't in the original version.

Simplicity is about subtracting the obvious and adding the meaningful.

The secret to building large apps is never build large apps. Break your applications into small pieces. Then, assemble those testable, bite-sized pieces into your big application.

One man's crappy software is another man's full time job.

If you're willing to restrict the flexibility of your approach, you can almost always do something better.

When in doubt, leave it out.

The cleaner and nicer the program, the faster it's going to run. And if it doesn't, it'll be easy to make it fast.

A design is “simple” if it follows these rules: Runs all the tests; Contains no duplication; Expresses the intent of the programmer; Minimizes the number of classes and methods.

An evolving system increases its complexity unless work is done to reduce it.

If it doesn’t work, it doesn’t matter how fast it doesn’t work.

Programs, like people, get old. We can’t prevent ageing, but we can understand its causes, limit its effects and reverse some of the damage.

The code you write makes you a programmer. The code you delete makes you a good one. The code you don't have to write makes you a great one.

The key to making programs fast is to make them do practically nothing.

A primary cause of complexity is that software vendors uncritically adopt almost any feature that users want.

Simple doesn't mean stupid. Thinking that it does, does.

A program is portable to the extent that it can be easily moved to a new computing environment with much less effort than would be required to write it afresh.

What matters for simplicity is that there's not interleaving.

Most of the biggest problems in software are problems of misconception.

The standard rule is, when you're in a hole, stop digging; that seems not to apply [to] software nowadays.

The key is to acknowledge from the start that you have no idea how this will grow. When you accept that you don't know everything, you begin to design the system defensively... You should spend most of your time thinking about interfaces rather than implementations.

Such is modern computing: everything simple is made too complicated because it's easy to fiddle with; everything complicated stays complicated because it's hard to fix.

It comes from saying no to 1,000 things to make sure we don't get on the wrong track or try to do too much.

Well-designed components are easy to replace. Eventually, they will be replaced by ones that are not so easy to replace.

Complexity kills. It sucks the life out of developers, it makes products difficult to plan, build, and test.

Code is like humor. When you have to explain it, it’s bad.