Experiment no.

– 1

Aim: Work Break-down Structure (Process Based, Product Based, Geographic

Based and Role Based)- Developing an Online Task Management System

Experiment Description:

In this software engineering experiment, we will create a Work Breakdown

Structure (WBS) for developing an Online Task Management System. The WBS will
be constructed using four different approaches: Process Based, Product Based,
Geographic Based, and Role Based. This experiment aims to showcase the
versatility and applicability of various WBS approaches in project planning and
management.

Objective:

The objective of this experiment is to understand and demonstrate how different

perspectives can be applied to create a comprehensive and effective Work
Breakdown Structure for a software development project.

Materials:

 Project requirements and scope document

 Pen and paper or digital tools for creating WBS diagrams
 Project management software (optional)

Experiment Steps:
Conclusion:

Through this experiment, we have successfully created four different Work

Breakdown Structures for an Online Task Management System using process-
based, product-based, geographic-based, and role-based approaches. This
exercise highlights the importance of tailoring the WBS to the specific project
context and objectives, showcasing the flexibility and versatility of this project
management tool.
 Experiment no. – 2

Aim: Estimating Cost and Schedule for a Software Development Project

Experiment Description:

In this software engineering experiment, we will focus on estimating the cost and
schedule for a software development project. Estimating these factors accurately
is crucial for effective project planning and management. We will use different
estimation techniques and tools to predict project costs and timelines, and then
compare the results to evaluate their effectiveness.

Objective:

The objective of this experiment is to understand various estimation techniques

for software project cost and schedule, and to analyze the impact of different
approaches on project planning and management.

Materials:

 Project requirements and scope document

 Software project management tools (e.g., Microsoft Project, Jira)
 Spreadsheets for cost estimation calculations
 Pen and paper or digital tools for documentation

Experiment Steps:
Conclusion:

Through this experiment, we have gained valuable insights into the various
techniques for estimating the cost and schedule of a software development
project. We've learned that accurate estimation is crucial for effective project
planning and decision-making. By comparing different estimation approaches
and performing sensitivity analysis, we have a better understanding of how
uncertainties can impact project outcomes and how to address them proactively
in software engineering projects.
 Experiment no. – 3

Aim: Modeling a Student Registration System using ERD, Context Flow Diagram,
and DFD

Experiment Description:

In this software engineering experiment, we will create three essential diagrams—

Entity Relationship Diagram (ERD), Context Flow Diagram (CFD), and Data Flow
Diagrams (DFDs)—to model a Library Management System. These diagrams will
help us understand the structural and functional aspects of the system,
facilitating effective communication and analysis.

Objective:

The objective of this experiment is to provide hands-on experience in creating

and analyzing Entity Relationship Diagrams, Context Flow Diagrams, and Data
Flow Diagrams for a practical software engineering scenario.

Materials:

 Pen and paper or digital tools for drawing diagrams

 Software for creating digital diagrams (e.g., draw.io, Lucidchart)
 Projector and screen for presentation (if needed)
 Sample requirements for the Student Registration System

Experiment Steps:
Conclusion:

Through this experiment, we have successfully modeled a Student Registration

System using Entity Relationship Diagram, Context Flow Diagram, and Data Flow
Diagram. We have demonstrated the importance of these modeling techniques in
understanding system structure, data flow, and functionality. This hands-on
experience enhances our understanding of software engineering concepts and
equips us with practical skills for designing and analyzing software systems.
 Experiment no. – 4

Aim: Modeling a User Authentication System using State Transition Diagrams

Experiment Description:

In this software engineering experiment, we will focus on behavioral modeling

using State Transition Diagrams (STDs). We will design and model a User
Authentication System using STDs to represent the different states and transitions
that occur during user login and logout processes. This experiment aims to
provide hands-on experience in creating and analyzing state transition diagrams
for software systems.

Objective:

The objective of this experiment is to understand how State Transition Diagrams

can effectively represent the behavior of a software system's states and
transitions, and how they can be applied to model user authentication processes.

Materials:

 Pen and paper or digital tools for drawing diagrams

 Software for creating digital diagrams (e.g., draw.io, Lucidchart)
 Sample requirements for the User Authentication System

Experiment Steps:
Conclusion:

Through this experiment, we have successfully created a State Transition Diagram

for a User Authentication System. We've gained insights into how this behavioral
modeling technique can effectively capture the various states, transitions, and
events within a software system. This practical experience enhances our
understanding of software engineering concepts and equips us with valuable
skills for accurately representing and analyzing system behaviors using State
Transition Diagrams.
 Experiment no. – 5

Aim: Creating a System Requirements Specification for an Online Shopping

Platform

Experiment Description:

In this software engineering experiment, we will focus on creating a System

Requirements Specification (SRS) document for an Online Shopping Platform. The
SRS document outlines the functional and non-functional requirements of the
system, serving as a crucial foundation for software development. This
experiment aims to provide hands-on experience in gathering, documenting, and
organizing requirements for a real-world software project.

Objective:

The objective of this experiment is to understand the importance of a well-

defined System Requirements Specification and to practice the process of
collecting, structuring, and documenting requirements for a software system.

Materials:

 Pen and paper or or word processing software

 Sample project scenario and requirements for the Online Shopping
Platform

Experiment Steps:
Conclusion:

Through this experiment, we have successfully created a System Requirements

Specification for an Online Shopping Platform. We've gained insights into the
importance of a well-structured and detailed SRS document in guiding the
software development process. This hands-on experience enhances our
understanding of software engineering concepts and equips us with practical
skills for effectively gathering, organizing, and documenting system requirements.
 Experiment no. – 6

Aim: Object-Oriented Design Using UML Diagrams

Experiment Description:

In this software engineering experiment, we will focus on Object-Oriented (OO)

design using Unified Modeling Language (UML) diagrams. UML diagrams are
essential tools for visualizing and communicating different aspects of software
systems. We will design a simple Library Management System and create various
UML diagrams to represent its structure and behavior. This experiment aims to
provide hands-on experience in using UML diagrams for effective object-oriented
design.

Objective:

The objective of this experiment is to understand the role of UML diagrams in

object-oriented design and to practice creating different types of UML diagrams
to model a software system.

Materials:

 Pen and paper or UML diagram drawing tools (e.g., UML design software,
online diagram tools)
 Sample requirements for the Library Management System

Experiment Steps:
Conclusion:

Through this experiment, we have successfully designed a Library Management

System using various UML diagrams, including Class Diagram, Use Case Diagram,
Sequence Diagram, State Machine Diagram, and Collaboration Diagram. We've
gained insights into how UML diagrams can effectively represent different
aspects of software systems and improve communication among stakeholders.
This hands-on experience enhances our understanding of object-oriented design
concepts and equips us with practical skills for creating and analyzing UML
diagrams in software engineering projects.
 Experiment no. – 7

Aim: Version Control Using Git and GitHub

Experiment Description:

In this software engineering experiment, we will focus on version control using

the Git version control system and the GitHub platform. Version control is
essential for collaborative software development and tracking changes to
codebases. We will create a sample project, make changes to it, and demonstrate
how Git and GitHub can be used for version control, collaboration, and code
management.

Objective:

The objective of this experiment is to understand the concepts of version control,

practice using Git for managing code changes, and utilize GitHub for
collaborative software development.

Materials:

 A computer with Git and GitHub accounts set up

 Sample project files for version control practice

Experiment Steps:
Conclusion:

Through this experiment, we have successfully demonstrated version control

using Git and GitHub. We've gained practical experience in creating repositories,
making commits, branching, merging, collaborating with others, and resolving
conflicts. This hands-on experience enhances our understanding of version
control concepts and equips us with practical skills for managing code changes
and collaborating on software development projects.
 Experiment no. – 8

Aim: Black-Box and White-Box Testing Techniques

Experiment Description:

In this software engineering experiment, we will explore and practice both Black-
Box and White-Box testing techniques. We will use a simple calculator application
as the target system and perform a series of tests using each approach. This
experiment aims to provide hands-on experience in understanding and applying
these testing techniques to ensure software quality.

Objective:

The objective of this experiment is to understand the concepts of Black-Box and

White-Box testing, practice applying both techniques, and compare their
effectiveness in identifying defects in software.

Materials:

 A computer with the calculator application installed

 Test cases prepared for both Black-Box and White-Box testing

Experiment Steps:
Conclusion:

Through this experiment, we have successfully practiced both Black-Box and

White-Box testing techniques on a calculator application. We've gained insights
into their differences, strengths, and weaknesses in identifying defects and
ensuring software quality. This hands-on experience enhances our understanding
of software testing concepts and equips us with practical skills for testing
software from both external and internal perspectives.
 Experiment no. – 9

Aim: Non-Functional Testing Experiment: Performance and Usability Testing

Experiment Description:

In this software engineering experiment, we will focus on non-functional testing,

specifically Performance Testing and Usability Testing. We will use a simple web
application as the target system and perform tests to evaluate its performance
under different conditions and assess its usability. This experiment aims to
provide hands-on experience in understanding and conducting non-functional
testing to ensure the software meets performance and usability requirements.

Objective:

The objective of this experiment is to understand the concepts of Performance

Testing and Usability Testing, practice applying these non-functional testing
techniques, and analyze the impact of non-functional aspects on software quality.

Materials:

 A computer with the web application installed or hosted

 Performance testing tools (e.g., Apache JMeter, LoadRunner) for load
testing
 Usability testing tools (e.g., UserTesting) for usability evaluation

Experiment Steps:
Conclusion:

Through this experiment, we have successfully conducted Performance Testing

and Usability Testing on a web application. We've gained insights into the
importance of evaluating non-functional aspects for software quality. This hands-
on experience enhances our understanding of non-functional testing concepts
and equips us with practical skills for assessing performance and usability of
software systems.