A Philosophy of Software Design - psd.pdf

Tags

Top Highlights

• If you write a piece of code and it seems simple to you, but other people think it is complex, then it is complex

• The first symptom of complexity is that a seemingly simple change requires code modifications in many different places.

• APIs with many methods

• global variables

• inconsistencies

• An unknown unknown means that there is something you need to know, but there is no way for you to find out what it is, or even whether there is an issue.

• ead every line of code in the system

• lower- level design decisions

• dependencies and obscurity

• Your primary goal must be to produce a great design, which also happens to work. This is strategic programming.

• the benefits from your past investments will save enough time to cover the cost of future investment

• Good design doesn’t come for free. It has to be something you invest in continually, so that small problems don’t accumulate into big ones.

• Providing choice is good, but interfaces should be designed to make the common case as simple as possible (see the formula on page 6).

• If an interface has many features, but most developers only need to be aware of a few of them, the effective complexity of that interface is just the complexity of the commonly used features.

• One common cause of information leakage is a design style I call temporal decomposition.

• One common cause of information leakage is a design style I call temporal decomposition.

• One common cause of information leakage is a design style I call temporal decomposition

• When designing modules, focus on the knowledge that’s needed to perform each task, not the order in which tasks occur.

• This example illustrates a general theme in software design: information hiding can often be improved by making a class slightly larger.

• Thus, it’s important to avoid exposing internal data structures as much as possible

Toughts & Comments

Nima Rezaeian

My guesses: Change amplification is caused by violating DRY, cognitive load is caused by violating good interface design and creating too many dependencies.