Richard Gabriel wrote a while back a piece explaining why C trumped Lisp "The Rise of `Worse is Better`".  The worse-is-better philosophy goes as follows:

Simplicity-the design must be simple, both in implementation and interface. It is more important for the implementation to be simple than the interface. Simplicity is the most important consideration in a design.

Correctness-the design must be correct in all observable aspects. It is slightly better to be simple than correct.

Consistency-the design must not be overly inconsistent. Consistency can be sacrificed for simplicity in some cases, but it is better to drop those parts of the design that deal with less common circumstances than to introduce either implementational complexity or inconsistency.

Completeness-the design must cover as many important situations as is practical. All reasonably expected cases should be covered. Completeness can be sacrificed in favor of any other quality. In fact, completeness must sacrificed whenever implementation simplicity is jeopardized. Consistency can be sacrificed to achieve completeness if simplicity is retained; especially worthless is consistency of interface

He also makes a pretty interesting observation about the evolution of worse-is-better implementations:

The lesson to be learned from this is that it is often undesirable to go for the right thing first. It is better to get half of the right thing available so that it spreads like a virus. Once people are hooked on it, take the time to improve it to 90% of the right thing.

Sounds awfully similar to Extreme Programming philosophy!  Reminds me also of a Viral Growth Strategy.