Eskil Steenberg: Architecting LARGE software projects.

In large software projects, the goal is to create dependable, extendable systems with scalable teams. Ideally, each module should be manageable by one person to avoid complex team dependencies and maintain development velocity.

When designing software, anticipate changes like platform shifts, language updates, hardware evolution, and personnel turnover. Insulating modules from these changes reduces risk and keeps the project stable over decades.

Modularization is key: modules act as black boxes with clear APIs. Developers interact only with the interface, not the internal code. This enables single-person ownership per module and easier maintenance or replacement.

For example, a video editor can be structured around a platform layer (windowing, input), a drawing layer (lines, text), and a UI toolkit. Wrapping platform dependencies ensures portability and control.

Start with minimal implementations, like simple bitmap text rendering, then improve over time without changing the API. This approach lets others build on incomplete features and ensures backward compatibility.

A core principle is to generalize data handling. For video editing, everything is a clip on a timeline with parameters. This abstraction simplifies the system and allows flexible feature additions.

Plugin architectures enable extensibility. Instead of a monolithic core, plugins handle specific formats or effects. This isolation allows independent development and easier integration of new capabilities.

Healthcare systems can follow similar principles: model data as events (appointments, treatments) and build a black box API for storage and access. This decouples storage implementation from users and supports gradual migration from legacy systems.

Jet fighter software also benefits from modular design: the core stores the current state of the world, sensors and systems subscribe to relevant data, and redundancy ensures reliability. APIs abstract complexity for developers.

Tooling is essential: recorders, playback systems, simulators, and loggers help developers test and debug modules independently, speeding up integration and improving quality.

Format design underpins all software architecture. A good format balances simplicity and power, separating semantics (meaning) from structure (data layout). Overly complex formats hinder implementation and interoperability.

Avoid supporting multiple incompatible formats simultaneously (e.g., polygons and NURBS) as it doubles implementation effort. Instead, choose one format to maximize quality and maintainability.

Implementation freedom is crucial: APIs should expose functionality without dictating backend details, allowing future changes without breaking clients. For example, avoid exposing SQL queries directly in healthcare APIs.

Prefer plugin systems where your software controls the environment and accepts plugins, rather than living inside others' ecosystems. Standalone modules are ideal but plugins offer flexibility when necessary.