System Partitioning the Analysis Model

Adding more layers to a software architecture offers several key benefits:

1. Separation of Concerns:
   • Clear Responsibilities: Each layer has a well-defined purpose (e.g., presentation, business logic, data access). This keeps code focused and reduces complexity within any single layer.
   • Better Maintainability: Changes in one layer have less chance of causing ripple effects throughout the system, making modifications easier and less prone to introducing bugs.
2. Modularity:
   • Independent Components: Layers interact through defined interfaces. This allows you to develop, modify, or replace layers independently without disrupting the entire system.
   • Reusability: Well-designed layers can potentially be reused across different projects or applications, saving development time and effort.
3. Improved Testability:
   • Unit Testing: With focused responsibilities, you can write comprehensive unit tests for each layer in isolation, improving code quality and reliability.
   • Integration Testing: Clear interfaces make it easier to test how layers communicate, ensuring they work together as intended.
4. Scalability:
   • Load Distribution: You can scale individual layers independently based on demand. For example, if the business logic layer becomes a bottleneck, you can add more servers to handle the increased load.
   • Flexibility: Layered architectures can more gracefully accommodate changing requirements or the need to integrate new technologies.
5. Enhanced Security:
   • Access Control: Implement security measures at specific layers (e.g., data access layer for database protection or presentation layer for input validation).
   • Isolation: Security breaches in one layer can be more easily contained, preventing them from spreading throughout the entire system.

Example:
Consider a web application with the following layers:

• Presentation Layer: Handles user interface elements and input.
• Business Logic Layer: Contains the application's core logic and rules.
• Data Access Layer: Handles the interaction with the database.

Key Points:

• Don't Overdo It: Too many layers can introduce unnecessary complexity and performance overhead. Find the right balance.
• Standard Patterns: Using established layered architecture patterns (like Model-View-Controller, N-Tier Architecture) provides a well-understood foundation

The purpose of system partitioning is to separate the different types of problems that you will need to address in order to create a successful software system. In this course you will learn two very different types of system partitioning that separate the software issues using two distinct criteria:

1. the client's functional requirements and
2. the application of technology.

Domain partitioning identifies the features that the users expect the system to provide. Technological partitioning divides the system according to the technologies that will best support the implementation of the software.

• Domain Partitioning: To partition the domain means to identify the different types of functions that the system must support. Functions should be grouped using the principles of cohesion and coupling so that related functions appear together. These functions are defined in the use case model. The resulting groups should each provide all of the data resources from the class and interaction diagrams that the users will need to successfully complete a reasonable unit of work. You can probably tell from this description that the process is somewhat subjective. However, as you learn the process, you will also learn techniques to measure the quality of the groupings more objectively.

Systems Analysis Design

Technological Partitioning