In software development, there are many rules that correctly followed allow building robust IT systems with high quality. In this post, I summarize some key points needed for CPSA certificate. I am not going into the deep details but rather mention everything what software architect have to take into account. As always in CPSA posts, I am inspired by the book Software Architecture Foundations.
Design principles
Abstraction: Simplify complex systems by focusing on the essential details while hiding implementation specifics. This reduces complexity and enhances flexibility.
Separation of Concerns: Divide a system into distinct parts, each addressing a separate concern. This simplifies maintenance and testing.
High Cohesion: Keep related functionalities within the same module. High cohesion improves modularity, making components easier to maintain and understand.
DRY (Don’t Repeat Yourself): Avoid redundancy by ensuring that each piece of knowledge has a single representation within the system.
SOLID Principles: Promote scalability and maintainability through principles like single responsibility, open-closed, and dependency inversion.
YAGNI (You Aren’t Gonna Need It): Implement features only when necessary. Overengineering wastes time and resources.
KISS (Keep It Simple, Stupid): Favor simplicity in design and implementation. Complex solutions introduce unnecessary risk.
Expect Errors: Design systems that gracefully handle failures and recover without user intervention.
Dependency management/Coupling
Coupling measures the degree of dependency between system components. High coupling can lead to tightly connected modules, making systems harder to modify or scale.
Risk and problems
Dependency management comes with inherent risks, particularly when dealing with tightly coupled systems. These include:
- Increased Complexity: High coupling makes it challenging to modify or extend systems without affecting other components, leading to brittle architectures.
- Limited Scalability: Dependencies between components can restrict independent scaling, which is critical in distributed systems.
- Error Propagation: Failures in one component can cascade to dependent components, increasing the risk of system-wide issues.
- Maintenance Overhead: Updating or replacing a dependent component requires extensive testing and may introduce unintended side effects.
- Vendor Lock-In: Direct dependencies on specific technologies or platforms can limit flexibility and increase migration costs.
Types of coupling
Use (Delegation): One component relies on another for functionality.
Composition: Objects are combined to form complex behaviors.
Creation: Dependency on specific objects or factories.
Inheritance: Tight coupling due to parent-child class relationships.
Messages or Events: Decouples components by using event-driven communication.
Temporal Coupling: Dependencies arise from specific execution orders.
Data Types and Data: Sharing complex data structures can increase coupling.
Hardware Coupling: Tightly integrated hardware dependencies reduce portability.
Reducing Coupling to Increase Quality
Reducing coupling enhances flexibility and maintainability:
- Use dependency inversion to replace direct calls with interfaces.
- Apply asynchronous communication to replace synchronous dependencies.
- Introduce redundancy to avoid reliance on shared resources.
- Use patterns like broker or registry to decouple components.
Quality requirements and tactics to achieve them
Performance Tactics
- Manage resource demand: Optimize algorithms and reduce computational overhead.
- Manage resources: Balance resource allocation and use pools or caches.
- Arbitrate conflicting demands: Use scheduling policies and synchronization mechanisms.
Availability Tactics
- Detect faults: Use monitoring, self-tests, and heartbeats to identify issues early.
- Recover from faults: Employ retries, rollbacks, and exception handling.
- Prevent faults: Use redundancy, transactions, and fault-tolerant designs.
Maintainability Tactics
- Localize expected changes: Split and encapsulate modules to isolate modifications.
- Restrict visibility of responsibilities: Keep interfaces simple and constant.
- Avoid ripple effects: Break dependency chains and make data self-identifying.
Closing Thoughts
This overview highlights the foundational principles and practices that every software architect must consider. By mastering these principles, architects can design systems that are robust, scalable, and maintainable, aligning with the CPSA framework for excellence in software architecture.