Agile Development Principles Quiz

Course Content

• CSE241/CMM341 Foundations of Software Engineering
• Topic 3: Agile Software Development
  • Agile Methods
  • Agile Development Techniques
  • Agile Project Management
  • Scaling Agile Methods

Learning Outcomes

• Understand the rationale for agile software development methods, the agile manifesto, and the differences between agile and plan-driven development
• Know about important agile development practices such as user stories, refactoring, pair programming and test-first development
• Understand the Scrum approach to agile project management
• Understand the issues of scaling agile development methods and combining agile approaches with plan-driven approaches in the development of large software systems

Categorization of Software Processes

• Plan-driven processes

  • all of the process activities are planned in advance
  • progress is measured against the plan

• Agile processes

  • planning is incremental
  • easier to change the process to reflect changing customer requirements

Rapid Software Development

• Rapid development and delivery is now often the most important requirement for software systems
• Businesses operate in a fast changing requirement and it is practically impossible to produce a set of stable software requirements
• Software changes to reflect business needs quickly

Agile Methods Characteristics

• no detailed system specification
• design documentation is minimized or generated automatically by the programming environment
• user requirements document: an outline definition of the most important characteristics of the system
• the processes of specification, design, and implementation are interleaved
• the system is developed in a series of increments
• end-users and other system stakeholders are involved in specifying and evaluating each increment
• proposed changes to the software and new requirements should be implemented in a later version of the system
• extensive tool support is used to support the development process (automated testing tools, tools to support configuration management and system integration, tools to automate user interface production)

Plan-Based vs Agile Development

• Plan-based development:
  • Requirements engineering -> Requirements specification -> Design and implementation
  • Requirements change requests are processed after
• Agile development:
  • Requirements engineering -> Design and implementation -> Requirements change requests

Agile methods

• Dissatisfaction with the overheads involved in software design methods of the 1980s and 1990s led to the creation of agile methods
• Focus on the code rather than the design
• Based on an iterative approach to software development
• Intended to deliver working software quickly and evolve requirements

Agile Manifesto

• Value individuals and interactions over processes and tools
• Value working software over comprehensive documentation
• Value customer collaboration over contract negotiation
• Value responding to change over following a plan

The Principles of Agile Methods

• Customer Involvement: Customers should be closely involved throughout the development process
• Incremental Delivery: Software is developed in increments with requirements specified for each increment.
• People not process: The skills of the development team should be recognized and exploited
• Embrace Change: Expect system requirements to change and design the system to accommodate these changes
• Maintain simplicity: Focus on simplicity in both the software and the development process

Agile Method Applicability

• Product development for small or medium-sized products for sale
• Custom system development within an organization with clear commitment from customer to be involved in development

Extreme Programming

• A very influential agile method, developed in the late 1990s, that introduced a range of agile development techniques
• Extreme Programming (XP) takes an 'extreme' approach to iterative development
• New versions may be built several times per day
• Increments delivered to customers every 2 weeks
• All tests must be run for every build and the build is only accepted if tests successfully run.

Extreme Programming Release Cycle

• Select user stories for this release
• Break down stories to tasks
• Plan release
• Develop/integrate/test software
• Release software
• Evaluate system

Extreme Programming Practices

• Incremental planning: Requirements are recorded, relative priority determined by time available
• Small releases: Minimal useful functionality to be developed first in frequent incremental releases
• Simple design: Enough design to meet present requirements but no more
• Test-first development: Automated unit tests for new functionality before implementation
• Refactoring: Continuous code improvement to make changes easier
• Pair programming: Developers work in pairs, checking each other's work and always doing a good job
• Collective ownership: All developers take responsibility for the whole code; anyone can change anything
• Continuous integration: Integration into entire system as soon as task is complete. All tests must pass after integration
• Sustainable pace: Large amounts of overtime not acceptable

Test-driven development

• Writing tests before code is developed
• Tests written as executable programs
• The tests should check that the code worked correctly
• Relies on testing framework (e.g. Junit)
• All previous and new tests run after every new functionality

Customer Involvement in TDD

• Help develop acceptance tests that will be implemented in the next release of the system
• Write tests along with team
• Validate all new code to meet customer needs (note: customer may have limited time)

Test Automation

• Essential for test-first development
• Tests written as executable components before implementation
• Testing Components stand-alone
• Simulates input to be tested
• Checking output meets specification
• Automated tests use frameworks to make it easy (like Junit)

Problems with Test-First Development

• Programmers prefer programming to testing
• Short-cuts on testing process
• Tests might be incomplete if not all possible exceptions are checked
• Tests difficult to write incrementally (with workflow)
• Difficult to judge the completeness of tested components

Pair Programming

• Programmers sit together at the same computer to develop the software
• Pairs are created dynamically, so all team members work with each other during the development process
• Sharing knowledge during pair programming reduces overall risk when team members leave

Agile Project Management

• Project managers responsible for delivering the software on time and within the budget
• Agile project management requires an approach that is adapted to incremental development and practices used in agile methods

Scrum Terminologies

• Development team: A self-organizing group of software developers with a maximum of 7 members
• Potentially shippable increment: The software increment that is delivered from a sprint, ready for delivery
• Product backlog: A list of 'to do' items to be tackled by Scrum Team
• Product owner: Identifies product features/requirements, prioritizes them for development and continuously reviews product backlog to meet business needs
• Scrum: A daily meeting to review progress and prioritize work
• Scrum Master: Responsible for ensuring Scrum process is followed, and guides the team on the effective use of Scrum
• Sprint: Development iteration (2-4 weeks long)
• Velocity: Estimate of how much a team can cover in a single sprint.

Scrum sprint cycle

• Review work to be done
• Select items
• Plan sprint
• Sprint
• Review sprint
• Potentially shippable software

Scrum Benefits

• Product broken into manageable chunks
• Unstable requirements don't halt progress
• Improved communication and teamwork
• On-time delivery of increments, feedback on product

Distributed Scrum

• Videoconferencing between product owner and development team.
• The Scrum Master is located with the development team
• The product owner visits developers to establish good relationships
• Continuous integration, so all team members can be aware of state of the product at any time
• Real-time communications for informal communication

Scaling agile methods

• Agile methods are successful for small and medium co-located teams
• Improved communications are a factor in successful agile approaches

Scaling up and Scaling out

• Scaling up: Using agile methods for large software systems that cannot be developed by a small team
• Scaling out: Introducing agile methods for larger teams and organizations

Practical Problems with Agile Methods

• Informality of agile development is incompatible with legal contracts
• Agile methods best suited for new development, not maintenance
• Agile methods designed for small co-located teams, but many developments are worldwide

Contractual issues

• Most software contracts are based around a specification, specifying what has to be implemented
• This prevents interleaving specification and development, which is common in agile development
• Contracts should pay for functionality, not time, but this is a high risk for legal departments

Agile methods and software maintenance

• Most organizations spend more maintaining existing software than developing new software
• Agile approach has to support maintenance as well as original development

Agile maintenance

• Lack of product documentation
• Keeping customers involved
• Maintaining continuity of development team

Agile vs. plan-driven methods

• Is a detailed specification needed before implementation? If yes, plan-driven. If no, agile.
• Is an incremental delivery realistic? If yes, agile. If no, plan-driven.
• How large is the system? If small, co-located team with informal communication, agile. If not, plan-driven.

Agile principles and organizational practice

• Customer involvement: Depends on customer availability
• Embrace change: Prioritizing changes can be difficult
• Incremental delivery: Rapid iterations may not fit with longer-term plans
• Maintain simplicity: Teams may not have time to simplify
• People not process: Team members may not have suitable personalities for intense involvement

System issues

• Size of the system (Agile best for smaller systems)
• System type (Some require extensive analysis and design)
• System lifetime (Longer lifecycles require documentation)
• External Regulation/Compliance

People and teams

• Programmer skill levels (Agile likely needs higher skill levels)
• Development team organization (Distributed team might need design documents)
• Available Support technologies (IDE support for visualization and analysis needed)

Organizational Issues

• Traditional organizational culture (Plan-based approach is common in traditional organizations)
• Customer availability (Customers may not have time for feedback on system increments)
• Organizational practice (Detailed system documentation might be standard)
• Agile integration with existing organizational culture (Informal agile methods might be difficult for organizations with documentation formality)

6 Factors in large systems

• System of systems: Large systems often involve disparate systems
• Brownfield development: Integration with existing systems
• Diverse stakeholders: Handling requirements from many different parties
• Prolonged procurement: Long development times
• Regulatory constraints: Regulations impacting development processes
• System Configuration: Large part of development effort often dealing with system configuration not new code.

Multi-Team Scrum

• Role replication: Each team has a Product Owner and Scrum Master
• Product Architects: Teams select and collaborate on overall system architecture
• Release alignment: Dates of releases from each team are aligned
• Scrum of Scrums: Daily meetings between representatives of different teams

Agile methods across organizations

• Project managers may be reluctant to implement new agile methods
• Large organizations may have established standards incompatible with the agile approach
• Agile may need highly skilled team members and cultures
• Resistance to change in established processes in some organizations

Key points (1/2)

• Agile developed incrementally, emphasis on frequent release of software
• Agile practices: User stories, frequent releases, continuous improvement, test-first development, customer participation

Key points (2/2)

• Scrum is an agile method centred on sprints
• Many practical methods integrate plan-based and agile approaches
• Scaling of agile methods poses challenge for large systems, particularly up-front design, documents, and organizational integration.

Test your knowledge of Agile development principles and practices with this quiz. Explore key concepts like simplicity, iterative development, and extreme programming practices. Perfect for anyone looking to deepen their understanding of Agile methodologies.