Agile Development

CITS3403 Agile Web Development

From Agile in a Nutshell, by Semester 1, 2021

Jonathan Rassmusson
Further reading: The agile
handbook
Agile Goals

Agile is a way to manage projects. It can be used

for virtually anything, but it was founded in
software development. This handbook focuses on
agile for software development, but many of
the principles can be expanded to other fields.

Agile breaks down larger projects into small,

manageable chunks called iterations. At the end of
each iteration (which generally takes place over a As made popular by the “Agile
consistent time interval) something of value is Manifesto”, agile values:
produced. The product produced during each 
Individuals and interactions
iteration should be able to be put into the world to over processes and tools
gain feedback from users or stakeholders. 
Working software over
comprehensive documentation
Unlike Waterfall project management, which is 
Customer collaboration over
strictly sequenced: you don’t start design until contract negotiation
research is done and you don’t start development 
Responding to change over
until the designs are signed off on; agile has following a plan
designers, developers and business people
working together simultaneously.
 12 Key Principles
1) Our highest priority is to satisfy the customer through early and continuous delivery of valuable
software.
2) Deliver working software frequently, from a couple of weeks to a couple of months, with a preference
to the shorter timescale.
3) Welcome changing requirements, even late in development. Agile processes harness change for the
customer’s competitive advantage.
4) Business people and developers must work together daily throughout the project.
5) Build projects around motivated individuals. Give them the environment and support they need, and
trust them to get the job done.
6) The most efficient and effective method of conveying information to and within a development team is
face-to-face conversation.
7) Working software is the primary measure of progress.
8) Agile processes promote sustainable development. The sponsors, developers, and users should be
able to maintain a constant pace indefinitely.
9) Continuous attention to technical excellence and good design enhances agility.
10)Simplicity--the art of maximizing the amount of work not done-- is essential.
11)The best architectures, requirements, and designs emerge from self-organizing teams.
12)At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its
What is Agile
How does it work:

• You make a list

• You size things up
• You set priorities
• You start executing
• You update the plan as you go…
Analysis, design, coding testing are
continuous
How is Agile different

• Development is iterative

• Planning is adaptive

• Roles blur

• Requirements change

• Working software
Agile myths

• Agile is a silver bullet

• Agile is anti-documentation
• Agile is anti-planning
• Agile is undisciplined
• Agile requires a lot of rework
• Agile is anti architecture
• Agile doesn’t scale
Fundamental approaches: User stories

• User stories describe features

• They are told from the end user point of view.
• These features can be deliver in short units of work.
• They are often written on cards to facilitate
communication
Fundamental approaches: estimation

• Estimation is difficult but essential.

• You should always practice estimating the amount
of time development will take.
Fundamental Approaches: Iterations

• Iterations are the core of software develpoment.

Fundamental approaches: planning

• Combines the user stories and estimations to build

a feasible plan for delivery.
Unit Testing
Refactoring

• To maintain a design and functionality, we must be

prepared to refactor code.

• Organise code
into manageable
modules.
• Don’t repeat
yourself (DRY)
Continuous Integration

• Continuous integration keeps the code in a

repository that is automatically maintained and
everyone works on at the same time.
Test Driven Development

• Write tests at the start and then write code to pass

the tests.
• The tests become the de facto documentation for
the system.
Types of Agile:
Flavours of Agile

• Good high
organisation
• But not IT
specific
Flavours of Agile

• Easy to
understand and
start
• Very popular
• Not much
engineering
Flavours of Agile

• Detailed engineering
practices
• IT focused
• Popular with
developers
 GIT

• Git is a distributed version control system

• Developed in 2005 by Linus Torvalds
• Now the most widely used version control system in
the world.
• Git is able to manage different branches of a
development, allowing teams to work on the latest
branch, roll back changes, or develop independent
features.
 Git Theory

• Git has a decentralised structure. Everyone on the

project has a copy of the history of the project.
• The history of the project is structured as a graph.
Each commit can be undone and replayed
• Git tracks changes in
the current working
directory.
• Changes are added,
then committed, then
pushed to a branch.
• The new code is then
pulled to other spaces.
Git CheatSheet
GIT CheatSheet
GIT operations

• Create a new repository: git init

– adds files monitoring changes, preferences etc.
• Checkout a repo: git clone usr@url:[path]
– copies files and history to a local copy
• The local repo has three trees:
– the working directory (the actual files)
– the index (a set of changes that is ready to commit)
– the head (the last commit you made)
GIT add, commit, push, pull

• Add new files: git add <filename>

– adds file to index
• Commit changes to Head: git commit –m “msg”
– commits changes in index to the head with the msg.
• Push changes to repository:
– git remote add origin <server>
– git push origin master
– adds remote server, and pushes latest commit to it.
• Get latest commit from repo: git pull
GIT branching

• Create a new branch: git checkout –b b1

– creates a new branch that can change independently.
• Switch back to master: git checkout master
– changes to the master branch.
• Delete Branch: git branch –d b1
• Push new branch: git push origin <branch>
• Merge into your branch: git merge <branch>
– merging is automatic, but there may be conflicts.
• To see the differences between two branches:
git diff <b1> <b2>
GIT utilities

• Get a log of commits: git log

• Tag a version: git tag 1.0.0 <commit-id>
– gives a version number to a commit tag.
• Rollback changes: git checkout -- <file>
– returns local file to last commit.
• Delete Branch: git branch –d b1
• Undo all changes and commits: git fetch origin
– then git reset –hard origin/master

• Lots of GUIs, environments exist: GitHub, BitBucket,

GitKraken
 GitHub

• GitHub is a service that hosts Git repositories.

• You can develop colaboratively, and use GitHub as a
remote Repo.
• Note: Free GitHub repositories are public, so anyone
can see your code.
• Students are able to get free education accounts,
which allow private repositories.
– https://education.github.com/pack

• Bitbucket is a similar service

Coordinating Dev Environments

• Git is a great way to link development and

deployment environments:
– Work on your local machine (a laptop) with all the
latest features and branches
– Push commits to GitHub or some central repo
– Pull changes from GitHub to a server environment for
test or deployment
– You can incorporate testing, documenting and
reporting into these workflows.
Git and the project

• Git should be used to manage your project and you git repository will need
to be submitted.
• You will be assessed on your commit history, and the readme should
contain a report of your work in markdown (a lightweight subset of HTML).