Tale of software architect(ure): Part 1 (Software Architecture and Software Design)

Story:

My uncle Salam wants to build a house. So he first hire Rafiq to plan the construction of his new house. Rafiq first try to understand uncle's needs: How many bedrooms do he want? Do he prefer a modern or traditional style? Will the house be two stories or one? Should there be a backyard and a garage?

Then Rafiq creates the blueprint of the house, which represents the high-level structure of his house. This blueprint shows where the rooms will be, how the electrical systems will be laid out, how plumbing will work, and the relationships between the major parts of the house. These decisions include:

• What materials to use for the foundation (so the house can last a long time)
• How many floors to have (to optimize space)
• How rooms are connected (to allow easy flow within the house)

At this stage, the architecture of his house is defined. It’s a big-picture plan, showing the major sections and how they fit together. Though he haven't yet figured out the detailed specifications of each room or part of the house, but the overall structure is in place. Once the architect’s work is done, it becomes difficult and expensive to change core elements of the plan, like adding an extra floor or switching the location of the garage.

Secondly, after the architect is done with the blueprint, Salam bring in a builder designer named Borkot to focus on the details. Borkot's job is to build and plan out the specific layout, look, and function of each room. He help decide things like:

• What type of furniture to place in the living room (so it’s comfortable and fits the space)
• The color scheme of the bedroom (to create a relaxing environment)
• The design of the kitchen cabinets (to make them functional and stylish)
• Where to place the lighting fixtures (to ensure good lighting in each room)

Borkot takes the broad plan from the architect and makes detailed decisions about each component in the house. These decisions ensure that every part of the house is functional, practical, and aesthetically pleasing.

What is Software Architecture?

Software Architecture refers to the high-level structure of a software system. It defines the major components of the system, their relationships, and how they interact with each other. It sets the foundational blueprint for the entire system, ensuring that it meets both functional and non-functional requirements such as performance, scalability, security etc.

Key Aspects of Software Architecture:

Components: These are the primary building blocks of the system, such as modules, services, or subsystems. Components can range from individual classes or objects to larger systems like databases or APIs.

Relationships: How components interact with each other, including communication protocols, data exchange methods, and control flows. This could be in the form of client-server interactions, data pipelines, or event-driven architectures.

Patterns and Styles: Architectural patterns provide tried-and-tested solutions to recurring problems. Common architectural patterns include:

• Layered Architecture (e.g. presentation, business logic, data layers)
• Microservices Architecture (independent, loosely coupled services)
• Event-Driven Architecture (using events to trigger actions)
• Client-Server Architecture (separating a client interface from a backend server)
• Monolithic vs. Distributed systems

Non-Functional Requirements: Architecture focuses heavily on system qualities like:

• Scalability: How well the system can grow in response to increased demand.
• Performance: Ensuring the system operates efficiently, even under heavy loads.
• Security: Defining how sensitive data and system components are protected.
• Maintainability: The ease of updating or modifying the system over time.
• Reliability: Ensuring the system operates correctly over time without failure.
• Extensibility: Enabling the system to evolve by adding new features without significant changes to the core structure.

Technological Choices: Software architecture involves making decisions about the tools, frameworks, languages, and platforms that will be used. For example, deciding to use cloud services, databases, or messaging systems.

Abstraction and Decoupling: Architectural design aims to reduce complexity by abstracting details and decoupling components so they can evolve independently. This results in systems that are modular, easier to understand, and more maintainable.

Architectural Decisions: These are decisions that have a long-term impact on the system, such as selecting between a monolithic or microservices architecture. These decisions are difficult to change later in development because they affect the entire structure.

Importance of Software Architecture:

• Foundation for Development: It provides a blueprint that guides developers and stakeholders throughout the development lifecycle.
• Risk Management: Good architecture helps mitigate risks by addressing critical concerns early (e.g. scalability, security).
• System Integrity: Ensures all components work cohesively and the system can evolve without breaking existing functionality.
• Communication Tool: It serves as a common language between technical and non-technical stakeholders to understand system structure and constraints.

Examples of Software Architecture:

• Netflix’s Microservices Architecture: Netflix’s system consists of hundreds of independent services, each responsible for a specific function (e.g. user preferences, recommendation engine).
• E-commerce Platform (Layered Architecture): An e-commerce system might use a layered architecture with distinct layers for the user interface, business logic, and database operations.

What is Software Design?

Software Design refers to the process of defining how individual components of a software system will function, interact, and be implemented. It operates at a lower level than software architecture and focuses on the details necessary to translate the overall system architecture into functional code. Software design ensures that each part of the system meets its requirements and can work together as a cohesive whole.

Key Aspects of Software Design:

Detailed Blueprint of Components:

• Software design breaks down the high-level components defined in the architecture into smaller, detailed parts. This includes classes, functions, modules, and data structures.
• It answers questions like how each component works internally, what methods or operations it will expose, and how data will flow between components.

Design Patterns:

• Design patterns are common solutions to recurring problems in software development. They help in structuring and organizing code effectively. (e.g. singleton, observer, strategy etc.)

Functional Requirements:

• While software architecture focuses on non-functional aspects like scalability and performance, software design is concerned with functional requirements. It ensures that each feature or module delivers the required functionality as defined by the system’s needs.
• Examples include how a login system should work, how data is validated, or how a search algorithm should retrieve results.

Algorithms:

• The choice of algorithms is an essential part of software design. Depending on the requirements, designers choose or create algorithms that perform specific tasks efficiently (e.g., sorting, searching, data processing).

Data Structures:

• A key part of software design is deciding how data will be stored, accessed, and manipulated. This includes the choice of appropriate data structures like arrays, linked lists, trees, or hash tables, based on the needs of the application.

Low-Level Design (LLD):

• Low-Level Design focuses on creating specific plans for how individual components of the system will be built. This includes defining: Classes, Interfaces, Interactions.

Modularity and Reusability:

• Good software design emphasizes modularity, where the system is broken into independent, interchangeable modules. Each module should be designed in such a way that it can be easily maintained and reused in other systems if needed.

Error Handling and Edge Cases:

• Software design must account for error handling, ensuring that the system behaves correctly in unexpected situations or failures. This includes designing mechanisms for handling exceptions, logging errors, and managing resource constraints.

User Interface (UI) Design:

• For user-facing applications, software design may also involve the design of user interfaces (UI), focusing on how users will interact with the system. This could include laying out screens, designing buttons, forms, navigation, etc.
• User Experience (UX) design ensures that the interaction is intuitive and efficient.

Testing and Validation:

• Software design involves defining how each module will be tested and validated. This ensures that the system functions as intended and meets quality standards. Techniques such as unit testing, integration testing, and test-driven development (TDD) are often integral parts of the design process.

Software Design Phases:

• High-Level Design (HLD): In this phase, the system is divided into high-level components or modules based on the architecture. It provides a broad understanding of the system but doesn’t go into details.
• Low-Level Design (LLD): This phase involves a more detailed specification of how each individual module will work, what data structures will be used, the flow of control within modules, and how algorithms will be implemented.

Importance of Software Design:

• Code Quality: Good design ensures that the code is well-structured, clean, and easy to understand. It promotes writing code that is maintainable, reusable, and scalable.
• Flexibility: A well-designed system can easily adapt to changes in requirements without requiring major rework. This helps accommodate future changes or feature additions.
• Collaboration: Proper design acts as a shared understanding among team members, making it easier for teams to collaborate on large projects.
• Performance: Design decisions can have a significant impact on performance, particularly when it comes to optimizing algorithms, data structures, and system resource use.

Examples of Software Design:

• Login System Design: A detailed design for a login system might involve how the input is validated, how passwords are hashed and stored securely, and how failed attempts are handled.
• E-commerce Shopping Cart: A design for an e-commerce shopping cart would involve defining how products are added, stored, and managed within the cart, how the cart is persisted between sessions, and how updates are communicated with the server.

Similarities or Relations between Software Architecture and Design:

• Both Involve Structure: Both software architecture and design deal with structuring a software system but at different levels of detail.
• Both Are Abstract: They focus on abstractions before actual code is written, thinking through how the system will behave and interact.
• They Overlap: A good software design follows from good architecture. Both involve decision-making that impacts the quality of the system.

Differences between Software Architecture and Design:

• Level of Abstraction: Architecture is more abstract and high-level, while design is more concrete, low-level and detailed.
• Impact: Architectural decisions affect the whole system, whereas design decisions are more localized and affect smaller components.
• Flexibility: Architectural changes are more difficult and costly to make once the system is developed, while design changes are relatively easier to adapt.

Summary:

Think of software architecture as the blueprint of a house, which shows the overall structure and layout, and software design as the detailed decisions for the interior, where each room’s layout and functionality are refined. Both architecture and design are essential for creating a functional, scalable, and maintainable system, just as both the blueprint and interior design are crucial for building a home that's both livable and aesthetically pleasing.

To get a good house we need good architecture and design. Similarly to get a good useful software system we need a solid architecture with perfect design/implementation.