For effective Scrumming, stories should have the desirable INVEST characteristics: They should be independent, negotiable, valuable, estimable, sized, and testable). We'll assume that the product owner is trained in Scrum and creates clean stories...

If you've been involved in Agile development for the past 10 or 15 years, you may have noticed that certain patterns of Agile application have emerged. The Scrum Patterns repository has captured at least some of them. Like the Design Patterns that...

As I mentioned in my previous post last week I needed to scan all the jar files included with the neo4j-enterprise gem and I started out by finding out where it’s located on my machine:

$ bundle show neo4j-enterprise
/Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-enterprise-1.8.2-java

I then thought I could get a list of all the jar files using find and pipe it into zipinfo via xargs to get all the file names and then search for HighlyAvailableGraphDatabaseFactory:

Unfortunately when I tried that it didn’t quite work:

$ cd /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-enterprise-1.8.2-java/lib/neo4j-enterprise/jars/
$ find . -iname "*.jar" | xargs zipinfo
caution: filename not matched:  ./lib/neo4j-enterprise/jars/logback-classic-0.9.30.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/logback-core-0.9.30.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-backup-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-com-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-consistency-check-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-ha-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-udc-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/org.apache.servicemix.bundles.netty-3.2.5.Final_1.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/server-api-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/slf4j-api-1.6.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/zookeeper-3.3.2.jar

I switched ‘zipinfo’ to ‘echo’ to see what was going on which resulted in the following output:

$ find . -iname "*.jar" | xargs echo
./log4j-1.2.16.jar ./logback-classic-0.9.30.jar ./logback-core-0.9.30.jar ./neo4j-backup-1.8.2.jar ./neo4j-com-1.8.2.jar ./neo4j-consistency-check-1.8.2.jar ./neo4j-ha-1.8.2.jar ./neo4j-udc-1.8.2.jar ./org.apache.servicemix.bundles.netty-3.2.5.Final_1.jar ./server-api-1.8.2.jar ./slf4j-api-1.6.2.jar ./zookeeper-3.3.2.jar

As I understand it, xargs expects arguments to be separated by a space and I thought it would apply the command to each argument individually but it seemed to be including the space as part of the file name.

I’ve previously used the ‘-n’ flag to xargs to explicitly tell it to call the corresponding command with one argument at a time and that seemed to do the trick:

$ find . -iname "*.jar" | xargs -n1 zipinfo
Archive:  ./log4j-1.2.16.jar   481535 bytes   346 files
-rw----     2.0 fat     3186 bX defN 30-Mar-10 23:25 META-INF/MANIFEST.MF
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/
-rw----     2.0 fat    11366 bl defN 30-Mar-10 23:14 META-INF/LICENSE
-rw----     2.0 fat      160 bl defN 30-Mar-10 23:14 META-INF/NOTICE
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/log4j/
...

Of course to solve this particular we don’t actually need to use find and xargs since we can just call zipinfo with the wildcard match:

$ zipinfo \*.jar
Archive:  log4j-1.2.16.jar   481535 bytes   346 files
-rw----     2.0 fat     3186 bX defN 30-Mar-10 23:25 META-INF/MANIFEST.MF
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/
-rw----     2.0 fat    11366 bl defN 30-Mar-10 23:14 META-INF/LICENSE
-rw----     2.0 fat      160 bl defN 30-Mar-10 23:14 META-INF/NOTICE
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/log4j/
-rw----    
...

I’m curious why xargs didn’t work as I expected it to though – have I just misremembered its default behaviour or is something weird going on?

neo4.rb is a JRuby gem that allows you to create an embedded neo4j database and last week I was working out how to setup a neo4j 1.8.2 HA cluster using the gem.

There is an example showing how to create a HA cluster using neo4j.rb so I thought I could adapt that to do what I wanted.

I had the following Gemfile:

source 'http://rubygems.org'
 
gem 'neo4j', '2.2.4'
 
gem 'neo4j-community', '1.8.2'
gem 'neo4j-advanced', '1.8.2' 
gem 'neo4j-enterprise', '1.8.2'

And the following code copied from the example to start up the cluster:

require "rubygems"
require "bundler"
require 'fileutils'
require 'neo4j'
 
def start(machine_id)
  # override this default config with this machine configuration
  Neo4j.config['enable_ha'] = true
  Neo4j.config['ha.server_id'] = machine_id
  Neo4j.config['ha.server'] = "localhost:600#{machine_id}"
  Neo4j.config['ha.pull_interval'] = '500ms'
  Neo4j.config['ha.discovery.enabled'] = false
  other_machines = [1,2,3].map{|id| "localhost:500#{id}"}.join(',')
  puts "ha.initial_hosts: #{other_machines}"
  Neo4j.config['ha.initial_hosts'] = other_machines
  Neo4j.config['ha.cluster_server'] = "localhost:500#{machine_id}"
 
  Neo4j.config[:storage_path] = "db/neo#{machine_id}"
  Neo4j.start
end

As per the example’s instructions I started up an irb session and tried to start up an instance:

$ bundle exec install
$ bundle exec irb
irb(main):001:0> require 'myapp'
=> true
irb(main):002:0> start 1
ha.initial_hosts: localhost:5001,localhost:5002,localhost:5003
I, [2013-06-09T17:23:09.110000 #33848]  INFO -- : starting Neo4j in HA mode, machine id: 1 at localhost:6001 db /Users/markhneedham/projects/neo4j-rb-ha/db/neo1
NameError: cannot load Java class org.neo4j.graphdb.factory.HighlyAvailableGraphDatabaseFactory
	from org/jruby/javasupport/JavaClass.java:1225:in `for_name'
	from org/jruby/javasupport/JavaUtilities.java:34:in `get_proxy_class'
	from file:/Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/jruby.jar!/jruby/java/java_package_module_template.rb:4:in `const_missing'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:188:in `start_ha_graph_db'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:62:in `start'
	from org/jruby/ext/thread/Mutex.java:149:in `synchronize'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:53:in `start'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j/neo4j.rb:41:in `start'
	from /Users/markhneedham/projects/neo4j-rb-ha/myapp.rb:21:in `start'
	from (irb):2:in `evaluate'
	from org/jruby/RubyKernel.java:1066:in `eval'
	from org/jruby/RubyKernel.java:1392:in `loop'
	from org/jruby/RubyKernel.java:1174:in `catch'
	from org/jruby/RubyKernel.java:1174:in `catch'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/bin/irb:13:in `(root)'

A quick scan of the neo4j code indicated that the class HighlyAvailableGraphDatabaseFactory didn’t actually exist in any of the neo4j 1.8.2 jars and Max then pointed out the neo4j.rb change log which indicated that the clustering example was based around a neo4j 1.9 cluster.

If we want to create a neo4j 1.8 cluster then we need to tweak the settings a bit.

The instructions are available from an earlier revision of the neo4j.rb repository but I’ve cloned the repository and created a 1.8HA tag for future reference.

Essentially we’d need to revert back to the ’2.2.1′ version of the neo4j.rb gem and then run a script to startup some Zookeeper instances before following a similar process as described at the beginning of this post.

I’ve been playing around with how you might model Premier League managers tenures at different clubs in neo4j and eventually decided on the following model:

The date modelling is based on an approach I first came across in a shutl presentation and is described in more detail in the docs.

I created a dummy data set with some made up appointments and dismissals and then tried to write a query to show me who was the manager for a team on a specific date.

CREATE (year2013 { name: "2013" })
CREATE (january2013 { name: "January" })
CREATE (january012013 { name: "1st" })
CREATE (january022013 { name: "2nd" })
CREATE (january032013 { name: "3rd" })
CREATE (january042013 { name: "4th" })
CREATE (january052013 { name: "5th" })
 
CREATE (chelsea { name: "Chelsea", type: "team" })
CREATE (joseMourinho { name: "Jose Mourinho"})
CREATE (mourinhoChelsea { name: "Mourinho tenure at Chelsea" })
 
CREATE (manUtd { name: "Manchester United", type: "team" })
CREATE (davidMoyes { name: "David Moyes"})
CREATE (davidMoyesUnited { name: "Moyes tenure at Manchester United" })
 
CREATE (year2013)-[:`January`]-(january2013)
CREATE (january2013)-[:`01`]-(january012013)
CREATE (january2013)-[:`02`]-(january022013)
CREATE (january2013)-[:`03`]-(january032013)
CREATE (january2013)-[:`04`]-(january042013)
CREATE (january2013)-[:`05`]-(january052013)
 
CREATE (january012013)-[:NEXT]-(january022013)
CREATE (january022013)-[:NEXT]-(january032013)
CREATE (january032013)-[:NEXT]-(january042013)
CREATE (january042013)-[:NEXT]-(january052013)
 
CREATE (mourinhoChelsea)-[:HIRED_ON {date: "January 1st 2013"}]->(january012013)
CREATE (mourinhoChelsea)-[:MANAGER]->(joseMourinho)
CREATE (mourinhoChelsea)-[:TEAM]->(chelsea)
CREATE (mourinhoChelsea)-[:FIRED_ON]->(january032013)
 
CREATE (davidMoyesUnited)-[:HIRED_ON {date: "January 2nd 2013"}]->(january022013)
CREATE (davidMoyesUnited)-[:MANAGER]->(davidMoyes)
CREATE (davidMoyesUnited)-[:TEAM]->(manUtd)

START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), 
      date = node:node_auto_index(name="5th") 
MATCH date<-[:NEXT*0..]-()<-[hire:HIRED_ON]-tenure-[:MANAGER]->manager, 
      tenure-[:TEAM]->team, 
      tenure-[fired?:FIRED_ON]-dateFired
RETURN team.name, manager.name, hire.date, dateFired

The query starts from January 5th, then gets all the previous dates and looks for a ‘HIRED_ON’ relationship and then follows that to get the manager and the team for which it applies to.

We then traverse an optional ‘FIRED_ON’ relationship as well because we don’t want to say a manager is currently at a club if they’ve been fired.

It returns the following:

==> +----------------------------------------------------------------------------------+
==> | team.name           | manager.name    | hire.date          | dateFired           |
==> +----------------------------------------------------------------------------------+
==> | "Manchester United" | "David Moyes"   | "January 2nd 2013" | <null>              |
==> | "Chelsea"           | "Jose Mourinho" | "January 1st 2013" | Node[5]{name:"3rd"} |
==> +----------------------------------------------------------------------------------+
==> 2 rows

In this data set Jose Mourinho gets fired on the 3rd January so Chelsea shouldn’t have a manager on the 5th January.

One way to exclude him is to collect all the dates that our ‘NEXT’ relationship takes us to and then check if the ‘dateFired’ is in that collection. If it is then the manager has been fired and we shouldn’t return them:

START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), 
      startDate = node:node_auto_index(name="5th") 
MATCH startDate<-[:NEXT*0..]-day 
WITH team, startDate, COLLECT(day) AS dates 
MATCH startDate<-[:NEXT*0..]-day<-[hire:HIRED_ON]-tenure-[:MANAGER]->manager, 
      tenure-[:TEAM]->team, 
      tenure-[?:FIRED_ON]-dateFired 
WHERE dateFired IS NULL OR NOT dateFired IN dates
RETURN team.name, manager.name, hire.date, dateFired

That returns the following:

==> +----------------------------------------------------------------------+
==> | team.name           | manager.name  | hire.date          | dateFired |
==> +----------------------------------------------------------------------+
==> | "Manchester United" | "David Moyes" | "January 2nd 2013" | <null>    |
==> +----------------------------------------------------------------------+
==> 1 row

Unfortunately we now don’t get a row for Chelsea because the WHERE clause filters Mourinho out.

I couldn’t think how to get around this so Wes suggested using neo4j 2.0 and the CASE statement which makes this very easy.

I eventually ended up with the following query which does the job:

START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), 
      startDate = node:node_auto_index(name="2nd") 
MATCH startDate<-[:NEXT*0..]-day 
WITH team, startDate, COLLECT(day) AS dates 
MATCH startDate<-[:NEXT*0..]-day<-[hire:HIRED_ON]-tenure-[:MANAGER]->manager, 
      tenure-[:TEAM]->team, 
      tenure-[?:FIRED_ON]->dateFired 
RETURN team.name,    
       CASE WHEN dateFired is null THEN manager.name 
            WHEN dateFired IN dates THEN null 
            ELSE manager.name END as managerName,       
       CASE WHEN dateFired is null THEN hire.date 
            WHEN dateFired IN dates THEN null 
            ELSE hire.date END as hireDate

Here we’ve introduced the CASE statement which works pretty similarly to how the SQL CASE statement works so it should be somehow familiar. That query returns the following:

==> +----------------------------------------------------------+
==> | team.name           | managerName   | hireDate           |
==> +----------------------------------------------------------+
==> | "Manchester United" | "David Moyes" | "January 2nd 2013" |
==> | "Chelsea"           | <null>        | <null>             |
==> +----------------------------------------------------------+
==> 2 rows

which is exactly what we want. Now I need to import a real data set to see what it looks like!

A nice video about TOC and bottlenecks, featuring real bottles! 

 

http://youtu.be/mWh0cSsNmGY

As many folks know, Net Objectives does both Scrum and Kanban. Admittedly, our Scrum is very much like Scrumban (or Scrum done under the context of Lean) but it is still an implementation of Scrum.  Scrum, as it normally manifests itself, has several challenges in that it requires teams to learn too much about how to apply it (much is know that hasn't been incorporated into it) and many teams try...

[[ This is a content summary only. Visit my website for full links, other content, and more! ]]

Since lean comes from manufacturing, many question its validity for software developers. Our own experience is that Lean in software is very important.  This blog covers three areas: The essential paradigm shift of lean and why it applies even more to software How the physical world is different from the software world during implementation The Essential Lean Paradigm Shift. Lean builds on top...

[[ This is a content summary only. Visit my website for full links, other content, and more! ]]

Hi,

It’s a busy summer ahead with events, SPC Certifications, and the release of SAFe 2.5 (see post). so I thought I’d take a moment to let you know my personal, public schedule for summer and fall:

• June 10-11 & 13 ,  SAFe Certification in Berlin (Sold Out)
• June 12: Keynote: Berlin ScrumDay, 1:00 PM  June 12. (http://www.scrum-day.de)
• June 15: Keynote: DARE conference in Antwerp, Belgium
• July 10: Keynote: Scaling Agile Leadership Summit in Atlanta with Rally Software
• July 30-Aug 2: SAFe SPC Certification in Boulder, CO (seats  available)
• August 6, (2 PM) Talk:Agile 2013 in Nashville. Be Agile. Scale Up. Stay Lean. (I’ll be there most of that week)
• September 24-27, 2013:  SAFe SPC Certification with Al Shalloway in Seattle, WA. (seats  available)
• October 7-8&11: SAFe SPC Certification in London, UK. (event not yet open for registration)
• October 10: Keynote: Agile Business London
• November 4-5&8:  SAFe SPC Certification in Tallin, Estonia
• November 11: Keynote: Helsinki Agile Conference (event not yet open)

In addition, others one our team will be delivering regional certification events as well, including SPC certifications in the US, and planned for Australia and China for fall. Stay tuned to http://www.scaledagileacademy.com/events/event_list.asp.

In double addition, our partners are now delivering Leading SAFe courses around the world (20 events and locations this summer). You can find a course near you at: http://www.scaledagileacademy.com/events/event_list.asp.

 

Here is my near term  schedule for SAFe certification and public speaking events:

• June 10-11 & 13 ,  SAFe Certification in Berlin (Sold Out)
• June 12: Keynote: Berlin ScrumDay Keynote 1:00 PM  June 12. (http://www.scrum-day.de)
• June 15: Keynote: DARE conference in Antwerp, Belgium
• July 10: Keynote: Scaling Agile Leadership Summit in Atlanta with Rally Software
• July 30-Aug 2: SAFe SPC Certification in Boulder, CO (seats  available)
• August 6, (2 PM) Talk: Agile 2013 in Nashville. Be Agile. Scale Up. Stay Lean. (I’ll be at the conference most of that week)
• September 24-27, 2013:  SAFe SPC Certification with Al Shalloway in Seattle, WA. (seats  available)
• October 7-8&11: SAFe SPC Certification in London, UK. (event not yet open for registration)
• October 10: Keynote: Agile Business London
• November 4-5&8:  SAFe SPC Certification in Tallin, Estonia
• November 11: Keynote: Helsinki Agile Conference (event not yet open)

How do we suggest that managers …well… manage self-organizing teams?  By self-organizing, we also mean self-managing.

Let’s assume that not all ‘self-organizing teams’ will self-organize effectively.

So, a few suggestions.

1. Get rid of almost all the old stuff.

Really.

Maybe keep one or two ‘group’ meetings at fairly long intervals, eg, once a month. (We are assuming that the Sprint meetings will give them and you most of the information you all need.)

2. Offer to give the teams feedback.

Get reasonable information from the Scrum teams. Information that they already have.  Discuss with them how you are looking at overall success.  Go to the main meetings. Offer to discuss.  Offer to give feedback.  But don’t force yourself on them.

2b. Overall success

Of course managers should be involved in defining overall success for a team. The basic mission and the key constraints.

I would typically recommend a focus on business value and velocity.  By velocity, we always have to say “We don’t want you working more than 40 hours per week, but we want the overall velocity of the team to double. By removing impediments, not by working harder.”  And focus on quality. Always, it needs to be higher.

Measuring BV success is hard, but important.  (Much more to say, but not here, now.)

In general, business managers should be defining what BV is.  What BV means for a specific team.  Not technology managers.  Ceteris paribus.  (Other things equal.)

3. Offer to fix impediments.

Offer to help. Or approve money, or other people, or just help get permission.

Offer once each Sprint, at least.

4. Group yourselves in small teams (of managers).

We think managing Scrum teams doing innovation is very hard.  The problems each team is trying to address are usually quite hard.  The dynamics inside a team are complex. Etc. Etc. It is a problem (or set of problems) where we need multiple heads to consult.

So, I recommend that 3 managers group themselves, and manage 5-7 teams together. And consult with each other about how to help the teams be more successful.

As implied by my prior comments, at least one of these managers should be a business manager.  Someone who looks at things mainly through a BV lens.

5. Impediment Removal Team

I recommend managers form an “impediment removal team” (IRT).  And that the managers take impediments from the teams, and work on them, one at a time. And deliver ‘fixes’.

Discuss with the team when the IRT will take impediments, and when the impediments will ‘stay’ with the team.

6. After some time, intervene if the team is failing.

“After some time” is the hard part.  How long to wait?  How much do you say?  When?  How?

First, let me suggest that if you smell problems, ask the Team.  And ask them if they want help.

Do not look only at the ‘leaders’ in the team (eg, the PO and the SM).  Ask the whole team.  Remind them that they are all responsible for success.

In some cases, the team or the situation can be quite messed up. You just must intervene.  But usually they should at least have told you the problems (the impediments) and you should be agreeing.  And usually, depending on the nature of the impediment, you have given the team a reasonable opportunity to address the impediment themselves, their way.

And your action (as a small team of managers) could be selected from a very broad range, depending on the nature of the situation.

You could cancel the effort.
You could disband the team.
You could add or subtract a person.
You could some people more highly dedicated.
You could help them get better Continuous Integation and better automated testing.
You could help them improve the Agile Specs getting into the Team (just enough, just in time, documentation).
You could get a more specific impediment fixed. In possibly lots of different categories.

Does this make the manager’s job more specific?

For those SPCs and others who have been working directly with the Scaled Agile Framework, it will come as no surprise that the next update – V2.5 – is imminent. Indeed, many of you have contributed to the new concepts, including a few of you who were directly involved in redesigning that gnarly release-planning-flow thing. In addition, we’ve struggled over time with communicating the Develop on Cadence, Deliver on Demand message, that is not so obvious from the 2.1 Big Picture, so we’ve had dozens of variants for that in flight as well.

In any case, we have finally converged on a new design and icon/objects for V 2.5, and we are releasing it here in a staging area for SPC and customer preview. It is incomplete, but communicates better than the existing model, so we are releasing it here scaledagileframework.com/BP25 incrementally, including linking a number of new articles to new BP objects/icons. Many new articles are yet to be developed.

SAFe 2.5 Big Picture Preview

 

There are two new major graphic/communication elements.

1. The new release planning flow. The yellow down and up bars, resulting in both Team PSI Objectives and Program PSI objectives. That was always true, but not very explained very well in the conflated “Objectives” object.

2. New treatment for Develop on Cadence. Deliver on Demand, now with “green means go tips”, not just at the PSI boundaries, but whenever the system has potentially releasable conceptual integrity.

There are 6 new objects:

1. Business Owners. Linked to draft article.

2. Sprint goals. Linked to draft article.

3. Value Streams. Linked to draft article.

4. Deployment Operations. WIP; not released yet

5. Team and Program PSI Objectives. WIP; not released yet.

6. Sprint Execution. WIP; not released yet.

The Plan

And here’s the plan:

• Update Courseware end of July
• Finalize and push new BP Aug 1, 2013 (may have some articles in Abstract form initially)
• Announce at Agile 2013.

….. then complete any missing article details as quickly as possible, if not already done.

 

 

I’ve done storymapping many times over the years, and Jeff Patton’s article is a great source for the fundamentals.  I always prefer to start with a few people to build the initial map.  But we had product owners, UX designers, coaches, and technical account managers all talking to customers in a new problem space, and they all wanted a say in what we build.  

So when my colleague Stephen asked me to help facilitate a meeting to talk about what we should build in that new problem space, I tried to get him to keep it to about four people.

Stephen wanted to include everyone who wanted a say, so he sent out an invite to 15.  Only 8 accepted, so I figured I’d just split into two groups of four and they’d work on different parts of the map.

But that morning, all 15 people showed up.  I had to improvise, but with some quick thinking, I was able to make it work and go from 15 different opinions to a prioritized list of user tasks.  Here’s how we did it.

1. We started with personas.  We have a standard set of a dozen or so that we use across key products.  We reviewed them with the group.  Then I split them into three groups: four people who had recently visited customer A, 4 people who had visited customer B, and 4 people who had spent time with several other customers.  I asked each group to think about the people they had encountered on their visits who were working in the problem space we were exploring.  I asked them to write those people’s names on purple index cards along with the persona they represented.

We read out from each group, and I set the purple cards on the matching persona sheets.  We then had a large group conversation about whether there were clusters of related personas who seemed to be working on similar activities from similar perspectives.  Turns out, we had 3 clusters of personas who basically approached the problem space in similar ways. All of this took about an hour.

2. After a 10 minute break, I asked people to split into 3 groups of 4-5 to focus on those clusters.  I gave each group exactly 5 blue index cards, and then gave them 7 minutes to identify the top 5 activities that their personas needed to do in the problem space.

(Why exactly 5 cards?  I didn’t want too many items at too fine a granularity. 5 seemed to be a good starting point.  I was ready with spare cards but nobody asked for them.)

After 7 minutes, one group had 5 perfect activities, another group had no activities written down, and the third group had found some sneaky blue sticky notes that almost matched the color of the index cards - they were debating 9 options.  (You can see another Steve in this group in the bottom of the photo above).  

To break the logjams, I rotated 1 person out of each group and gave them another 5 minutes to finish the top five user activities.  We did a quick readout from each group, and then I rotated another person out (so each group had 2 original members and 2 new members).  

3. With the newly mixed groups, I gave each a big pile of yellow stickies and asked them to break their activities into user tasks - specifically tasks where the personas were substantially blocked in their activity and we felt we could make a big difference with software.  I gave them 15 minutes for this.  

4. Then I asked each group to choose a spokesperson to stay behind, and 3 people to move to another group, listen to the presentation, and provide feedback.  Each participant got 2 sticker dots to vote on the tasks they thought represented the best opportunities for us in the problem space.  

 

5. I repeated this for the other remaining group, and did a final 5-minute chance for the spokespeople to also see and vote on the other clusters.

6. Now, I reformed the original groups from step 3.  I asked them to order the yellow cards, best opportunities highest, using the dots as an input.

7. I gave the groups 90 seconds to choose their number 1 task for each persona cluster.  The results were read out to much cheering from other participants.  We repeated - another 90 seconds to choose number 2, and 90 seconds to choose number 3.  (This tight timebox worked out because we had been discussing the work for several hours and we just needed to push for a decision.)

Presto! In just a couple of hours, 15 strong-willed and well-informed people were in agreement about our top priorities in a new and complex problem space.

I’d love to answer clarifying questions in the comments about the details of running this kind of activity.

 

Alex Pukinskis

Something I wish I had read years ago (or found out about) is this nice concise list of resources around distributed systems:

http://dancres.org/reading_list.html

When I started having issues around 2PC, and twitter was being beyond unhelpful with pointers to actual resources, this list of papers did way more than random internet searching did. One of the more frustrating things about the distributed systems community is that the writings are…well…distributed. You don’t know what questions to ask or even what to begin looking for. This list at least provides a great start.

And for ongoing information, the high scalability blog is also a nice resource. Hopefully this helps the next person with scale problems out!

Post Footer automatically generated by Add Post Footer Plugin for wordpress.

A very effective learning that has come out of many fields of research is that we function well in small groups, specifically groups that range from five to seven people in total. Scrum allows for a slight expansion of that range up to twelve people.  This allows for enough people to be together to discuss issues and solve complex software problems with a diversity of skills and experience.  As well as avoiding the problem of having too many people that the lines of communication become overwhelming.  If the Scrum Team is only four people, then that means that you only have two people doing the tasks in the Sprint Backlog (since the others are the ScrumMaster and the Product Owner). If the team is thirteen or more people then trying to discuss issues, having a focused Daily Scrum meeting, and even building an effective Scrum Team becomes that much harder.  The larger the team, the longer it takes to get to a high-performance state.