Professional Documents
Culture Documents
Architecture Logiciel Exercice
Architecture Logiciel Exercice
- Architecture Style:
- Definition : Architectural Style refers to a set of guidelines or principles for designing and building
software systems. It specifies the components and connectors of the system and constraints on how
they can be composed.
- Example 1 : Layered Architecture - In this style, the system is divided into layers, where each layer
provides services to the layer above it and serves as a client to the layer below. Common in
enterprise applications.
- Example 2: Client-Server Architecture - This style divides the system into two main types of
components: clients, which request services, and servers, which provide services.
- Architectural Pattern:
- Example 1: Model-View-Controller (MVC) - This pattern separates an application into three main
components: Model (data), View (user interface), and Controller (business logic). Widely used in web
applications.
- **Disadvantages**:
- **Complexity**: As the application grows, the complexity of managing and maintaining the
monolithic codebase increases.
- **Scalability**: Scaling a monolithic application can be challenging because all components must
be scaled together, even if only one part of the system experiences high load.
- **Deployment**: Any change, no matter how small, requires the entire application to be
redeployed, which can lead to longer release cycles.
- **Reliability**: A bug in one part of the application can potentially bring down the entire system.
- **Advantages**:
- Simplicity : Easier to develop and deploy initially as all components are within a single codebase.
- Performance : Often more performant within a single process as there is no overhead of inter-
process communication.
- Development : Easier to develop initially with a small team since there are fewer complexities
around managing dependencies and services.
- **Advantages**:
- **Fault Isolation**: A failure in one service does not necessarily impact others, improving the
overall resilience of the application.
- Continuous Delivery : Easier to deploy updates and new features for individual services without
affecting the whole system.
- Domain-Driven Design (DDD) : Identify the core business domains and subdomains to define the
boundaries of each microservice. Use concepts like bounded contexts to ensure each service has a
clear and well-defined scope.
- Business Capabilities : Break down the application by business capabilities, ensuring each service
corresponds to a specific business function.
- Event Storming : Engage stakeholders in a collaborative workshop to map out the events that drive
the business processes, which helps in identifying the services that need to be created.
- Data Ownership : Assign ownership of different parts of the data to different services, ensuring that
each service is responsible for its own data management.
- Decentralized Governance : Allow teams to choose the best tools and practices for their specific
services, promoting autonomy and innovation.
- System Analysis :
- Focus: Understanding and specifying what the system should do. It involves gathering
requirements, analyzing the needs of users, and documenting the functional requirements.
- Outcome : A detailed requirement specification that serves as a basis for system design.
- System Design :
- Focus : Specifying how the system will fulfill the requirements. It involves defining the system
architecture, components, modules, interfaces, and data for the system to satisfy the specified
requirements.
- Outcome: Detailed design specifications, architecture diagrams, and technical details necessary for
implementation.
- **Modularity**: Divide the system into distinct modules that can be developed independently but
work together as a whole.
- **Separation of Concerns**: Ensure that different concerns or aspects of the system are managed
separately to reduce complexity and improve maintainability.
- **Reusability**: Design components and modules to be reusable across different parts of the
system or in different projects.
- **Scalability**: Ensure the architecture can handle increasing loads and can be scaled up easily as
demand grows.
- **Performance**: Optimize the architecture for performance to ensure the system meets required
response times and throughput.
- **Security**: Incorporate security principles to protect the system from threats and ensure data
integrity and privacy.
- **Subdomains**:
### 2. Clearly state the system requirements for the system (1.5pts)
- **Student Enrollment and Management**: The system should allow students to enroll in courses,
view their records, and update their profiles.
- **Course Creation and Management**: Administrators and faculty should be able to create and
manage courses, including schedules and content.
- **Faculty Assignments**: The system should manage faculty profiles, course assignments, and
schedules.
- **Assessment and Grading**: The system should support creating and managing assessments,
grading submissions, and publishing results.
- **Notifications**: The system should send notifications for important events such as enrollment
deadlines, exam schedules, and grade releases.
- **Scalability**: The system must be able to handle increasing numbers of students, courses, and
assessments without performance degradation.
- **Reliability**: The system must be reliable and available to ensure continuous operation and
access to critical educational functions.
```plaintext
|---------------------------------------------|
|---------------------------------------------|
| - Student Enrollment |
| - Student Records |
| - Student Profiles |
|---------------------------------------------|
| - Course Creation |
| - Course Scheduling |
| - Course Content |
|---------------------------------------------|
| - Faculty Profiles |
| - Course Assignments |
| - Faculty Schedules |
|---------------------------------------------|
| - Exam Creation |
| - Assignment Management |
| - Grading |
|---------------------------------------------|
| Notification Service |
| - Event Notifications |
| - Deadline Reminders |
| - Result Announcements |
|---------------------------------------------|
```
- **Architecture**: Refers to the high-level structure of the system, defining its components and
their interactions. It focuses on how the system's overall structure will achieve the required
functionality and quality attributes.
- **Design**: Refers to the detailed implementation of individual components and modules within
the architectural framework. It includes the specific algorithms, data structures, and interfaces used
to achieve the system's functionality.
Not every small or simple software project may need a formal software architecture. However, for
larger and more complex projects, having a well-defined software architecture is crucial to ensure
the system's scalability, maintainability, reliability, and overall success. Even for small projects, some
level of architectural consideration can help in managing complexity and future growth.