IT-414 Software Project Management

Lab-1
Name:-Shruti Verma
SID:-202103027

Software Development Life Cycle

→The Software Development Life Cycle (SDLC) is a structured

approach used by software development teams to plan, design, build,
test, deploy, and maintain software applications.
→It provides a systematic and organized way to develop high-quality
software efficiently.
→SDLC helps ensure that the development process is well-managed
and that the resulting software meets the desired requirements and
quality standards.
→The phases of the Software Development Life Cycle include:-
1) Requirements Analysis
2) Specification
3) Design
4) Coding
5) Verification & Validation
6) Implementation/Installation
7) Maintenance & Support
1)Requirements Analysis
A critical stage of software development called Requirement Analysis
entails acquiring, capturing, and comprehending stakeholder needs and
expectations. By ensuring that the software system is in line with user
needs and corporate objectives, this phase establishes the framework
for the entire project. Here are descriptions of two commonly employed
requirement analysis tools:-
➔ Interviews and Workshops:
Interviews and workshops are crucial techniques for capturing
requirements, even if they are not software tools in the classic
sense. Clients, end users, subject matter experts, and developers
are among the project stakeholders who are directly questioned in
order to learn more about their requirements, goals, and
suggestions for the product. In order to generate ideas, have
productive discussions, and jointly define requirements, workshops
include bringing together a variety of stakeholders. The goal of
these interactive meetings is to synchronise everyone's
understanding of the project, clarify unclear areas, and uncover
dependencies.

Interviews:

Structured communication: During interviews, the interviewer has

the opportunity to speak with the candidate directly and ask
pertinent questions to learn more about the requirements in-depth.
This open dialogue makes ambiguities clear and elicits exact
responses.
Flexibility: Interviewers can modify their questions in reaction to the
interviewee's answers, exploring detours that could yield insightful
sidebars.
Rich Context: Interviews provide interviewees the chance to give
background information, share experiences, and comment on their
wants, which helps to better grasp what is needed.

Workshops:

Collaboration: During workshops, several stakeholders work

together. They promote the members' idea-sharing, brainstorming,
and ability to come to agreements.
 Rapid Requirement Gathering: When time is of the essence,
workshops are very helpful. Workshops speed up the requirement
elicitation process by gathering all necessary parties.
Resolution of Conflict: Workshops offer a forum for open
discussion and compromise when several stakeholders have
divergent demands or expectations.

Workshops and interviews both provide insights that may not be

easily accessible through written documentation. They improve the
lines of communication between developers and stakeholders,
resulting in a better comprehension of user requirements,
priorities, and restrictions.Interviews and workshops facilitate direct
communication with stakeholders, uncovering nuanced
requirements and enabling collaborative discussions.

➔ Case Diagrams: A use case diagram is a graphical depiction of

how actors (users, external systems, or entities) interact with a
system to accomplish particular objectives or activities. During the
requirement analysis stage of software development, this
diagram—a core tool in the Unified Modelling Language (UML)—is
frequently used to comprehend and convey the functional needs of
a system.

Actors: Actors are extraneous entities that communicate with the

system to accomplish specific objectives. They could be people,
components of other systems, or even hardware. In the diagram,
actors are shown as stick figures.

Use cases: Use cases depict certain operations, actions, or

interactions that the system must carry out to satisfy the demands
of the actors. Each use case stands for a distinct work unit. Ovals
are used to represent use cases in the graphic.

Relationships: Connecting lines are used to depict how actors and

use cases interact. These lines show the relationship between the
actors and the use cases they are associated with. Associations
can be straightforward exchanges or intricate webs of connections.

System Boundary: The use case diagram is often enclosed within

a rectangle known as the system boundary. It defines the scope of
the system under consideration and demarcates it from the
external actors.

Visual Clarity: Using use case diagrams, you can see clearly how
various actors interact with the system and how it reacts.
Understanding intricate interactions and functionalities is made
easier by this visual representation.

Use case diagrams serve as a communication link between

technical and non-technical stakeholders in a project. Without
getting into technical details, they aid stakeholders in
understanding the system's behaviour and functionality.

The graphic aids in defining the scope of the system by

highlighting the actors and the use cases they are related with.
This avoids scope creep and guarantees that the development
effort is kept on the most crucial features.

Use case diagrams serve as the basis for the development of the
software's functionalities by developers. The diagrams operate as
a road map for user interactions, which helps the coding process.

Use case diagrams are a useful tool for documentation that may
be used at any time during the development lifecycle. They offer a
broad overview of the interactions and functionality of the system.

In conclusion, a use case diagram is a graphic representation of

how actors interact with a system's functions. It improves
communication, defines scope, and acts as a development road
plan. Use case diagrams help guarantee that the software satisfies
the intended requirements and user demands by offering a user-
centered perspective.
2) Design
During the design phase of software development, various tools and
techniques are used to create detailed plans and blueprints for the
software system. These tools assist developers and designers in
translating the requirements gathered during the earlier phases into a
structured design. Here are some commonly used tools for the design
phase:
➔ Unified Modeling Language (UML) Tools:Unified Modeling
Language (UML) tools are widely used in the design phase to
create visual representations of the software system. UML
provides a standardized set of notations and diagrams to model
various aspects of the system, making it easier for developers,
designers, and stakeholders to understand and communicate the
system's architecture and behavior.UML tools, such as Enterprise
Architect, Visual Paradigm, and Lucidchart, offer a wide range of
diagram types, including class diagrams, sequence diagrams, use
case diagrams, activity diagrams, and more. Class diagrams help
visualize the static structure of the system, showing classes, their
attributes, and relationships. Sequence diagrams illustrate the
dynamic behavior by showcasing interactions between objects
over time. Use case diagrams capture the functional requirements
by representing user interactions and system responses.These
tools facilitate collaborative design, allowing multiple team
members to work on the same models simultaneously. UML
diagrams serve as blueprints for the development team, guiding
them throughout the coding process. Additionally, UML models can
be reverse-engineered from code, enabling designers to keep the
documentation in sync with the actual implementation.
A software programme called a Unified Modelling Language (UML)
tool is made expressly to make it easier to create, visualise, and
manage different UML diagrams during the design stage of
software development. Software systems are modelled using UML,
a standardised visual language that captures the architecture,
components, relationships, and behaviours of these systems. The
conversion of abstract design ideas into concrete representations
that direct programmers through the coding process is made
possible by UML tools, which are of utmost importance. I'll give a
thorough explanation of UML tools here for the design stage.
 UML Tool Functionality: UML tools provide a range of
functionalities that aid in designing and documenting software
systems:
Class diagrams, sequence diagrams, use case diagrams, activity
diagrams, state diagrams, and other UML diagrams can all be
created by users using UML tools. Each style of diagram captures
particular elements of the system's design, enabling a
comprehensive understanding of the software.
Visual Representation: UML diagrams make complicated design
concepts easier to comprehend and communicate by providing a
visual representation of the system's architecture and behaviour.
The divide between technical and non-technical stakeholders is
reduced thanks to these visual representations.
Modelling Elements: A variety of modelling elements, including
classes, objects, actors, use cases, components, and more, are
available with UML tools. These components can be added to the
diagram canvas by users by dragging and dropping them there.
A UML tool is a piece of software that facilitates the generation,
administration, and visualisation of UML diagrams during the
design stage of software development. These tools are essential
for encouraging collaboration, directing the development process,
and turning abstract design thoughts into concrete representations.
UML tools dramatically increase communication, documentation,
and code quality, which is essential for the success of software
projects.

➔ Wireframing and prototype tools:-

Wireframing and prototyping tools are essential components of the
design phase in software development, particularly for creating
user interfaces (UI) and user experiences (UX) that align with user
expectations. These tools facilitate the creation of visual
representations and interactive simulations, enabling designers,
developers, and stakeholders to collaboratively refine the design
before the actual development process begins.

Tools for Wireframing:

Wireframes, which are low-fidelity visual representations of the
user interface, are produced using wireframing technologies.
Without going into specific images or aesthetics, wireframes
concentrate on the organisation, structure, and positioning of items
inside the application's screens. The following details how
wireframing tools benefit the design stage:

Conceptualization: Wireframes make it easier for designers and

other stakeholders to see the fundamental framework of each
screen. They give a precise sketch of the locations of various
elements, like as buttons, navigation bars, and content sections.

Functional Clarity: Wireframes give a functional perspective of the

application's flow and user interactions by focusing on the layout
and content hierarchy. This helps to make the order of the steps
users will take inside the programme more clear.

Prototyping Tools: Prototyping tools take the design process a step

further by creating interactive and dynamic simulations of the
software's user interface and interactions. These prototypes
provide a tangible experience that closely resembles how users
will interact with the actual application:

Interactive Simulation: With the use of prototyping tools, designers

may make interactive prototypes that let users explore various
screens, interact with buttons and input fields, and learn how an
application works.

User Experience Testing: Before design is put into production,

interactive prototypes let designers and other stakeholders mimic
user interactions, spot usability problems, and confirm design
choices. As a result, the user experience is improved based on
actual usage scenarios.

User Feedback: To get insightful feedback on the usability,

navigation, and general user experience, prototypes can be shared
with users and stakeholders. Making wise design improvements
need this feedback.
3) Coding
During the coding phase of software development, developers use a
variety of tools to write, debug, and test their code efficiently. These tools
help streamline the coding process and ensure the code is of high
quality. Here are some commonly used tools during the coding phase:
➔ Integrated Development Environments (IDEs)
Integrated Development Environments (IDEs): IDEs offer a unified
platform for developing, testing, debugging, and deploying code.
They are complete software tools. Developers can code more
effectively and productively because to the features and tools that
IDEs provide. Popular IDEs include PyCharm, IntelliJ IDEA,
Eclipse, and Visual Studio. The following is how IDEs benefit the

coding stage:
Advanced code editors with capabilities like syntax highlighting,
autocompletion, code formatting, and intelligent code suggestions
are provided by IDEs. These capabilities improve the speed and
accuracy of creating and editing code.

Debugging: IDEs have integrated debuggers that let programmers

set breakpoints, step through code, examine variables, and find
and correct bugs. Finding and fixing problems in the code is made
much easier by debugging tools.

Integrated Tools: Version control, code review, testing, and build

automation are all included with IDEs. By removing the
requirement to transition between various software applications,
this streamlines the development workflow.

Code navigation is made simpler for developers by IDE tools like

code search, navigation shortcuts, and code outlining, which help
them browse big codebases and find certain functions or classes.

Integration with Frameworks: A variety of programming languages

and frameworks are supported by several IDEs with specialised
support. To speed up development, they provide templates, code
generators, and libraries tailored to the technology of choice.
➔ Version Control Systems(VCS):-
Git and other version control systems (VCS) are crucial tools for
managing source code changes during the coding period. Git is a
distributed version control system that allows programmers to
communicate, track changes, and preserve the integrity of their
work. Here is how Git helps with the coding stage:

Git keeps track of all codebase updates, including additions,

deletions, and additions. It is simple for developers to review the
history of changes and comprehend how the code has changed.

Branching and merging: Git enables programmers to set up

branches so they can independently work on features or bug fixes.
Parallel work is possible without causing problems because
branches can be merged back into the main source.

Reverting to a previous, working state of the codebase is possible

using Git in the event that a bug or other problem is introduced.
This makes it easier to swiftly remove undesired modifications and
keep the code in a stable state.

Git interfaces with platforms and tools for code reviews, making it
simpler to examine changes, offer comments, and guarantee code
quality through cooperative peer reviews.

Git offers a thorough commit history as well as annotations that

identify who made what changes and when. This facilitates the
tracking of development progress and the identification of
contributors to code modifications.

Git enables remote repositories on websites such as GitHub,

GitLab, and Bitbucket. These tools make it easier for scattered
teams to share code and host backups centrally.
The use of Integrated Development Environments (IDEs) can
increase developer productivity by providing a complete coding
environment including tools for writing, debugging, and maintaining
code. Git and other version control systems make it possible to
effectively collaborate, track changes, and maintain the integrity of
the code, ensuring a collaborative and controlled development
period.
4) Verification / Validation:-
Verification and validation of the software ensures that project
functions as expected and meets the requirements. Different testing
methods like unit testing, integration testing, system testing, and user
acceptance testing are performed to identify and fix any defects or
issues.
→Automated testing Frameworks:-Frameworks for automated
testing, such as Selenium, JUnit, and pytest:
The verification and validation stage of software development
requires the use of automated testing frameworks as a critical tool.
These frameworks offer a disciplined and methodical way to
automatically run test cases, making sure the programme complies
with its functional specifications and behaves as expected. Popular
automated testing frameworks include pytest for Python, JUnit for
Java, and Selenium for web applications. These frameworks'
contributions to the verification and validation process are as
follows:
Test Automation: Test scripts that imitate user interactions and test
different scenarios can be created by developers using automated
testing frameworks. These scripts can be run automatically, which
lowers the amount of manual testing necessary and increases
testing coverage.
Regression Testing: Automated tests are especially helpful for
regression testing, which involves retesting previously tested
features to make sure that fresh code changes haven't caused any
regressions or unwanted side effects.
Consistency: Automated tests are executed consistently, which
lowers the possibility of human error that can happen during
manual testing. The reliability and repeatability of the tests are
ensured by this consistency.
Multiple test cases can be run simultaneously thanks to the parallel
execution capabilities of many automated testing frameworks. This
increases testing efficiency and speeds up the procedure.
Automated testing frameworks and CI/CD (Continuous
Integration/Continuous Deployment) pipelines effortlessly interact
thanks to continuous integration (CI). This guarantees that tests
are immediately run each time code changes are posted to the
repository, giving developers quick feedback.
Integration testing is a process in which several software
components are tested alongside one another to make sure their
interactions function as expected. Automated testing frameworks
make this process possible.
→Static Code Analysis Tools
Static code analysis tools, such as SonarQube, ESLint, and
Checkstyle, are essential for the software development process'
verification stage. Without running the code, these tools examine
the source code to find potential problems, weaknesses, and
coding irregularities. Tools for static code analysis include
Checkstyle for Java, ESLint for JavaScript, and SonarQube for
general code quality. What these tools add to the verification step
is as follows:
Static code analysis tools evaluate the quality of the code by
locating coding patterns that could result in bugs, security flaws, or
maintainability problems.
Code Style Enforcement: The team's established standards and
norms for coding are enforced by these technologies. This
guarantees consistency in the name standards, formatting, and
general coding practises.
Bug detection: Before the code is executed, static analysis
techniques can find typical programming flaws including null
pointer dereferences, resource leaks, and potential memory
problems.
Identification of Security Vulnerabilities: By detecting security flaws
like SQL Injection or Cross-Site Scripting, these technologies
assist developers in proactively addressing security issues.
Technical debt management: Tools that analyse static code help
developers by pointing out potential technical debt-ridden sections
of the codebase and directing them to fix coding smells and design
flaws.
Similar to continuous integration, continuous inspection
incorporates static code analysis into the development process.
This results in rapid feedback for developers and stops code errors
from building up.
Enforcement of Documentation: These tools can make sure that
the documentation for the code is thorough, making it easier to
understand and maintain.
In summary, automated testing frameworks enable automate test
execution, ensure consistency, and support continuous integration,
whereas static code analysis tools promote coding standards
enforcement, uncover code quality concerns, and identify potential
bugs and vulnerabilities. Both kinds of tools improve the quality,
dependability, and conformance to requirements of the
programme, which has a substantial positive impact on the
verification and validation phase.
5) Maintenance and Support:-
After deployment, the software enters the maintenance phase, where
developers continue to monitor, support, and update the software to fix
bugs, introduce new features, and adapt to changes in the user's needs
or technology.
→ Issue Tracking and Helpdesk Systems:-Systems for tracking
issues and providing customer service are essential during the
maintenance and support stages of software development. These
technologies offer a methodical way to handle difficulties,
questions, and support requests brought forth by users. JIRA and
Zendesk are two examples of popular tools in this category. These
tools' contributions to the maintenance and support stages are as
follows:
Issue Resolution: Users may run into errors, hiccups, or
unexpected behaviour in the software during the maintenance
process. Support staff can methodically log and manage these
issues with the aid of issue tracking solutions. This include
documenting the problem's specifics, allocating it to the right team
member, and monitoring its progression until resolution.
Prioritisation: Support teams can use problem tracking
technologies to rank issues according to their seriousness,
significance, and immediacy. This complies with the idea of giving
timely support and guarantees that urgent concerns are handled
quickly.
Collaboration and communication are made easier by issue
tracking systems between users, developers, and support staff.
Teams can communicate updates on their progress, work together
to solve problems, and share ideas.
User Interaction: Helpdesk platforms like Zendesk give users a
place to post requests for help, questions, or feedback. Users'
overall experience is improved by the ability to follow the progress
of their requests, get updates, and contact with support staff.
Knowledge Base: Helpdesk systems frequently come with a
knowledge base that contains answers to frequently asked
queries. By assisting users in locating solutions to their questions
without directly contacting support, this tool can lighten the
pressure on that team.
Reporting and analytics: These tools produce metrics and reports
that give information about the different issues that have been
reported, the typical response and resolution timeframes, and
other important performance data. Resource allocation and
process improvements can be guided by this data.

→Remote Monitoring and Management Tools (e.g., Nagios,

SolarWinds): Tools for remote monitoring and administration are
crucial for continuing to support and maintain software systems.
With the help of these technologies, administrators and support
groups can remotely check on the functionality, performance, and
availability of software and hardware resources. Such programmes
include SolarWinds and Nagios, for instance. Here is how these
tools help:
Real-time Monitoring: While the software is being maintained,
administrators and support staff can keep an eye on the
performance, server health, and other crucial statistics. This aids in
locating problems before they worsen and affect consumers.
Alerting and messages: When predetermined thresholds are
surpassed or anomalies are found, remote monitoring tools can be
set up to send alerts and messages. Support teams can respond
quickly to newly discovered problems thanks to this proactive
strategy.
Capacity Planning: Remote monitoring technologies support
capacity planning by continuously monitoring resource use. This is
crucial during the maintenance stage to make sure the software's
infrastructure can support the anticipated loads.
Remote troubleshooting: These tools frequently support remote
administration and access. Support personnel may analyse and
resolve problems remotely, minimising the requirement for on-site
assistance and downtime.
Update and patch management can be facilitated by remote
monitoring and management solutions. To keep the programme up
to current and secure, they can remotely deploy updates, security
patches, and repairs.
Performance Optimisation: These tools assist in locating
performance bottlenecks and potential areas for improvement by
monitoring performance data over time. This helps to increase the
effectiveness of the programme throughout the maintenance
phase.
Automation: Some remote monitoring technologies enable the
automation of recurring operations like system backup, scalability,
and maintenance. This lessens the need for manual intervention
and improves operational effectiveness.
As a result, user engagement and issue resolution during the
maintenance and support stages are streamlined by issue tracking
and helpdesk solutions. Tools for remote monitoring and
management make proactive monitoring, troubleshooting, and
performance optimisation possible, all of which help to maintain
the software's health and dependability. By offering organised
procedures, effective problem-solving techniques, and efficient
communication, both kinds of technologies improve the support
and maintenance phases.

Plagiarism :- 3%