IT451 Software Engineering 21DIT002

Practical 1: Jira as a project management tool

Aim:

Explore the Jira as a project management tool for agile Development. Execute following Activity
in Jira Tool.
1) Free Trial Setup
2) Create an Epic
3) Create an Issue
4) Create Story
5) Create Subtask
6) Create Sprint
Reference Link: https://www.atlassian.com/

Screenshot:

Fig 1.1: Getting started with Jira

DEPSTAR-IT Page 1
IT451 Software Engineering 21DIT002

Fig 1.2: Login / Signup

Fig 1.3: Select the Project Management template

DEPSTAR-IT Page 2
IT451 Software Engineering 21DIT002

Fig 1.4: Epic created

Fig 1.5: Create an issue

DEPSTAR-IT Page 3
IT451 Software Engineering 21DIT002

Fig 1.6: Issue created

Fig 1.7: Create a story

DEPSTAR-IT Page 4
IT451 Software Engineering 21DIT002

Fig 1.8: Story created

Fig 1.9: Create a subtask

DEPSTAR-IT Page 5
IT451 Software Engineering 21DIT002

Fig 1.10: Create a new project by selecting scrum as a template

Fig 1.11: Add the project details

DEPSTAR-IT Page 6
IT451 Software Engineering 21DIT002

Fig 1.12: Create a spirit

Fig 1.13: Start the Sprint

DEPSTAR-IT Page 7
IT451 Software Engineering 21DIT002

Fig 1.14: Sprint started

Learning Outcome:
By setting up a free trial and creating epics, issues, stories, subtasks, and sprints, I experienced
firsthand how Jira helps structure and track work.

DEPSTAR-IT Page 8
IT451 Software Engineering 21DIT002

Practical 2: Wireframe
Aim:

Create Wireframe for your given Project.

Figma Link:
https://www.figma.com/design/ug2j4rnR1H5xyOxCcg5kRC/Practical---2?node-id=5-
904&t=aClMZrhDmeUNGX83-1

Screenshot:

Figure 1: Splash Screen Figure 2: Login Screen

DEPSTAR-IT Page 9
IT451 Software Engineering 21DIT002

Figure 3: Create Account Figure 4: Verification Code

DEPSTAR-IT Page 10
IT451 Software Engineering 21DIT002

Figure 5: Welcome Screen Figure 6: Home Screen

DEPSTAR-IT Page 11
IT451 Software Engineering 21DIT002

Figure 7: Messanger Drawer Figure 8: Messager Screen

DEPSTAR-IT Page 12
IT451 Software Engineering 21DIT002

Figure 9: Search People Figure 10: Add Post On feed

DEPSTAR-IT Page 13
IT451 Software Engineering 21DIT002

Figure 11: Notification panel Figure 12: Profile Page

DEPSTAR-IT Page 14
IT451 Software Engineering 21DIT002

Figure 13: Edit Profile Figure 14: Followers

DEPSTAR-IT Page 15
IT451 Software Engineering 21DIT002

Figure 15: Following Figure 16: Logout

Learning Outcome:

In this practical, I learned to design wireframes for a social media platform project. By utilizing
Figma's collaborative features and design capabilities, I was able to streamline the design process
and efficiently implement necessary revisions. This experience helped me enhance my design
skills and understand the importance of collaboration in creating effective user interfaces.

DEPSTAR-IT Page 16
IT451 Software Engineering 21DIT002

Practical 3 : Setting Up and Managing a Git Repository

Using Command Line
Aim: Practice GIT by creating a repository and demonstrating key commands.

Screenshot :
1. Open Github and create a new repository.

Figure 1

2. Keep the URL of the repository handy, you’ll need it later

Figure 2

DEPSTAR-IT Page 17
IT451 Software Engineering 21DIT002

3. Open the project directory in your local computer.

Figure 3

4. Download git from the official website or if you already have it , do update to
the latest version.

Figure 4

5. Initializing a local repository,

Figure 5

6. Setting up a remote repository.

Figure 6

DEPSTAR-IT Page 18
IT451 Software Engineering 21DIT002

7. Creating a text file.

Figure 7

8. Printing the data of the file.

Figure 8

9. To add the file to the repository.

Figure 9

10. To stage all changes.

Figure 10

11. Commit the changes in the repository

Figure 11

Learning Outcome:

 Through this practical, I understood the basic concepts of Git and also deepened my
knowledge of accessing repositories via Git CMD and performing various tasks such as
uploading files, adding files, processing commits, and generating a personal access token.
 I gained hands-on experience with essential Git commands like `git add`, `git commit`, `git
push`, and `git remote`, which are crucial for version control and collaboration. Additionally,
I learned how to manage remote repositories on platforms like GitHub, ensuring seamless
integration between local and remote versions of projects.
 This practical exercise not only enhanced my technical skills but also highlighted the
importance of proper version control in software development workflows.

DEPSTAR-IT Page 19
IT451 Software Engineering 21DIT002

Practical 4: Code Quality Analysis with SonarQube

Aim:
Analyzing Code Quality with SonarQube

Screenshot / Graph / Explanation etc.

Open SonarCloud and login with your account or access your institution’s instance.

To analyze a project , you’d have a previous project or can analyze a new project

DEPSTAR-IT Page 20
IT451 Software Engineering 21DIT002

Select the projects and click Set up

Once the setup is done the ready projects will be scanned by the software and few whose
configuration is left will be ignored

DEPSTAR-IT Page 21
IT451 Software Engineering 21DIT002

Configure remaining projects

Once done you’ll be prompted to update the workflow of the project.

Another way is by signing the Sonar Cloud and generating a user token

DEPSTAR-IT Page 22
IT451 Software Engineering 21DIT002

Analysis the code of your project

Learning Outcome:
How to create a project on sonarqube, install sonarqube, and start a server for project analysis.

DEPSTAR-IT Page 23
IT451 Software Engineering 21DIT002

Practical 5 : JUnit Testing

Aim:
To install the JUnit Testing Framework and develop test cases for Java programs using JUnit.
This involves downloading the JUnit JAR or configuring it through Maven/Gradle, writing Java
test classes with methods annotated by `@Test`, employing assertions, executing tests via an IDE
or build tool, and analyzing the results.

Screenshot :

DEPSTAR-IT Page 24
IT451 Software Engineering 21DIT002

Learning Outcome:

In this practical, I configured the JUnit Testing Framework and tested assertions using the
`@Test` annotation. This experience demonstrated the importance of automated testing in
ensuring code reliability and quality.

DEPSTAR-IT Page 25
IT451 Software Engineering 21DIT002

Practical 6 : Install Selenium and create test scripts

Aim:
Download the Selenium WebDriver and necessary browser drivers or use package managers like
pip for Python. Write test scripts in your chosen language (e.g., Python) to automate browser
interactions using Selenium’s API. Execute the scripts to verify browser automation and review
the results.

Screenshot:

1. Setting Up Selenium-webdriver with Node.js

initialize project

Install the Selenium-webdriver

DEPSTAR-IT Page 26
IT451 Software Engineering 21DIT002

Downloading browser drivers

Url => https://googlechromelabs.github.io/chrome-for-testing/#stable

Adding browser driver to PATH

DEPSTAR-IT Page 27
IT451 Software Engineering 21DIT002

2. Writing a script to automatically login in test website

(https://practicetestautomation.com/practice-test-login/)

DEPSTAR-IT Page 28
IT451 Software Engineering 21DIT002

Learning Outcome:

Selenium to simulate user actions such as clicking buttons, filling out forms, and navigating
between web pages. They will also develop skills in writing scripts that can interact with web
elements using locators like ID, class name, and XPath, enabling them to automate repetitive
tasks and perform functional testing of web applications efficiently.

DEPSTAR-IT Page 29
IT451 Software Engineering 21DIT002

Practical 7:Website performance analysis using GTMetrix

Aim
:
Briefly explain the purpose of using GTMetrix to analyze and optimize your website’s
performance. Capture screenshots of the GTMetrix analysis results. Ensure these include the
performance scores, recommendations, and any relevant metrics.Summarize the key findings
from the GTMetrix report, including reasons for slow performance and suggested optimizations.
List the recommendations provided by GTMetrix and describe how they can be implemented to
improve site performance.

Screenshot / Graph / Explanation etc.

Provide website URL for analysis purpose

It will start analysing your provided URL

DEPSTAR-IT Page 30
IT451 Software Engineering 21DIT002

The dashboard will be displayed a summary of your website performance

Below it will show the loading time of each component and the top issue related to it

DEPSTAR-IT Page 31
IT451 Software Engineering 21DIT002

My top issue that might affect my website performance

Chart showing resource utilization by my website

They are providing alert functionality by monitoring your website

DEPSTAR-IT Page 32
IT451 Software Engineering 21DIT002

Analysis Summary:

The reason provided by FTMetrix for the slow performance of my website

1. The <meta name="viewport"> tag is essential for optimizing a website for mobile devices
by controlling the page's width and scaling on different screen sizes. Without it, mobile
users may experience poor layout and a 300ms delay in touch input responsiveness.
2. Keep the server response time for the main document short because all other requests
depend on it.
3. The Critical Request Chains below show you what resources are loaded with a high
priority. Consider reducing the length of chains, reducing the download size of resources,
or deferring the download of unnecessary resources to improve page load.

Optimization Opportunities :
1. Using the viewport meta tag lets you set the width and scaling of the viewport so that it's
correctly sized on all devices, particularly mobile devices.
2. As a primarily back-end optimization, reducing TTFB can complement your front-end
development to significantly improve performance.
3. Remove unnecessary characters (like spaces, line breaks) from code to reduce its size.
Compress images and serve them in modern formats. Delay the loading of images or
scripts that aren’t needed right away.

Learning Outcome:

 Users will gain insight into how GTMetrix can be used to analyze and evaluate a
website's performance.
 Users will be able to interpret GTMetrix performance scores, recognizing key areas for
improvement by understanding metrics like First Contentful Paint (FCP), Largest
Contentful Paint (LCP), and Total Blocking Time (TBT).
 Users will develop the ability to identify causes of slow website performance, such as
large image sizes, unoptimized scripts, and excessive HTTP requests, based on the
GTMetrix report analysis.

DEPSTAR-IT Page 33
IT451 Software Engineering 21DIT002

Practical-8

Aim: Explore the Jenkins DevOps tool as a continuous Integration and continuous deployment tool.
Theory:
Jenkins is an open-source automation server used widely for continuous integration and continuous delivery
(CI/CD). It facilitates the automation of building, testing, and deploying software applications, making it a
cornerstone for modern DevOps practices.
1. Overview of Jenkins
Jenkins was originally developed as Hudson in 2004, and after a fork in 2011, it became known as Jenkins.
It is written in Java and offers a rich ecosystem of plugins that extend its functionality to integrate with
numerous tools and technologies across the software development lifecycle.
2. Continuous Integration (CI) with Jenkins
Continuous Integration (CI) is the practice of merging code changes into a shared repository several times a
day. Jenkins plays a critical role in automating this process by continuously monitoring the repository and
triggering automated builds whenever changes are detected. This allows developers to detect integration
issues early, reducing the risk of major bugs and conflicts late in the development cycle.
Key Features for CI:

 Automated Builds: Jenkins can be set to automatically pull the latest code from a version control
system (e.g., Git) and trigger builds, ensuring that code changes are integrated frequently.
 Automated Testing: Jenkins supports automated testing, allowing it to run unit, integration, or
system tests on the code to verify functionality and quality.
 Notifications: It can notify developers about build and test results via email, Slack, or other
communication platforms, making sure that teams are always informed about the current state of
the project.
3. Continuous Delivery (CD) and Jenkins
Continuous Delivery (CD) extends CI by ensuring that code changes are automatically prepared for
deployment. Jenkins plays an essential role in automating the process from build to deployment, allowing
teams to deliver software to production in shorter cycles with minimal manual intervention.
Key Features for CD:
 Pipeline Automation: Jenkins supports pipeline as code through its "Jenkins Pipeline" feature,
allowing developers to define complex workflows for build, test, and deploy processes in a simple,
readable script (e.g., using Groovy-based DSL or declarative pipelines).
 Environment Management: Jenkins can deploy applications to different environments (development,
testing, staging, or production), ensuring that each version of the application is consistent across the
board.

DEPSTAR-IT 34
IT451 Software Engineering 21DIT002
 Integration with Tools: Jenkins integrates with various deployment tools, containerization platforms
(like Docker, Kubernetes), and cloud services to automate the delivery of applications to production
environments.
4. Jenkins and DevOps
In the DevOps paradigm, automation is crucial, and Jenkins provides the automation necessary for
integrating, testing, and delivering applications efficiently. Jenkins acts as the backbone of CI/CD pipelines,
connecting different tools and technologies to form a cohesive workflow that enhances collaboration
between development and operations teams.
Key Benefits:
 Faster Feedback Loop: Jenkins allows developers to get immediate feedback on code quality and
potential issues through automated testing and builds.
 Reduced Risk: By automating repetitive tasks such as testing and deployment, Jenkins reduces the
chances of human error, making releases more reliable and secure.
 Scalability: Jenkins' distributed architecture allows the use of "agents" (slaves) to offload heavy
tasks, enabling scalability as the project grows.
5. Jenkins Architecture
Jenkins follows a master-agent architecture, where the master node handles scheduling, coordination, and
job delegation, while agent nodes execute the actual build and test tasks. This distributed approach ensures
efficient utilization of resources and supports parallel builds for faster processing.
 Master: Responsible for managing jobs and pipelines, providing a user interface, and
orchestrating the overall workflow.
 Agents: These execute the jobs delegated by the master. Agents can be distributed across
multiple machines, allowing Jenkins to scale horizontally.
6. Plugins in Jenkins
One of Jenkins' strengths lies in its extensive plugin ecosystem. There are over 1,000 plugins that enable
Jenkins to integrate with version control systems (Git, SVN), build tools (Maven, Gradle), test frameworks
(JUnit, Selenium), deployment platforms (Docker, Kubernetes), and cloud services (AWS, Google Cloud).
These plugins enhance Jenkins' capabilities and allow it to adapt to various project needs.
7. Key Use Cases of Jenkins
CI/CD Pipelines: Automating the entire process from code commit to deployment.
Automated Testing: Running tests automatically after every code change to ensure the stability and quality
of the code.
Monitoring and Reporting: Collecting and displaying real-time reports on the health of software projects,
enabling teams to make data-driven decisions.

DEPSTAR-IT 35
IT451 Software Engineering 21DIT002

Screenshot:

DEPSTAR-IT 36
IT451 Software Engineering 21DIT002

DEPSTAR-IT 37
IT451 Software Engineering 21DIT002

DEPSTAR-IT 38
IT451 Software Engineering 21DIT002

DEPSTAR-IT 39
IT451 Software Engineering 21DIT002

DEPSTAR-IT 40
IT451 Software Engineering 21DIT002

Learning Outcome: In this practical, I will gain valuable hands-on experience using Jenkins as a key
DevOps tool for continuous integration and continuous deployment (CI/CD). By delving into its installation,
configuration, and seamless integration with version control systems, I will enhance my ability to automate
essential processes like building, testing, and deploying applications. Furthermore, creating a Jenkins
pipeline and integrating it with webhooks will offer deeper insights into automating the software
development lifecycle, significantly boosting the efficiency and reliability of application delivery.

DEPSTAR-IT 41
IT451 Software Engineering 21DIT002

Practical-9

Aim:

1: Briefly explain the purpose of estimating project metrics and its importance in software
engineering.: Clearly outline the objectives of the practical session. For example:

 To understand different project metrics.

 To learn estimation techniques.
Summarize key concepts from the reference link, including types of metrics (e.g., effort,
cost, schedule) and methods of estimation.

 Describe the process of estimating metrics.

 Include tools or techniques used (e.g., COCOMO model, use case points).
 Provide details on the metrics estimated during the practical.
 Include calculations and any assumptions made.
: Present the estimated metrics in a clear format (tables or charts) and interpret the findings.
: Summarize the significance of the estimated metrics and their impact on project
management.

1. Purpose of Estimating Project Metrics and its Importance in Software Engineering

The process of estimating project metrics in software engineering plays a pivotal role in
ensuring that projects are successfully executed, delivered on time, and within budget.
Estimating project metrics involves calculating various parameters, such as effort, cost,
schedule, and quality, which are crucial for effective project planning and management. This
process serves several important purposes:

 Project Planning and Forecasting: Estimating metrics is fundamental for

predicting the duration, resources, and budget required for a project. With accurate
metrics, project managers can plan project timelines, allocate resources
appropriately, and ensure that they stay on course to achieve their goals.
 Budgeting and Cost Control: Metrics estimation helps in accurately forecasting
costs, allowing project managers to develop a budget that accounts for all foreseeable
expenses. This minimizes financial risk and ensures that funds are utilized efficiently.
 Resource Allocation: Proper estimation ensures that the right people, tools, and
equipment are assigned to the right tasks. This helps in avoiding resource bottlenecks
or under-utilization.

DEPSTAR-IT Page 42
IT451 Software Engineering 21DIT002

 Risk Management: By identifying metrics early in the project lifecycle, potential

risks and uncertainties can be anticipated and addressed in advance. This reduces the
likelihood of schedule slippage or budget overruns.
 Performance Measurement: Metrics provide a means of measuring progress
throughout the project lifecycle. By comparing actual metrics with estimated values,
project teams can track performance, identify deviations, and take corrective actions.
 Stakeholder Communication: Accurate metrics are essential for communicating with
stakeholders. They set clear expectations regarding what is feasible, how much it will
cost, and how long it will take, thereby preventing misunderstandings and misaligned
expectations.
In summary, the estimation of project metrics is an essential component of software
engineering that contributes significantly to a project's success by enabling informed
decision-making, managing risks effectively, and ensuring optimal resource allocation.

2. Objectives of the Practical Session

The objectives of this practical session are clearly defined to ensure that participants not only
understand the theoretical aspects of project metrics estimation but also gain practical skills
in applying estimation techniques to real projects. The main objectives are:
 Understanding Different Project Metrics: To familiarize students with various
types of project metrics, such as effort, cost, schedule, and quality metrics.
Understanding these metrics is key to managing the lifecycle of software projects.
 Learning Estimation Techniques: To learn about different estimation methods and
tools used in software engineering, such as the Constructive Cost Model (COCOMO)
and Use Case Points (UCP). These methods are essential for predicting the resources,
time, and budget required for software development projects.
 Hands-on Practice with Estimation Techniques: To provide hands-on practice in
using estimation techniques to calculate project metrics. This practical application
helps students better understand the challenges and nuances involved in estimating
metrics.
 Interpreting Estimated Metrics: To interpret the estimated metrics to make informed
decisions about project planning and execution. This includes analyzing the feasibility
of projects, budgeting, and allocating resources effectively.

DEPSTAR-IT Page 43
IT451 Software Engineering 21DIT002

3. Key Concepts and Types of

Metrics Types of Project Metrics
Project metrics can be broadly categorized into several types, each serving a specific
purpose in project management:
 Effort Metrics: These metrics represent the amount of work that needs to be
performed to complete a project or a specific task within a project. Effort is typically
measured in person-hours, person-days, or person-months. Accurate effort
estimation is crucial for planning project timelines, resources, and assigning
responsibilities to the project team.
 Cost Metrics: Cost metrics are used to determine the financial requirements for the
project. This includes estimating costs for personnel, hardware, software, and other
related expenses. Cost metrics are critical for budgeting and financial planning. They
help ensure that the project is completed within the allocated budget, thus
minimizing financial risk.
 Schedule Metrics: Schedule metrics estimate the time required to complete the
project or specific tasks. These metrics include information about key project
milestones, start and end dates of project activities, and critical paths. Proper
scheduling is important to avoid project delays and meet deadlines.
 Quality Metrics: Quality metrics are used to measure the quality of the software
being developed. These metrics include attributes such as reliability, maintainability,
and defect density. Quality metrics help ensure that the software meets the required
standards and that potential defects are identified and addressed.
Estimation Techniques
Several estimation techniques are used in software engineering to predict project effort,
cost, and schedule. The key estimation techniques include:
1. Expert Judgment: This method involves consulting experts who have extensive
experience in similar projects to provide their estimates. This technique is highly
reliant on the experience and expertise of individuals and can provide a quick
estimation.
2. Analogous Estimation: This method uses historical data from similar projects to
estimate metrics for the current project. It is most suitable for projects where a
similar project has been completed in the past.

3. Parametric Models: Parametric estimation techniques use statistical and

mathematical models to estimate project metrics. These models rely on parameters
such as project size, complexity, and cost drivers to calculate effort and cost. The
COCOMO Model is a popular parametric model used to estimate software
development effort.

DEPSTAR-IT Page 44
IT451 Software Engineering 21DIT002

4. Use Case Points (UCP): The UCP method estimates effort based on the use cases
identified in the software requirements. It considers the number of use cases, actors,
and system complexity to calculate the overall effort required to develop the system.
Estimation Tools and Techniques Covered
 COCOMO (Constructive Cost Model): COCOMO is a parametric estimation
model that helps estimate the cost, effort, and schedule of a software project. The
basic COCOMO model uses a formula that includes constants and project size in
terms of thousands of lines of code (KLOC) to estimate the required effort. The three
levels of COCOMO—basic, intermediate, and detailed—offer different levels of
accuracy.
 Use Case Points (UCP): This method involves calculating the total use case points
by categorizing use cases based on their complexity and then multiplying these with
predefined weights. The result is then adjusted based on technical and
environmental factors.
These estimation methods are critical in providing an accurate forecast of project
parameters, which is fundamental for successful project management.

4. Process of Estimating
Metrics Steps in the
Estimation Process
1. Requirement Analysis: The first step in estimating project metrics is to
thoroughly analyse the project requirements. The scope and objectives of the
project must be clearly understood to ensure that estimates are accurate.
Requirements analysis includes breaking down the software system into modules,
identifying the functionalities, and determining the project complexity.
2. Selection of Estimation Technique: Based on the project type, size, and
available data, an appropriate estimation technique is selected. For example, for a
small to medium-sized software development project with a well-defined set of
requirements, Use Case Points (UCP) may be suitable. For large projects with
historical data available, COCOMO is often a preferred method.
3. Data Collection: Collect data relevant to the project, such as project size (in lines of
code or use case points), complexity factors, and historical data from similar projects.
This data is used as input to calculate the estimates.
4. Application of the Estimation Technique: Calculate the estimated metrics using
the chosen estimation model. In the case of the COCOMO model, constants such as
a, b,

DEPSTAR-IT Page 45
IT451 Software Engineering 21DIT002

and other parameters are used to determine the effort in person-months. Similarly,
the UCP method is applied based on the number and complexity of use cases.
5. Review and Refinement of Estimates: Review the estimated metrics with project
stakeholders and subject matter experts to refine the values. Assumptions made
during the estimation process are reviewed, and adjustments are made to improve
accuracy.
Example of Tools and Techniques Used
 COCOMO Model Calculation:
The COCOMO basic formula for estimating effort is:
Effort (in person-months) = a ×
(Size)^b Where:
o a and b are constants that vary depending on the type of software (organic,
semi-detached, embedded).
o Size represents the estimated number of lines of code (in
KLOC). For example, for an organic software project estimated to be 30 KLOC:
Effort = 2.4 × (30)^1.05 = 35.1 person-months
 Use Case Points
Calculation: UCP is calculated
based on:
o Unadjusted Use Case Points (UUCP): Derived from use cases and
actors based on their complexity.
o Technical Complexity Factors (TCF) and Environmental Factors (EF):
Used to adjust the UUCP to obtain the final effort estimate.
The formula is:
UCP = UUCP × TCF ×
EF

DEPSTAR-IT Page 46
IT451 Software Engineering 21DIT002

5. Metrics Estimated During the Practical

Session Metrics Estimated
During the practical session, the following key metrics were estimated:

1. Effort (Person-Months): Estimated using the COCOMO model, which calculates

the number of person-months required based on project size and complexity.
2. Cost: Derived from the estimated effort by multiplying the effort by the average cost
per person-month.
3. Schedule: The schedule, or project duration, was estimated using a formula that
relates effort and productivity. This involved calculating key project phases such as
requirements analysis, design, coding, and testing.
Calculations and Assumptions
 The project was estimated to be 30 KLOC in size.
 For effort estimation, the COCOMO model was used, with a = 2.4 and b =
1.05 (values for an organic software project).
 Average productivity was assumed to be 6 person-hours/day.
 Average cost per person-month was assumed to be $10,000.
Using these inputs:
 Effort: Calculated as 35.1 person-months.
 Cost:
Cost = Effort × Cost per person-month = 35.1×10,000 = $351,000
 Schedule: Estimated to be 8 months, calculated using COCOMO formulas
to determine the expected duration of the project.

DEPSTAR-IT Page 47
IT451 Software Engineering 21DIT002

6. Presentation of Estimated Metrics

The estimated metrics were presented using tables and visual charts to ensure clarity and
facilitate easy interpretation.

Table of Estimated Metrics:

Metric Value Assumptions

Effort 35.1 Person-Months Project size: 30 KLOC (COCOMO

Model)
Cost $351,000 $10,000 per person-month

Schedule 8 Months Based on COCOMO schedule estimation

Chart Representation:
 Gantt Chart: The Gantt chart depicted the project schedule, outlining major phases
such as requirement analysis, design, coding, testing, and deployment.
 Effort Distribution Chart: This chart displayed how effort was distributed across
different phases, providing insights into which activities required the most resources.
Interpretation:
The metrics provide valuable insights into the overall project:
 Effort: The estimated 35.1 person-months indicates the workload for the project
team. This helps in planning team size and project duration.
 Cost: The estimated $351,000 helps determine the project's budget, enabling
financial planning.
 Schedule: The estimated schedule of 8 months allows the project manager to set
deadlines and milestones for the project phases.

DEPSTAR-IT Page 48
IT451 Software Engineering 21DIT002

7. Significance of the Estimated Metrics

The significance of the estimated metrics can be summarized as follows:
 Enhanced Project Planning: Estimating effort, cost, and schedule provides a
strong foundation for detailed project planning. With reliable estimates, project
managers can define a clear timeline, allocate resources effectively, and manage the
project lifecycle.
 Improved Resource Management: Metrics estimation ensures that the appropriate
resources are allocated to each task, reducing the likelihood of resource bottlenecks.
It also helps in planning staffing requirements, ensuring that the right number of
people are working on the project at each stage.
 Risk Mitigation: Estimation allows the identification of potential risks early in the
project lifecycle. For instance, an estimation that exceeds initial expectations can
indicate potential challenges such as understaffing or under-budgeting, prompting
early intervention.
 Stakeholder Confidence: Providing stakeholders with accurate and realistic estimates
helps build trust. Clear communication regarding project timelines, costs, and
resources aligns stakeholder expectations with the reality of the project.
 Performance Monitoring: During the project execution, actual metrics can be
compared with estimated values to track performance. Deviations from estimates
can serve as indicators of issues that need immediate attention, enabling proactive
problem-solving.
 Financial Planning and Control: Estimated cost metrics provide a financial
benchmark for the project. Budgeting based on these metrics allows for proper
financial allocation and ensures that expenses remain within limits. This is
particularly crucial for avoiding project overruns and maintaining profitability.
Conclusion
In conclusion, estimating project metrics is an essential practice in software engineering that
contributes significantly to the success of software projects. By providing a structured
approach to estimating effort, cost, and schedule, metrics estimation enhances planning,
resource management, and risk mitigation. Through practical application of estimation
techniques such as COCOMO and Use Case Points, students gain an understanding of the
nuances of project metrics estimation and its impact on project management.
Effective project metrics estimation is not only about providing numbers; it is about
empowering project teams to make informed decisions, manage resources efficiently, and
deliver high-quality software within time and budget constraints. This practical session has
provided an opportunity to apply theoretical concepts in a real-world context, thereby
bridging the gap between learning and practical application in software engineering.

DEPSTAR-IT Page 49