Archives for posts with tag: system theory

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

Finding the real cause of a project problem can be a difficult task. You have to look for patterns

“These patterns are dynamic systems in action, a human system seen over a time period. Patterns are trends over time and involve dependencies with other systems. To spot such trends in projects we use metrics as indicators. If I have the right metrics I can ignore everything around me and focus just on the dashboard.”

loop Systems Thinking: A Technique To Find Project Problems
Image by Kjai.rm

A technique that can be used to find patterns and the real cause-effect-chains in projects is systems thinking. “Systems Thinking” is one of the 5 disciplines described in the famous book “The Fifth Discipline” by Peter Senge (for an overview view my posting “Fifth Discipline: What To Do When All Your Projects Are Failing“).

This is the first post in a series that will describe this technique and how to use it in your projects.

In The Fifth Discipline an organization is viewed as multiple “systems” (or you may think about processes) that interact with each other. The systems are not viewed as linear, but more as loops that keep on repeating, until some change has been done.

In the Fifth Discipline Fieldbook the image that is presented is that of “loops” and “links”:

“In systems thinking, every picture tells a story. From any element in a situation (or ‘variable’), you can trace arrows (‘links’) that represent influences on another element. These in turn, reveal cycles that repeat themselves, time after time, making situations better or worse.”

Car Repair Shop

To give you an idea, consider the following example:

A car repair shop has not much to do. If a client comes with his car, he can be serviced immediately. After a while worth of mouth about the speed of service, provides this repair shop with an increasing number of clients. As the number of clients grows, the waiting time for service also increases. When the service time takes too long, clients go away. Having fewer clients, again, the speed of service is up again.

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

The archetypes are the stereotypes of organizational problems; the sweet girl, the evil stepmother and the jealous husband from organizational theory if you want.

Basic Structures Underlying The Archetypes

However, underlying the archetypes are three basic structures, the components that make up almost everything, the systems DNA:

  1. Reinforcing Feedback Loops
  2. Balancing Feedback Loops
  3. Delays

Feedback Loops In General

A feedback loop is like a boomerang: you throw it away from you, and after a while, it kicks you back in the head. In the sample of the car repair shop the speed of service creates a chain of event (word of mouth, increase in customers), which after a while influences the speed of service. So with feedback loops there is a cause, and after a chain of effects, the cause itself is influenced again: this is why it’s called a “loop”.

Reinforcing Feedback Loops

This kind of loop generates an ongoing rise of growth or fall (exponential, if you are into that kind of lingo). Sales keep on growing and growing with ever increasing speed. The quality of service is dropping of the scale more and more. With a reinforcing loop a small change feeds itself; it starts slow, but will have a tremendous speed after a while, all by itself. You can actually think about it as a “snowball effect”.

Balancing Feedback Loops

Balancing loops have some kind of limit build in them. When this limit is reached, the plateau, it drops, and having reached some lower limit, it goes up again. It is balancing around a certain point. This type of feedback loops have the appearance of self-regulating.

For an example see the car repair shop earlier in this post.

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.

Let me give you an example:

A fast paced project runs into time and money problems. New plans are drawn up fast to minimize the impact, but as some more time and budget may be needed, an agreement / decision of some higher level is needed (e.g. a steering committee).

When this higher corporate instance needs a long time to give the ok or to take a decision (either because of availability of the players, or corporate politics, or some “we need more info”, “create more alternatives”) the project should halt. However, the running project might not stop (even if it is the wise thing to do), and can
either run in the original way, or already starts adopting the new plan.

If the project starts adopting the new plan, pending the decision, on the assumption that they will get the ok the situation can occur that when the ok comes, everything is already finished: you can call it “Retrospective Decision Making”.

Next time:

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?

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