Architecture vs Design | Understanding Software Architecture Series | 2
🎯 This is session 2 of understanding architecture series. Purpose of the series to help Indian developers build the mindset needed for architecting, designing and building great softwares.
After this session -
✅ You will be able to tell difference between design and architecture
✅ You will be able to use mechanism to categorise item effectively into design or architecture category.
✅ You will able to use this information to decide which part of an item need architectural understanding and which one need design understanding.
Overview:
This video is part of a series focused on understanding software architecture. It specifically delves into the differences between software architecture and design, and how understanding these differences can impact decision-making in software projects.
Key Differences Between Architecture and Design:
1. *Architecture (Big Picture):*
Involves high-level decisions that shape the entire system.
Comparable to discussions with a building architect, focusing on aspects like the number of rooms, layout, and structural integrity.
In software, this includes decisions about cloud providers, database types (SQL, NoSQL), deployment models (e.g., Kubernetes, AWS), and security protocols.
2. *Design (Detailed Execution):*
Focuses on the specifics of how different parts of the system interact.
Comparable to working with an interior designer who deals with the finer details like lighting, color schemes, and furnishings.
In software, this includes the database schema, class structures, code organization, design patterns, and UI layouts.
Practical Application:
*Decision-Making Exercise:*
The video discusses an exercise to determine whether a task is architectural or design-focused. For instance, merging microservices is generally an architectural decision, while choosing a persistence framework could involve both architectural and design elements.
Frameworks for Understanding:
1. *Strategic vs. Tactical:*
Strategic decisions (e.g., choosing between microservices and monolithic architectures) have long-term impacts and are generally architectural.
Tactical decisions (e.g., selecting an algorithm for a specific feature) tend to be more design-focused.
2. *Effort Level:*
High-effort tasks (e.g., implementing scalability) often involve extensive planning and coordination, making them architectural.
Low-effort tasks (e.g., adding features within a service) usually require less planning and are more design-related.
3. *Tradeoffs:*
Significant tradeoffs, such as choosing between eventual and strong consistency, are often architectural because they impact the system's performance and success.
Less significant tradeoffs, like choosing between libraries, generally fall under design.
Decision-Making Scale:
The video suggests using a scale to categorize decisions, helping teams prioritize and allocate resources effectively. Architectural decisions often require more focus due to their wider impact.
Conclusion:
Understanding whether a task is architectural or design-oriented helps in prioritizing decisions, managing risks, clarifying roles, and handling changes more efficiently. The video concludes by promising a deeper dive into architectural characteristics in future sessions.
___
Software Architecture, Software Design, Software Architecture vs Design, How to distinguish design and architecture, Software Architecture Course, Learn Together
___
Discord: / discord
Hinglish Channel: / @developernoteshindi
LinkedIn: / arunveersingh