Software Design

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.
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.
• 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.
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.
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.
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.
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.
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.
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
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.
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.
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.
• 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.
• 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.
• 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.
• 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.
• 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.
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.
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.
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.
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.
UI designing tools
• AdobeXD
• Axure
• Balsamiq
• Draw
• Figma
• InVision Studio
• Jira
• Marvel
• Sketch, and
• Zeplin
UI design using Adobe XD

• https://www.youtube.com/watch?v=PF7DGvoS68E&t=11s
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.
• 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.
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.
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.
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.
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.
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.
Designing for Success
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.
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.
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.
Thank you