Lec5 – Agile Software Development

Rapid development and delivery are crucial due to fast-changing business requirements.
Stable software requirements are difficult to produce in dynamic environments.
Agile development methods were introduced in the late 1990s to drastically reduce software delivery times.

Integrates program specification, design, and implementation into one continuous process.
Development proceeds through versions or increments, with stakeholder collaboration in version evaluation.
Emphasizes frequent delivery of new versions for user feedback.
Utilizes extensive tools like automated testing to support development efforts.
Focuses on producing working code with minimal documentation.

Plan-driven development involves distinct stages with pre-determined outputs; can be incremental.
Agile methodologies support an interleaved approach where specification, design, implementation, and testing happen simultaneously through negotiation.

Emerged in response to the inefficiencies of software design approaches in the 1980s-1990s.
Focuses on delivering working software quickly, adapting to changing requirements with minimal documentation.

Customer Involvement: Stakeholders are actively engaged throughout the development lifecycle.
Incremental Delivery: Software is built in increments, with customer-defined requirements for each.
People over Process: Teams can determine their own ways of working.
Embrace Change: Systems are designed to accommodate evolving requirements.
Maintain Simplicity: Focus on simplifying both software and processes, aiming to eliminate unnecessary complexity.

Well-suited for product development in small and medium-sized enterprises; almost all software products now utilize agile methodologies.
Ideal for custom system development in organizations ready to engage with agile practices.

Developed in the late 1990s, XP significantly influences agile methodologies with a focus on iterative development.
Features rapid release cycles, with updates delivered to customers bi-weekly.
Requires passing all automated tests for new builds to ensure quality control.

Incremental Planning: Prioritizes requirements via story cards, determining releases based on urgency and importance.
Small Releases: Focuses on delivering the minimum viable product initially and builds upon it incrementally.
Simple Design: Limits design efforts to current needs to maintain simplicity.
Test-First Development: Tests are created prior to functionality implementation.
Refactoring: Continuous improvement of code to enhance maintainability and readability.

Pair Programming: Developers work in pairs to ensure code quality and mutual support.
Collective Ownership: All team members are responsible for all areas of the codebase, preventing knowledge silos.
Continuous Integration: New code integrates into the main system as soon as completion, with all unit tests passing post-integration.
Sustainable Pace: Discourages excessive overtime to maintain code quality and productivity.
On-site Customer: Involves a customer representative full-time to clarify requirements and priorities.

User stories articulate requirements as narratives.
Developers convert user stories into manageable tasks, informing schedule and cost estimates.
The customer prioritizes which stories to include based on business value.

Advocates for continuous improvement of code structure to prepare for future changes.
Enhances code clarity, reducing the necessity for heavy documentation.
Ensures code remains adaptable and easier to modify.

Testing is integrated into each phase, with a focus on test-first approaches.
Automated tests confirm the correctness of new features and detect regression issues with each build.
Relies on frameworks like JUnit for executing automated tests efficiently.