CSC/ECE 517 Fall 2009/wiki3 11 j8

From Expertiza_Wiki
Jump to navigation Jump to search

Agile Development

Agile development is a relatively new software development method that is becoming increasingly popular in the software industry. These methods promote smaller development iterations and much quicker stable builds of a product. Typically iterations can last between one and three weeks, compared with a normal 9 month or longer waterfall model.

There are many different agile methodologies, the most popular of which Extreme Programing. This page attempts to compare the different agile methods with that of Extreme Programming.


Extreme Programming (XP)

Several types of documentation are used for planning and design purposes:

  • User story cards
  • Task List
  • CRC Cards
  • Customer Acceptance Tests
  • Visible Wall Graphs

Also there are may different roles that individuals of the team may take, of which someone may take more than one role.

  • Manager - Manages the team and its resources.
  • Coach - Ensures everyone is following the extreme program guidelines, usually a programmer.
  • Tracker - One of the programmers, puts together wall charts and progress tracking.
  • Programmer
  • Tester - Assists in writing tests with the customer and running the tests.
  • Customer - Writes acceptance tests and user stories for the development team.

There are 13 goals and practices of extreme programming:

  • Sitting together - The entire team sits in an open space
  • Whole team - Include everyone necessary to success.
  • Informative workspace - Include signs around the workspace to indicate progress.
  • Energized Work - Do not overextend members for a long period of time.
  • Pair programming
  • Stories (User stories) - Small statements of functionality ordered in priority by the customer.
  • Weekly cycle - At the beginning of the week the customer picks stories to complete during that week
  • Quarterly Cycle - Each yearly quarter should focus on a 'theme' or stories.
  • Slack - Lower priority stories that can be dropped if time is limited.
  • Ten-minute build - Ensure the project and its tests can be built and run within 10 minutes.
  • Test-first - Every story should have an acceptance test.
  • Continuous Integration - Code should be checked in several times a day, with unit tests being run all the time.
  • Incremental Design - Design daily at each step.

There are also 11 secondary practices which are considered somewhat optional. These will not be discussed here.


Adaptive Software Development (ASD)

Adaptive Software Development places a strong emphasis on dynamic programming languages. It features a three phased cycle of:

  • Speculate - Instead of 'planning', the term speculate is used due to the nature that planning cannot account of all things and many things may be incorrect.
  • Collaborate - Balancing the certain parts of planning with those that are uncertain.
  • Learn - The design/build/test cycle.

Scrum

Scrum utilizes two to four week iterations called 'sprints'. Within each of these a set of user stores are designed, developed, and tested.

Places emphasis on different roles (Chicken/Pig) 

 Scrum Master - Runs daily scrum meetings
 Product Owner - The 'customer' who comes up with user stories.
 Developer - Tester or programmer who does the work during the sprints.
  • Daily scrum meetings - 15 minutes meeting where developers answer three questions:
    • What have you done since the last Scrum?
    • What will you do between now and the next Scrum?
    • What got in your way of doing work?
  • Sprint review (at end of sprint) - Review the stories that were completed during the sprint, usually a demonstration is performed.
  • Sprint retrospective (at end of sprint) - Discuss how the sprint went, areas for improvement.
  • Spring planning meeting (at beginning of sprint) - Gather user stories to complete during the sprint.

Items

  • Product Backlog - A collection of user stories that make up what can be added to a sprint.
  • Sprint Backlog - The user stories that will be done during the sprint.
  • Burndown Chart - A chart displaying the amount of work left in the current sprint.



Crystal

Crystal methodologies are a range of methodologies that consist of varying degrees of agile development, for example Crystal Clear is the most agile and Crystal Red is the least. These different sub-methodologies are designed to accommodate different team sizes as well. Crystal Clear for example, is to be used with eight developers or less and should have incremental releases of at most every four months. Crystal Orange is designed to be used with twenty to fourty developers and should have a duration of no longer than two years.

All Crystal methodologies try to ensure three things:

  • Safety (in project outcome)
  • Efficiency
  • Habitability (ensure that developers are happy with the process)


Feature Drive Development (FDD)

Model-driven short-iteration process composed of 5 activities. Generally each iteration lasts two weeks.

Roles:

  • Project Manager - Administrative lead. Manages resources.
  • Chief Architect - Manages the overall design of the project.
  • Development Manager - Leads normal daily activities.
  • Chief Programmer - Guides and mentors other programmers.
  • Class Owner - Responsible for designing and coding certain 'areas' that he or she is responsible for.
  • Domain Experts - Anyone who has expert knowledge of the market the system is being designed for.
  • Feature teams - Groups of programmers formed temporarily to work on a particular aspect of the project.

Activities:

  • Develop Overall Model - Walkthroughs of different models are done and presented for peer review.
  • Build Feature List - The result of the modeling stage is used to gather a list of features. Domain is split into subject areas which contain business activities. Max feature time is two weeks.
  • Plan by Feature - development plan from feature list
  • Design by Feature - A set of features that can be done in two weeks is selected. The design is done at the class level.
  • Build by features - each of the selected features is built. Unit tests and code inspection a must.

Typically each feature is tracked individually and a "Burn Up" chart is kept to keep track of the different features for each iteration.


Lean Software Development (LSD)

This methodology consists of the following principles:

  • Eliminate Waste - eliminate everything that is not adding value for the customer
  • Amplify learning - Techniques to increase learning and improve the software
    • Write tests as soon as code (to be tested) is written.
    • Instead of detailed planning, code different techniques and try them out
  • Decide as Last as possible - Decision should be delayed as long as possible
  • Deliver as fast as possible - The shorter the iteration the quicker the delivery to the customer and the more feedback the developer receives.
  • Empower the team - The managers should be listening to the developers for decision. If developers are consulted, they feel empowered.
  • Build Integrity In - Refactor often. This improves the code base and long term maintainability. Keep the feature set at a minimum.
  • See The Whole - While tasks are small and compartmentalized, the project needs to be thought of as a whole with all the pieces interacting.

This method also features a morning standing meeting.

Agile Modeling (AM)

A supplement to other Agile methodologies, it is a collection of values and principles for modeling software specifically designed to be used in agile software development, typically replacing UML.

Since this is not really a stand alone method in and of itself, it will not be discussed in great detail.

Agile Unified Process (AUP)

A simplified agile version of Rational Unified Process (RUP).

Composed of four phases:

  • Inception - identify the scope of the project, a potential architecture, and get the initial resources and acceptance.
  • Elaboration - Prove the architecture.
  • Construction. Create functional software on an incremental time frame which completes the highest priority features as designated by the stakeholders.
  • Transition - Deploy the new system to production and validate its effectiveness.

Major Differences

All of these methodologies are very similar and you have to look very close to spot the differences aside from nomenclature. Generally the only differences from any of these methods are the lengths of the iteration. Each method also generally emphasises some aspect of software development that the others do not. For example, Extreme Programming places an emphasis on paired programming and CRC cards, while none of the others do so. This does not mean you cannot use these techniques with the other methods, they simply do not place an emphasis on them.

Also some of them introduce a daily status meeting while others do not. Overall it is somewhat difficult to spot too many differences between the methods.

Definitions

  • Agile development - A group of software development methodologies that focus on rapid iterative development allowing for development to more quickly respond to changing requirements.
  • Chicken/Pig philosophy - In software development there are two kinda of roles, chickens and pigs. Chickens are involved in the project and contribute to it, but pigs require a total sacrifice.
  • CRC (Class-Responsibility-Collaboration) Cards - A software design methodology where Objects and their interactions are written onto small index cards.

References

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2009/wiki3_11_j8&oldid=29854"