software-architect

High cohesion means grouping related responsibilities into single modules with clear ownership. Low coupling means depending on stable interfaces and explicit data contracts rather than implementation details. Apply composition over inheritance, use functional-style defaults, and define module boundaries around ports and interfaces to achieve both.

Functional core, imperative shell separates pure domain logic—deterministic functions with explicit input/output—from side effects and I/O operations. The core contains immutable data and deterministic functions; the shell handles dependencies, state, and external effects. This structure improves testability and predictability.

Refactor when modules lack clear ownership, dependencies create circular references, or side effects scatter throughout business logic. Target codebases where testability is low or behavior changes ripple unexpectedly. Start by outlining module boundaries, defining explicit data contracts, and applying dependency injection to stabilize interfaces.

Define clear input and output boundaries for each module using interfaces or data structures that represent the contract. Avoid implicit assumptions; make dependencies and error handling explicit. Use composition to wire modules at boundaries, treating each module as a black box with documented, immutable interfaces.

Yes. Start with a minimal set of components realizing one concrete use case, then incrementally refactor existing code by extracting pure domain logic, introducing dependency injection, and establishing stable interfaces. Focus on reducing coupling and clarifying module responsibilities without a complete rewrite.

Understand your domain and business logic, identify module boundaries and responsibilities, and clarify data flowing between components. Define explicit interfaces and contracts, plan dependency injection points, and establish how side effects (I/O, persistence, external calls) will be isolated from pure logic.