Principles of Computer System Misdesign


Retard civilization
Dissipate effort
Retard progress
Make it not work
Make it slow.
Make it fail
Create difficulties
Create work
Avoid learning.
Hide power
Make it complex
Get it wrong early
Combine functions with diverse requirements.
Prevent feasible optimizations
Merge policy and mechanism
Abstraction
Use abstraction to preempt decisions
Use programming languages to preempt system design
Make it inflexible
If it's worth doing, it's worth doing right
Use obscurity to confuse and confound
Create obscurity with programming langauges
Avoid composability
Avoid portability
Work towards, but do not create, reusability
Generalize
Generalize a good idea rather than reusing it
Do things which don't work
Make it inexpressible
Require workarounds
Add unnecessary requirements
Avoid good ideas
Optimize blindly
Avoid understanding what is going on
Create fragility
Obscure performance
Choose names which obscure
Document well
Tackle everything at once
Cache well
Do the right thing in your second system
Get it wrong
Manage well
Under-specify
Require wheel reinvention
Require new implementations create new abstractions
Make it powerful
bar
bar
bar
bar

Perfection is reached,
either when there is no longer anything to add,
or when there is no longer anything left to take away.
(E. Aint-Xupery)

You can have any two: fast, clean, robust.
Discard the one which matters most, along with the other two if possible.
(Programmer's Adage)

Retard civilization

Civilization advances by reducing the number of things one has to worry about. It is a bootstrap process. Our task is to maintain continuity by conserving and creating worries. People work with the opposite intent. So we try to dissipate their effort harmlessly.

Dissipate effort

Retard progress

Make it not work

Make it slow.

Make it fail

Create difficulties

Create work

Avoid learning.

Hide power

Make it complex

The price of unavoidable unreliability is complexity.
(H. Coare)

The more intricate the plot, the greater the renoun,
regardless of success.
(Romulan proverb)

A powerful way to Make it fail , Make it slow. and Make it inflexible

Get it wrong early

Preempt success - get it wrong early.

Combine functions with diverse requirements.

"where the integrity of the entire system is concerned, the operations provided should be as complex as possible"
(Lutler Bampson)

Prevent feasible optimizations

Merge policy and mechanism

Abstraction

I found a large number of programs perform poorly because of the language's tendency to hide "what is going on" with the misguided intention of "not bothering the programmer with details". [N. Wirth, "On the Design of Programming Languages", quoted in Kiczales p4]
The purpose of abstraction is to conceal desireable properties, and to create undesirable ones. There is a tradeoff here. Some undesireable properties get concealed along with the desirable ones. And one or two desirable properties are often unavoidably created with the undesireable ones. Balence well. Create difficulties

Use abstraction to preempt decisions

Use programming languages to preempt system design

A form of Use abstraction to preempt decisions

Make it inflexible

Make the system brittle with respect to requirment changes. Design narrowly to a specific set of requirements.

If it's worth doing, it's worth doing right

Pay on principle.

Use obscurity to confuse and confound

Create obscurity with programming langauges

Avoid composability

Else things could be built.

Avoid portability

Work towards, but do not create, reusability


The struggle towards reusability is a great source of work.
Even should it succeed, often more work can be created than is lost by the attainment.

Generalize

Generalize a good idea rather than reusing it

Generalize a good idea rather than reusing it. It is less likely to work.

Do things which don't work

Make it inexpressible

Require workarounds

The more contorted and obscure the better.

Add unnecessary requirements

Avoid good ideas

Optimize blindly

Tune first, measure later.

Avoid understanding what is going on

Create fragility

Obscure performance

Choose names which obscure

Document well

Tackle everything at once

The bigger the foe, the greater the honor.
(Klingon proverb)

Cache well

Do the right thing in your second system

In your second system, fix everything you did wrong, or didn't think of, when you did the first system.

Get it wrong

Manage well

An engineer is someone who can do for a dime what any fool can do for a dollar.
So give a fool a quarter to manage a engineer working with 1/10 of a cent.
(Anonymous)

Under-specify

Require wheel reinvention

Once the programmer is forced away from being able to use the old interface, and into the problem of designing one of their own, its quite likely they won't do as good a job. Simply put, the application programmer doesn't have the time (even if they do have the interest) to design the new interface as cleanly [...] [Kiczales p3]

Require new implementations create new abstractions

([...E]ven if the interface ends up being just as (or more) elegant, one of the primary purposes of high-level standardization - to be able to easily read each other's code - has been defeated.) [Kiczales p3]

Make it powerful

bar

bar

bar

bar