Lecture 1 & 2

Software Design Challenges

1. Balancing Requirements : Functionality vs. performance/security (use MoSCoW

prioritization).

2. Handling Complexity : Modularize, abstract, use layered architectures.

3. Scalability : Adopt microservices, load balancing, caching.

4. Changing Requirements : Use Agile methodologies.

5. Reusability : Standardize patterns, coding practices.

6. Technical Debt : Refactor regularly, automate testing.

7. Legacy Integration : Use APIs/middleware.

8. Security : Follow secure principles, conduct threat modeling.

9. Cost vs. Quality : Use open-source tools, focus on core features.

10. Team Collaboration : Use collaborative tools, maintain clear

documentation.

11. Tool Selection : Evaluate scalability, support, compatibility.

12. Emerging Trends : Foster continuous learning, experiment safely.

13. Testability : Use Dependency Injection, logging, unit tests.

14. Cross-Platform Support : Use responsive design, frameworks,

compatibility testing.

15. Ethics & Sustainability : Design for accessibility, minimize resource use.

Challenges at Business Levels

1. Strategic :

 Align architecture with business goals (e.g., monolithic vs. microservices).

 Plan for scalability, avoid vendor lock-in.

2. Operational :

 Integrate legacy systems, ensure compliance (e.g., GDPR).

 Streamline workflows with automation.

3. Tactical :

 Optimize code quality, performance, security.

  Ensure testability, usability.

Cross-Cutting Concerns

 Agility: Iterative design, rapid prototyping.

 Globalization: Multi-language support.

 Sustainability: Ethical, eco-friendly designs.

Business-Specific Examples

1. Startups : Focus on MVP, scalability.

2. SMEs : Balance budget with robustness.

3. Large Enterprises : Manage distributed systems, ensure compliance.

4. Tech Giants : Innovate architectures, scale globally.

 Lecture 3

The Role of a Software Designer

A software designer bridges theoretical concepts and practical implementation, ensuring

software is functional, maintainable, scalable, and user-friendly. Below are the key roles
they play in modern software engineering:

1. Architect of the System

 Designs the system's architectural blueprint, including structure, technology

selection, and scalability.

 Example: Choosing between monolithic or microservices architecture for a

web application.

2. Advocate for Quality

 Ensures robustness, maintainability, and reusability of the system.

 Example: Creating modular, well-documented code with clear interfaces.

3. Mediator Between Stakeholders

 Translates user needs into technical specifications and balances trade-offs

like time, cost, and resources.

 Example: Collaborating with marketing teams to integrate analytics while

ensuring data privacy.

4. User Experience (UX) Facilitator

 Focuses on usability, accessibility, and iterative design improvements based

on feedback.

 Example: Prototyping and testing navigation flows for a mobile app.

5. Risk Assessor

 Identifies risks, proposes solutions, and ensures compliance with standards

and regulations.

 Example: Designing fault-tolerant systems for high-availability platforms like

online banking.

6. Innovator and Visionary

 Explores emerging technologies, fosters creativity, and future-proofs designs.

 Example: Integrating AI-based recommendations into an e-commerce

platform.

7. Educator and Mentor

  Guides teams, promotes best practices, and shares knowledge through
workshops and documentation.

 Example: Teaching junior developers how to design RESTful APIs.

Conclusion

The role of a software designer is both technical and strategic, requiring a balance of
creativity and practicality. By aligning user needs, business goals, and technical
constraints, they contribute to immediate project success and long-term innovation.
 Lecture 4

Classifications of Software Design and Role of UML

1. Classifications of Software Design

Software design is categorized into three levels, each with specific goals and UML
representations:

 Architectural Design :

 Defines the high-level structure of the system, including components

and their interactions.

 Key Elements : Modules, communication pathways, deployment

environments.

 UML Diagrams : Use Case, Component, and Deployment Diagrams.

 Example : Modeling a client-server architecture using Deployment

Diagrams.

 High-Level Design :

 Focuses on subsystems and modules within the architecture.

 Key Elements : Subsystem functionalities, interfaces, data flow.

 UML Diagrams : Class, Sequence, and Activity Diagrams.

 Example : Designing a payment processing subsystem using

Sequence and Activity Diagrams.

 Detailed Design :

 Involves designing individual components, classes, and methods.

 Key Elements : Algorithms, data structures, class responsibilities.

 UML Diagrams : Class, State, and Object Diagrams.

 Example : Designing a class hierarchy for an e-commerce product

catalog.

2. Role of UML in Software Design

UML (Unified Modeling Language) is essential for visualizing, standardizing, and
documenting software designs:

 Visualization : Provides clear representations of system components and

relationships.

 Standardization : Ensures consistency across designs for easier

collaboration and maintenance.

 Analysis and Validation : Identifies design flaws early and supports

simulations.
  Documentation : Acts as a reference for future updates and scalability.

3. Key UML Diagrams for Each Design Level

 Use Case Diagrams : Capture system functionality from a user’s

perspective (Architectural Design).

 Class Diagrams : Show static structure of the system (High-Level and

Detailed Design).

 Sequence Diagrams : Illustrate object interactions over time (High-Level

and Detailed Design).

 Activity Diagrams : Model workflows and processes (High-Level Design).

 Component Diagrams : Represent system components (Architectural

Design).

 Deployment Diagrams : Show hardware/software deployment

(Architectural Design).

4. Case Study: Online Food Delivery System

 Architectural Design :

 Use Case Diagram: Identify actors (customers, delivery personnel,

administrators).

 Component Diagram: Modules like ordering, payment, and delivery

tracking.

 High-Level Design :

 Class Diagram: Classes such as User, Order, and Restaurant.

 Sequence Diagram: Interaction for placing an order.

 Detailed Design :

 Class Diagram: Add attributes/methods for each class.

 State Diagram: Lifecycle of an Order object (e.g., Created → Confirmed

→ Dispatched → Delivered).
 Lecture 5

Logical vs. Physical Components in Software Development

1. Definitions

 Logical Components :

 Abstract, high-level design elements focusing on functionality,

relationships, and interactions.

 Examples: Modules, classes, interfaces, workflows, algorithms.

 Physical Components :

 Tangible, real-world entities where the logical design is implemented.

 Examples: Servers, databases, APIs, containers, hardware devices.

2. Comparison: Logical vs. Physical Components

Aspect Logical Components Physical Components

Concrete implementation and

Focus Abstract functionality and relationships deployment

Representation UML diagrams, flowcharts, pseudocode Physical hardware, runtime environments

Tied to specific
Dependency Independent of technology platforms technologies/infrastructure

Purpose Planning and design Execution and operationalization

3. Examples

 E-commerce Application :

 Logical Component: Order management module (e.g., adding items to

cart, checkout).

 Physical Component: Server hosting the database and APIs.

 Mobile Banking App :

 Logical Component: Authentication module (e.g., multi-factor logic).

 Physical Component: Cloud-based authentication service and mobile

device sensors.

4. Role in Software Development

 Design Phase :
  Logical components define system architecture and workflows using
tools like UML diagrams.

 Implementation Phase :

 Physical components map logical designs to real-world entities using

tools like IDEs and cloud platforms.

 Integration :

 Logical components guide the integration of physical components for

seamless interaction.

 Testing :

 Logical components define test cases, while physical components

determine the test environment.
 Lecture 6

Patterns and Styles in Software Architecture

1. Introduction to Software Architecture

 Definition : Software architecture defines the structure, behavior, and

interactions of a system's components.

 Importance : Ensures scalability, maintainability, performance, and security.

 Role of Architects : Design systems that align with business goals and
technical requirements.

2. Software Architecture Styles

 Monolithic Architecture :

 Single-tiered, tightly coupled system.

 Pros: Simple to develop and deploy.

 Cons: Hard to scale and maintain.

 Layered Architecture :

 Divides system into layers (e.g., Presentation, Business Logic, Data).

 Common in MVC and N-Tier applications.

 Microservices Architecture :

 Decomposes systems into small, independent services.

 Pros: Scalability, flexibility, and fault tolerance.

 Cons: Increased complexity in communication and monitoring.

 Event-Driven Architecture :

 Focuses on asynchronous event processing.

 Ideal for real-time systems like notifications or IoT.

 Service-Oriented Architecture (SOA) :

 Similar to microservices but broader in scope, often using middleware.

 Pipe-and-Filter Architecture :

 Processes data in stages, useful for workflows like ETL pipelines.

 Client-Server Architecture :

 Traditional model where clients request services from a central server.

3. Architectural Patterns
  Model-View-Controller (MVC) : Separates UI (View), logic (Controller), and
data (Model).

 Repository Pattern : Centralizes data access logic for persistence.

 Broker Pattern : Facilitates communication between decoupled

components via middleware.

 Adapter Pattern : Bridges incompatible interfaces for seamless integration.

 Factory Pattern : Encapsulates object creation logic.

 Observer Pattern : Implements event-driven mechanisms for state

changes.

4. Selecting the Right Architecture

 Factors : Business needs, scalability, maintainability, and team expertise.

 Trade-offs : Balance performance, complexity, and flexibility.

 Case Studies : Examples from companies like Netflix (microservices) and

Amazon (cloud-native).

5. Emerging Trends in Software Architecture

 Cloud-Native Architectures : Optimized for cloud environments (e.g.,

Kubernetes).

 Serverless Computing : Event-driven, pay-per-use models for scalable

applications.

 AI-driven Decisions : Using AI to optimize architectural choices.

 Domain-Driven Design (DDD) : Aligns software design with business

domains for better clarity.