Archives for posts with tag: fifth-discipline

“All this talking about self-organization, complex systems and other fuzzy wuzzy stuff. HOW DO I USE THIS IN A REAL PROJECT?”

Fair enough. It is the same question I have.

In this post I will outline my idea for a technique that combines the notion of a project as human system working towards a desired goal (see: Second Turn: Structure For Resilience) and systems thinking, a technique that can be used to find patterns and the real cause-effect-chains in projects. I would really appreciate your additions and comments to this concept.

teamflow2 Shared Systems View: Bootstrapping Adaptive Capacity In Your Project

Adaptive Capacity

A project is a human system working towards a desired goal. A project is running within an environment that is changing continuously.The project needs ways to deal with these changes and still keep performing its function, that is, reaching the desired goal. The project needs a capacity to adapt.

Self Organization

An important concept that allows for adaptive capacity is “self organization”. In contrast to a traditional central plan-and-control organization this would allow for individuals to act fast upon changes in the environment, it would allocate the proper resources to a problem more efficiently. There is no central bottleneck for information which consumes time. There is no central point of decision that has only a fraction of the collective mental capacity.

Self-organization in project teams only works when everybody uses the same rules of engagement, when everybody has the same sense of how things are done within the team (culture).

Continuous Transparent Feedback

A system always communicates with its environment and based upon the feedback it gets from it, alters its behavior. If a group of animals will drink water from a well and one of the groups dies because of it, they entire group may search for a different well. If a company introduces a new product, and sees its stock plummeting because of it, it might change its strategy. It is therefor essential that the organization members get continuous feedback on their own performance and the environment. This is where the use of analytics, metrics and in-your-face information visualization comes in.

Creating A Shared Systems View

Disclaimer: this is an experimental technique. This is not tested. This is not a best-practice. You should only try this if your are really good. If you know what you are doing. This is an idea.

At the start of your project organize a workshop with your team and key stakeholders. You will create a shared systems view of the project. The benefits of doing this are

  • this will synchronize an important part of the “how we do things” rule set.
  • you will discuss and define the metrics that will be used as a feedback mechanism to the team to self-organize.
  • you will create insights in a complex situation by using the collective knowledge of your team.
  • you create the foundation for fast and speedy discussions when the project is actually running into problems.

The process contains five steps:

1. Go through the flow of the process

The first step is to discuss the flow of the process, the project steps (Prince2, Scrum, XP or your own process). Don’t copy the outline of your handbook, make it dynamic using a whiteboard.

The goal is to create a common understanding of the process. Use an informal notation that uses words and arrows pointing from one word to another.

Look at these examples for suggestions.

2. Define metric variables

The behavior of a system can be described using variables. A variable is an element of the systems you are looking at that changes over time, like “speed of service”, “number of clients” or “number of customers that slap you in the face”. When analyzing or discussing your project, you have to look at a certain variable (like budget overrun, defect rate) over time, and then investigate the trend.

First you have to decide on your variables. You can start anywhere.

Just pick the issue that is bothering you the most, or variables that have the highest priority.

Remember, you are going to look for patterns over time. E.g. Programmer productivity is dropping.

For projects you can use for example:

  • Schedule slippage
  • Budget overrun
  • Developer productivity
  • Size of backlog
  • Number of change requests
  • Number of bugs found
  • Number of test cases performed per day

3. Discuss how variables influence each other

All these variables can rise or fall over a period of time. Discuss how a variable evolved over time and what the current status is. Always use words that indicate movement: goes down, goes up, increases, rises, falls, improves …

Then comes the next step: connecting variables. What is the impact of the movement of the first element on the next?

Because productivity is dropping, the risk of schedule slippage increases. You have to try to tell your story using sentences that indicate a causal relationship. “As this happens, then …”, “This in turn causes …”.

Go back and forth for a while. Make the story as detailed as possible. Avoid being judgemental. Only look for cause and effects.

(This technique is described in detail in The Fifth Discipline Fieldbook.)

4. Put delays in to the systems view

In this step you explicitly focus on delays. Not every effect follows its cause nicely in a timely fashion; it doesn’t have to wait neatly until the cause is completely finished before it will start. You can have time issues. Delays can occur in all kinds of loops. Problematic situations can arise when interacting loops have different kinds of timing. Delays make it difficult to “see” cause and effects, because it is not clear what triggered an event if its root happened already a while ago.

One of the main causes of problems within projects (and companies in general) are two interacting processes where one of them has a large delay; this delay causes problems in the other, much faster process.

5. Summarize

In the final step of the workshop you will create an integrated map of the process steps, the variables, causes and effects and delays. This will be the reference/starting point when future problems in the project are discussed. Every future discussion will cause an update in the systems view.

I would really appreciate your additions and comments to this concept.

This is the final post in my series about using systems thinking for analyzing problems in projects.

1. Systems Thinking: A Technique To Find Project Problems
2. Systems Thinking: Looking For Causal Loops
3. Shifting The Burden And Fixes That Backfire – Archetypes Part 1
4. Limits To Growth And Tragedy Of The Commons – Archetypes Part 2

I started this topic to be able to analyze problematic situations in projects. You will need to try this technique a few times before you really get the hang of it.

To be a good project manager you have to “see” potential problems. Literature provides us with large lists of potential problems in projects. You could look at all those lists to see if your problem is on it somewhere. But wouldn’t it be great to be able to look at problems in your project on a more fundamental level? That would be the best thing that can happen to you, and the techniques discussed in this series, will help you just with that!

Start running small workshops where you discuss the variables you chose (like budget overrun, number of bugs).

  • If this variable is going up or down with ever increased speed you have to look for a reinforcing loop;
  • If the variable is moving towards a threshold, and either stays on this threshold or starts oscillating around it, you have a balancing loop;
  • When a problem symptom alternately improves (the variable goes down) and deteriorates (problem goes up worse than before) you might have a “Fixes That Backfire” on your hands;
  • There is growth (sometimes explosive) leveling off or failing into decline, you might start looking for “Limits To Growth”.

Getting familiar with the archetypes helps you looking for the right loops and links.

And there is an additional bonus: when discussing and talking about the problems in this way, the solutions just “pop up” as you are addressing the fundamental causes.

This is the fourth post in my series about using systems thinking for analyzing problems in projects. I recommend you read the previous posts before diving head first into this post.

Archetypes can be considered as stereotypes of problematic situations. When analyzing a situation they are the standard patterns you look for.

In this post I will describe two archetypes:

  • Limits To Growth
  • Tragedy Of The Commons

limgr Limits To Growth And Tragedy Of The Commons   Archetypes Part 2
Image by laurenatclemson.

Limits To Growth

In this case two processes are intervening with each other: a process that indicates growth, and a process that puts limits to this growth (with a delay). If you think about project management a classical sample of this type is the addition of members to a team to increase the total productivity of this team.

limitsgrowth Limits To Growth And Tragedy Of The Commons   Archetypes Part 2

Example

To increase productivity of a team new fresh employees are added to the team. However, people need time to learn the ropes within the teams working environment, and with extra members to total communication overhead increases.

Within small teams this may not have a large impact on the productivity of the individual team members, but as more and more new members are put to a team, the productivity gain will drop. It will probably plateau at a given moment, or, when teams are getting too large, too much new members are added simultaneously, etc. it may even drop.

If you have a variable that is increasing and all of a sudden you hit a plateau or it even collapses, you might look for a “Limits To Growth” situation.

Tragedy Of The Commons

The Fifth Discipline archetypes I discussed until know can be considered as relatively simple. Just a view loops that are interacting. Reality will be more complex where multiple archetypes are interacting with each other. The next archetype is such a situation: Tragedy of The Commons.

With Tragedy of The Commons you have multiple Limits To Growth that are interacting with each other. To be more precise, they are interacting on the same limiting process or constraint. The symptoms are identical to a single Limits To Growth, but with increased speed, and not transparent.

tragedy Limits To Growth And Tragedy Of The Commons   Archetypes Part 2

Example

Consider the situation where you have two projects (A and B) that are both in testing phase. The growing process is finding new bugs by the test team. The overall performance per project is the number of bugs at a given moment. This will not be increasing forever as the bugfix team will resolve the bugs with some delay. However, the speed of fixing is limited by the capacity of the team.

Now consider the situation where the fix team within a company is shared. So project B will use the same capacity of the fix team. The two processes are interacting on a common resource.

Normally the capacity is calculated for such situations. But what happens: project A sees that by giving bugs a high priority, the time they get their fix speeds up. Project B concludes the same thing, and does this also. And although the capacity is calculated to handle two projects (but only when using the “real” priorities of bugs) the overall performance drops like a fly.

Next time:

Final analysis.

This a post in my series about using systems thinking for analyzing problems in projects.

1. Systems Thinking: A Technique To Find Project Problems
2. Systems Thinking: Looking For Causal Loops
3. Shifting The Burden And Fixes That Backfire – Archetypes Part 1
4. Limits To Growth And Tragedy Of The Commons – Archetypes Part 2
5. Systems View – Final Analysis

This is the third post in my series about using systems thinking for analyzing problems in projects. I recommend you read the previous posts before diving head first into this post.

After extensive research Peter Senge, author of the book The Fifth Discipline, found patterns that were common among the situations he studied; a couple of loops that occurred in multiple situations: the archetypes.

Archetypes can be considered as stereotypes of problematic situations. When analyzing a situation they are the standard patterns you look for.

In this post I will describe two archetypes:

  • Shifting The Burden
  • Fixes That Backfire

oops Shifting The Burden And Fixes That Backfire    Archetypes Part 1
Image by Terry Wha.

Shifting The Burden

With Shifting The Burden a problem is only superficially fixed and not at its root. A problem occurs and a corrective measure is put into place. However, this is a symptomatic solution that doesn’t tackle the fundamental problem. The fundamental solution takes time; there is a delay before its effects will be visible.

Because of the delay the fundamental solution is harder to find, or more costly to implement. But as the symptomatic solution has only side effects (negative) on the fundamental problem, the situation will not be solved, and will even deteriorate.

shiftingburden Shifting The Burden And Fixes That Backfire    Archetypes Part 1

(note: the hourglass in the diagrams indicate a delay)

Example

Two information systems have an interface running from system A to system B. Short after going live many data records are marked as error on the receiving end at system B.

The fundamental solution would be to analyze the records properly, perhaps do some redesign and code fixing. However that will take time (delay). The short-term symptomatic solution is to just “fix” the erroneous records by updating the fields that cause the errors.

At first this does the trick, however after doing this for a while the backlog of wrong records is large; one cannot keep up with fixing the data records. Because of the large amount errors are cascading, making the situation worse and worse.

Fixes That Backfire

Within this system you have two loops that interfere with each other: there is a problematic situation that is solved by a short term (quick) solution. However this loop has unintended consequences that only make the situation worse. The quick fix that bites you in the back.

The sneaky part here is that there is a delay in the backfire: you will only see the unintended consequences after a while.

backfire Shifting The Burden And Fixes That Backfire    Archetypes Part 1

Example

Suppose you have a software system under development. The quality is not good enough and it is not addressing the right business issues. You assume that this is caused by the lack of quality that your user
group brings into the project: they have a hard time formulating the requirements, they have no experience in testing, and seem to resist change in general.

A quick solution is to bring in external consultants. They will analyze the requirements, they will even do all the testing for you. You actually leave the end users completely out of the loop. Quality of the software increases, and the speed of your project progress is going up.

However, because the lack of involvement, there comes a time when the end users are needed for crucial information, or even in the end, when they have to use the system. It is not their system, it’s yours.

They will not help you out with the important info, and will not accept the system as something they really want to adopt. Which in the end lowers the quality of the system and ruins your chances of reaching the business goals set for the new system.

Next time:

Two other archetypes: Limits To Growth and Tragedy Of The Commons.

This a post in my series about using systems thinking for analyzing problems in projects.

1. Systems Thinking: A Technique To Find Project Problems
2. Systems Thinking: Looking For Causal Loops
3. Shifting The Burden And Fixes That Backfire – Archetypes Part 1
4. Limits To Growth And Tragedy Of The Commons – Archetypes Part 2
5. Systems View – Final Analysis

Yesterday I talked about how systems thinking can be used to find patterns and cause-effect-chains that help you find solutions to problems in projects.

All these patterns, links and loops are fine and dandy, but you are probably wondering right now how this is going to help you running your project?

Check Out This Example Of The Housing Crisis.

housing Systems Thinking: Looking For Causal Loops
Image by I See Modern Britain.

First have a look at this great example about the housing crisis. Twitter user @jeremyx sent it in reply to yesterday’s post. Thanks!

I recommend to go to this example and click on “2. Trace Causal Loops”. It provides a nice, step by step explanation of the elements of the housing crisis

“Tracing the CLD (causal loop diagram) will give you a high-level understanding of the relationships between the key components of the underlying model – housing supply, housing prices and demand for both housing and mortgages.

Stepping through the feedback loops really helps to explain the situation in very operational terms. And it’s much easier to understand what’s happening when you’re dealing with one loop at a time.”

And… you’re back!

The behavior of a system can be described using variables. A variable is an element of the systems you are looking at that changes over time, like “speed of service”, “number of clients”” or “number of customers that slap you in the face”. Or in the housing example “housing supply” and “housing prices”.

When analyzing your project using systems thinking, you have to look at a certain variable (like budget overrun, defect rate) over time, and then investigate the trend.

You are looking for patterns of behavior over time. As the systems are reocurring loops that effect certain aspects, patterns will emerge when you view them over time.

The pattern that you might discover is a hint to which archetypes one might look into (archetypes are the stereotypes of organizational problems and will be discussed in a later post). They don’t provide the final answer at once, you might try several archetypes before settling on your final verdict.

But first you have to decide on your variables.

You can start anywhere.

Just pick the issue that is bothering you the most, but don’t try to explain it, yet.

Remember, you are just looking for patterns over time. E.g. Programmer productivity is dropping. When you are doing this exercise with other people, it is always nice to use an element of the situation that can relatively be measured neutral.

For projects you can use:

  • Schedule slippage
  • Budget overrun
  • Programmer productivity
  • Size of backlog
  • Number of change requests
  • Number of bugs found
  • Number of test cases performed per day

You get the idea.

Telling The Story

All these elements can rise or fall over a period of time. Try to describe how this element evolved over time and how the current status is. Always use words that indicate movement: goes down, goes up, increases, rises, falls, improves …

Then comes the next step: connecting elements. What is the impact of the movement of the first element on the next?

Because productivity is dropping, the risk of schedule slippage increases. You have to try to tell your story using sentences that indicate a causal relationship. “As this happens, then …”, “This in turn causes …”.

Go back and forth for a while. Make the story as detailed as possible. Avoid being judgemental. Only look for cause and effects. After a while, your loops will pop of the whiteboards!

This technique is described in detail in “The Fifth Discipline Fieldbook”.

Next up…

The Archetypes explained.

This a post in my series about using systems thinking for analyzing problems in projects.

1. Systems Thinking: A Technique To Find Project Problems
2. Systems Thinking: Looking For Causal Loops
3. Shifting The Burden And Fixes That Backfire – Archetypes Part 1
4. Limits To Growth And Tragedy Of The Commons – Archetypes Part 2
5. Systems View – Final Analysis