Pingdom Home

US + international: +1-212-796-6890

SE + international: +46-21-480-0920

Business hours 3 am-11:30 am EST (Mon-Fri).

Do you know if your website is up right now? We do! LEARN MORE

Quirky but (mostly) useful software development rules

There are plenty of both formal and informal rules that programmers love to quote, either because they’re fun or quirky, or simply because they are useful and thought-provoking.

We’ve gathered some of the most interesting ones for your reading pleasure. Enjoy!

The ninety-ninety rule

The first 90% of the code accounts for the first 90% of the development time. The remaining 10% of the code accounts for the other 90% of the development time.

Hofstadter’s law

It always takes longer than you expect, even when you take Hofstadter’s Law into account.

Brooks’s law

Adding manpower to a late software project makes it later.

Lister’s law

People under time pressure don’t think faster.

The MoSCoW method

A technique to prioritize delivery requirements during development. MoSCoW stands for:

M – MUST have this.
S – SHOULD have this if at all possible.
C – COULD have this if it does not affect anything else.
W – WON’T have this time but WOULD like in the future.

The KISS principle

Keep It Simple, Stupid. In other words: avoid complexity, embrace simplicity.

Gall’s law

A complex system that works is invariably found to have evolved from a simple system that worked.

Worse is better (New Jersey style)

Describes how a seemingly “inferior” product can be better from a user perspective. A limited but easy-to-use software may be more popular among users than a “better”, more comprehensive one.

Greenspun’s tenth rule

Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.

(A funny note is that there are no preceding rules, only the tenth. According to Philip Greenspun, this was because he was “just trying to give the rule a memorable name.”)

Zawinski’s law

Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can.

Linus’s law

Given enough eyeballs, all bugs are shallow.

Murphy’s law

Anything that can go wrong, will go wrong.

Sutton’s law

Go where the money is.

(When attempting to diagnose a problem, confirm the most likely diagnosis first (i.e. test the most likely solution first). Named after Bank robber Willie Sutton, who robbed banks “because that’s where the money is”.)

Wirth’s law

Software is getting slower more rapidly than hardware becomes faster.

Conway’s law

Any piece of software reflects the organizational structure that produced it.

(Interesting example of how this can cause problems: NASA’s Mars Climate Orbiter crashed because one development team used English units while the other used metric units to control the thrusters.)

The Hollywood principle

Don’t call us, we’ll call you.

(Instead of your program running the system, the system runs your program.)

The Dilbert Principle

The most ineffective workers are systematically moved to the place where they can do the least damage: management.

Your favorite rule/law?

There are sure to be plenty of useful/funny/interesting development laws and rules we haven’t included here, so let us know in the comments if we missed your favorite!

Sources: Wikipedia for everything except Lister’s law which we found here.

Image credit: The always excellent Geek and Poke.



13 Comments

1st rule, 1st error:
The first 90% of the code accounts for the first >>>10%<<< of the development time.
Fun read, anyhow.

@FuePi: It’s actually not an error, but I see where you’re coming from. See the Wikipedia entry for the ninety-ninety rule: http://en.wikipedia.org/wiki/Ninety-ninety_rule People just modify it sometimes to make it add up to 100% (like you just did). It’s a pretty common rewrite, apparently.

My favorite rule which I apply whenever my technology gets messed up by someone is Hanlon’s razor: Never attribute to malice that which can be adequately explained by stupidity.

The Conway example doesn’t quite fit my understanding of the ‘law’.

Sturgeon’s Law usually applies.

Occam’s Razor also.

Kenneth Wildenhain

July 8th, 2009 at 4:03 pm


Kermit’s Law

To err is human, but to realy f*&# things up you need a computer.

Andrew from Vancouver

July 8th, 2009 at 5:28 pm


The Dilbert Principle is a funny variation of the Peter Principle which is “In a Hierarchy Every Employee Tends to Rise to His Level of Incompetence.”

http://en.wikipedia.org/wiki/Peter_Principle

… and I’ve found that Conway’s Law is better represented by contrasting that an ITIL-laden company you will find huge amount of comments and error checking and references to dates and supporting documents in the sourcecode, but in a more lithe company the same sourcecode will be a small shell script.

Hi you got me thinking about Moore’s law vs Writh’s law. If it was true then surely software would be so slow/complex that is wouldn’t run on todays computers! Anyway I looked as software complexity based on the growth of Lines of Code for a desktop operating system and plotted that against CPU power increase.

http://performancetestersdiary.wordpress.com/2009/07/10/wriths-verses-moores-law/

The Sunnyvale Principle:
There’s never time to do it right, but always time to do it over.

Danzibar’s Rule:

If something can go wrong, it already HAS. Be prepared.

Law of Rx  Moving a working Database and code to a “e-” platform can actually lower productivity. Wait for the “f-” or “g-” to work out the kinks. (e.g   g-commerce to replace e-commerce)