I'm currently reading
Brain of the Firm, by
Stafford Beer.
On page 36 he writes:
The outcome is startling ...
... the total system is dominated, not by the forward network, but by the feedback network ...
The output signals will be of greater 'purity' than we had any right to expect.
The word
feedback caught my eye.
Feedback is a key principle of
complex
adaptive
systems.
Feedback is also one of the
4 values of
eXtreme Programming.
Feedback also gets several mentions in the official
Scrum Guide.
So I've been playing around with
Feller's walk (named after
William Feller) some more...
Feller's Walk
Each Feller's walk is 1000 steps long, and at each step I flip a fair coin.
As I walk I keep a running total (starting at zero):
- adding one each time I flip a head
- subtracting one each time I flip a tail
What will the total look like as the walk progresses?
Here's the plot of the step (x-axis) against the total (y-axis) during one simulated walk.
It starts at a total of zero on the far left and wanders along, edging upwards when a head is thrown, edging downwards when a tail is thrown, and ending at about -26 indicating that overall there were 487 heads and 513 tails (487-513=-26, 487+513==1000).
Apparently, most people's intuition is that the total will hover around zero.
But it doesn't.
You cannot rely on randomness to correct the problems that randomness creates.
Without constraints variance will accumulate.
If the total happens to be +24 the coin isn't going to throw more tails for a while to try to balance things up.
Without feedback the coin has no memory.
To help see this I simulated 5000 walks and plotted the frequency of the total (y-axis) against the total (x-axis)
at various points along the walks:
- after 10 steps in gold
- after 100 steps in blue
- after 1000 steps in red
- I chop the x-axis to +- 2 standard deviations
| step |
freq[0] |
max abs(total) |
std.dev |
| 10 |
1204 |
-10 |
3.19 |
| 100 |
405 |
36 |
10.15 |
| 1000 |
121 |
140 |
31.71 |
Over all the walks, at the
10th step:
- the total was zero 1204 times
(5 heads, 5 tails, 5-5=0, 5+5=10)
- the total farthest from zero was -10
(0 heads, 10 tails, 0-10=-10, 0+10=10)
- the standard deviation of the total was 3.19
Over all the walks, at the
100th step:
- the total was zero 405 times
(50 heads, 50 tails, 50-50=0, 50+50=100)
- the total farthest from zero was 36
(68 heads, 32 tails, 68-32=36, 68+32=100)
- the standard deviation of the total was 10.15
Over all the walks, at the
1000th step:
- the total was zero 121 times
(500 heads, 500 tails, 500-500=0, 500+500=1000)
- the total farthest from zero was 140
(570 heads, 430 tails, 570-430=140, 570+430=1000)
- the standard deviation of the total was 31.71
The further along the walk I progress, the less likely my total is to be zero.
Without constraints variance will accumulate.
Once again, with feedback
Every Nth step, instead of flipping the coin, I look at the total and:
- if the total is negative (more tails than heads) I pretend I've flipped a head, and add one to the total.
- if the total is positive (more heads than tails) I pretend I've flipped a tail, and subtract one from the total.
This feedback increases the likelihood of the total
staying nearer to zero.
The smaller the value of N, the greater the effect.
Estimating feedback effectiveness
Using the simulation I can measure how good (or bad) people's estimates are of how effective feedback is.
For example, I can:
- run the simulation with some feedback (N==10 say) and display the results
- gather estimates with no feedback (N==never) of, eg
- freq[0], or
- max abs(total), or
- std.dev, etc
- run the simulation with no feedback and see how the actual results compare.
Or
- run the simulation with no feedback and display the results
- gather estimates of the least feedback needed to, eg
- triple freq[0], or
- quadruple max abs(total), or
- half std.dev, etc
- run the simulation with various amounts of feedback and see how the actual results compare.
I've put the simulation source up on
https://github.com/JonJagger/Fellers-1000-coin-tosses.
The simulation runs directly from this URL
https://rawgithub.com/JonJagger/Fellers-1000-coin-tosses/master/fellers.html so you can try out various values of N if you want to before reading on...
A little feedback goes a long way
Here's 5000 simulations of a 1000 step walk with N==25.
That means, that every 25th step instead of flipping the coin, the simulation nudges the total towards zero as described above.
| step |
freq[0] |
max abs(total) |
std.dev |
| 10 |
1379 |
-10 |
2.97 |
| 100 |
553 |
32 |
8.04 |
| 1000 |
387 |
84 |
15.18 |
The effectiveness of one feedback nudge every 25 steps amazes me.
- freq[0] tripled from
121 to
387
- max abs(total) shrank from
140 to
84
- std.dev halved from
31.71 to
15.18
Startling! Just as Stafford Beer said.
Let's hear it for feedback!