MCA –I SEM II (2023-2024)

Subject- IT-22 Software Project Management

(SPM)

Practical Assignment:-1

Name:Aniket Patil

Roll no:46

Q1. You are part of a software development team at Amazon, tasked with enhancing the search
functionality on the Amazon website. Your team has received a backlog of features and
improvements to implement. As the team's product manager, your responsibility is to estimate the
backlog and assign story points to each item to facilitate efficient planning and prioritization.
Additionally, you need to design your team structure, and create epics, user stories, and tasks for the
project.

Step 1:-
Here first we created the new project based on the jira software development .In above pannel
we have to give the name to our project that we are require in future

1)Creating New Project on Jira:

Step 2:- Here in the step 2 we add the team members which are require for our project
development.

2)Adding Team Members:

Teams:
Step 3:- In the step 3 we have to create the different epics according to the customer feedback.

3)Epics:

1) Epic 1:Search Algorithm Enhancement.

2) Epic 2:User Experience Optimization.

3) Epic 3: Performance Optimization
Step 4:- In the Step four we have to create and assign the different user stories.

4)User Stories:
1) Improve search relevance:

2) Implement advanced search filters:

3) Enhanced search autocomplete feature:

4) Implement voice search capability:

5) Improve search speed and responsiveness:
Step5:- In the step 5 it include the completed and not completed task by the team members.

5)Tasks:
Step 6:- In the step 6 a particular timeline is setup for each epic completion.

6)Timeline:
7)Backlog/sprint:
8)Board:
9)Dashboard:
 Q2. You are a project manager at Book My Show, an online platform for booking movie tickets,
events, and experiences. Your team has been tasked with enhancing the user experience and adding
new features to the website. As part of your responsibilities, you need to estimate the product
backlog, assign story points, design your team structure, and create epics, user stories, and tasks for
the project.

Step 1:-
Here first we created the new project based on the jira software development .In above pannel
we have to give the name to our project that we are require in future

1)Creating New Project on Jira:

Step 2:- Here in the step 2 we add the team members which are require for our project
development.

2)Adding Team Members:

Teams:
Step 3:- In the step 3 we have to create the different epics according to the customer feedback.

Epics:

1) Epic 1: Movie Booking

2)Epic 2:Event Booking.

3)Epic 3: User Account Management.
Step 4:- In the Step four we have to create and assign the different user stories.

4)User Stories:

1) As a user, I want to search for movies by title, genre, or location

2) As a user, I want to view movie details, including synopsis, cast, and ratings.
3) As a user, I want to browse upcoming events by category or location.

4) As a user, I want to book tickets for events and receive confirmation.

5) As a user, I want to create an account and manage my profile

6) As a user, I want to view my booking history and manage my preferences.

Step5:- In the step 5 it include the completed and not completed task by the team members.

5)Tasks:
Step 6:- In the step 6 a particular timeline is setup for each epic completion.

6)Timeline:
7)Backlog/sprint:
8)Board:
9)Dashboard:
 Q3. You are a project manager at a leading food delivery company, tasked with enhancing their food
ordering application. Your team has received a backlog of features and improvements to implement.
As part of your responsibilities, you need to estimate the product backlog, assign story points,
design your team structure, and create epics, user stories, and tasks for the project.

Step 1:-
Here first we created the new project based on the jira software development .In above pannel
we have to give the name to our project that we are require in future

1)Creating New Project on Jira:

Step 2:- Here in the step 2 we add the team members which are require for our project
development.

2)Adding Team Members:

Teams:
Step 3:- In the step 3 we have to create the different epics according to the customer feedback.

Epics:

Epic 1: Ordering Food

Epic 2:User Account Management

Epic 3:Order Tracking.
Step 4:- In the Step four we have to create and assign the different user stories.

4)User Stories:
1) as a user I want to Browse restaurants and menus.

2) as a user I want to Customize order and add items to cart.

3) as a user I want to be able to Create an account and login.

4) As a user, I want to be able to edit my profile.

5) As a user, I want to be able to track my Order status.

6) As a user, I want to be able to Receive notification about my order status.

Step5:- In the step 5 it include the completed and not completed task by the team members.

5)Tasks:
Step 6:- In the step 6 a particular timeline is setup for each epic completion.

6)Timeline:
7)Backlog/sprint:
8)Board:
9)Dashboard:
GitHub-
Q.2 Create Account on GitHub & add screenshot & describe below terms with the screenshots.
1. Create a new Git repository for any project.

2. Explain the steps involved in adding files to the staging area and committing changes in Git.

3. Describe the process of creating and switching between Git branches.

4. How do you merge branches in Git, and what precautions should you take to avoid conflicts?

5. What is a pull request in Git, and how does it facilitate code review and integration?

6. Discuss the importance of writing descriptive commit messages and provide examples of

good practices.

7. Describe common Git workflows used in collaborative software development projects.

8. Discuss strategies for troubleshooting common Git issues encountered during project
management.

1) GitHub Profile:-

GitHub profile since GitHub is the most popular platform for Git hosting, is
a crucial part of your presence as a developer or contributor. It's where
you showcase your work, contributions, and projects to the wider
community. Here's some information about what your GitHub profile
typically includes:
1. Create a new Git repository for any project.

GitHub repositories are the backbone of collaborative software development and version
control. These repositories serve as centralized hubs for storing and managing project files,
source code, documentation, and more. Each repository has a unique name and can be set to
either public or private visibility, depending on the creator's preferences. When creating a new
repository on GitHub, users are prompted to provide essential details such as the repository
name, a brief description, and whether to initialize it with a README file. The README file
often serves as a project overview and includes information on how to get started, installation
instructions, and other essential details.

2. Explain the steps involved in adding files to the staging area and
committing changes in Git.
1. Check Status: Before adding files, it's helpful to check the current status of your
repository. You can do this by running `git status` in your terminal or command prompt. This
command provides an overview of any modified, untracked, or staged files.

2. Stage Changes: To stage files for the next commit, you use the `git add` command
followed by the filenames or directories of the files you want to stage. For instance, if you want
to stage a file named `example.txt`, you would run `git add example.txt`. Alternatively, you can
use `git add .` to stage all modified and untracked files in the current directory and its
subdirectories.
3. Verify Staging Area: After staging files, you can verify which changes are staged by
running `git status` again. Staged files will be listed under the "Changes to be committed"
section.

4. Commit Changes: Once you're satisfied with the changes staged in the previous step,
you commit them to the repository using the `git commit` command. When committing
changes, you include a commit message that summarizes the modifications made. For
example, you can run `git commit -m "Add new feature"` to commit changes with the message
"Add new feature".

5. Review Commit History: After committing changes, you can review the commit history
using `git log`. This command displays a chronological list of commits, including the commit
hash, author, date, and commit message. Reviewing the commit history allows you to track the
evolution of your project and understand the changes made over time.

3. Describe the process of creating and switching between Git branches .

1.Create a New Branch: To create a new branch, you use the `git branch` command followed by
the desired branch name. For example, if you want to create a branch named `feature-x`, you
would run:
git branch feature-x
2. Switch to the New Branch: After creating the branch, you need to switch to it to start
working on your changes. You can do this using the `git checkout` command followed by the
branch name. git checkout feature-x

3. Work on Changes: Once you've switched to the new branch, you can begin making
changes to your project. These changes will be isolated to the branch you're currently on,
allowing you to work independently of other branches.
4.Commit Changes: As you make changes to your project, you'll need to periodically commit
them to the branch. This is done using the `git commit` command, which captures a snapshot
of the current state of your files along with a descriptive commit message.
5.Switch Between Branches: To switch between branches, you use the `git checkout` command
followed by the name of the branch you want to switch to. For example, if you want to switch
back to the `main` branch, you would run:

4.How do you merge branches in Git, and what precautions should you
take to avoid conflicts?
1.Ensure Branches are Up-to-Date: Before merging, it's essential to ensure that the branch
you're merging into (often the `main` branch) is up-to-date with the latest changes. You can do
this by switching to the target branch (`git checkout main`) and pulling any changes from the
remote repository (`git pull origin main`).
2.Switch to Target Branch: Next, switch to the branch you want to merge changes into. For
example, to merge changes from a feature branch named `feature-x` into the `main` branch,
you would run:
3.Merge Branch: Once on the target branch, you can merge changes from the source branch
using the `git merge` command followed by the name of the branch you want to merge. For
example:
4.Resolve Conflicts**: In some cases, Git may encounter conflicts during the merge process.
Conflicts occur when the changes in the source branch conflict with changes in the target
branch. Git will pause the merge process and prompt you to resolve these conflicts manually.
You can identify conflicted files by running `git status`. Open the conflicted files in your text
editor, and Git will mark the conflicting sections. You need to manually edit the files to resolve
the conflicts, removing any unwanted changes and keeping the desired modifications. After
resolving conflicts, you need to stage the changes using `git add` and then commit the merge
using `git commit`.
5. What is a pull request in Git, and how does it facilitate code review and
integration?
1. Creation of Pull Request: A developer creates a pull request by selecting the source branch
(where the changes were made) and the target branch (where the changes will be merged).
They provide a title and description detailing the purpose of the pull request, the changes
made, and any relevant information.
2.Code Review: Once a pull request is created, team members can review the proposed
changes. They can view the code diffs, leave comments, ask questions, and provide feedback
directly within the pull request interface. Code review is a collaborative process aimed at
improving the quality of the codebase, identifying bugs, ensuring adherence to coding
standards, and sharing knowledge among team members.
3. Iterative Changes: During the code review process, the author of the pull request may
need to make additional changes based on feedback received. They can make these changes
directly in their feature branch and push them to the remote repository. The pull request
automatically updates to reflect the new changes, allowing reviewers to review the updated
code.

4. Approval and Merge: Once the code review process is complete and all feedback has
been addressed satisfactorily, a team member with the necessary permissions can approve the
pull request. They may also perform a final review to ensure everything looks good. Once
approved, the changes are merged into the target branch, typically using the "Merge pull
request" button in the pull request interface.

6. Discuss the importance of writing descriptive commit messages and

provide examples of good
practices.
1.Clarity and Understanding: Descriptive commit messages make it easier for developers to
understand the changes introduced by a commit without needing to examine the code diffs
extensively. This clarity improves communication and reduces the likelihood of
misunderstandings.
2.Code Review and Collaboration: Clear commit messages streamline the code review process
by providing reviewers with context and insights into the changes being made. This facilitates
constructive feedback and ensures that the review process is efficient and effective.
3.Project History and Documentation: Commit messages serve as a historical record of the
project's evolution. Well-written messages document the rationale behind each change,
providing valuable insights to future developers who may need to understand why specific
decisions were made.
4.Debugging and Troubleshooting: When troubleshooting issues or debugging code, descriptive
commit messages can provide valuable clues about the origin of a problem. Developers can
quickly identify which commit introduced a particular change or bug by reading the commit
messages.
Examples of well-formatted commit messages:
- `Add user authentication feature`

- `Fix bug causing infinite loop in data processing`

- `Update README with installation instructions`

- `Remove deprecated function from utility module`

- `Refactor code for improved performance`

7. Describe common Git workflows used in collaborative software

development projects.
1.Centralized Workflow:
- In the Centralized Workflow, all developers work directly on a single central repository,
typically the `main` branch.

- Developers clone the repository, make changes locally, commit them, and then push
those changes directly to the central repository.

- This workflow is simple and suitable for small teams or projects where centralized
control over the codebase is preferred.
2. Feature Branch Workflow:
- In the Feature Branch Workflow, each new feature or bug fix is developed on its own
branch, separate from the main development branch (e.g., `main` or `master`).

- Developers create a new branch for each feature they work on, make changes, commit
them, and then push the branch to the central repository.

- Once the feature is complete, it undergoes code review, and if approved, it's merged
into the main development branch.

- This workflow encourages isolation of changes, facilitates code review, and enables
parallel development of multiple features.

3. GitHubflow Workflow:
- The Gitflow Workflow extends the Feature Branch Workflow by adding support for
release and hotfix branches.

- It distinguishes between long-lived branches (`main` and `develop`) and short-lived

branches (feature, release, and hotfix branches).

- Features are developed on separate branches, merged into the `develop` branch for
integration testing, and then merged into `main` for release.

- Release branches are created from `develop` to prepare for a new release, undergo
testing, and then merged into both `main` and `develop`.

- Hotfix branches are used to quickly address critical issues in production and are
created from `main`, merged back into both `main` and `develop`.

- This workflow provides a structured approach to managing releases and hotfixes while
maintaining a stable mainline.

5. Pull Request Workflow:

- The Pull Request Workflow is similar to the Feature Branch Workflow but places a strong
emphasis on using pull requests for code review and integration.

- Developers create feature branches, make changes, commit them, and then push the branch
to the central repository.

- Instead of directly merging branches, changes are submitted as pull requests, which undergo
code review by team members.

- Once approved, pull requests are merged into the main development branch.

- This workflow promotes collaboration, ensures code quality through code review, and
provides a structured process for integrating changes.
8. Discuss strategies for troubleshooting common Git issues encountered
during project management.
Troubleshooting common Git issues encountered during project management is essential for
maintaining productivity and ensuring the integrity of the codebase. Here are some strategies
for troubleshooting common Git issues:
1.Check Git Status: The `git status` command provides valuable information about the current
state of your repository, including any untracked files, changes to be committed, and the
branch you're on. Running `git status` is often the first step in diagnosing Git issues.
2.Review Recent Changes: Use `git log` to review recent commits and changes to the
repository. This can help identify when and where an issue was introduced. You can also use
`git diff` to view the differences between commits or branches.
3.Verify Remote Configuration: If you're encountering issues with remote repositories, such as
push or fetch failures, verify that your remote configuration is correct. Use `git remote -v` to
view the configured remote repositories and ensure they point to the correct URLs.
4.Check Branches: Verify that you're on the correct branch and that your local branches are up-
todate with remote branches. Use `git branch` to list local branches and `git branch -r` to list
remote branches. Use `git checkout` to switch branches as needed.
5.Resolve Merge Conflicts: If you encounter merge conflicts during a merge or rebase
operation, carefully review the conflicted files and manually resolve the conflicts. Use `git
status` to identify conflicted files, edit them to resolve conflicts, and then use `git add` to stage
the resolved changes.
6.Revert Commits: If you need to undo changes introduced by a specific commit or series of
commits, you can use `git revert` to create a new commit that undoes the changes.
Alternatively, you can use `git reset` to reset the current branch to a specific commit, though
this should be used with caution as it modifies the repository history.
7. Use Git Reflog: The `git reflog` command provides a log of all Git actions performed in the
repository, including commits, merges, and resets. Use `git reflog` to view the history of recent
actions and identify where issues may have occurred. You can then use `git reset` or other
commands to revert to a previous state if needed.
8.Consult Documentation and Resources: If you're unsure how to resolve a particular Git issue,
consult the Git documentation, online resources, or community forums for guidance. Websites
like Stack Overflow and GitHub Discussions are valuable resources for finding solutions to
common Git problems.