UNIT - 2

(4) System Design:

Design Objectives:
Software Design Objectives

Software design objectives refer to the goals and principles that guide the
development of a software system's architecture, ensuring that the final
product is functional, efficient, and maintainable. These objectives aim to
align the design with user requirements, system constraints, and long-term
scalability.

Key Objectives of Software Design

1. Correctness
○ The design should accurately translate the system's functional
and non-functional requirements.
○ Ensures that the software behaves as expected under all
specified conditions.
2. Modularity
○ The system should be divided into independent modules, each
responsible for a specific functionality.
○ Supports easier development, testing, debugging, and
maintenance.
3. Scalability
○ The design should accommodate future growth, allowing for the
addition of new features or increased workload without
significant rework.
4. Flexibility
○ The system should be adaptable to changes in requirements,
technologies, or environments with minimal impact on the
overall design.
5. Reusability
○ Components or modules should be designed to be reused in
other systems or projects, reducing redundancy and saving
development effort.
6. Efficiency
○ The software should optimize resource usage, including time
(speed), memory, and energy.
○ Ensures that the system performs well even under heavy loads.
7. Maintainability
○ The design should enable easy identification and fixing of bugs,
updates, and modifications.
○ Facilitates long-term sustainability of the software.
8. Reliability
○ The design should ensure consistent performance and fault
tolerance, minimizing system failures.
○ Critical for high-stakes applications like healthcare or finance.
9. Portability
○ The software should be platform-independent or easily
adaptable to run on different hardware and operating systems.
10. User Friendliness
○ The design should focus on creating an intuitive, user-friendly
interface that enhances the user experience.
○ Involves considerations for accessibility and ease of use.
11. Consistency
○ The design should follow consistent standards, naming
conventions, and structural patterns to ensure readability and
understandability.
○ Supports collaboration among development teams.
 12. Security
○ The system should protect data and functionality from
unauthorized access and ensure compliance with relevant
security standards.
13. Traceability
○ The design should allow tracing requirements back to the
corresponding components or modules, ensuring that all user
needs are met.
14. Testability
○ The design should make it easy to verify and validate individual
components and the entire system.
○ Promotes early detection and correction of issues.
15. Cost-Effectiveness
○ The design should minimize development and maintenance costs
while meeting all functional and non-functional requirements.

Conclusion

By adhering to these objectives, software design achieves a balance between

functionality, performance, and maintainability. This ensures that the system
not only meets current user needs but also remains adaptable to future
challenges and requirements.

Design Principles:
Software Design Principles

Software design principles are guidelines that help developers and designers
create robust, maintainable, and scalable systems. These principles aim to
improve the overall quality of the software by promoting clarity, simplicity,
and efficiency. By adhering to these principles, developers can minimize
errors, reduce complexity, and enhance the software's longevity.
Key Software Design Principles

1. Modularity
○ Divide the system into smaller, independent modules, each
handling a specific functionality.
○ Encourages easier maintenance, testing, and parallel
development.
2. Separation of Concerns (SoC)
○ Each module or component should address a distinct concern or
functionality.
○ Reduces overlap and improves code organization.
3. Single Responsibility Principle (SRP)
○ A module or class should have one and only one reason to
change.
○ Simplifies understanding and minimizes the impact of changes.
4. Open/Closed Principle (OCP)
○ Software entities (classes, modules, functions) should be open
for extension but closed for modification.
○ Promotes flexibility by allowing new features without altering
existing code.
5. Liskov Substitution Principle (LSP)
○ Subtypes should be substitutable for their parent types without
altering the correctness of the program.
○ Ensures proper inheritance relationships and consistent behavior.
6. Interface Segregation Principle (ISP)
○ No client should be forced to depend on methods it does not use.
○ Encourages creating smaller, more focused interfaces.
7. Dependency Inversion Principle (DIP)
○ High-level modules should not depend on low-level modules;
both should depend on abstractions.
○ Abstractions should not depend on details; details should
depend on abstractions.
8. Encapsulation
○ Restrict direct access to an object’s internal data and expose only
what is necessary through public methods.
○ Protects data integrity and reduces interdependencies.
9. Abstraction
○ Hide unnecessary implementation details and expose only the
essential features of a module or system.
○ Simplifies complexity and improves code readability.
10. DRY (Don’t Repeat Yourself)
○ Avoid duplicating code or logic.
○ Promotes reuse by extracting common functionality into reusable
components or modules.
11. KISS (Keep It Simple, Stupid)
○ Design should be as simple as possible while fulfilling
requirements.
○ Reduces complexity and makes the system easier to understand
and maintain.
12. YAGNI (You Aren’t Gonna Need It)
○ Avoid adding features or functionality until they are absolutely
necessary.
○ Prevents over-engineering and wasted effort.
13. High Cohesion
○ Ensure that all parts of a module or class are closely related to
its primary functionality.
○ Improves readability, reusability, and maintainability.
14. Low Coupling
○ Minimize dependencies between modules or components.
○ Changes in one module should have little to no impact on others,
enhancing modularity.
15. Code Reusability
○ Design components or modules in a way that they can be reused
in other projects or parts of the system.
○ Reduces development time and promotes consistency.
 16. Scalability
○ Ensure the design can accommodate growth in users, data, or
functionality without major rework.
17. Fault Tolerance
○ Design the system to handle errors gracefully without causing a
total failure.
18. Testability
○ The design should make it easy to write and execute tests for the
system.
○ Promotes early detection of bugs and ensures long-term
reliability.
19. Consistency
○ Follow uniform design patterns, naming conventions, and coding
standards throughout the project.
○ Makes the codebase easier to understand and collaborate on.
20. Minimize Resource Consumption
○ Optimize the design to use system resources like memory,
processing power, and bandwidth efficiently.

Conclusion

By following these principles, software designers can create systems that are
robust, scalable, and easy to maintain. These principles not only enhance the
quality of the software but also improve collaboration and reduce
development time, ensuring long-term success for the project.
Design Methodologies:

(1) Structured Design:

What is Structured Design?

Structured Design is a systematic approach to software development that

focuses on creating a clear and organized architecture for a system. It
emphasizes breaking down a complex system into smaller, manageable parts
(modules) to improve understanding, development, and maintenance. It is
closely linked to the structured programming paradigm and aims to produce
a design that is easy to implement, test, and maintain.

Key Concepts of Structured Design

1. Top-Down Approach:
○ The system is developed from a high-level overview to detailed
components.
○ It begins with identifying the overall functionality and
progressively breaking it down into smaller, specific modules or
processes.
2. Functional Decomposition:
○ Dividing the system into a hierarchy of functions or modules,
each performing a specific task.
○ Helps in understanding and managing the system’s complexity
by separating concerns.
3. Structure Charts:
○ A visual representation of the system’s architecture.
○ Shows the hierarchy and relationships between different
modules, such as control flow and data flow.
○ Includes constructs like modules, decisions, loops, and calls.
 4. Data Flow Diagrams (DFDs):
○ Diagrams that illustrate how data moves through the system.
○ They represent processes, data stores, external entities, and data
flows.
5. Modularity:
○ The system is divided into modules that are independent yet
interconnected.
○ Each module performs a specific function and interacts with
others through well-defined interfaces.
6. Cohesion and Coupling:
○ Cohesion: Measures how closely related the tasks within a
module are. High cohesion (single responsibility) is preferred.
○ Coupling: Measures the level of interdependence between
modules. Low coupling (minimal dependency) is desirable.
7. Functional Independence:
○ Modules are designed to operate independently, minimizing
interactions.
○ Independent modules enhance reusability, maintainability, and
debugging.

Important Concepts of Structured Design

1. Hierarchical Organization:
○ The system is represented in a hierarchy, where high-level
modules control lower-level ones.
○ Promotes clarity by showing how different parts of the system
interact.
2. Transform Analysis:
○ Identifies input and output transformations in a system.
○ Focuses on processes that take inputs, process them, and
produce outputs.
 3. Transaction Analysis:
○ Used to design systems that involve user-driven transactions or
workflows.
○ Helps in identifying decision-making processes and control
flows.
4. Abstraction:
○ Simplifies complex systems by focusing on essential features
and hiding unnecessary details.
○ Enhances readability and understanding of the system.
5. Refinement:
○ The process of progressively adding details to a system design
while maintaining its overall structure.
○ Ensures a smooth transition from conceptual design to
implementation.

Advantages of Structured Design

1. Improved Clarity:
○ By breaking down the system into smaller parts, it becomes
easier to understand and document.
2. Easier Maintenance:
○ Independent modules allow developers to fix or update specific
components without affecting others.
3. Promotes Reusability:
○ Modules can be reused across different systems or projects.
4. Better Testing and Debugging:
○ Each module can be tested individually, making it easier to
isolate and fix errors.
5. Encourages Team Collaboration:
○ Different teams can work on different modules simultaneously,
improving productivity.
Example of Structured Design

Consider a banking system:

● Top-Level Module: "Banking System"

● Sub-Modules:
○ "Account Management" (handles account creation, deletion, and
updates)
○ "Transaction Processing" (manages deposits, withdrawals, and
transfers)
○ "Report Generation" (creates account statements and
summaries)

Each sub-module is independent but works together to fulfill the system’s

objectives.

Conclusion

Structured Design is a vital methodology in software engineering that

promotes clarity, modularity, and functional independence. By emphasizing
hierarchical decomposition, cohesion, and low coupling, it ensures that
systems are easy to develop, understand, and maintain. This approach is
particularly suitable for large and complex systems where organization and
simplicity are critical for success.

(2) Modular Design:

What is Modular Design?

Modular Design is a software design approach where a system is divided

into smaller, self-contained components called modules. Each module is
responsible for a specific part of the system's functionality, making it easier to
design, implement, and maintain complex systems. Modules are designed to
work independently but can interact with one another through well-defined
interfaces.

Key Concepts of Modular Design

1. Modules:
○ Self-contained units that encapsulate a specific functionality.
○ Each module has a clear purpose and operates independently of
other modules.
2. Interfaces:
○ Mechanisms that allow modules to communicate and share data.
○ Define how modules interact with each other without exposing
internal details.
3. Encapsulation:
○ Hides the internal implementation of a module, exposing only
what is necessary.
○ Protects the module's data and operations from being directly
accessed by other modules.
4. Hierarchy:
○ Modules are often organized in a hierarchical structure, with
higher-level modules coordinating lower-level ones.
5. Abstraction:
○ Simplifies complex functionalities into generalized
representations, making them easier to implement and
understand.

Characteristics of Modular Design

1. Functional Independence:
○ Each module performs a distinct function without relying heavily
on others.
○ Enhances reusability and simplifies debugging.
 2. High Cohesion:
○ Each module focuses on a single task, making it more
understandable and manageable.
3. Low Coupling:
○ Modules are loosely connected, minimizing dependencies.
○ Changes in one module have little impact on others.
4. Reusability:
○ Modules can be reused across different projects or systems.
○ Saves development time and effort.
5. Scalability:
○ New modules can be added without disrupting the existing
system.
6. Maintainability:
○ Isolated modules are easier to test, debug, and update.
○ Errors can be traced to specific modules, reducing
troubleshooting time.

Benefits of Modular Design

1. Simplifies Complexity:
○ Dividing a large system into smaller, manageable pieces makes it
easier to design and understand.
2. Supports Team Collaboration:
○ Different teams can work on different modules simultaneously,
speeding up development.
3. Improves Flexibility:
○ Modules can be modified or replaced without affecting the rest
of the system.
4. Enhances Testing:
○ Individual modules can be tested independently, ensuring each
component works correctly.
Examples of Modular Design

1. Software Libraries:
○ Libraries like NumPy and Pandas in Python are modular and can
be used independently.
2. E-commerce Websites:
○ Separate modules handle user authentication, product catalog,
and payment processing.
3. Operating Systems:
○ Modules manage tasks such as memory allocation, file handling,
and device drivers.

Conclusion

Modular Design is a cornerstone of software engineering, promoting

scalability, maintainability, and efficiency. By breaking down a system into
smaller, independent modules with well-defined interfaces, developers can
create robust, reusable, and flexible software systems tailored to evolving
requirements.

(3) Object- Oriented Design:

What is Object-Oriented Design (OOD)?

Object-Oriented Design (OOD) is a software design approach that models a

system as a collection of interacting objects, each representing a real-world
entity. These objects encapsulate both data (attributes) and behavior
(methods), allowing for modular, reusable, and flexible designs. The primary
goal of OOD is to create a system that is easy to develop, maintain, and scale.

OOD is a natural extension of the object-oriented programming (OOP)

paradigm and is used to translate requirements into a logical design, which
forms the foundation for coding.
Core Concepts of Object-Oriented Design

1. Objects:
○ The basic building blocks of OOD.
○ Represent entities in the real world, with specific attributes
(data) and behaviors (operations).
○ Example: A "Car" object might have attributes like color, model,
and speed, and behaviors like start(), stop(), and accelerate().
2. Classes:
○ Blueprints for creating objects.
○ Define the properties (attributes) and methods (behaviors) that
objects of the class will have.
○ Example: A "Vehicle" class can be used to create objects like
"Car," "Bike," and "Truck."
3. Encapsulation:
○ Hides the internal details of an object and exposes only what is
necessary through a public interface.
○ Ensures better modularity and protects the integrity of data.
○ Example: Attributes like "accountBalance" in a "BankAccount"
object can be accessed only via methods like getBalance() and
deposit().
4. Inheritance:
○ Enables new classes to derive properties and behaviors from
existing classes.
○ Promotes code reuse and establishes a hierarchical relationship
between classes.
○ Example: A "Bird" class might inherit attributes like "wings" and
"fly()" behavior from a parent "Animal" class.
5. Polymorphism:
○ Allows objects to be treated as instances of their parent class,
enabling the same interface to behave differently based on the
context.
 ○ Achieved through method overloading (same method name,
different parameters) and overriding (same method, different
implementation in a subclass).
○ Example: A "Shape" class might define a draw() method, while
subclasses like "Circle" and "Rectangle" implement it differently.
6. Abstraction:
○ Hides complex implementation details and shows only the
essential features of an object.
○ Achieved using abstract classes and interfaces.
○ Example: A "Payment" interface might define methods like pay()
without specifying how the payment is processed (e.g., via credit
card or PayPal).

Process of Object-Oriented Design

1. Identify Objects:
○ Analyze the system's requirements and identify the real-world
entities to be modeled as objects.
○ Example: In a library management system, objects might include
"Book," "Member," and "Librarian."
2. Define Relationships:
○ Establish how objects interact with one another.
○ Relationships include inheritance (is-a), composition (has-a), and
association (uses-a).
3. Define Class Hierarchies:
○ Organize classes into a hierarchy using inheritance to promote
reuse and eliminate redundancy.
4. Design Interfaces:
○ Specify how objects will interact through methods and
interfaces, ensuring modularity and flexibility.
5. Refine Design:
○ Refactor the design to optimize class relationships, minimize
coupling, and enhance cohesion.
Advantages of Object-Oriented Design

1. Modularity:
○ Encapsulation ensures that each object is a self-contained
module, making systems easier to understand and maintain.
2. Reusability:
○ Inheritance and polymorphism promote code reuse, reducing
duplication.
3. Scalability:
○ The modular structure of OOD makes it easy to add new
functionality without disrupting the existing system.
4. Flexibility:
○ Polymorphism and abstraction enable systems to handle
changes with minimal impact on other components.
5. Real-World Modeling:
○ By mirroring real-world entities, OOD makes systems intuitive
and easier to design.
6. Improved Testing and Debugging:
○ Independent objects can be tested individually, simplifying
debugging and error resolution.

Example of Object-Oriented Design

Consider an e-commerce system:

1. Objects:
○ "Product," "Customer," "Order," "Payment," and "Cart."
2. Class Relationships:
○ A "Product" is part of a "Cart."
○ An "Order" is placed by a "Customer."
○ A "Payment" is associated with an "Order."
 3. Behaviors:
○ A "Customer" can browse products, add them to the cart, and
place orders.
○ An "Order" object can calculate the total price and generate an
invoice.

Conclusion

Object-Oriented Design is a powerful methodology that simplifies software

development by modeling systems as a collection of interacting objects. By
leveraging key principles like encapsulation, inheritance, and polymorphism,
OOD promotes modularity, flexibility, and reusability, making it ideal for
building complex and scalable software systems.

(4) User Interface Design:

What is User Interface (UI) Design?

User Interface (UI) Design refers to the process of designing the visual and
interactive elements of a software application or website to ensure an
intuitive, user-friendly, and visually appealing experience for users. It focuses
on how users interact with the system and aims to make those interactions as
efficient and enjoyable as possible.

The UI encompasses everything a user can see and interact with, including
buttons, icons, menus, typography, and layout. A good UI design bridges the
gap between the system's functionality and the user's expectations.
Key Objectives of UI Design

1. Ease of Use
○ The design should minimize the learning curve for new users and
allow experienced users to operate efficiently.
2. Consistency
○ Maintain uniform design elements, such as buttons, colors, fonts,
and layouts, across the interface to avoid confusion.
3. User-Centric Approach
○ Prioritize user needs, preferences, and behaviors while designing
the interface.
4. Accessibility
○ Design for inclusivity, ensuring the interface is usable for people
with disabilities (e.g., colorblind users, users with limited
mobility).
5. Aesthetics
○ Ensure the interface is visually appealing while not
overwhelming the user.
6. Responsiveness
○ The interface should adapt seamlessly to different devices,
screen sizes, and resolutions.
7. Efficiency
○ Minimize the number of steps required to perform a task,
reducing user effort and time.

Elements of User Interface Design

1. Layout
○ The arrangement of components such as text, images, buttons,
and navigation menus.
○ A well-structured layout guides the user’s attention and
improves usability.
 ○ Example: Using a grid system to maintain alignment and
balance.
2. Typography
○ The style, size, and arrangement of text to ensure readability and
convey the appropriate tone.
○ Example: Sans-serif fonts for digital screens for better
readability.
3. Color Scheme
○ Colors are used to create contrast, draw attention, and evoke
emotions.
○ Should follow accessibility standards, such as proper contrast for
visually impaired users.
4. Icons and Visual Elements
○ Small graphical representations used to aid navigation and
communicate functionality (e.g., a trash can icon for "delete").
○ Must be intuitive and consistent across the interface.
5. Navigation
○ Enables users to move through the interface easily.
○ Includes menus, tabs, breadcrumbs, and search bars.
○ Example: A sticky navigation bar that remains visible while
scrolling.
6. Buttons and Controls
○ Interactive elements like buttons, sliders, and checkboxes that
allow users to perform actions.
○ Example: A "Submit" button that changes color when hovered
over.
7. Feedback and Response
○ Provides visual or auditory feedback when users interact with
the system (e.g., a button changes color when clicked, a progress
bar for uploads).
8. Images and Media
○ Use of pictures, videos, and animations to enhance user
engagement and understanding.
○ Example: Tutorials or walkthrough animations for onboarding.
 9. Error Handling
○ Informative error messages and guidance to help users recover
from mistakes.
○ Example: Highlighting a missing required field in a form with a
red message.

Principles of UI Design

1. Clarity
○ Ensure that all elements are easily understandable and intuitive.
○ Example: Using descriptive labels on buttons like “Submit”
instead of vague terms.
2. Simplicity
○ Keep the design minimalistic, avoiding unnecessary elements
that may distract users.
3. Consistency
○ Uniform design across different sections of the interface
enhances familiarity and usability.
4. User Control
○ Give users control over their actions (e.g., Undo or Cancel
options).
5. Accessibility
○ Ensure the interface is usable by everyone, including those with
disabilities.
6. Visual Hierarchy
○ Organize elements in a way that prioritizes important content
and guides users effectively.
7. Feedback
○ Immediate and clear responses to user actions to confirm success
or failure.
Advantages of Good UI Design

1. Improved Usability: Users can complete tasks easily and efficiently.

2. Enhanced User Satisfaction: Intuitive and appealing design leads to
positive user experiences.
3. Reduced Errors: Clear navigation and feedback minimize user
mistakes.
4. Higher Engagement: A well-designed UI keeps users engaged and
encourages repeat visits.
5. Brand Credibility: A professional-looking interface builds trust and
reflects positively on the brand.

Example of UI Design

Consider a food delivery app:

1. Navigation: A simple menu with options for "Home," "Search,"

"Orders," and "Profile."
2. Color Scheme: Warm colors (like orange) to evoke appetite.
3. Feedback: A confirmation message after placing an order.
4. Icons: Intuitive icons, such as a magnifying glass for "Search" and a
shopping cart for "Orders."
5. Responsiveness: The design adjusts seamlessly to mobile and tablet
screens.

Conclusion

User Interface Design is crucial for creating systems that are intuitive,
aesthetically pleasing, and efficient. A good UI design not only enhances user
satisfaction but also contributes to the overall success of the software by
ensuring ease of use, accessibility, and visual appeal.