Scrum is an iterative, incremental methodology for project management often seen in agile software development, a type of software engineering.
Although Scrum was intended for management of software development projects, it can be used to run software maintenance teams, or as a general project/program management approach.
Over the course of time the development life-cycle has evolved. Many approaches have been used for this process, with varying degrees of success. Most traditional development models fail at some point to address the fundamental issues faced by software development teams. Traditional development process first were designed around the Waterfall Process. This process was not very flexible, and required a significant amount of planning to execute.
The process would look something like this:
- Requirements Gathering
- Design / Specification
- Functional Development
While this process seemed to fit the basic needs for software, the process was long and drawn out. Often the specifications or application needs would change during the process, and development teams would find it difficult or in some cases impossible to change the course of development to meet these changes.
The basic need for any software development team has not changed. Teams needed to be able to deliver software to users. In addition, teams needed to be able to adapt to changes in specifications or user needs. Many approaches have been tried to address this need. The most successful approach has been an approach called Agile. The Agile approach is a highly effective means to deliver software to the users and still remain flexible enough to change directions as specification and priorities change. The code, or manifesto, for this methodology is stated like this:
Individuals and interactions – processes and tools
Working software – comprehensive documentation
Customer collaboration – contract negotiation
Responding to change – following a plan
That is, while there is value in the items on the right, we value the items on the left more. The Agile principals can be stated like this:
- Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
- Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
- Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
- Business people and developers must work together daily throughout the project.
- Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
- The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
- Working software is the primary measure of progress.
- Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
- Continuous attention to technical excellence and good design enhances agility.
- Simplicity–the art of maximizing the amount of work not done–is essential.
- The best architectures, requirements, and designs emerge from self-organizing teams.
- At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
So how do we put all of this into action? First let’s look at the Scrum Team. Each team should be comprised of 3-9 cross-functional members. Members of the team should be from the various groups normally involved with typical software developmental cycles; these could include development, testing, design, implementation, etc.
Next time we will examine the roles of team members, and how they work together to make this process flow…
Next Up [Agile Part 2: The Pigs & Chickens]