def programming

#complexity

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

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

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

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.

Constraints are advantages in disguise. Limited resources force you to make do with what you've got. There's no room for waste. And that forces you to be creative.

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

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.

Programs must be written for people to read, and only incidentally for machines to execute.

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.

Make everything as simple as possible, but not simpler.

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

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

We are just as proud of what our products don't do as we are as what they do.

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

A sentence should be enough to get the idea across.

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.

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.

Whenever there is a sticking point, ask, "are we staying true to the vision?".

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.

Simplicity is prerequisite for reliability.

The central enemy of reliability is complexity.

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

Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away.

Controlling complexity is the essence of computer programming.

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.

Built with using

Source code available @ githubpull requests are more than welcome ;-)