MODULE III

DESIGN CONCEPTS AND

TESTING
 Topics

• The Design Concepts - The Design Model - Architectural Design -

• User Interface Design: Interface Analysis - Interface Design Steps -
• Requirements Modeling –
• Software Testing Fundamentals
• Black Box Testing, White Box Testing, Unit Testing, Integration Testing, validation
testing, system testing
• Art of debugging
• Project management
 Software Design Concepts
• Software design is the process of defining the architecture, components, modules,
interfaces, and data for a software system to satisfy specified requirements. It
involves making high-level structural decisions and creating blueprints that guide
the development process.
• For assessing user requirements, an SRS (Software Requirement Specification)
document is created whereas for coding and implementation, there is a need of
more specific and detailed requirements in software terms. The output of this
process can directly be used in programming language implementation.
1.Purpose: Ensure the software is functional, maintainable, scalable, and efficient.
2.Key Activities:
I. Requirement Analysis: Understand what the software needs to do.
II. System Architecture: Define the overall structure (e.g., monolithic, microservices).
III. Component Design: Break down the system into smaller, manageable parts.
IV. Interface Design: Specify how components interact with each other and users.
V. Data Design: Plan how data will be stored, accessed, and managed.
3.Principles:
I. Modularity: Divide the system into independent, interchangeable components.
II. Abstraction: Simplify complex systems by modeling classes appropriate to the
problem domain.
III. Encapsulation: Hide internal details and expose only necessary functionalities.
IV. Separation of Concerns: Different aspects of the software should be handled by
4. Design Patterns: Reusable solutions to common problems
5. Tools & Models: Use diagrams (e.g., UML) and tools to visualize and communicate
design.
6. Outcome: A detailed plan that developers follow to build the software.
• Design and application: To-Do List Application
• Requirements:
I. Users can create, update, and delete tasks.
II. Tasks have a title, description, due date, and status (e.g., pending, completed).
III. Users can view all tasks or filter them by status.
IV. The application should be accessible via a web interface and a mobile app.
V. Data should be stored in a database.
Software Design
1. System Architecture:
• Frontend: User interface (web and mobile).
• Backend: Handles business logic and data processing.
• Database: Stores tasks and user data.
• APIs: Communication between frontend and backend.
2. Component Design:
• Frontend:
• Web Interface (HTML, CSS, JavaScript).
• Mobile App (React Native, Flutter).
• Backend:
• Task Management Module (create, update, delete tasks).
• User Authentication Module (login, signup).
• API Gateway (routes requests to appropriate modules).
• Database:
• Tables for Tasks and Users.
3. Interface Design:
• RESTful APIs for communication between frontend and backend.
4. Data Design:
•Tasks Table:
•id (Primary Key)
•title
•description
•due_date
•status
•Users Table:
•id (Primary Key)
•username
•password (hashed)
• Architectural Diagram
• Below is a high-level architectural diagram for the To-Do List Application:

Backend(API,Gatewa
Frontend(Web& Database(
y, Task Mgmt,
Mobile) Tasks,Users)
Authentication)

1.Frontend: The user interacts with the web or mobile interface.

2.Backend: Handles requests from the frontend, processes business logic, and
communicates with the database.
3.Database: Stores all the data (tasks and users).
Example Workflow:
1.User Action: A user adds a new task via the web interface.
2.Frontend: Sends a POST /tasks request to the backend with task details.
3.Backend:
•Validates the request.
•Stores the task in the database.
•Sends a success response to the frontend.
4.Frontend: Displays the updated list of tasks to the user.
• Design Principles Applied:
• Modularity: Frontend, backend, and database are separate modules.
• Abstraction: The frontend doesn’t need to know how the backend processes data.
• Separation of Concerns: Authentication, task management, and data storage are
handled by different components.
• Scalability: The backend can be scaled independently of the frontend.
The software design phase is the
first step in the SDLC (Software
Development Life Cycle) that
shifts the focus from the problem
domain to the solution domain. In
software design, the system is
viewed as a collection of
components or modules with
clearly defined behaviors and
bounds.
 Objectives of Software Design
• Correctness: A good design should be correct, which means that it should correctly
implement all of the system's features.
• Efficiency: A good software design should consider resource, time, and cost
optimization parameters.
• Understandability: A good design should be easy to grasp, which is why it should be
modular, with all parts organized in layers.
• Completeness: The design should include all components, such as data structures,
modules, and external interfaces, among others.
• Maintainability: A good software design should be flexible when the client issues a
modification request.
Levels of Software Design
Architectural Design
• A system's architecture can be defined as the system's overall structure and how
that structure offers conceptual integrity to the system. The architectural
design characterizes the software as a system with numerous interconnected
components. The designers acquire an overview of the proposed solution domain at
this level.

• The architectural design is the highest abstract version of the system. It identifies
the software as a system with many components interacting with each other. At this
level, the designers get the idea of the proposed solution domain.
High-level Design
• The high-level design breaks the ‘single entity-multiple
component’ concept of architectural design into less-abstracted
view of sub-systems and modules and depicts their interaction
with each other. The high-level design focuses on how the system
along with all of its components can be implemented in forms of
modules. It recognizes the modular structure of each sub-system
and their relation and interaction with each other.
Detailed Design
• Detailed design deals with the implementation part of what is
seen as a system and its sub-systems in the previous two
designs. It is more detailed towards modules and their
implementations. It defines logical structure of each module and
their interfaces to communicate with other modules.
 Software Design Concepts

• Let us look at some software design concepts that assist a software engineer in
creating the model of the system or software product to be developed or built. The
following ideas should be grasped before designing a software system.
Abstraction
• One of the fundamental concepts of object-oriented programming (OOP) languages
is abstraction. Its primary purpose is to deal with complexity by concealing internal
details from the user. This allows the user to build more complicated logic on top of
the offered abstraction without having to understand or even consider all the
hidden complexity.
Modularity
Modularity refers to breaking a system or project
into smaller sections to lessen the system's or
project's complexity. Similarly, modularity in
design refers to the division of a system into
smaller elements that can be built independently
and then used in multiple systems to execute
different. As a result, modularity in design has
become a trend that is also essential.
Architecture
• A system's software architecture represents the design decisions linked to the
general structure and behavior of the system. Architecture assists stakeholders in
comprehending and analyzing how the system will attain critical characteristics such
as modifiability, availability, and security. It specifies how components of a software
system are constructed, as well as their relationships and communication. It acts as
a software application blueprint and a development foundation for the developer
team.
Refinement
• Refinement means removing any impurities and improving the quality of something.
The software design refinement idea is a process of building or presenting the
software or system in a detailed manner, which implies elaborating on a system or
software. In addition, refinement is essential for identifying and correcting any
possible errors
Design Patterns
• A Software Design Pattern is a general, reusable solution to a commonly occurring
problem within a given context in software design. They are templates to solve
common software engineering problems, representing some of the finest practices
experienced object-oriented software engineers utilize. A design pattern
systematically describes and explains a general design that handles a recurring
design challenge in object-oriented systems. It discusses the problem, the remedy,
when to use it, and the repercussions. It also provides implementation guidance
and examples.
Information/Data Hiding
• Simply put, information hiding implies
concealing information so that an
unauthorized entity cannot access it. In
software design, information hiding is
accomplished by creating modules in
such a way that information acquired or
contained in one module is concealed
and cannot be accessible by other
modules.
Refactoring
• Refactoring is the process of reorganizing code without affecting its original
functionality. Refactoring aims to improve internal code by making modest changes
that do not affect the code's exterior behavior. Computer programmers and
software developers refactor code to improve the software's design, structure, and
implementation. As a result, Refactoring increases code readability while decreasing
complications. Refactoring can also assist software engineers in locating faults or
vulnerabilities in their code.