Agile Software Development Lecture 5

Study Notes

Rapid development is critical due to fast-changing business requirements, necessitating quick adaptation of software.
Traditional plan-driven development is insufficient to meet these dynamic business needs.
Agile development methods emerged in the late 1990s to significantly reduce software delivery timelines.

Interleaved processes for specification, design, implementation, and testing enhance flexibility.
Development occurs in increments, with stakeholder involvement in defining and evaluating each version.
Frequent version delivery supports continuous feedback and improvement.
Minimal documentation is prioritized, focusing predominantly on functional code.

Plan-driven development follows a structured sequential approach with predefined outputs at each stage, allowing for iterative progress.
Agile development leverages ongoing negotiation for outputs throughout the development phase, enabling adaptability.

Emerged from dissatisfaction with rigid software design practices of the 1980s and 1990s.
Emphasizes coding over formal design, utilizing an iterative approach for rapid software evolution.

A prominent agile methodology introduced in the late 1990s featuring several key practices.
XP encourages frequent iterations, potentially building new versions several times daily and delivering every two weeks.
Each build relies on successful execution of all tests to ensure quality.

Incremental Planning: Requirements are documented on story cards, prioritized by urgency and available time, transforming them into actionable development tasks.
Small Releases: Focuses on delivering a minimal viable product first, incrementally adding functionality in subsequent releases.
Simple Design: Aims to maintain only necessary design elements that meet current needs, avoiding complexity.
Test-First Development: Incorporates writing automated tests before implementing code, prompting requirement clarification.
Refactoring: Encourages ongoing code improvements to enhance maintainability and simplify future changes.

Pair Programming: Promotes collaboration, with two developers working together to enhance code quality and accountability.
Collective Ownership: Ensures all developers contribute to all code areas, preventing knowledge silos and encouraging shared responsibility.
Continuous Integration: Integrates completed tasks into the main system immediately after development, ensuring all unit tests pass.
Sustainable Pace: Avoids excessive overtime to protect code quality and productivity.
On-Site Customer: Involves a customer representative in the development team for immediate feedback and requirements clarification.

Incremental development allows for regular system updates.
Customer engagement is vital, facilitating team alignment with user needs.
Emphasis on people and relationships over processes through collaborative coding practices.
Supports change management with regular releases, simplifying code through consistent refactoring.

Customer-driven, user requirements are articulated as user stories that shape task breakdown and project estimation.
Prioritization of user stories directs the focus for the next development cycle, ensuring alignment with business needs.

Promotes continual improvement of code structure to ease future modifications, opposing traditional anticipatory design.
Enhances functionality understandability, thereby reducing reliance on extensive documentation.

Testing is integral to the XP framework, where tests are developed prior to coding to clarify required functionality.
Automated test harnesses ensure every new release is validated against previous and new functionality to prevent regression errors.

Difficulty in creating comprehensive tests, particularly for complex user interfaces.
Potential programmer resistance to prioritizing testing over coding, risking incomplete test coverage.

Pair programming cultivates shared ownership of code, spreads expertise among team members, and promotes quality assurance through collaborative effort.