Agile Methodologies in Software Development

Agile Software Development

Agile development prioritizes rapid development and delivery, focusing on iterative development and adapting to changing requirements.
Stable software requirements are difficult to maintain in a fast-changing environment.
For safety-critical systems, plan-driven approaches are preferred.
Agile methods are more suitable for business systems needing rapid adaptability.
Agile methods focus on producing useful software quickly iteratively.

Key Characteristics of Agile

Interleaved Processes: Specification, design, and implementation occur simultaneously with minimal detailed documentation.
Incremental Development: The software is developed in increments with ongoing input and feedback from stakeholders for adaptation to changing needs
Extensive Tool Support: Automated testing, configuration management, integration, and UI production tools aid in the rapid development process.

Agile Methods

Agile methods are a form of incremental development, releasing software in small frequent updates (typically twice a week ).
The approach emphasizes close customer involvement for rapid feedback.
Agile minimizes formal documentation in favor of informal communication and meetings.
Design and implementation are central, integrating activities like requirements elicitation and testing.
Plan-driven approaches follow distinct stages with specific outputs for subsequent activities—Agile approaches prioritize iteration and concurrent activities.

Agile Methods (Continued)

Plan-Driven Approaches: Iteration occurs within individual stages (e.g., requirements, design, implementation) with formal documents guiding their transitions.
Agile Approaches: Iteration occurs across activities like requirements and design—development happens concurrently rather than sequentially.

Agile Manifesto

Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

Principles of Agile Methods

Customer Involvement: Customers are involved throughout the development process— their role is to identify and prioritize new system requirements.
Embrace Change: The system's design should be adaptable to changing requirements.
Incremental Delivery: Software is developed in increments, reflecting changing customer needs.
Maintain Simplicity: Focus on simplicity in the developed software and the development process to avoid complexity.
People over Process: Recognize and exploit the skills of the team, allowing them to develop their ways of working without prescriptive processes.

Agile Method Applicability

Product Development: Agile approaches are standard practice for smaller and medium-sized product development companies.
Custom System Development: Agile methods are suited for custom systems where customer involvement is high and there are fewer external constraints.

Problems with Agile Methods

Customer Engagement: Keeping customers engaged throughout the process can be difficult for some.
Team Suitability: Agile methodologies demand intense collaboration and involvement.
Prioritization of Changes: Prioritizing changes can be complex when dealing with various stakeholders, different priorities, and needs.
Maintaining Simplicity: Maintaining simplicity requires continuous effort on the part of teams.
Contractual Issues: Traditionally, contracts assume a fixed scope. The flexible nature of Agile can complicate contract management for some.

Technical, Human, and Organizational Issues

Detail Requirements: Detailed specification and design may be crucial for some projects, necessitating a plan-driven approach.
Feedback & Delivery: Agile methods work well with rapid feedback and incremental delivery.
System Size: Agile methods are suitable for smaller teams. Larger systems might need more extensive (Plan-Driven) teams with significant planning and documentation.
System Type: Plan-driven approaches are preferred in real-time systems with critical requirements involving deep analysis.
System Lifetime: Long-lifetime systems might require detailed design documentation as they continue to develop over time.
Technology: Agile heavily relies on tools for managing evolving designs.
Team Organization: Distributed teams or outsourced development may require detailed documentation to coordinate tasks effectively.
Cultural Issues: Traditional engineering cultures might favor plan-based methods rather than Agile ones.
Team Skills: Agile development might require higher skill levels compared with plan-driven approaches.
Regulation: Systems with external regulatory requirements may demand highly detailed documentation.

Extreme Programming (XP)

Often considered one of the best-known and widely adopted agile methods.
Iterative development approach designed to enhance customer satisfaction.
Frequent Builds: Creating regular new releases of the software.
Regular Deliveries: Frequent delivery and feedback from the client.
Rigorous Testing: Rigorous testing at each build is crucial for quality assurance.

XP and Agile Principles

Incremental Development: Small, frequent releases of the system with ongoing feedback and adaptation.
Customer Involvement: Continuous engagement from the client to ensure the system meets user needs.
People and Team Dynamics: Practices for maintaining good team dynamics and productivity like pair programming. ( Pair Programming: Two developers work together at one workstation)
Collective Ownership: Shared responsibility among team members for the codebase and a broad reach of knowledge across the team..
Avoiding Long Hours: Fostering practices that reduce burnout and support team productivity.
Support for Change: Regularly releasing incremental updates to allow adaptability to meet client needs.
Maintaining Simplicity: Consistent refactoring maintains code readability, quality, and maintainability.

The Extreme Programming Release Cycle

Select user stories for the release.
Break down stories into tasks.
Plan the release.
Develop/integrate/test the software.
Release the software.
Evaluate the system.

XP Practices

Collective Ownership: Team members share responsibility for the entire codebase.
Continuous Integration: Integrating the codebase into the system immediately once the work is complete.
Incremental Planning: Requirements are tracked as ‘stories‘ that are broken down into development ‘tasks’ that are planned in the right order.
On-site Customer: The customer is actively involved in the development process often in a collaborative way.
Pair programming
Refactoring: Continuous code improvement after implementation.
Simple Design: Simple design that meets the current needs only—not over-designing for future scenarios.
Small Releases: Delivering small releases frequently.
Sustainable Pace: Maintaining productivity and avoiding excessive overwork.
Test First Development: Writing tests before the actual code which helps provide detailed requirements and tests for functionality.

Requirements Scenarios in XP

Customer Involvement: Customers have a key role in defining and prioritizing requirements.
User Stories: Requirements are articulated as brief descriptions of interactions.
Story Cards and Task Breakdown: User stories are used to guide scheduling and cost estimation.
Prioritization and Scheduling: The team and customer priorities user stories and schedules deadlines.

Scrum

Scrum is a general agile method focusing on iterative development management.
Initial Phase: Establishing project objectives, creating a foundation design for the architecture—outlining planning and architectural design
Sprint Cycles: Iterative cycles for developing and delivering system increments.
Project Closure Phase: Finalizing project deliverables and documentation.

Scrum Framework Overview

Key Roles:
- Product Owner: Defines and prioritizes product backlog items.
- Scrum Master: Facilitates the Scrum process and removes impediments.
- Development Team: Self-organizing team responsible for delivering increments within sprints..
Artifacts:
- Product Backlog: Prioritized list of product features, enhancements, and fixes.
- Sprint Backlog: Tasks selected by the development team for completion within a Sprint.
- Increment: Completed increments from previous sprints and the current sprint work combine to form the ‘increment’.

Scrum Events

Sprint: Time-boxed iteration (usually 2-4 weeks).
Sprint Planning: Team plans the work for the Sprint.
Daily Scrum: Brief daily meeting for synchronization and progress discussion.
Sprint Review: Presenting completed work to stakeholders and getting input.
Sprint Retrospective: Reflecting on and improving the Sprint process

Scrum Benefits

Manageable Chunks: Tasks are subdivided into manageable pieces.
Adaptability to Change: Changes are incorporated into each sprint, supporting iterative and rapid adaptation.
Improved Communication: Team has visibility and regular updates which improve and facilitate collaboration.
Customer Engagement: On-time deliverables and continuous customer feedback to align work with requirements.
Trust and Culture: Fostering trust and alignment through frequent feedback, review, and feedback.

Scaling Agile Methods

Scaling Agile methods involve adapting techniques to manage larger projects, multiple teams and dispersed employees.
Successful for smaller projects where communication and face-to-face work is effective.
Larger contexts with more complexity involve coordination of work across multiple teams with geographically dispersed locations requiring different agile methods for success.
Communication and adaptation are crucial elements in scaling agile methods, especially in larger contexts.
Maintaining agile fundamentals like flexible planning, frequent releases, and continuous integration in larger contexts requires a focus on up-front planning and documentation to manage larger systems effectively.

Large Systems Development

Multiple Teams/Locations: Large systems often involve separate interacting teams spread across different locations and time zones.
Brownfield Systems: Systems often already interact with other existing systems and processes, making modifications harder.
System Configuration: Integrating with existing systems and processes, resulting in much of the work being around configuration changes.
Extended Development/Time: Longer development cycles lead to potential personnel changes over time.
Diverse Stakeholders: Engaging all stakeholders and managing their concerns involves many complexities.

Scaling Out and Scaling Up

Scaling Up: Applying agile principles to the development of larger projects across bigger teams and multiple locations and time zones—typically involves adapting existing agile processes, tools, and project management practices.
Scaling Out: Implementing agile methodologies throughout an organization, usually an enterprise or large company, rather than a single project. Involves implementing agile principles and practices across the entire organization to improve processes, and communication across different departments and teams within an organization, rather than just across a single project.

XP Testing Difficulties

Programmer Preferences: Testing can be less prioritized than writing code.
Complex Testing: Testing complex features and user interfaces can be difficult and rigorous.
Test Coverage: Ensure that all features, scenarios, and edge cases are tested adequately.

Pair Programming

Two programmers work together at a single workstation.
Dynamic Pairs: Ensure team members interact throughout the process.
Encourages Refactoring: Shared work fosters ongoing refinement.
Enhances Productivity: Studies suggest pair programming can be more productive than independent work.
Promotes Knowledge Sharing: It facilitates knowledge transfer and avoids information siloes.

Advantages of Pair Programming

Supports collective ownership of the codebase.
Facilitates continuous testing and review.
Pairs are supported in making continuous improvement to code.

Prescribing Medication Story

Kate (Doctor) can prescribe medication for patients.
She can select existing medication or new ones from the formulary.
The system checks that the dose is within the approved range.
The system records the prescription and options for changes are available.

Examples of Task Cards for Prescribing Medication

Task 1: Change Dose of Prescribed Drug Changes or adds medication dosages.
Task 2: Formulary Selection Selects a medication from a database.
Task 3: Dose Checking Checks the selected dose against the formulary's recommended maximum and minimum.

Refactoring

Refactoring is the process of restructuring existing code without changing its external behavior.
Making systematic improvements to the code, improving code structure, readability, and maintainability over time.
Continuously improving the code—not just when a problem is encountered.

Testing in XP

Test-First Development: Writing tests before writing the code, ensuring requirements are comprehensive.
Incremental Test Development: Develop unit tests that work against each implementation task.
User Involvement: Including users in the testing process for feedback and validation.
Automated Test Harnesses: Automated test setups, testing regularly with each new increment build.

Test Automation

Automating test execution through frameworks speeds up development and validation and provides a consistent set of tests immediately available.
This method helps writing tests as components that are executed independently to quickly validate functionality after changes.