My My.Fragility framework adds my insights for fixed price (-negotiable scope) projects to XP and Scrum.
I included a Product Backlog Estimation model to calculate a total price using my Definition Of Agile Planning. And on top of User Stories and Story Points the Sizing of User Stories is to be considered:
The right size of a User Story is 0,5-5 ideal days (di) (ideal time = Story Points). For development. To be invEST. To comfortably fit a Sprint.
- Epic Stories can be 5-15 di. A size not suited for development but acceptable for estimating. To be split into User Stories.
- Cosmic Stories are >15 di. They can serve only as a beginning to understand a Product, not for estimation or development.
- Tiny Stories are < 0,5 di. To be combined into User Stories.
Note: ‘Minimal Marketable Features’ (MMF) from Kanban can be a set of User Stories. Possibly an Epic Story.
The best base to estimate is experience. When experience is limited, use relative estimates (complexity scaling). I use a 1-2-5 scale:
- Size is set upon complexity to 1-2-5-10-20-50-100-… Always use the higher value if you end up in between two points.
- Find some reference points in your experience to compare.
- Refine until you end up with real estimates (Story Points).
note: Ideal time is development time without breaks, questions, problems or any interrupts. It is multiplied with Velocity to get Planning days.
I have combined personal insights for fixed price (-negotiable scope) projects with practices from eXtreme Programming and Scrum in my My.Fragility framework.
The main estimation steps from the framework’s Product Backlog Estimation model were highlighted in my Definition Of Agile Planning. But the model also implies at least an understanding of some definitions.
After my definition for User Stories here’s how I use Story Points:
- Story Points equal ideal time (“ti”). But using ‘Story Points’ might prevent people from confusing it with realistic time. The eXtreme Programming notion of Gummy Bears (“Bg”) might be a bit too abstract, although it’s fun to use.
- Ideal time is the development time for a User Story without breaks, questions, problems or interrupts of whatever nature. Spending every minute of every working day on productive coding.
- Ideal time is mulitplied with Velocity (“v”) to estimate Planning time (“tp”). In my experience, an overall velocity of 2,5-3 results in a realistic number of planning days.
planning time (“tp”) = ideal time (“ti”) * Velocity (“v”)
- An alternative definition of Story Points is the number of productive coding hours per day. This is generally accepted as maximum 5-6. Velocity is then expected to be around 1,33.
Note I generally apply an overall Velocity to all User Stories, although my model allows a specific Velocity per User Story, e.g. depending on the expected complexity.
Over various projects I have applied a set of Agile practices from eXtreme Programming and Scrum. Adding personal insights to specifically handle fixed price (-negotiable scope) projects resulted in my My.Fragility framework.
The framework includes a Product Backlog Estimation model, for which the main estimation process steps were highlighted as part of my Definition Of Agile Planning. Furthermore does the model at least imply an understanding of my definition of a User Story:
A User Story describes a feature from an end-user perspective. It is independent of software layers or parts of the project
A User Story can be explained as an essential Use Case
A User Story should be INVEST to be ready for development
- Independent: User Stories have as little interdependence as possible. Resolve it by putting related Stories in the same Sprint
- Negotiable: a User Story is an invitation to discuss implementation. The best design and code result from communication!
- Valuable: a User Story represents effective business value for an end-user
- Estimatable: the size and knowledge on a User Story is sufficient to reliably estimate the Story
- Small: a User Story is small enough to be estimated, developed and tested. It is comfortably realizable in one Sprint
- Testable: a User Story has a clear result that can be tested
When reviewing Chet Hendrickson’s paper on the evolution of Extreme Programming practices, I was surprised that he completely ignored Kent Beck’s revision of 2004. As does Ron Jeffries’ practices representation, by the way.
5 Years of eXPerience resulted in a complete revision of Extreme Programming Explained. The general tone softened, partial adoption became acceptable and the practices were extended, and divided into primary and secondary practices. Maybe Kent considered XP as under-adopted, but I missed the strong and ahead leadership from v1. No compromise. Working software is the goal. Extreme focus. Programming is the way.
I also felt that in the v2 edition, good ideas were introduced, but good practices were also replaced. Because I instantiate Scrum’s engineering standards with XP practices in my framework My.Fragility, I decided to merge the best of both:
Note: when checking the original Extreme Programming Installed book myself, I wondered (after all these -6- years!) why it did not mention the Coach role. When moving to Scrum after our ‘pure’ XP application, I kept promoting this role. I still do in my My.Fragility framework (on top of Scrum’s Product Owner, Team and ScrumMaster).
And I still don’t known why User Stories was not an explicit XP practice from the beginning…
To review Chet Hendrickson’s retrospective paper on his book Extreme Programming Installed, I went back in time myself. Back to my first experience with Extreme Programming.
In September 2003 I was asked to urgently take on a project as project manager. Customer approval was late but the predicted delivery date remained (December).
A 15 min introduction convinced me of eXtreme Programming. Because so much was incorporated that was traditionally so easily forgotten or overlooked. We convinced management, and off we went (October). After 3 iterations (of 3 weeks) we delivered… in time and on budget!
Because I considered myself too illiterate (after all, we only did it) to present the project at Javapolis 2003, I started reading some books. The inevitable Extreme Programming Explained (‘Embrace Change‘), Planning Extreme Programming and… Extreme Programming Installed. It was remarkable to find that our ‘naive application’ was an extraordinary match with what I was reading. Presentation went very well.
In 2004 I started using Scrum as process and certified as a ScrumMaster. During follow-up projects for our satisfied customer we kept combining Scrum and XP. However, we had to operate within a context of realizing a (negotiable) scope in a given timeframe. So along the way (2004-2006) additional practices, tools and views were embedded, to finally become my My.Fragility* framework.
The framework holds following (partially XP based) Quality Loops:
Implementation of Engineering Standards. To be performed every day:
- A pair writes all code upon a Test First basis (including Selenium GUI tests)
- Checked in code is tested in a Continuous Integration system (multiple times a day) and can be refactored
- A ‘guide’ (additional, explicit role) functionally tests a stable, CI’ed version (multiple times a day) and feeds back results to the team
- A functional working version may be deployed for performance testing (running overnight)
* The name of the framework has its roots in the big relief I felt when morphing from project manager to ScrumMaster. The option to be fragile (agility through fragility), of not constantly having to intimidate people. Because, after all, it’s just a matter of talents and roles, not of… hierarchical slavery.
Recently Scrum godfather Ken Schwaber resigned as chairman from the ScrumAlliance, which he co-founded.
I remember Ken from turning my ScrumMaster certification course in 2004 into a great experience. Not because of the certificate, but for comprehending Scrum. I’ve since then advised people to attend the certification course, but mainly to get in touch with other people and dive into the matter.
Ken launched Scrum.org as a move from ceremony and formal organization to process and community. From certification to assessment (for self-improvement). There’s an online Scrum Assessment (note: no longer available), upon a Scrum Guide. Because… “Unlike certification, assessment makes no public claim of competence and cannot be misused to assert qualifications that may or may not exist“.
I scored 69 out of 80 (86%), which took 25 minutes (1h allowed). This feels okay but the most important aspect was that through the reflection on some missed points I could improve my insights.
“Although there’s value in certification, assessment is valued more.”
In The adoption of Agile I stated that ‘Agile’ is not one method, but a set of common principles and practices. The same goes for ‘Agile Planning’.
I created my My.Fragility framework iteratively over the various software development projects I mastered, all serving to realize a (negotiable) scope within a certain timeframe.
The included Product Backlog Estimation model allows to:
- Write User Stories. Or Epic Stories
- Make up estimates in Ideal Time / Story Points
- Determine Velocity. Possibly, but not advisable, per story
- Determine #pairs. Consider project elapse time, max = 6
- Determine #FTE for umbrella tasks. Upon #pairs and complexity
- Set daily rates
- Set slack, holiday percentage and coach development
- Assess result & iterate using other parameters
- Set Value of Stories. Total to be 100 (for relative tracking)
The Product Backlog Tracking model implements my Tracking Loops:
This assures a continuous image of spent and expected progress, effort, budget and delivered value, at Product and at Sprint level.
The book User Stories Applied by Mike Cohn was a great source of inspiration. Essentials I still use are:
- User Stories, Epic Stories and micro (tiny) Stories
- The INVEST acronym
- Complexity scaling. I use ‘1-2-5’ (over Fibonacci)
Mike’s publisher (Prentice Hall) has made 2 chapters of his second book Agile Estimating and Planning available, for F R E E:
An interesting poll was posted at Scrumology asking us to indicate where we consider ‘Agile’ to be on the Hype Cycle. A little note…
The presentation of my framework My.Fragility starts with a general introduction on ‘Agile’ before diving into Scrum and going beyond. This introduction ends with a maturity assessment of Agile using Geoffrey Moore’s Technology Adoption Life Cycle. The conclusion is that Agile has Entered the Bowling Alley (so has definitely Crossed the Chasm).
In 2008 I added a comparison with Gartner’s Hype Cycle for Application Development, which puts Agile in the Trough of Disillusionment and predicts a period of 5-10 years before mainstream adoption.
However, having studied and compared both models I am convinced that Agile is -at least- on its way to the Slope of Enlightenment:
Other objections I have with Gartner are:
- Agile is primarily the common denominator of a number of methods and is as such not one defined method. As a practitioner of Scrum, combining it with XP and going beyond with My.Fragility, I believe these methods to be certainly farther in adoption.
- A complete Agile approach covers a number of practices and disciplines that Gartner separates (e.g. various testing levels). See my indications on the Hype Cycle.
- My intuition and daily experience contradict the 5-10y expectation.
Challenge: from the TALC I expect Scrum to become the Agile Gorilla…
Scrum is also in the minds of people. My mind is set on the ability of fragility. How about you?
Are you ‘management’? Then you should not only be willing to believe that a software project can truly deliver quality and business value. You should also do (a lot) more than just gather a group of programmers with a project manager on top during a (project’s) timebox.
Okay, so far for a view the community will quickly agree upon.
What is usually less focused on is the level of commitment of the actual team members. In my experience this may turn out to be at least as difficult to achieve. Because it takes the absolute will to self-organize, not wanting to depend on other people to take decisions for you (the essence of ScrumMaster facilitation versus Project Management’s execution of control), to outweigh every (technical) choice against the (business) value and functional profit, to discuss and communicate openly, etc.
Scrum is a simple way to outperform and excel but all parties should respect its essence, that I represent on my Scrum Diamond:
think (talk) about it…
Kan and Ban are Japanese for Card and Signal. A Kanban (signal card) originates from the Toyota Production System (TPS) where it is a physical card that visualizes a pull question for inventory. It serves to minimize stock in a ‘Just In Time’ strategy and is a way to ‘eliminate waste’ while assuring a continuous flow of goods.
In an Agile context, a Story Card is a Kanban. Out of eXtreme Programming it grew into an established Agile practice in describing a feature. A Kanban Board holds the active Story Cards per ‘status’, thus being an Information Radiator (term by Alistair Cockburn, also my inspiration for the Games metaphor).
My Scrum Product ànd Sprint Backlog items are User Stories. (‘Minimal Marketable Feature’ is more generic, but I stick to ‘User Story’) The Sprint Backlog is made visible by sticking a printout from my (Excel) tracking model on a wall. Around the Daily Scrum (we do it standing up) each Story Lead writes the estimated time to finish a Story on the printout and I create the Sprint Burndown. That works fine. We use a Kanban Board only for feedback from functional testing. This is generally too small to create a Story (would be ‘waste’).
Velocity is a way to optimize the inventory and the continuity of work. Traditionally ‘velocity’ equals the #Story Points (gummy bears) that can be finished in one iteration (a Sprint). However, I apply an overall Velocity as a multiplicator on Story Points (ideal time) to result in #planning days. The size of the inventory (in #Story Points) for a Sprint is determined by dividing the available #planning days of a team (minus 2 slack days) by expected Velocity (Yesterday’s weather). Note: continuity is also assured by the presence of the Product Owner. He/she makes sure that no functional issue remains unsolved, on the spot!