3. Understanding Software Design
• Definition: Software design is the process of defining the architecture,
components, modules, interfaces, and data for a system to satisfy specified
requirements.
• Software design refers to the process of conceptualizing and planning the
creation of a software system.
• It involves making crucial decisions about how the software will function,
how its components will interact, and how the system will be structured to
meet specific requirements and objectives.
4. This phase typically includes:
• Architectural Design: Defining the overall structure and high-level components of
the software system. This involves choosing the right architectural style (like client-
server, MVC, microservices), determining data flow, and identifying interfaces
between different modules.
• Detailed Design: Developing a more detailed plan for individual
components/modules, specifying algorithms, data structures, and implementation
details. It involves designing classes, methods/functions, and their relationships, as
well as defining interfaces and protocols.
5. • User Interface Design: Focusing on the design and layout of the user
interface elements to ensure user-friendly interactions.
• Database Design: Planning the structure and organization of the database
that the software will use, including tables, relationships, and data storage
methods.
• Testing Strategy: Designing how the software will be tested to ensure
functionality, reliability, performance, and security.
6. Objectives of Software Design:
• Correctness:
A good design should be correct i.e. it should correctly implement all the functionalities of the system.
• Efficiency:
A good software design should address the resources, time, and cost optimization issues.
• Flexibility:
A good software design should have the ability to adapt and accommodate changes easily. It includes designing
the software in a way, that allows for modifications, enhancements, and scalability without requiring significant
rework or causing major disruptions to the existing functionality.
• Understandability:
A good design should be easily understandable, for which it should be modular and all the modules are arranged
in layers.
• Completeness:
The design should have all the components like data structures, modules, and external interfaces, etc.
• Maintainability:
A good software design aims to create a system that is easy to understand, modify, and maintain over time. This
involves using modular and well-structured design principles eg.(employing appropriate naming conventions and
providing clear documentation). Maintainability in software Design also enables developers to fix bugs, enhance
features, and adapt the software to changing requirements without excessive effort or introducing new issues.
7. Software Design Concepts
• Concepts are defined as a principal idea or invention that comes into our mind or in
thought to understand something.
• The software design concept simply means the idea or principle behind the design.
• It describes how you plan to solve the problem of designing software, the logic, or
thinking behind how you will design software.
8. Core Design Principles
• Abstraction:
Definition: Representing essential features without unnecessary details.
Importance: Simplifies complexity and focuses on relevant aspects.
• Modularity:
Definition: Breaking down a system into smaller, manageable, and independent
components.
Importance: Enhances maintainability and scalability.
• Encapsulation:
Definition: Hiding internal details and exposing only what is necessary.
Importance: Protects data integrity and promotes code organization.
• Coupling and Cohesion:
Definition: The degree of dependence between components (coupling) and the degree to
which components within a module belong together (cohesion).
Importance: Minimizing coupling and maximizing cohesion improves system robustness.
9. Abstraction
• Hide Irrelevant data
• Abstraction simply means to hide the details to reduce complexity and
increases efficiency or quality. Different levels of Abstraction are necessary
and must be applied at each stage of the design process so that any error
that is present can be removed to increase the efficiency of the software
solution and to refine the software solution.
• The solution should be described in broad ways that cover a wide range of
different things at a higher level of abstraction and a more detailed
description of a solution of software should be given at the lower level of
abstraction.
10. Modularity
• Subdivide the system
• Modularity simply means dividing the system or project into smaller parts
to reduce the complexity of the system or project. In the same way,
modularity in design means subdividing a system into smaller parts so that
these parts can be created independently and then use these parts in
different systems to perform different functions.
• It is necessary to divide the software into components known as modules
because nowadays there are different software available like Monolithic
software that is hard to grasp for software engineers. So, modularity in
design has now become a trend and is also important. If the system contains
fewer components then it would mean the system is complex which requires
a lot of effort (cost) but if we are able to divide the system into components
then the cost would be small.
11. Encapsulation
• Hiding internal details and exposing only what is necessary.
• Data Hiding: It refers to restricting access to certain components of an
object, typically its attributes, from the outside. This is achieved by making
the attributes private or protected, preventing direct modification by
external code. Access to these attributes is usually provided through public
methods (getters and setters) defined in the class, allowing controlled
manipulation of the object's state.
• Information Hiding: This aspect emphasizes the idea that the internal
details of an object should not be visible to the outside world. It protects the
object's integrity by preventing unauthorized access or modification of its
internal state.
• Protects data integrity and promotes code organization
12. Coupling and Cohesion
• The degree of dependence between components (coupling) and the degree to which
components within a module belong together (cohesion).
• Coupling refers to the degree of interdependence between different modules or
components in a software system. It measures how closely connected or reliant one
module is on another.
• Cohesion, on the other hand, refers to the degree to which the elements inside a
module belong together. It measures how closely related and focused the
responsibilities of a module are.
13. Architectural Design
• Definition:
In software engineering, the architectural design of a project refers to the high-level
structure and organization of the software system.
Modules, layers, and subsystems that define the system's structure.
It involves creating a blueprint that outlines the components, modules, interactions,
and relationships within the system.
The goal is to provide a framework that ensures the system meets functional and
non-functional requirements while being scalable, maintainable, and adaptable.
14. Software design architectures
• Layered Architecture: This architecture divides the software into logical
layers, each responsible for specific functionalities. Common layers include
presentation, business logic, and data access layers. This separation helps in
modularity, scalability, and easier maintenance.
15. • Client-Server Architecture: In this model, clients (e.g., web browsers or
applications) communicate with a central server to request and receive
services or data. It allows for distributed computing and facilitates
scalability by distributing tasks between clients and servers.
16. • Microservices Architecture: Microservices break down a software
application into small, independently deployable services. Each service
focuses on a specific business capability and communicates via APIs. This
architecture enhances scalability, flexibility, and allows for continuous
deployment.
17. • Service-Oriented Architecture (SOA): SOA involves creating reusable
services that can be accessed and reused across multiple applications. It
promotes interoperability, flexibility, and modular design by encapsulating
business functionalities into services.
18. • Model-View-Controller (MVC): MVC separates an application into three
interconnected components: Model (data and business logic), View (user
interface), and Controller (handles user input). It promotes a clear
separation of concerns and facilitates modular development.
19. • Component-Based Architecture: This architecture focuses on building
software by combining reusable components or modules. It promotes
reusability, maintainability, and flexibility by assembling components into
larger systems.
20. Wireframing
• It helps determine the basic structure of software like the navigation and
features before adding substantial design components like colors, graphics,
and fonts. It helps both the clients and the developers to understand how
things are going to be placed to make functional and feature-loaded
software.
21. Data Flow Diagrams
• These help in determining the different levels of concept in a system by
showing the complete system requirement, detailed aims of the system, and
also details about the functioning of the software.
22. User Interface (UI) Design
• Enhancing User Experience
• Definition:
Designing the visual and interactive aspects of the software.
• Principles:
Consistency, feedback, efficiency, and simplicity.
• Elements:
Navigation, layout, color schemes, and interactive components.
• User-Centered Design:
Involving end-users in the design process for better usability.
23. UI Designing
• It comprises the parts with which the user interacts with software, that help
in making the interface understandable, usable, and friendly.
• There are three types of user interfaces namely the graphical user interface,
voice-controlled interfaces, and gesture-based interfaces.
25. UI design using Adobe XD
• https://www.youtube.com/watch?v=PF7DGvoS68E&t=11s
26. Prototyping
• It is a detailed version of a wireframe that helps in testing the layouts and
the entire functionality of the software. It helps save time, money, and effort
by gathering user feedback to provide the desired outcome.
• Furthermore, it is classified into three different types i.e. Low, medium, and
high fidelity prototyping respectively which ensures that the designed
prototypes meet the business requirements to deliver the best user
experiences.
27. • Low Fidelity Prototyping approach is a paper-based approach that
includes sketching and doesn’t allow user interactions. It also makes the
design process more productive by helping you brainstorm the design ideas
before finalizing the final design.
• Medium Fidelity Prototyping has limited or basic functionality with
clickable areas, which helps in deciding whether you’ve met the design
requirements or not.
• High-Fidelity Prototyping allows user interactions. It provides a realistic
and high-quality environment to determine the design accuracy and helps as
a form of reference for the designers.
28. Integration of Design Concepts
Alignment of Functionalities:
• Architectural Design: Defines the structure, components, and interactions
within the software system, focusing on functionality, data flow, and system
behavior.
• UI Design: Translates functional requirements into intuitive interfaces,
visually representing the functionalities and interactions for users.
29. Interoperability and Integration:
• Architectural Design: Determines how different system components
interact, integrate, and communicate with each other, influencing system
interoperability and scalability.
• UI Design: Reflects these interactions visually, showcasing integration
points and ensuring seamless user experiences during transitions between
various system functionalities.
30. Consistency and Design Patterns:
• Architectural Design: Establishes coding patterns, guidelines, and
principles to ensure consistency, maintainability, and scalability within the
system.
• UI Design: Adheres to these principles to maintain a consistent user
interface, applying design patterns that align with the underlying
architecture for visual consistency.
31. Adaptability and User Interface Updates:
• Architectural Design: Supports the adaptability of the system, facilitating
future updates, and modifications without compromising the overall
structure.
• UI Design: Adapts to changes in the system's functionalities, ensuring that
visual elements remain coherent and user-friendly even after updates or
feature enhancements.
32. Performance and Usability:
• Architectural Design: Optimizes system performance, ensuring efficient
resource utilization, speed, and responsiveness.
• UI Design: Reflects this performance by providing interfaces that are
responsive, reducing load times, and optimizing user interactions for a
smoother user experience.
34. example of a mobile banking application and how
good design principles contribute to its success:
1. User-Centered Design:
• Principle: Understanding user needs and behaviors drives the design process.
• Contribution: The app offers a clear and intuitive interface, prioritizing features like
easy fund transfers, bill payments, and account management based on user priorities.
2. Consistency and Visual Hierarchy:
• Principle: Consistent layout, colors, and typography are maintained throughout the app.
• Contribution: Users easily navigate different sections of the app with familiar visual
cues, ensuring a seamless experience and reducing cognitive load.
3. Responsiveness and Accessibility:
• Principle: The app is optimized for various devices and accessible to all users.
• Contribution: Users can access their accounts from smartphones and tablets with
consistent functionality and accessibility features for those with disabilities.
35. 4. Information Architecture:
• Principle: Organizing financial information logically and hierarchically.
• Contribution: Users find it easy to locate transaction histories, account summaries, and
statements, improving overall usability and reducing search time.
5. Performance Optimization:
• Principle: Optimizing for fast loading and smooth interactions.
• Contribution: Users experience quick loading times for account data, seamless
transaction processes, and minimal lag, increasing user satisfaction.
6. Security and Trust:
• Principle: Prioritizing robust security measures and transparent communication about
data protection.
• Contribution: Users trust the app with sensitive financial information due to strong
encryption, multi-factor authentication, and clear privacy policies.
36. 7. Iterative Design Process:
• Principle: Embracing continuous improvement through user feedback.
• Contribution: Regular updates incorporate user suggestions, fixing bugs,
and introducing new features that align with evolving user needs and
technological advancements.
8. Scalability and Reliability:
• Principle: Designing for scalability and reliability under high user loads.
• Contribution: The app functions reliably even during peak usage times,
ensuring uninterrupted service and user satisfaction.
