III Design Engineering:

Design process and design quality, design concepts, the design model. Creating an architectural
design: software architecture, data design, architectural styles and patterns, architectural
design, conceptual model of UML, basic structural modeling, class diagrams, sequence
diagrams, collaboration diagrams, use case diagrams, component diagrams.

🌟 1. Design Process and Design Quality

✅ What is the Design Process?
●​ It transforms requirements into a blueprint for building the system (like architecture for
a house).​

●​ Goal: Convert “what” the system should do → “how” it will do it.​

✅ Stages of the Design Process:

1.​ Architectural Design – Overall structure, major components, and how they interact.​

2.​ Abstract Specification – Describe external behavior of components.​

3.​ Interface Design – How components interact (inputs, outputs).​

4.​ Component Design – Internal logic of each module.​

5.​ Data Structure Design – Data storage and access details.​

6.​ Algorithm Design – Steps needed to perform tasks.​

✅ Design Quality Aspects:

●​ Correctness – Fulfills all requirements.​

●​ Understandability – Easy to comprehend and modify.​

●​ Efficiency – Optimal use of resources.​

●​ Maintainability – Easy to change or upgrade.​

●​ Reusability – Can be reused in other projects.​

🌟 2. Design Concepts
These are fundamental principles that guide good software design:

Concept Description

Abstraction Focus on essential features, ignore details. (e.g., function name

without worrying about its inner code)

Refinement Go step-by-step from high-level to detailed design.

Modularity Divide system into independent components/modules.

Information Hiding Hide inner details of a module, only show what's needed.

Architecture High-level structure (components + their connections).

Patterns Reusable solutions for common problems (e.g., MVC).

Separation of Break system into sections, each handling a specific concern.

Concerns

Functional Each module does a single task.

Independence

Refactoring Improve internal structure without changing behavior.

🌟 3. The Design Model

The design model helps convert the analysis model (what the system should do) into the system
design (how it will do it). It includes:

📌 Design Elements:
1.​ Data/Class Design – Structures to store and manage data.​

2.​ Architectural Design – Structure and interaction of major components.​

3.​ Interface Design – Interfaces between:​

○​ Software and users​

 ○​ Software and other systems​

○​ Internal modules​

4.​ Component-Level Design – Detailed design of individual components.​

5.​ Deployment-Level Design – How software components are mapped to hardware

📐 Creating an Architectural Design

🧠 1. Software Architecture
✅ What is it?
●​ The structure of a system, showing how components interact.​

●​ Like a blueprint for building software.​

✅ Purpose:
●​ Defines the organization, communication, and control flow between components.​

●​ Ensures non-functional requirements are addressed (like scalability, security, etc.).​

✅ Representation:
●​ Uses models like:​

○​ Block Diagrams​

○​ Flowcharts​

○​ UML Diagrams​

✅ Goals:
●​ Understand system structure​

●​ Reduce design complexity​

 ●​ Improve maintainability​

💾 2. Data Design
✅ What is it?
●​ It defines data structures and how data is accessed, processed, and stored.​

✅ Key Concepts:
●​ Data Structures: Arrays, Lists, Trees, etc.​

●​ Database Design: Tables, Keys, Relationships​

●​ File Design: Format of files, naming conventions​

●​ Ensure data integrity, efficiency, and consistency​

🏛️ 3. Architectural Styles
✅ What is an Architectural Style?
●​ A design pattern for organizing components and their interactions.​

✅ Common Styles:
Style Description

Data-Centered Uses a central data store (e.g., database). Example: Repository pattern

Data Flow Components work in sequence, passing data. Example: Batch

Processing, Pipe & Filter

Call and Return Control is passed via function/procedure calls. Example: Main program
+ subroutines

Layered System is divided into layers, each built on top of the other. Example:
OSI Model
Client-Server Server provides services, client requests them.

Component-Bas Independent components interact via interfaces (like plugins)

ed

🧩 4. Architectural Patterns
✅ What is a Pattern?
●​ A reusable solution to a recurring architectural problem.​

✅ Examples:
●​ Model-View-Controller (MVC):​

○​ Model: Manages data​

○​ View: UI​

○​ Controller: Handles input​

●​ Microservices:​

○​ Application is split into small services, each doing one job.​

●​ Event-Driven Architecture:​

○​ Components react to events.​

●​ Broker Pattern:​

○​ Used in distributed systems; intermediates between clients and servers.​

🧱 Architectural Design
✅ What is Architectural Design?
●​ It's the first step in designing the system.​

●​ It defines the overall structure of the software system.​

✅ Purpose:
●​ To create a blueprint that shows how the software will be organized and how
components will interact.​

✅ Key Points from the Notes:

●​ Acts as a bridge between requirements and implementation.​

●​ Focuses on structure, interactions, and behavior of components.​

●​ Helps in understanding system complexity.​

●​ Involves data design, interface design, and component design.​

🧠 Conceptual Model of UML

✅ What is UML?
●​ UML stands for Unified Modeling Language.​

●​ It's a visual modeling language used to design and document software systems.​

✅ What is a Conceptual Model in UML?

●​ It shows the static structure of the system (what objects/classes exist and how they
relate).​

●​ Think of it as the map of the system’s main components.​

✅ Core Elements in Conceptual Model:

Element Description

Class Blueprint of objects (attributes + behavior)

Association Relationship between classes

 Attributes Data members of a class

Operations Functions or methods of a class

Generalization Inheritance (IS-A relationship)

Aggregation HAS-A relationship (whole-part)

Multiplicity Specifies how many instances are involved in a relationship (e.g.,

1-to-many)

✅ Benefits:
●​ Helps visualize and analyze system structure.​

●​ Acts as a communication tool between stakeholders.​

●​ Can be translated into code skeletons during implementation.

🧱 Basic Structural Modeling

✅ What is it?
●​ Focuses on the static aspects of the system.​

●​ Describes how system parts are organized, related, and interact.​

✅ Main Elements:
●​ Classes​

●​ Objects​

●​ Relationships​

●​ Packages​

It forms the foundation for all structural UML diagrams.

🧾 1. Class Diagram
✅ Purpose:
●​ Shows the blueprint of the system by modeling classes, attributes, operations, and
relationships.​

✅ Key Components:
●​ Class: Represented by a rectangle divided into three parts:​

○​ Class name​

○​ Attributes (variables)​

○​ Operations (methods)​

●​ Relationships:​

○​ Association – Connection between classes​

○​ Generalization – Inheritance (is-a)​

○​ Aggregation/Composition – Whole-part relationship (has-a)​

📌 Used for: Object-oriented design, static structure of systems.

⏳ 2. Sequence Diagram
✅ Purpose:
●​ Shows how objects interact over time.​

●​ Focuses on the order of message flow between objects.​

✅ Key Elements:
 ●​ Lifelines – Object instances (vertical dashed lines)​

●​ Messages – Arrows showing method calls between objects​

●​ Activation Bars – Time period an object performs an action​

📌 Used for: Modeling scenarios, understanding object interaction order.

🤝 3. Collaboration Diagram (Now called Communication

Diagram)
✅ Purpose:
●​ Shows how objects interact but emphasizes structural organization over time
sequence.​

✅ Key Elements:
●​ Objects with links​

●​ Messages are labeled on links (with sequence numbers)​

📌 Used for: Understanding how objects are connected and interact.

🎭 4. Use Case Diagram

✅ Purpose:
●​ Represents user interactions with the system.​

✅ Key Elements:
●​ Actors – Users or external systems (stick figures)​
 ●​ Use Cases – Functions/services the system provides (ovals)​

●​ System Boundary – Defines scope of the system​

📌 Used for: Requirements gathering, understanding system functionality from the

user’s perspective.

🧩 5. Component Diagram
✅ Purpose:
●​ Shows the physical components of the system (like files, libraries, modules).​

✅ Key Elements:
●​ Components – Represent software parts (e.g., a class, package, or system file)​

●​ Interfaces – Points of interaction with other components​

●​ Dependencies – Dashed arrows showing usage between components​

📌 Used for: Visualizing system at the implementation level.