Software architecture refers to the high-level structure of a system and the method for creating these structures. It emphasizes the overall view of the system. Nearly all decisions made at the architectural level have long-term effects.
Here are just a few of the key components:
Characteristics: The -illities of the architecture, such as scalability, security, etc.
Decomposition: Dividing the system into smaller parts or modules.
Interactions: How different parts of the system communicate and interact with each other.
Style: The shape of the architecture, such as Service Based, Microkernel, Modular Monolith, etc.
Documentation: Architectural decisions are usually documented in Architectural Decision Records (ADRs) or similar documentation, which serve as a reference for future development and maintenance.
Stakeholder Communication: Architecture provides a common language and understanding among different stakeholders (developers, business analysts, management) about what the system will look like.
Software design focuses more on the details on the system and how the system will be implemented. This can include things such as the interfaces, class diagrams, software design patterns that will be used.
Here are a few key details:
Design Patterns: Choosing software design patterns helps solve common problems within the system.
User Interface Design: Decisions about how users will interact with the software.
Unit and integration testing: Making sure all-important parts of the system are tested. This includes simple unit tests, integration tests, continuous tests, and health checks.
Class Diagrams: In object-oriented systems, these define classes, their attributes, methods, and relationships. Sequence Diagrams: These illustrate how objects interact over time.
While Software Architecture provides the overall structure, Software Design fills in the details. Architecture decides how the system will be built, while design specifies how individual components will work within that framework. For example, if you're developing a SaaS product, your architecture might choose between a modular monolith application or a distributed system with separate services for different functions.
Misconceptions
It's important to clarify some common misunderstandings:
Architecture is not just about tools: It's about the system's structure and how components interact, not merely the selection of tools or frameworks.
Design isn't just aesthetics: In software development, design is about functionality, efficiency, and usability—both for users and within the system.
Interaction and Overlap
Iterative Process: Both architecture and design can evolve. Decisions made during design might lead to revisiting architectural choices.
Dependency: Good software design depends on a sound architecture, but the reverse is also true; sometimes, design practices can influence architectural decisions.
Summary
Software architecture defines the system's high-level structure, focusing on long-term decisions, component interactions, and stakeholder communication, often documented in Architectural Decision Records. It shapes the system through characteristics like scalability and security, and various styles like microkernel or modular monolith. Software design, on the other hand, deals with implementation details, leveraging design patterns, user interface design, and testing. It specifies how components operate within the framework. Both architecture and design are iterative and interdependent, with design influencing architecture and vice versa, emphasizing functionality, efficiency, and usability.
Understanding these differences can help developers make informed decisions about their projects, whether they're focusing on the strategic layout of a system or the detailed implementation of its components. By balancing both architecture and design, developers can build systems that not only function well but also provide an excellent user experience.
References
Neal Ford, and Mark Richards. Fundamentals of Software Architecture: An Engineering Approach. O'Reilly Media, 2020.
Neal Ford, Mark Richards and Raju Gandhi. Head First Software Architecture. O'Reilly Media, 2024.