How to manage a product backlog with ease

Leave a comment

Source: http://blogs.atlassian.com/2013/04/how-to-manage-a-product-backlog-with-ease/

This article is part of a blog series!

Part Title
1 Organizing your backlog
2 Prioritizing work
3 Handing off to engineering

Product owners have the challenging task of ingesting feedback from multiple sources, organizing it into a meaningful format, and communicating out to the product teams. Feedback is a critical part of the product life cycle. We can’t iterate to make our products better without it, as we talked about in our three-part series on collecting feedback a few weeks ago. But what do we do when we get too much feedback? Backlogs quickly become unmanageable. As product owners, if we become less adept at our backlog, we lose hold on the future direction of our product.

Establish a triage process

Once your product has a feedback stream flowing, you’ll need to take action on it. Input should always be coming directly from your customers, using tools like JIRA CaptureJIRA Issue Collectors, and JIRA Mobile Connect–at Atlassian we use JIRA to manage user feedback on our products at https://jira.atlassian.com. Not all feedback in the backlog is valuable, however. Set up a simple feedback loop to triage all incoming feedback. You’ll want to understand each piece of feedback and see if it’s:

  • Valid and on target for action: “When I click button X, I expect Y to happen, but instead, Zhappens.”
  • Represented elsewhere: two tickets express the same feedback.
  • Not relevant to the product direction: “There should be another button for option X.
  • Not cost effective to implement: “Hitting esc in the browser should save my form text, should I want to re-use it.”
  • As designed: the product team made an explicit decision to work this way. Feedback here should be carefully reviewed.

managinginput

If your product backlog is clogged with inactionable feedback, you’ll have a harder time moving forward. Send the inactionable feedback to a parking lot. We close tickets of this type with the appropriate resolution. Closed issues are not lost! We can target searches of closed issues just like open ones. Tagging an appropriate resolution makes searching closed issues much more efficient. You never want to delete feedback, as you may want to come back to it, thus take the time to ensure you can quickly find it later. JIRA’s resolution fields can be customized to add each of the cases above. Epics, components, and labels can track large feature areas for review at a later time.

Tier your backlog

It costs a product owner time for each issue he or she reviews. The JIRA team uses a three-tier backlog to denote levels of review for each piece of feedback. If we expand the first “passes review” section above we can see two more levels of fidelity in our backlog.

managingoutput

In the raw feedback stage, the product owner quickly decides whether to keep or pass on a piece of feedback. If the feedback is kept, then it gets moved to the unprioritized state. This means the product owners intend to take action on it at some point, but it’s not in a state where it can be handed off to the product teams. Once the product owner has fleshed out a particular story, it moves from the unprioritized state into the “ready for feature teams” queue. This queue is the tight, ordered backlog that the product teams can quickly pull into future sprints.

What happens when the “ready for feature teams” queue gets low? The product owner only has to pull from the unprioritized queue. They don’t have to look over the entire backlog as there is a higher fidelity set of data ready for review.  Rather than review potentially hundreds (or thousands) of issues, the product owner can see a set of a much lower magnitude.

JIRA Agile, it’s not just for developers

JIRA Agile is the agile add-on for JIRA. Many development teams use it to track their work in an agile fashion. Product owners can use it to track their backlogs. The JIRA Product Management (PM) team tracks their backlog with JIRA Agile using a Kanban board. Kanban boards model a flow process so it’s easy to see issues flow from feedback into features. Note, this is a different board than development uses. Think of it as the precursor to the development process.

productbacklog

The JIRA roadmap backlog has four major states:

  • Not ready yet: Raw feedback
  • Unprioritized: Committed to the back log, but not ready for handoff to development
  • Ready for feature teams: The feature teams should work on the highest priority items first
  • In design (PM and Dev): The feature story is actively being worked on

The PM team then uses swim lanes to group issues by epic so all of the related issues are contextually close to one another on the screen. Swim lanes can be easily collapsed so the PMs can focus on one epic at a time. This helps the PM quickly traverse the backlog.

Ready to transform your backlog? Try JIRA Agile today!

Try JIRA Agile

For more, visit The Agile Coach – our no-nonsense agile tutorial site.

About Dan Radigan

Software has been a passion since the days of the floppy disk (you know, the actual 5.25 inch floppy ones). Agile has had a huge impact on me both professionally and personally as I’ve learned the best experiences are agile, both in code and in life. You’ll often find me at the intersection of technology, photography, and motorcycling. Find me on Twitter:@danradigan.

View all posts by Dan Radigan »

Agile Principles, Patterns, and Practices in C# by Robert C. Martin

Leave a comment

Source: http://druss.co/wp-content/uploads/2013/10/Agile-Principles-Patterns-and-Practices-in-C.pdf

| Index
With the award-winning book Agile Software Development: Principles, Patterns, and Practices,
Robert C. Martin helped bring Agile principles to tens of thousands of Java and C++ programmers.
Now .NET programmers have a definitive guide to agile methods with this completely updated
volume from Robert C. Martin and Micah Martin, Agile Principles, Patterns, and Practices in
C#.
This book presents a series of case studies illustrating the fundamentals of Agile development and
Agile design, and moves quickly from UML models to real C# code. The introductory chapters lay
out the basics of the agile movement, while the later chapters show proven techniques in action.
The book includes many source code examples that are also available for download from the
authors’ Web site.
Readers will come away from this book understanding
Agile principles, and the fourteen practices of Extreme Programming
Spiking, splitting, velocity, and planning iterations and releases
Test-driven development, test-first design, and acceptance testing
Refactoring with unit testing
Pair programming
Agile design and design smells
The five types of UML diagrams and how to use them effectively
Object-oriented package design and design patterns
How to put all of it together for a real-world project
Whether you are a C# programmer or a Visual Basic or Java programmer learning C#, a software
development manager, or a business analyst, Agile Principles, Patterns, and Practices in C# is
the first book you should read to understand agile software and how it applies to programming in
Agile Principles, Patterns, and Practices in C#
By Martin C. Robert, Martin Micah
………………………………………..
Publisher: Prentice Hall
Pub Date: July 20, 2006
Print ISBN-10: 0-13-185725-8
Print ISBN-13: 978-0-13-185725-4
Pages: 768
Table of Contents | Index
With the award-winning book Agile Software Development: Principles, Patterns, and Practices,
Robert C. Martin helped bring Agile principles to tens of thousands of Java and C++ programmers.
Now .NET programmers have a definitive guide to agile methods with this completely updated
volume from Robert C. Martin and Micah Martin, Agile Principles, Patterns, and Practices in
C#.

This book presents a series of case studies illustrating the fundamentals of Agile development and
Agile design, and moves quickly from UML models to real C# code. The introductory chapters lay
out the basics of the agile movement, while the later chapters show proven techniques in action.
The book includes many source code examples that are also available for download from the
authors’ Web site.

Readers will come away from this book understanding
Agile principles, and the fourteen practices of Extreme Programming
Spiking, splitting, velocity, and planning iterations and releases
Test-driven development, test-first design, and acceptance testing
Refactoring with unit testing
Pair programming
Agile design and design smells
The five types of UML diagrams and how to use them effectively
Object-oriented package design and design patterns
How to put all of it together for a real-world project

Whether you are a C# programmer or a Visual Basic or Java programmer learning C#, a software
development manager, or a business analyst, Agile Principles, Patterns, and Practices in C# is
the first book you should read to understand agile software and how it applies to programming in
the .NET Framework.

Agile Principles, Patterns, and Practices in C#
By Martin C. Robert, Martin Micah
………………………………………..
Publisher: Prentice Hall
Pub Date: July 20, 2006
Print ISBN-10: 0-13-185725-8
Print ISBN-13: 978-0-13-185725-4
Pages: 768
Table of Contents | Index
Copyright
Robert C. Martin Series
Foreword
Foreword
Preface
Acknowledgments
About the Authors

Section I. Agile Development

Chapter 1. Agile Practices
The Agile Alliance
Principles
Conclusion
Bibliography

Chapter 2. Overview of Extreme Programming
The Practices of Extreme Programming
Conclusion
Bibliography

Chapter 3. Planning
Initial Exploration
Release Planning
Iteration Planning
Defining “Done”
Task Planning
Iterating
Tracking
Conclusion
Bibliography

Chapter 4. Testing
Test-Driven Development
Acceptance Tests
Serendipitous Architecture
Conclusion
Bibliography
Chapter 5. Refactoring
A Simple Example of Refactoring: Generating Primes
Conclusion
Bibliography

Chapter 6. A Programming Episode
The Bowling Game
Conclusion
Overview of the Rules of Bowling
Section II. Agile Design

Chapter 7. What Is Agile Design?
Design Smells
Why Software Rots
The Copy Program
Conclusion
Bibliography

Chapter 8. The Single-Responsibility Principle (SRP)
Defining a Responsibility
Separating Coupled Responsibilities
Persistence
Conclusion
Bibliography

Chapter 9. The Open/Closed Principle (OCP)
Description of OCP
The Shape Application
Conclusion
Bibliography

Chapter 10. The Liskov Substitution Principle (LSP)
Violations of LSP
Factoring Instead of Deriving
Heuristics and Conventions
Conclusion
Bibliography

Chapter 11. The Dependency-Inversion Principle (DIP)
Layering
A Simple DIP Example
The Furnace Example
Conclusion
Bibliography

Chapter 12. The Interface Segregation Principle (ISP)
Interface Pollution
Separate Clients Mean Separate Interfaces
Class Interfaces versus Object Interfaces
The ATM User Interface Example
Conclusion
Bibliography

Chapter 13. Overview of UML for C# Programmers
Class Diagrams
Object Diagrams
Collaboration Diagrams
State Diagrams
Conclusion
Bibliography

Chapter 14. Working with Diagrams
Why Model?
Making Effective Use of UML
Iterative Refinement
When and How to Draw Diagrams
Conclusion

Chapter 15. State Diagrams
The Basics
Using FSM Diagrams
Conclusion
Chapter 16. Object Diagrams
A Snapshot in Time
Active Objects
Conclusion

Chapter 17. Use Cases
Writing Use Cases
Diagramming Use Cases
Conclusion
Bibliography

Chapter 18. Sequence Diagrams
The Basics
Advanced Concepts
Conclusion

Chapter 19. Class Diagrams
The Basics
An Example Class Diagram
The Details
Conclusion
Bibliography

Chapter 20. Heuristics and Coffee
The Mark IV Special Coffee Maker
OOverkill
Bibliography
Section III. The Payroll Case Study

Chapter 21. COMMAND and ACTIVE OBJECT: Versatility and Multitasking
Simple Commands
Transactions
Undo Method
Active Object
Conclusion
Bibliography

Chapter 22. TEMPLATE METHOD and STRATEGY: Inheritance versus Delegation
Template Method
Strategy
Conclusion
Bibliography

Chapter 23. Facade and Mediator
Facade
Mediator
Conclusion
Bibliography
Chapter 24. Singleton and Monostate
Singleton
Monostate
Conclusion
Bibliography
Chapter 25. Null Object
Description
Conclusion
Bibliography

Chapter 26. The Payroll Case Study: Iteration 1
Rudimentary Specification
Analysis by Use Cases
Reflection: Finding the Underlying Abstractions
Conclusion
Bibliography

Chapter 27. The Payroll Case Study: Implementation
Transactions
Main Program
The Database
Conclusion
About This Chapter
Bibliography

Section IV. Packaging the Payroll System

Chapter 28. Principles of Package and Component Design
Packages and Components
Principles of Component Cohesion: Granularity
Principles of Component Coupling: Stability
Conclusion

Chapter 29. Factory
A Dependency Problem
Static versus Dynamic Typing
Substitutable Factories
Using Factories for Test Fixtures
Importance of Factories
Conclusion
Bibliography

Chapter 30. The Payroll Case Study: Package Analysis
Component Structure and Notation
Applying the Common Closure Principle (CCP)
Applying the Reuse/Release Equivalence Principle (REP)
Coupling and Encapsulation
Metrics
Applying the Metrics to the Payroll Application
The Final Packaging Structure
Conclusion
Bibliography

Chapter 31. Composite
Composite Commands
Multiplicity or No Multiplicity
Conclusion

Chapter 32. Observer: Evolving into a Pattern
The Digital Clock
The OBSERVER Pattern
Conclusion
Bibliography
Chapter 33. Abstract Server, Adapter, and Bridge
Abstract Server
Adapter
Bridge
Conclusion
Bibliography

Chapter 34. PROXY and GATEWAY: Managing Third-Party APIs
Proxy
Databases, Middleware, and Other Third-Party Interfaces
Table Data Gateway
Using Other Patterns with Databases
Conclusion
Bibliography

Chapter 35. Visitor
Visitor
Acyclic Visitor
Decorator
Extension Object
Conclusion
Bibliography

Chapter 36. State
Nested Switch/Case Statements
Transition Tables
The State Pattern
Classes of State Machine Application
Conclusion
Bibliography

Chapter 37. The Payroll Case Study: The Database
Building the Database
A Flaw in the Code Design
Adding an Employee
Transactions
Loading an Employee
What Remains?

Chapter 38. The Payroll User Interface: MODEL VIEW PRESENTER
The Interface
Implementation
Building a Window
The Payroll Window
The Unveiling
Conclusion
Bibliography

Appendix A. A Satire of Two Companies
Appendix B. What Is Software?
Afterword
InsideFrontCover
Manifesto for Agile Software Development
Principles behind the Agile Manifesto
InsideBackCover
Practices of Extreme Programming
The Principles of Object Oriented Design
Index

Scrum in 7 Minutes; Learn the basics of the scrum development framework in just 7 minutes! By the end of this video you’ll be ready to take the first steps towards implementing scrum practices on your development team!

Leave a comment

Top 20 Best Agile Development Books

Leave a comment

BooksI recently created a Top 100 Best Software Engineering Books, Ever. I created that list using four different criteria: 1) number of Amazon reviews, 2) average Amazon rating, 3) number of Google hits and 4) Jolt awards. The nice thing about such a big list is that it enables you to extract all kinds of mini-lists out of it.

Like, for example, the Top 20 Best Agile Development Books, Ever

1: Robert C. Martin
Agile Software Development: Principles, Patterns and Practices

2: Martin Fowler
Refactoring: Improving the Design of Existing Code

3: Mike Cohn
Agile Estimating and Planning

4: Mike Cohn
User Stories Applied: For Agile Software Development

5: Andrew Hunt, David Thomas
The Pragmatic Programmer: From Journeyman to Master

6: Alistair Cockburn
Agile Software Development: The Cooperative Game (2nd Edition)

7: Craig Larman
Agile and Iterative Development: A Manager’s Guide

8: Kent Beck
Extreme Programming Explained: Embrace Change (2nd Edition)

9: Jim Highsmith
Agile Project Management: Creating Innovative Products

10: Paul Duvall, etc.
Continuous Integration: Improving Software Quality and Reducing Risk

11: Mary PoppendieckTom Poppendieck
Lean Software Development: An Agile Toolkit

12: Ken Schwaber
Agile Project Management with Scrum

13: Ken Schwaber, Mike Beedle
Agile Software Development with Scrum

14: Alistair Cockburn
Crystal Clear: A Human-Powered Methodology for Small Teams

15: Venkat Subramaniam, Andy Hunt
Practices of an Agile Developer: Working in the Real World

16: Kent Beck
Test Driven Development: By Example

17: Johanna Rothman
Manage It!: Your Guide to Modern, Pragmatic Project Management

18: James Shore, Shane Warden
The Art of Agile Development

19: Ron Jeffries, etc.
Extreme Programming Installed

20: Esther Derby, etc.
Agile Retrospectives: Making Good Teams Great

Source: http://agilesoftwaredevelopment.com/blog/jurgenappelo/top-20-best-agile-development-books

Agile vs. Waterfall: A Tale of Two Teams

Leave a comment

Scrum Master in Under 10 Minutes

Leave a comment