Principles for Reducing Software Complexity

Based on John Ousterhout's "A Philosophy of Software Design", the article discusses how to reduce software complexity.

Complexity is defined from cognitive load and development effort, with a formula C = Σ(Cp * tp) where Cp is module complexity and tp is time weight.

Key factors contributing to complexity include modification ripple, cognitive burden, and unknown unknowns, often caused by code dependencies and obscurity.

General principles to tackle complexity:

Iterative design and continuous improvement.

Layered architecture: separate horizontal layers with clear interfaces.

Modular decomposition (e.g., micro‑services) to isolate concerns.

Rich documentation and comments to lower cognitive load.

Specific practices:

Avoid tactical programming; favor strategic design.

Design twice: provide multiple alternatives before finalizing.

Push complexity down to lower layers when possible.

Prefer deep modules (simple interfaces, powerful functionality) over shallow modules.

Balance generic vs. specialized modules.

Encapsulate information (information hiding).

Merge or split modules based on shared information and interface simplicity.

Write purposeful comments focusing on what and why, not how.

Code examples illustrate deep vs. shallow modules:

int open(const char* path, int flags, mode_t permissions);

FileInputStream fileStream = new FileInputStream(fileName);
BufferedInputStream bufferedStream = new BufferedInputStream(fileStream);
ObjectInputStream objectStream = new ObjectInputStream(bufferedStream);

void delete(Cursor cursor);
void deleteSelection(Selection selection);
// can be merged into
void delete(Position start, Position end);

The article concludes that these principles have practical value and are supported by other works such as "Code Complete" and "Refactoring".