CS261

Software Engineering

Topic 3: Early Team Organisation

James Archbold
[email protected]

In association with Deutsche Bank

CS261 - Software Engineering - Introduction 1

Key Roles Early in the Project

The assigning of roles is important for effective software

development.
Roles provide structure and guidance, and help to ensure each team
member is aware of their responsibilities.
You’re familiar with some roles, such as Software Developer, however
we are still early in the project.
This is the time of the Project Manager and the Business Analyst

CS261 - Software Engineering - Introduction 2

What is Project Management & Business Analysis?
Project Management Business Analysis
“Project management is the “The practice of enabling change
application of processes, in an organisational context, by
methods, knowledge, skills and defining needs and
experience to achieve the project recommending solutions that
objectives” deliver value to stakeholders”
Associate for Project Management (APM) International Institute of Business Analysis (IIBA)

Over the course of a project, these roles have numerous

responsibilities and activities.

CS261 - Software Engineering - Introduction 3

Looking at the big picture
Do not make the mistake of disregarding these roles, just
because they are stereotypically non-technical.
You also need someone
You need someone capable of
who can identify the utility
managing deadlines, keeping
of the project, document
the team on track and making
its progress and analyse
hard organisational decisions.
potential solutions.

Your commander should not be on the front lines…

CS261 - Software Engineering - Introduction 4
Initiation
The process of defining the project, objectives, scope, purpose and
deliverables. This is mostly the responsibility of the PM.

Understand the Business Goals (PM/BA)

Identify business needs, problems or opportunities.
Justify the investment necessary to deliver solution.

Provides a clear vision of the project, and makes it easier

to gain approval. Could take the form of a business case.

Plan the Project (PM)

Breakdown project into manageable pieces of work, ensuring
clear definition of responsibilities and dependencies.

Allows for the project to have a clear structured approach.

Could take the form of a Project Initiation Document

CS261 - Software Engineering - Introduction 5

Initiation
Governance (PM)
The process and procedures that will support the management and
decision making during the project.

Enables efficient delivery and accountability. May involve the

selection of a delivery methodology.

Quality Management (PM)

Standards, processes and procedures to ensure fit for purpose deliverables.

Have to ensure processes are consistent, predictable and repeatable.

May include quality gates.

Risks and Issues (PM)

Managing risks and issues to stop them preventing progress.

Improves pro-activism. May include the creation of a risk and issue log.

CS261 - Software Engineering - Introduction 6

Project Initiation Document
This document should contain everything needed to
run the project soundly.

It provides a reference point throughout the project, so

that its progress can be better tracked.

The aim of creating a PID is to understand the outcomes

of the project, both immediate and longer term.

As such, it should include the project purpose, scope,

dependencies and constraints.

The project’s organisation and communication methods

should also be defined here, as well as the plan to
ensure quality.

CS261 - Software Engineering - Introduction 7

Analysis
The tasks and techniques used to work as a liaison among stakeholders in
order to understand the structure, policies and operations of an organisation,
and recommend solutions the enable the organisation to achieve its goals.
Plan Analysis Approach (BA)
Identify activities, stakeholders, analysis techniques and process
for managing requirements.

Will also establish communication methods, the ID of the

stakeholders and the requirements.

Elicit Requirements (BA)

ID and understand stakeholder’s existing environment, needs and concerns.
Ensure underlying needs are understood.

Allows for the sharing of understanding in terms of the environment and

desired requirements.

CS261 - Software Engineering - Introduction 8

Analysis
Document and Validate Requirements (BA)
Techniques to organise and formally agree requirements, which allow the BA to
define require capabilities of a potential solution that will fulfil stakeholder needs.

Organising the requirements allows them to be better managed in the future.

Traceability and Re-use (BA)

Techniques to ensure requirements can be traced through to the
solution and re-used in future projects / processes.

By linking the goal and objectives to the produced solution, it allows

for easier re-use of knowledge.
CS261 - Software Engineering - Introduction 9
Design & Build
Design: The process of reviewing, selecting and designing the solution in
a way that optimises value delivered to stakeholders
Build: Development of the solution in line with the approved requirements
and solution design

Review Solution Options (BA)

The selection of the solution that delivers the most value based on factors such
as scope, risks, reusability capabilities and strategic architecture direction.

This helps ensure our solution will be valid and reduces the risk of rework
occurring.

CS261 - Software Engineering - Introduction 10

Design & Build
Document Solution Functionality (BA)
Documentation that clearly defines the functionality of the agreed
solution using techniques that explains the functionality clearly.

These documents help to ensure the solution’s functionality is

understood by technical stakeholders.

Communication (PM)
Providing clear transparent communication own the progress of the
project - good or bad to provide an update on current status. This can
take many different forms and not just emails and presentations.

With good communication, there is clear accountability and responsibility,

which helps to manage expectations.

CS261 - Software Engineering - Introduction 11

Test
Independent validation of the solution in line with the approved requirements to
ensure ‘fit for purpose’ deliverables

Review Test Plan (BA/PM)

Ensure plan is in line with project governance and that scenarios are in line
with requirements and solution design.

A good test plan can identify mistakes before the development even begins.

Monitor Test Execution (PM)

Scenarios performed against solution to ensure it is fit for purpose and in
lone with requirements. Monitoring ensures there are no delays.

This is a form of independent verification which can give customers more

confidence in the solution.

CS261 - Software Engineering - Introduction 12

Test

Prioritise Defects (PM)

Understand the key defects that must be solved before solution is implemented.

This prevents a project being unnecessarily delayed, and can maximise the
customer value.

Testing Sign-off (BA/PM)

Formal sign-off to confirm deliverables are ‘fit for purpose’ and meet
stakeholders requirements.

This is an agreement that the project is ready to go live.

CS261 - Software Engineering - Introduction 13

Implement
The business end of the project - when all the hard work to analyse, design,
build, and test the solution is complete and ready for go-live and handover to
the customer or end user.

Implementation ‘Go-Live’ Plan (PM)

Step-by-step plan that will implement the projects deliverables in
Production environment and deal with hand over.

Helps to ensure stakeholders and team members are clear about when,
who and how the project will go-live.

Handover to Production and Early Life Support (PM)

Provide tools, training and documents needed to support project.

Planning this properly can help to deal with teething problems in early
deployment.

CS261 - Software Engineering - Introduction 14

Implement
Operational and Maintenance Support (PM)
Provide details of tasks that will need to be carried out in production.

When done properly, this can ensure that future operation and
maintenance does not need a support team.

Formal Project Acceptance and Sign off (PM)

Formally completing the project and signalling the project can be closed down.

This is when the deliverables are all accepted, and the project is delivered as
expected.

CS261 - Software Engineering - Introduction 15

Closedown
Final phase of the project where it is closed down in a controlled and planned
manner.

Review Benefits (PM)

Review the expected benefits against actual benefits at the end of the project.

This will confirm if the project delivered the expected benefits, and identify if it
was a success or failure.

Archive Project Artefacts (PM)

Ensure documentation, products and deliverables are stored appropriately
and available following closure of the project.

This will help to assist with support and future enhancements.

CS261 - Software Engineering - Introduction 16

Closedown
End Project Status Report and Lessons Learnt (PM)
Document what went well, what did not go well and what lessons
we learnt throughout the project.

Allows us to highlight the successes and problems that can help

if future projects.

Reward and Recognition (PM)

Reward high performance and highlight any areas for improvement.

This can help to support growth within the company, and increase staff
morale.

CS261 - Software Engineering - Introduction 17

Speaking of accountability
• Hopefully you can see the
importance of organisation and
having someone who can see the
bigger picture.

• There is a strong theme of

accountability, as it is important to
know exactly who should be doing
what and when.

• When you get to the actual coding,

this notion still needs to be there.

• A great way to organise your efforts

is through git.

CS261 - Software Engineering - Introduction 18

Git on it
• git is a system for version control.

• We’ll talk about that more later.

• For now, we’re concerned with it’s collaborative

capabilities

• git allows for a group of people to collaborate on

a coding project, and helps to minimise errors

CS261 - Software Engineering - Introduction 19

Why bother?

• Without proper management, think of what can happen when

collaborating on a coding project:

• Code duplication - If multiple people are working on the code, they may
each create the same utility methods without consulting the other

• Code erasure - What happens if someone is working on an older version

and then uploads their new additions? It could delete newer code.

• Lack of accountability - How do we know who did what?

• Introduction of errors - If someone uploads a new version, that breaks

the build, how do we revert back to an older version?

CS261 - Software Engineering - Introduction 20

Git’s here to fix it!
git provides numerous features to help alleviate these
terrible problems

✓ Logs of updates - Allows all contributors to track new additions to the

code.

✓ Version control - A contributor cannot upload their additions until they’re

confirmed to have the most recent version of the code.

✓ git blame - There is a specific command to help identify the author of

each update.

✓ Roll back - You can roll back the current version of your code to older
version if it really is beyond repair.

CS261 - Software Engineering - Introduction 21

How does it work?

• git works on a tree structure

• You create a master branch,

which is the original version of
the project.

• When a new feature is being

worked on, you can make a
new branch, meaning any
updates do not affect the master
branch.

• When your feature is complete,

you merge your branch with the
master.

CS261 - Software Engineering - Introduction 22

Gittin’ Started - creating a repository

• To get started, you need to set up a repository for the project.

• If the project does not exist on git (you’re setting it up for the
group):

• git init - Execute this command in the local directory you’ve made
for the project

• If the project exists remotely:

• git clone <repo url> - This will pull the repo down and set it up in
the folder you’re currently in

CS261 - Software Engineering - Introduction 23

Gittin’ Started - making sure you’re updated

• With lots of people working on the same project, or even if you just
work from different machines, you’ll need to make sure your local
version is always updated

• git pull <remote> - Pulls the most up-to-date version of the

remote repository.

• You always need to make sure your local branch is the same as the
remote branch before you can save any changes you’ve made.

CS261 - Software Engineering - Introduction 24

Gittin’ Started - Saving your changes

• Once you’ve made your edits in the local version of the repository,
you need to push it to the remote version.

• git add <file> - This will add the <file> to the list of updates to be
pushed. You can use ‘*’ to add the entire directory.

• git commit - This will store all the changes as a single update. Use
the flag ‘-m’ to add a helpful commit message, detailing what you’ve
changed.

• git push <remote> - This will push the local branch to the remote
version, including all the commits and changes you’ve made

CS261 - Software Engineering - Introduction 25

Gittin’ Started - Burn it down, start again

• Occasionally, someone will break something beyond any

reasonable ability to fix.

• In that case, you need to revert the branch to a previous, working

version.

• git revert “<commit message>” - This will undo the changes of

the commit with the corresponding message

• You can also use the commit reference, found with the ‘git log’
command.

CS261 - Software Engineering - Introduction 26

Gittin’ Started - Branching Out

• If you don’t want to bloat the master branch, you can create a
branch to work on something until it is complete.

• Many of the commands in previous slides can be amended with a

branch name, typically after ‘<remote>’

• git branch <branch> - This creates the current branch. This will
need to be pushed to the remote repository like any other update.

• git branch -d <branch> - Deletes the branch, and none of it’s

changes are merged with the master branch.

• git merge <branch> - Combines the branch with the master

branch. You will need to be careful about merge conflicts!

CS261 - Software Engineering - Introduction 27

Commit to Git
• Some of you are already familiar with
git, and the rest of you should be now.

• We’ve covered some of the basics,

enough to help you work with your team.

• The tool set is extremely powerful, and

there are a lot of advanced things that
can be done. Look up some tutorials!

• GitHub offers free private repos for

students, and BitBucket just offers free
private repos for all.

• Do not underestimate the utility in

properly managed code collaboration.
CS261 - Software Engineering - Introduction 28
Coder’s Strong Together
• You should consider the use of other tools to make the
organisation of your team more efficient!

• Group chat’s are fine, but there are a number of other chat apps
and tools that can help make sure things are getting done (Slack,
Trello, etc.)

• You should be meeting regularly, and making sure you’re making

good progress

CS261 - Software Engineering - Introduction 29

Next Time on Software Engineering GT

• We will consider the interface with the development team

(D-requirements)

• We will also start to look at design

• We will pay particular attention to system modelling as a

way of ensuring that your design document is clear and
unambiguous

CS261 - Software Engineering - Introduction 30