Agile Practices

Freda Fung
Mind Map by Freda Fung, updated more than 1 year ago
Freda Fung
Created by Freda Fung about 5 years ago
53
3

Description

Graduate diploma Graduate Diploma in Computing (Agile) Mind Map on Agile Practices, created by Freda Fung on 09/23/2016.

Resource summary

Agile Practices
  1. Project Initiation
    1. Developing a Shared Vision
    2. Planning & Features
      1. Creating User Stories
        1. Short, simple description of a feature told from the perspective of the person who desires the new capability, usually a user or customer of the system.
          1. Defer details and capture them through discussion just in time for development
            1. Captured by team members, product owners, scrum master and users
              1. Usually in the format of Role-Feature-Reason
                1. Why?
                  1. Useful for planning work
                    1. Focus on delivering value to stakeholders
                      1. Eliminate waste effort by just-in-time elaboration
                        1. Vehicle to add features in iterative development
                          1. Bill Wake

                            Annotations:

                            • Bill Wake's invest model to write user stories 1. Independent 2. Negotiable 3. Valuable 4. Estimateable 5. Small 6. Testable
                          2. Non-Functional Requirements

                            Annotations:

                            • e.g. Speed & availability
                            1. Technical stories

                              Annotations:

                              • e.g. The system will conform to corporate user interface guidelines
                              1. are
                                1. Cross-cutting
                                  1. Pertinent to many functional requirements (user stories)
                                    1. Typically maintained outside of the work item list
                                      1. Addressed throughout the entire project
                                        1. Often technical constraints on your solution
                                        2. Drive
                                          1. Development of acceptance or system tests

                                            Annotations:

                                            • which validate that your solution conforms to those requirements
                                            1. Development of architectural aspects
                                              1. The definition of what it means to be done at the end of an iteration
                                          2. Backlog Grooming

                                            Annotations:

                                            • Also called  Backlog Refinement or Story Time
                                            • act of adding detail, estimates and order to items in the Product Backlog.  If this is not doen at Backlog Grooming meeting, the tasks will be done in a sprint planning meeting
                                            1. Ongoing process conducted by the collaboration of the Product Owner and team members
                                              1. Help make Sprint Planning Meeting more efficient and enhance quality through better understanding
                                                1. Grooming usually time-boxed to 5-10% of the Development Team's capacity
                                                  1. Typically 3 days before Sprint Planning Meeting and on a weekly basis
                                                    1. Development Team is responsible for all estimates. Product Owner supports team by helping understand items and select trade-offs
                                                      1. Development Team is responsible for all estimates. Product Owner supports team by helping understand items and select trade-offs
                                                        1. How grooming is performed is determined by the Scrum Team
                                                          1. Ideally discuss 2 sprints worth of backlog items
                                                            1. 3 common ways to add details
                                                              1. Create graphics and/or text to describe a user story
                                                                1. Break up a complex user story into a few simple user stories
                                                                  1. Identify Acceptance Criteria for a user story
                                                                2. Prioritise User Stories

                                                                  Annotations:

                                                                  • prioritised user stories / features will be added to product backlog.
                                                                  • product backlog will also contain technical tasks, defects to be fixed, and knowledge acquisitions tasks.
                                                                  1. Product Owner

                                                                    Annotations:

                                                                    • Prioritisation is performed by the product owner, who balances the needs of all stakeholders, not just users.
                                                                    1. Team Member

                                                                      Annotations:

                                                                      • suggest priorities but must be able to explain the reasoning and trade-offs invoved
                                                                      1. done at:
                                                                        1. when creating the initial user stories / features that define initial scope of the backlog
                                                                          1. Sprint Planning meeting
                                                                            1. any time required by Stakeholders (decided by product owner)
                                                                            2. Approaches
                                                                              1. Value-driven approach (core approach)

                                                                                Annotations:

                                                                                • assign in-scope high-level requirements across all Sprints in priority oder by business value
                                                                                1. Risk - Value Driven Approach (disciplined approach)

                                                                                  Annotations:

                                                                                  • Assign high-risk items, particularly architecturally significant requirements, to early iterations
                                                                              2. Estimate Story Points
                                                                                1. Break into Tasks & Effort Estimate
                                                                                2. Burndown tracking

                                                                                  Annotations:

                                                                                  • A graph that shows the remaining units to complete that is measurable and will eventually become zero Scrum Master keeps track of the points completed and remaining in each and plot them in charts and put up on a whiteboard
                                                                                  1. Iteration burndown

                                                                                    Annotations:

                                                                                    • estimated effort hours remaining in the iteration
                                                                                    1. Release burndown

                                                                                      Annotations:

                                                                                      • estimated functionality yet to be built for the release
                                                                                      1. Product burndown

                                                                                        Annotations:

                                                                                        • estimated functionality yet to be built spanning multiple releases
                                                                                        1. Release and Iteration Planning
                                                                                          1. Scheduling
                                                                                            1. Daily Scrum Meeting
                                                                                            2. Construction
                                                                                              1. Iterations & Pace

                                                                                                Annotations:

                                                                                                • process that makes progress through successive refinement. 
                                                                                                1. Sustainable pace

                                                                                                  Annotations:

                                                                                                  • the rate of work that a team can consistently maintain without burning out team members
                                                                                                  1. Xp

                                                                                                    Annotations:

                                                                                                    • popularised by the Extreme Programming (XP) methodology
                                                                                                    1. 40 hour work week

                                                                                                      Annotations:

                                                                                                      • brief spurts of overtime are acceptable, but can't be sustained indefinitely.
                                                                                                      • reconise sustained overtimer as failure
                                                                                                      1. Strategies
                                                                                                        1. Acknowledge - you're still working productivly at sustainable pace
                                                                                                          1. Organise - the project into short iterations
                                                                                                            1. Avoid mini-waterfalls
                                                                                                              1. Adopt a continuous integration strategy
                                                                                                                1. Collaborate frequently with team membrs
                                                                                                              2. Iterations & Incremental Development
                                                                                                                1. Incremental process

                                                                                                                  Annotations:

                                                                                                                  • process which software is built and delivered in pieces.  Each piece, or increment, represents a complete subset of functionality.  The increment ma be either small or large, perhaps ranging from just a system's login screen on the small end, to a highly flexible se of data management screens
                                                                                                                  1. Iteration process

                                                                                                                    Annotations:

                                                                                                                    • An iterative process is one that makes progress through successive refinement.  A development team takes a first cut at a system, knowing it is incomplete or weak in some (perhaps many) areas.  The team then iteratively refines those areas until the product is satisfactory.  With each iteration the software is improved through the addition of greater detail
                                                                                                                2. Architectural Spike
                                                                                                                  1. Model Storming
                                                                                                                    1. Continuous Integration

                                                                                                                      Annotations:

                                                                                                                      • Practice of merging all developer working copies with a shared mainline sereval times a day. was first named and proposed as part of Extreme Programming
                                                                                                                      • The practice involves team members integrate their work frequently, usually each person integrates at least daily leading to multiple integrations per day.  Version Control to repository and continuous build tools are used for integration the code nd build, and then automated tests are run to get immediate feedback on integration problems.
                                                                                                                      • Key benefits: identify integration problems early andaddress them before they build up to more complex problems, or integration Hell as described by XP
                                                                                                                      1. Test Driven Development

                                                                                                                        Annotations:

                                                                                                                        • The practice of dveloping a functionality by writing unit tests before the code is written.  By default, it requires tests to be automated.
                                                                                                                        1. Add a Test

                                                                                                                          Annotations:

                                                                                                                          • To start developing new functionality, write a test for the new functionality and then add the test to the list of existing tests.
                                                                                                                          • To write a test, the developer must clearly understand the feature's specification and requirements.  They come from User Stories and related discussions
                                                                                                                          1. Run all Tests

                                                                                                                            Annotations:

                                                                                                                            • The newly added tests should fail because no code has been written to fulfill the feature yet. This gives you some confidence that the test is working
                                                                                                                            1. Wrte More Code

                                                                                                                              Annotations:

                                                                                                                              • Write just enough code to pass all the failed tests.  It is ok if the code is not elegant at this stage
                                                                                                                              1. Run all Tests Again

                                                                                                                                Annotations:

                                                                                                                                • Test your new code.  Note that is also tests whether your new code breaks old functionalities.  If the tests failed, writes code to pass it
                                                                                                                                1. Pair Programming

                                                                                                                                  Annotations:

                                                                                                                                  • The concept comes from Extreme Programming (XP).  2 or more developers work on the same piece of code together - typyically one watching over the shoulder of the other for a period of time and then switch
                                                                                                                                  1. Benefits
                                                                                                                                    1. Enhanced quality

                                                                                                                                      Annotations:

                                                                                                                                      • The pair or group checks the artifact for quality
                                                                                                                                      1. Redused Cost of Development

                                                                                                                                        Annotations:

                                                                                                                                        • Inconsistencies and bugs are caught early in the cycle
                                                                                                                                        1. Knowledge sharing

                                                                                                                                          Annotations:

                                                                                                                                          • Domain knowledge and development techniques are shared among individuals (pair or group).
                                                                                                                                        2. POtential barriers
                                                                                                                                          1. Work in pairs

                                                                                                                                            Annotations:

                                                                                                                                            • Some ppl might not be comfortable or feel intimidated working in pairs
                                                                                                                                            1. Culture / habits

                                                                                                                                              Annotations:

                                                                                                                                              • Some cultural aspects  personal habits can be obstacles to pairing
                                                                                                                                        3. Refactor Code
                                                                                                                                          1. Refactoring

                                                                                                                                            Annotations:

                                                                                                                                            • Simple change to your source that improves the design without changing its semantics
                                                                                                                                            • by refactoring you can evolve your development assets in a controlled manner, maintain the high quality of your design.
                                                                                                                                            1. Code Refactoring

                                                                                                                                              Annotations:

                                                                                                                                              • A small change to your code to improve your design that retain the behavioural semantics of your code.
                                                                                                                                              • eg Rename a method, move a method, remove a setting method
                                                                                                                                              1. Database Refactoring

                                                                                                                                                Annotations:

                                                                                                                                                • Simple change to a database schema that improves its design while retaining both its behaviour and informational semantics eg Move a column, rename a table, replace a blob with a table
                                                                                                                                                1. User Interface Refactoring

                                                                                                                                                  Annotations:

                                                                                                                                                  • A simple change to the user interface that improves the design without changing the semantics of the function that is provided to the user. e.g. Align widgets, standardise formats, move a widget
                                                                                                                                          2. Delivering
                                                                                                                                            1. Continuous Delivery
                                                                                                                                              1. Demonstrations
                                                                                                                                                1. Retrospective
                                                                                                                                                Show full summary Hide full summary

                                                                                                                                                Similar

                                                                                                                                                Introduction to Agile
                                                                                                                                                Freda Fung
                                                                                                                                                Agile Teams, Work Environment & Scrum Overview
                                                                                                                                                Freda Fung
                                                                                                                                                Expertise in Project Management
                                                                                                                                                tonesha_g
                                                                                                                                                PMP® Pre-Test by Coursefountain.com
                                                                                                                                                Team Coursefountain
                                                                                                                                                Ch1 - The nature of IT Projects
                                                                                                                                                mauricio5509
                                                                                                                                                Introduction notes on SCRUM Project management framework.
                                                                                                                                                Wesley Thomson
                                                                                                                                                Project Management: Week 1
                                                                                                                                                Sharon Ott
                                                                                                                                                Summary of Definitions/Key Terms for the PMP Exam
                                                                                                                                                Andrea Leyden
                                                                                                                                                PMP Prep quiz
                                                                                                                                                Andrea Leyden
                                                                                                                                                Project Scope Management Process
                                                                                                                                                neeshar
                                                                                                                                                06 PROJECT TIME MANAGEMENT
                                                                                                                                                miguelabascal