Software Architecture defines the high-level structure and organization of a software system, including its components, their relationships, interfaces, and the principles guiding its design and evolution.

Key aspects:

• Structural organization: How system components are arranged and connected
• Component interfaces: How different parts communicate and interact
• Design principles: Rules and guidelines governing system design decisions
• Quality attributes: Non-functional requirements like performance, security, and scalability
• Technology choices: Selection of frameworks, databases, platforms, and tools

Why Software Architecture matters:

• Foundation for development: Provides clear roadmap and guidelines for implementation teams
• Stakeholder communication: Enables effective communication between technical and business stakeholders
• Risk mitigation: Identifies potential technical and architectural issues early in the development lifecycle
• Quality assurance: Ensures system meets performance, scalability, security, and maintainability requirements
• Cost management: Helps estimate development effort and identifies potential technical debt
• Team coordination: Enables multiple development teams to work effectively on large systems

Architecture focuses on high-level structure and major components:

• System-wide decisions and constraints
• Technology choices and frameworks
• Component relationships and interfaces
• Non-functional requirements (performance, security)
  Design focuses on detailed implementation:
• Class structures and method signatures
• Algorithms and data structures
• Implementation-specific patterns
• Code organization within components
  Example:
• Architecture: "We'll use microservices with REST APIs and a message queue"
• Design: "The UserService class will have a getUserById() method that queries PostgreSQL"

Quality Attributes (also called Non-Functional Requirements) are measurable properties that determine how well a system performs its intended functions. They directly influence architectural decisions.
Key Quality Attributes:

• Performance: Response time, throughput, resource utilization
• Scalability: Ability to handle increased load
• Availability: System uptime and reliability
• Security: Protection against threats and unauthorized access
• Maintainability: Ease of modification and enhancement
• Usability: User experience and interface design
• Testability: Ease of testing and validation

Performance measures how fast a system responds to requests under current load:

• Response time for individual requests
• Throughput (requests per second)
• Resource utilization (CPU, memory)
  Scalability measures how well performance is maintained as load increases:
• Vertical scaling: Adding more power to existing machines
• Horizontal scaling: Adding more machines to handle load
  Example:
  A system might have good performance (responds in 100ms) but poor scalability (response time increases to 5 seconds when user load doubles).

Separation of Concerns is a design principle that divides a system into distinct sections, each addressing a specific concern or responsibility. This reduces complexity and improves maintainability.
Benefits:

• Modularity: Each component has a single, well-defined purpose
• Maintainability: Changes to one concern don't affect others
• Reusability: Components can be reused across different contexts
• Testability: Each concern can be tested independently
  Example:

// Poor separation
class UserController {
    public void createUser(UserDto user) {
        // Validation logic
        if (user.email == null) throw new Exception();
        // Business logic
        User newUser = new User(user.name, user.email);
        // Data access logic
        database.save(newUser);
        // Notification logic
        emailService.sendWelcome(user.email);
    }
}
// Good separation
class UserController {
    public void createUser(UserDto user) {
        validator.validate(user);
        User newUser = userService.createUser(user);
        notificationService.sendWelcome(newUser);
    }
}

MVC separates an application into three interconnected components:
Model: Manages data and business logic
View: Handles user interface and presentation
Controller: Manages user input and coordinates between Model and View
Benefits:

• Separation of concerns
• Parallel development
• Code reusability
• Easier testing
  Example flow:

1. User clicks button (View)
2. Controller receives input
3. Controller updates Model
4. Model notifies View of changes
5. View updates display