Scrum Methodology for Software Development

Characteristics of SCRUM methodology are :

· The first and last phases (Planning and Closure) consist of defined processes, where
all processes, inputs and outputs are well defined. The knowledge of how to do these
processes is explicit. The flow is linear, with some iterations in the planning phase.

· The Sprint phase is an empirical process. Many of the processes in the sprint phase
are unidentified or uncontrolled. It is treated as a black box that requires external
controls. Accordingly, controls, including risk management, are put on each iteration
of the Sprint phase to avoid chaos while maximizing flexibility.

· Sprints are nonlinear and flexible. Where available, explicit process knowledge is
used; otherwise tacit knowledge and trial and error is used to build process
knowledge. Sprints are used to evolve the final product.

· The project is open to the environment until the Closure phase. The deliverable can
be changed at any time during the Planning and Sprint phases of the project. The
project remains open to environmental complexity, including competitive, time,
quality, and financial pressures, throughout these phases.

· The deliverable is determined during the project based on the environment.

SCRUM has the following groups of phases:
1.Pregame
· Planning : Definition of a new release based on currently known backlog, along with
an estimate of its schedule and cost. If a new system is being developed, this phase
consists of both conceptualization and analysis. If an existing system is being
enhanced, this phase consists of limited analysis.

· Architecture : Design how the backlog items will be implemented. This phase
includes system architecture modification and high level design.

2.Game

· Development Sprints : Development of new release functionality, with constant
respect to the variables of time, requirements, quality, cost, and competition.
. Interaction with these variables defines the end of this phase. There are multiple,
iterative development sprints, or cycles, that are used to evolve the system.

3.Postgame

Closure : Preparation for release, including final documentation, pre-release staged
testing, and release.

Phase Steps
Each of the phases has the following steps:
1.Planning

· Development of a comprehensive backlog list.
· Definition of the delivery date and functionality of one or more releases.
· Selection of the release most appropriate for immediate development.
· Mapping of product packets (objects) for backlog items in the selected release.
· Definition of project team(s) for the building of the new release.
· Assessment of risk and appropriate risk controls.
· Review and possible adjustment of backlog items and packets.
· Validation or reselection of development tools and infrastructure.
· Estimation of release cost, including development, collateral material, marketing,
training, and rollout.
· Verification of management approval and funding.

2. Architecture/High Level Design

· Review assigned backlog items.
· Identify changes necessary to implement backlog items.
· Perform domain analysis to the extent required to build, enhance, or update the
domain models to reflect the new system context and requirements.
· Refine the system architecture to support the new context and requirements.
· Identify any problems or issues in developing or implementing the changes
· Design review meeting, each team presenting approach and changes to implement
each backlog item. Reassign changes as required.

3. Development (Sprint)

The Development phase is an iterative cycle of development work. The management
determines that time, competition, quality, or functionality are met, iterations are
completed and the closure phase occurs. This approach is also known as Concurrent
Engineering. Development consists of the following macro processes :
· Meeting with teams to review release plans.
· Distribution, review and adjustment of the standards with which the product will
conform.
· Iterative Sprints, until the product is deemed ready for distribution.

A Sprint is a set of development activities conducted over a pre-defined period, usually
one to four weeks. The interval is based on product complexity, risk assessment, and
degree of oversight desired. Sprint speed and intensity are driven by the selected duration
of the Sprint. Risk is assessed continuously and adequate risk controls and responses put
in place. Each Sprint consists of one or more teams performing the following:
· Develop: Defining changes needed for the implementation of backlog requirements
into packets, opening the packets, performing domain analysis, designing,
developing, implementing, testing, and documenting the changes. Development
consists of the micro process of discovery, invention, and implementation.
· Wrap: Closing the packets, creating a executable version of changes and how they
implement backlog requirements.
· Review: All teams meeting to present work and review progress, raising and
resolving issues and problems, adding new backlog items. Risk is reviewed and
appropriate responses defined.
· Adjust: Consolidating the information gathered from the review meeting into affected
packets, including different look and feel and new properties.
Each Sprint is followed by a review, whose characteristics are :
· The whole team and product management are present and participate.
· The review can include customers, sales, marketing and others.
· Review covers functional, executable systems that encompass the objects assigned to
that team and include the changes made to implement the backlog items.
· The way backlog items are implemented by changes may be changed based on the
review.
· New backlog items may be introduced and assigned to teams as part of the review,
changing the content and direction of deliverables.
· The time of the next review is determined based on progress and complexity. The
Sprints usually have a duration of 1 to 4 weeks.
4. Closure
When the management team feels that the variables of time, competition, requirements,
cost, and quality concur for a new release to occur, they declare the release “closed” and
enter this phase. This phase prepares the developed product for general release.
Integration, system test, user documentation, training material preparation, and marketing
material preparation are among closure tasks.