Agile Flashcards
12 principles of Agile:
- Our highest priority is to satisfy the customer through early and continuous delivery of valuable software
- Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage
- Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale
- Business people and developers must work together daily throughout the project
- Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done
- The most efficient and effective method of conveying information to and within a
development team is face-to-face conversation - Working software is the primary measure of progress
- Agile processes promote sustainable development. Team members should be able to maintain a constant pace indefinitely
- Continuous attention to technical excellence and good design enhances agility
- Simplicity–the art of 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 behaviour accordingly
benefits of Agile:
- improved quality
- increased team motivation
- better business
- greater frequency of release
etc.
Agile team:
Agile teams are self-organizing. Everyone in the team:
- is responsible for the outcome
- Evolves the solution collaboratively
- Participates in most or all decisions
- Contributes to stories, testing, planning, sweeping floors, …
Incremental development
?
Value driven
- Focus on minimum viable
product (MVP) - Learn from customer feedback
- Adapt plan
- Iterate & increment
- Progressive elaboration
Plan driven
- Focus on project completion
- No value increments of product
- Big bang value at the end
- No feedback cycles
Continuous delivery
the ability to get changes of all types into production, or into the hands of users, safely and quickly in a sustainable way
Continuous delivery, goal and achievement method:
- goal: to make deployments predictable, routine affairs that can be performed on demand
- Achieve this by: ensuring our code is always in a deployable state
Advantages/benefits of continuous delivery:
- Low risk releases
- Faster time to market
- Higher quality
- Lower cost
- Better products
- Happier teams
Customer (Agile)
Agile advocates customer and developers work together, daily.
- customer provides direction for product
- Customer heavily involved:
- Making known requirements
- Quantifying when requirements are met
Customer (Scrum)
Product Owner that is customer/represents customer
customer (XP)
customer as member of the team
Planning, traditional:
- massive upfront planning
- little to no re-plan
- plan driven
- non-adaptive planning
planning, agile:
- Small upfront planning
- Continuous planning
- Value driven
- Adaptive planning
User stories =
agile requirements. Defining a user story:
- Reminders
- Cards to have conversation
- JIT analysis
User story, exercise:
As “who” I want
“what” so that
“why”
INVEST in great user stories:
- Independent
- Negotiable
- Valuable
- Estimable
- Scalable (small sized)
- Testable
acceptance criteria:
written in Given-When-Then format:
- Given “a precondition”
- When “I preform XYZ function”
- Then “I expect ABC result”
Timeboxing =
end date of iteration is “fixed”.
Unfinished stories move to next iteration.
Timeboxing, advantages:
- Good for customer confidence in team
- Prevents compromised quality
- Contributes to sustainable work pace
story points + sprints
?
Project adaption -> rapid feedback cycle (Agile):
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behaviour accordingly.
Our chosen framework must accommodate time to
showcase our complete
functionality/product
* Build feedback cycles into the system
* Short feedback cycles ->
quicker learning and
adaption
Agile:
- encourage doing the least amount of documentation. (post-its, index cards)
aanvullen….TODO?
Agile method:
- Scrum
- Extreme programming
Scrum =
an agile way to manage a project, usually software development. Agile software
development with Scrum is often perceived as a methodology; but rather than viewing Scrum as methodology, think of it as a framework for managing a process.
3 scrum roles:
- Product owner
- Scrum master
- Team member
scrum, product owner:
- Customer advocate
- Sets product vision, direction
- Accountable for ROI on product
- Responsible to work with team to get user stories ready for next sprint
- Prioritizes backlog based on business value
- Has final say in any priority
quibbles
Scrum master:
- Keeper of the Scrum process
- Removes impediments
- Coaches team members to become more effective
- Guards/protects the team from interruptions
- Continuously looking for ways to improve self and team
- The glue between project
stakeholders
Scrum, team member:
- Anyone on the team doing work
- BA, developer, UX designer, tester etc.
- T-Shaped people
- Cross functional
- Learning mindset as opposed to fixed mindset
Scrum Artefacts:
- Product Backlog
- Sprint Backlog
- Burndown chart
Scrum, product backlog:
- The list of work pertaining to a product
- May or may not get done
- Prioritized by product owner
- Top priority items on top (priority descending)
- Enough work for 2-3 iterations must be groomed
- Product owner’s responsibility
Scrum, Sprint backlog:
- The work committed to by the team
- Work that must get done in the iteration
- Sprint backlog should not be changed
- Estimated in story points
- Team owns the sprint backlog
Scrum ceremonies:
- Backlog grooming
- Sprint planning
- Daily Scrum
- Product demo
- Retrospective
Scrum, backlog grooming:
- It is advised teams spend 5% of time grooming the Backlog. - Ken Schwaber (co-founder of Scrum)
- Engage the Team
- Grooming:
- Adding, removing stories
- Sizing, Breaking down stories
- Reprioritizing stories
- Adding info to stories
Scrum, sprint planning:
- Product Owner sets sprint goal
- Product Owner presents the dev team with candidate user stories
- Team asks questions about the work that has not been covered in backlog grooming
- Team commits to work until velocity threshold reached
- Product owner responsible for the ‘What’ and Scrum team for ‘How’
- Scrum Master facilitates ceremony
Scrum, product demo:
- Goal: Get approval from
PO & feedback from as
many possible - Demo fully integrated
end-to-end product - Team takes PO and
interested parties through
the sprint’s product
increment - Successes, impediments
and future goals are shared
Scrum, retrospective:
- Continuous improvement opportunity
- What worked well?
- Where can we improve?
- Make plans to improve, assign a driver and check in regularly
Extreme programming
- Selected the minimal set of effective practices
- “Turned the knob up to 10” on each practice
- Very short cycles
- Continuous code reviews (pair programming)
- Extensive testing (automatic tests, test first)
- Constant design improvement (refactoring)
- Etc…
Extreme programming, XP project community:
- Emphasis on the “Whole Team”
- Collaboration and colocation
- Three general roles:
- Customer
- Developer
- Manager
- Specific job functions neither specified nor excluded (e.g., QA)
Extreme programming, customer:
- On site!
- Accountability for:
- Knowing and communicating business needs
- Definition of features
- Prioritization
- Test for acceptance of features
Extreme programming, developer:
- Accountability for:
- Knowing and communicating solutions
- Cost estimations and explaining trade-offs
- Delivering usable functionality that meets requirements and priorities
Extreme programming, manager:
- Accountability for:
- Interfacing with organizational entities (status)
- Environmental issues (facilities, equipment)
- Personnel administration (reviews, hiring)
- Business administration (budgets)
Extreme programming, development episodes:
- Developer obtains a pair partner
- Pair verifies understanding of story for this task (analysis)
- Pair determines detailed
implementation approach (detailed design) - Pair begins test-driven cycle of write test, implement to pass, refactor
- At appropriate intervals, pair integrates to code base
Extreme programming, XP cycle in small:
- analysis
- test
- code
- design
(repeat!)
extreme programming, refactoring:
- Improve the design of existing code without changing its functionality
- Allows design to incrementally evolve
- Refactoring can occur just prior or just after writing new code
extreme programming, the original 12 practices:
- The Planning Game
- On-Site Customer
- Testing
- Pair Programming
- Small Releases
- Simple Design
- Refactoring
- Continuous Integration
- Collective Ownership
- Coding Standards
- Metaphor
- 40-Hour Week
Scaling XP/Agile:
- XP seems to allow smaller teams to accomplish an awful lot
- XP seems to hit single-team challenges around 10 developers
- XP can scale by building recursive teams
XP/Agile is excellent if:
-You are in a world of rapid change
- You have uncertain requirements
- The project is small or medium sized
