Agile Manifesto: Values and Principles

• The Agile Manifesto is a foundational document for the Agile methodology, created in February 2001 at the Snowbird Ski Resort in Utah by a group of software developers.
• It emphasizes flexibility, collaboration, and customer satisfaction through key values and principles.

Agile Manifesto Values:

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

Agile Manifesto Principles:

• Customer satisfaction is achieved through early and continuous delivery of valuable software.
• Changing requirements are welcomed, even late in development, to provide a competitive advantage.
• Deliver working software frequently, with a preference for shorter timescales ( weeks to months).
• Business people and developers must work together daily throughout the project.
• Build projects around motivated individuals by providing them with the necessary environment, support, and trust.
• Face-to-face conversation is considered the most efficient and effective method of conveying information within a development team.
• Working software is the primary measure of progress.
• Agile processes promote sustainable development, allowing sponsors, developers, and users to maintain a constant pace indefinitely.
• Continuous attention to technical excellence and good design enhances agility.
• Simplicity - maximizing the amount of work not done - is essential.
• The best architectures, requirements, and designs emerge from self-organizing teams.
• At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
• The Agile process adapts to change and encourages collaboration, guiding Agile teams in software development.

Agile Process Steps:

• This agile process emphasizes flexibility, collaboration, and customer satisfaction by delivering working software in short, frequent cycles and adapting to changing needs

Backlog Creation and Prioritization:

• Begins with a creating a prioritized list known as a backlog, which includes features, user stories, and tasks.
• The Product Owner manages the backlog, working with stakeholders to define and prioritize items based on business value and customer needs.

Sprint Planning:

• The development team and the Product Owner select a subset of items from the backlog.
• This subset constitutes the work to be performed during the upcoming sprint.
• Sprint planning involves breaking down selected items into smaller tasks.
• Effort estimation and definition of the sprint goal are also part of sprint planning.

Sprint Execution:

• A sprint lasts one to four weeks, during which the development team works on implementing selected items.
• Daily stand-up meetings are held to discuss progress, identify impediments, and plan the day's work.
• Sprint execution focuses on delivering a potentially shippable product increment by the end of the sprint.

Continuous Integration and Testing:

• The development team merges their code changes into a shared repository regularly.
• Automated tests are frequently run to ensure software remains functional and meets acceptance criteria for each user story.

Sprint Review:

• At the end of the sprint, the team conducts a sprint review meeting to demonstrate the completed work to stakeholders.
• Stakeholders provide feedback on delivered product increments.
• Necessary adjustments or changes are also discussed.

Sprint Retrospective:

• The team holds a meeting following the sprint review, intended to reflect on the sprint process
• The retrospective meeting serves to identify opportunities for improvement.
• The meeting's focus is to enhance future sprints by determining what went well and what could be improved.

Repeat:

• The Agile process is iterative where each sprint builds upon the work of previous sprints.
• For each sprint the cycle of backlog refinement, sprint planning, execution, review, and retrospective is repeated.
• This repetition allows the team to adapt to changing requirements while continually delivering value.

Success Factors (Human):

Competence:

• Competence means having the skills, knowledge, and expertise to perform tasks effectively.
• Agile teams need competence to deliver high-quality work and to meet project objectives.
• Skilled team members contribute to the team's success in their respective roles.

Common Focus:

• Common focus occurs team members understand the project's goals, objectives, and priorities.
• A common focus ensures everyone works towards the needed outcomes.
• Teams avoid misunderstandings, conflicts, and wasted effort with a common focus.
• This common focus leads to more efficient and effective collaboration.

Collaboration:

• Involves working together towards a common goal, while also sharing ideas, knowledge, and resources, and supporting each other's efforts.
• Agile methods value collaboration among team members, stakeholders, and customers throughout the development process.
• Effective collaboration leads to improved communication, problem-solving, and decision-making, resulting in high-quality products and customer satisfaction.

Decision-Making Ability:

• Refers to the capacity to make timely and informed decisions based on available information, analysis, and judgment.
• Team members who can evaluate options, weigh risks and benefits, and make decisions aligned with project goals and priorities are beneficial.

Fuzzy Problem-Solving Ability:

• Refers to the capacity to approach complex or ambiguous problems, adapt to uncertainty, and explore creative solutions.
• Agile teams often face unpredictable challenges and changing requirements that require critical thinking, experimentation, and innovation.
• Members with these skills can explore multiple solutions and adapt their approach as needed.

Mutual Trust and Respect:

• Essential for fostering positive relationships, open communication, and collaboration within Agile teams.
• Enables team members to rely on each other, share ideas, and give feedback openly, working together towards common goals.
• Fosters a supportive environment. Respect ensures team members value each other's contributions, perspectives, and expertise.

Self-Organization:

• Refers to the ability of teams to manage their own work, make decisions autonomously, and respond to changing circumstances without external direction.
• Self-organizing teams have the flexibility and responsibility to plan, prioritize, and execute their work collaboratively.
• Promotes autonomy, ownership, and accountability, which leads to higher motivation, productivity, and innovation.

Agile Methodologies:

Extreme Programming (XP):

• Aims to improve software quality and responsiveness to changing customer requirements by focusing on engineering practices.
• XP emphasizes collaboration, feedback, and continuous improvement. Kent Beck in the late 1990s created the XP methology.
• Key features of XP include: -Iterative and Incremental Development: Advocates for small, frequent releases of working software. These iterations run one to two weeks. -Continuous Integration: Encourages integrating code changes into a shared repository multiple times a day. -Test-Driven Development (TDD): Developers write automated tests before writing the corresponding code. -Pair Programming: Developers work in pairs. One writes code while the other reviews and provides feedback. -Continuous Refactoring: Emphasizes continuously improving the design and structure of the codebase through refactoring. -On-Site Customer: Advocates for having a customer representative who works closely with the development team. -Collective Code Ownership: All team members have the responsibility and authority to modify any part of the codebase. -Small Releases: Encourages releasing small increments of working software frequently.

Adaptive Software Development (ASD):

• Focuses on flexibility, adaptability, and responsiveness to change It was developed by Jim Highsmith and Sam Bayer in the late 1990s.
• It emphasizes iteration, collaboration, and learning throughout the development process.
• Key principles and practices of ASD include: -Speculation: Begins with a speculative phase where high-level goals and objectives are identified, and initial plans are developed. -Collaboration: ASD promotes close collaboration between stakeholders, including customers, end-users, and development teams. -Learning: ASD embraces a learning-oriented mindset where experimentation, feedback, and reflection are valued. -Iterative Development: ASD advocates for iterative and incremental development, where the project is broken down into small, manageable increments. -Risk Management: ASD emphasizes the importance of identifying and managing risks throughout the development process. -Adaptive Planning: ASD promotes adaptive planning, where plans are viewed as dynamic documents that can evolve.

Dynamic Systems Development Method (DSDM):

• Primarily used for software development projects. It was initially developed in the 1990s in the UK as a framework for rapid application development (RAD).
• Key characteristics and principles of DSDM include: -User Involvement: DSDM emphasizes the active involvement of end-users throughout the development process. -Iterative and Incremental Development: DSDM advocates for iterative and incremental development, where a project is divided into smaller, manageable increments. -Timeboxing: DSDM uses timeboxing to manage project schedules and ensure timely delivery. -Prototyping: Prototyping validates requirements and design decisions early in the development process. -Incremental Delivery: DSDM delivers working software increments to users frequently -Collaboration and Communication: DSDM emphasizes communication among team members and stakeholders. -Iterative Planning: DSDM uses to adapt to changing requirements and priorities. -Frequent Reviews and Reflection: DSDM encourages to assess progress, identify issues, and make necessary adjustments.

Scrum:

• Used to manage complex projects, primarily used in software development but applicable to various fields. Developed by Jeff Sutherland and Ken Schwaber.
• It provides a flexible, iterative approach to product development.
• Key components of Scrum: Roles, Artifacts and Events -Roles -Product Owner: Represents the stakeholders and defines the product vision, -Scrum Master: Facilitates the Scrum process -Development Team: A cross-functional, self-organizing group -Artifacts -Product Backlog: A prioritized list of features, -Sprint Backlog: A sprint subset of items from the Product Backlog -Increment: A potentially shippable product increment produced
• Events -Sprint: Time-boxed Iteration -Sprint Planning: A at the beginning of each sprint -Daily Stand-up (Scrum): A brief, daily meeting -Sprint Review: A the end of each sprint -Sprint Retrospective: A meeting at the end of each sprint to enhance process.

Crystal:

• A family of Agile methodologies that focuses on adapting the project management approach to fit the unique characteristics of each project. Alistair Cockburn developed Crystal.
• Key aspects of Crystal methodologies: -Human-Centric Approach: Prioritizes the human factors in software development, -Flexibility: Highly adaptable and flexible. -Risk Management: Emphasizes early and ongoing risk management. -Incremental Delivery: Advocates for delivering working software incrementally and frequently. -Continuous Improvement: Promotes a culture of continuous improvement -Focus on Communication: Crystal methodologies prioritize communication and collaboration -Scaling: Provides guidance on scaling Agile practices to larger teams and projects,

Feature-Driven Development (FDD):

• Centers on building software systems by iteratively delivering small, client-valued features. Jeff De Luca and Peter Coad developed FDD.
• Key characteristics and principles of Feature-Driven Development: -Feature-Oriented: Revolves around identifying, designing, implementing, and delivering features. -Domain Modeling: Starts with creating a high-level domain model of the problem domain. -Development by Feature: Organizes the development process around features. -Incremental and Iterative Development: Emphasizes incremental and iterative development. -Regular Builds and Integration: Promotes regular builds and integration of features. -Project Management: Provides guidelines for project management, -Code Ownership: Encourages code ownership,

Agile Modeling (AM):

• AM is a set of principles for effective modeling and documentation practices for Agile software development projects. Scott Ambler developed AM.
• Key aspects of Agile Modeling are: -Modeling for Communication: Promotes the use of models as a means of communication among team members and stakeholders. -Just-in-Time (JIT) Modeling: Advocates for creating models just when they are needed. -Multiple Models: Recognizes that different stakeholders have different needs and perspectives, -Active Stakeholder Participation: Emphasizes active participation and collaboration among stakeholders -Incremental and Iterative Approach: -Simplicity: Values simplicity and avoids unnecessary complexity in models. -Documentation: Views documentation as a byproduct of the modeling process. -Tool Independence: Agile Modeling is tool-agnostic

Agile-Scrum:

• A term for the combination of Agile principles and Scrum practices.
• Key aspects of Agile-Scrum are: -Agile Principles: Principles, as outlined in the Agile Manifesto and its 12 principles, emphasize flexibility -Scrum Framework: the method of managing complex projects, particularly in software development.

Agile-Scrum:

Extreme Programming (XP):

-Focus: Technical excellence and continuous improvement.
-Practices: Paired programming, test-driven development, continuous integration, and frequent releases.
-Customer Involvement: Close collaboration with customers through on-site customer representatives.
-Iterations: short (typically 1-2 weeks).
-Roles: Collective ownership of code and emphasizes cross-functional teams.

Adaptive Software Development (ASD):

-Focus: Adaptability and responsiveness to change.
-Phases: Three phases: speculation, collaboration, and learning.
-Iterative Planning: Rolling-wave planning.
-Risk Management: Focuses on identifying and managing risks throughout the development     process.

Dynamic Systems Development Method (DSDM):

-Focus: Deliver business value and ensure project feasibility.
-Lifecycle: Phases (pre-project, feasibility study, business study, functional model iteration, design and build iteration, etc.)
-Roles: specific roles such as business sponsor, business vision holder, and technical coordinator.
-Prototyping: Encourages prototyping to validate requirements and design.

Crystal:

-Focus: Human factors, such as team communication and collaboration.
-Tailoring: Several methodologies (e.g. Crystal, Clear Crystal, Orange).
-Team Size: Based on project complexity and communication overhead.
-Frequent Delivery: Frequent delivery of working software.

Scrum:

-Framework: a light weight framework with roles, events iterations and artifacts.
- Iterative Development: Uses short iterations (sprints) to deliver working software increments.

CRC (Class-Responsibility-Collaboration) Cards

• Used in object-oriented analysis and design (OOAD) to define and organize the responsibilities and collaborations of classes in a software system.

• In the 1980s Ward Cunningham and Kent Beck first deployed the cards for modeling.

• Each card contains the: -Class Name -Responsibilities -Collaborators

• The Benefits of using include visualization and collaboration