Unit 3: Design Engineering

Introduction to Design Engineering

Design engineering is a crucial phase of the software development life cycle (SDLC). It is the process of defining the architecture, components, interfaces, and other characteristics of a system or its elements. The design phase bridges the gap between the requirements phase and the implementation phase by providing a blueprint for constructing the software. It is not just about writing code, but about creating a framework that ensures the system is efficient, reliable, and maintainable.

The goal of design engineering is to transform user requirements into a complete, detailed specification of the system that can be implemented. This includes architectural design (high-level design), component-level design (detailed design), and user interface design.

Design Process and Quality

The design process refers to a set of tasks and activities that engineers perform to produce a design that meets the specified requirements. A well-structured design process leads to a software system that is not only functional but also of high quality. Key aspects of a high-quality design include:

Correctness: The design must meet the system's requirements.
Completeness: The design should cover all aspects of the system.
Consistency: The design should not contain contradictions.
Efficiency: The design should optimize performance and resource utilization.
Flexibility: The design should accommodate future changes without significant effort.
Maintainability: The design should be easy to understand, modify, and extend.

A well-defined design process involves several stages:

Requirement Analysis: Identifying the key features and constraints of the system.
System Design: Creating a high-level view of how the system will meet the requirements.
Component Design: Breaking the system into smaller, reusable components.
User Interface Design: Designing how users will interact with the system.
Validation and Verification: Ensuring the design meets the requirements and can be implemented effectively.

Design Concepts

Design engineering involves several core concepts that guide the design process:

Abstraction: Focusing on the essential features of a system while ignoring unnecessary details. For instance, in object-oriented design, classes represent abstractions of real-world entities.
Modularity: Dividing a system into distinct modules or components, each responsible for a specific piece of functionality. This approach makes systems easier to understand, develop, test, and maintain.
Encapsulation: Hiding the internal details of a component and exposing only what is necessary for other components to interact with it.
Decomposition: Breaking down a complex system into smaller, manageable parts.
Cohesion: Refers to how closely related the responsibilities of a single module or component are. High cohesion within a module is desirable.
Coupling: Refers to the interdependencies between modules or components. Low coupling (i.e., minimal dependencies) is desirable as it makes the system more modular and easier to maintain.
Hierarchy: Organizing components in a hierarchical structure, with relationships between higher-level and lower-level modules.

Design Models

A design model is a structured representation of the software system that provides a roadmap for how it will be constructed. Several types of models are used during design:

Data Design Model: Focuses on how data is structured and stored within the system. This model typically involves defining database schemas and data flow diagrams.
Architectural Design Model: Describes the overall structure of the system, including its components, their interactions, and the underlying architecture.
Component Design Model: Details the internal design of individual components and their interactions.
Interface Design Model: Defines the user interface elements and how users will interact with the system.
Behavioral Design Model: Represents the dynamic behavior of the system, showing how it responds to different inputs and events over time.

Pattern-Based Software Design

Design patterns are reusable solutions to common software design problems. They provide a template for how to solve specific problems within a given context. The use of design patterns helps in creating a well-structured, maintainable system by following best practices. Some commonly used patterns include:

Creational Patterns: Deal with object creation mechanisms, ensuring that the system is flexible in how objects are created, composed, and represented. Examples include the Singleton and Factory patterns.
Structural Patterns: Focus on how classes and objects are composed to form larger structures. Examples include Adapter and Composite patterns.
Behavioral Patterns: Concerned with how objects interact and communicate with each other. Examples include Observer and Strategy patterns.

Using design patterns ensures that the software design is robust, flexible, and easy to understand, as they promote code reuse and standardized design techniques.

Architectural Design

Architectural design refers to the high-level structure of a software system. It involves making fundamental decisions about the system’s structure and organization.

Design Decisions

Architectural design is characterized by key design decisions that define the overall structure and behavior of the system. These decisions include choosing between different architectural styles (e.g., layered architecture, client-server architecture) and selecting key components and their responsibilities.

Design Views

The architectural design process typically considers different views of the system to address the concerns of various stakeholders. Common views include:

Logical View: Describes the system's functionality and the relationships between different components.
Physical View: Focuses on the hardware and software infrastructure where the system will run.
Process View: Deals with dynamic aspects, including how the system responds to events and how processes interact.
Development View: Shows how the system is divided into development subsystems and components.

Design Patterns

Architectural patterns are higher-level design patterns that provide reusable solutions to common architectural problems. Examples include:

Layered Architecture: Divides the system into layers, each responsible for a specific set of tasks (e.g., presentation layer, business logic layer, data layer).
Microservices Architecture: Breaks the system into small, loosely coupled services that can be developed and deployed independently.

Application Architectures

Application architectures refer to the design of specific types of systems, such as web-based systems, desktop applications, or mobile applications. Each type of system has its own set of design principles, patterns, and best practices that guide the development process.

Component-Level Design

Component-level design is a detailed design process that focuses on individual components of the system. Components are reusable units of functionality that can be assembled to form a complete system.

Components

A component is a modular, deployable, and replaceable part of a system that encapsulates a set of related functions or data. In object-oriented design, components often correspond to classes or a group of classes.

Designing Class-Based Components

Class-based component design focuses on defining the classes that make up a component and their relationships. This involves identifying:

Attributes: The data that the class will store.
Methods: The operations that the class will perform.
Relationships: How the class interacts with other classes.

Conducting Component-Level Design

Component-level design involves breaking down the system into individual components, each with a specific responsibility. The process includes:

Identifying Components: Based on the architectural design, components are identified and assigned responsibilities.
Defining Interfaces: Each component’s interface is designed to allow other components to interact with it without knowing its internal details.
Ensuring Modularity: The design should ensure that components are modular and can be reused in different contexts.

User Interface Design

The user interface (UI) design focuses on how users will interact with the system. A good UI is critical for ensuring that the system is easy to use and meets the user's needs.

The Golden Rules of User Interface Design

Place Users in Control: The interface should empower users by providing clear options, undo features, and easy navigation.
Reduce User’s Memory Load: The UI should reduce the cognitive effort required by users by making actions intuitive and predictable.
Consistency: The design should be consistent in terms of layout, language, and interaction elements.

Interface Design Steps and Analysis

The process of UI design includes several key steps:

Requirement Gathering: Understanding what users expect from the interface.
Design Prototyping: Creating wireframes or mockups to visualize the interface layout.
Evaluation: Testing the design with users to identify areas of improvement.

Design Evaluation

After the interface is designed, it must be evaluated to ensure it meets user needs. This involves usability testing, where real users interact with the system and provide feedback on their experience. Common evaluation criteria include:

Usability: How easy the interface is to use.
Efficiency: How quickly users can complete tasks.
**

Learnability**: How easy it is for new users to learn the interface.

Error Handling: How well the system prevents and recovers from user errors.

Unit-02 Unit-04