[Part 3] Software design 101

Multiplayer's mission is to make debugging distributed systems effortless for engineering and support teams, through full-stack, session-based visibility.

Our team found that aligning on a shared language into what our full stack session recordings provide visibility is helpful to understand their scope and impact. That's because terms like distributed system, software system, system design, software design, etc. can have broad, overlapping or, sometimes, interchangeable definitions.

This article series explores what these terms mean and how your team can use them to communicate more clearly.

• TL;DR System design vs software design
• System design 101
• Software design 101

Software design 101

“[…] software architecture consists of the structure of the system [i.e. Software Architecture Styles], combined with the architecture characteristics the system must support, architecture decisions, and finally design principles” - Fundamentals* of Software Architecture

* Availability, Reliability, Testability, Scalability, Security, Agility, Fault Tolerance, Elasticity, Recoverability, Performance, Deployability, Learnability

Software Design defines the Software Architecture, providing a high level structure of the entire software system.

It zooms in on the nitty-gritty of how individual software components are crafted and communicate, and how the code is written (e.g. classes, functions, and modules).

Although Software Architecture has a narrower scope than System Architecture (i.e. it specifically focuses on the software), it is similarly dynamic: it evolves overtime, as the application requirements change.

Phases in the Software Design Process

Software Design is usually articulated into two phases:

• Conceptual Design phase: The initial phase of software design where you focus on creating a high-level, abstract representation of the software system. It involves defining the overall structure, major components, and the relationships between them.
• Technical Design phase: Also referred to as low-level design, is the subsequent phase where the high-level concepts from the conceptual design are translated into detailed specifications for the actual implementation of the software system. It delves into the specifics of algorithms, data structures, and coding standards.

Software Design is considered one of the initial steps of the Software Development Life Cycle (SDLC).

Software Architecture Styles

Often there is no distinction between System and Software Architecture Styles, however, it’s worth mentioning some Architecture Styles outline specifically how to organize the information at the software level (and not at the system level). For example:

• Component-based Architecture
• Domain Driven Design (DDD) Architecture
• Object Oriented architecture
• Hexagonal Architecture (Ports and Adapters)
• Clean Architecture
• Functional Architecture
• Data Driven Architecture

Software Design Patterns

Software Design Patterns are reusable solutions to commonly occurring problems in software design - e.g. specific coding and implementation issues with the design of classes, objects, and their interactions. They are akin to pre-made blueprints that you can customize to solve a recurring design problem in your code.

Changes to Design Patterns have a local impact, affecting a specific area of the code.

• Creational patterns
  • Factory Method / Virtual Constructor
  • Abstract Factory
  • Builder
  • Prototype / Clone
  • Singleton
• Structural patterns
  • Adapter / Wrapper
  • Bridge
  • Composite / Object Tree
  • Decorator / Wrapper
  • Facade
  • Flyweight / Cache
  • Proxy
• Behavioral patterns
  • Chain of Responsibility / CoR, Chain of Command
  • Command / Action, Transaction
  • Iterator
  • Mediator / Intermediary, Controller
  • Memento / Snapshot
  • Observer / Event-Subscriber, Listener
  • State
  • Strategy
  • Template Method
  • Visitor