Hi. I'm Jon Jagger.
I help software teams improve their effectiveness.
I built cyber-dojo, the place teams practice programming.
I'm based in the UK.
I've worked in 22 countries.
If you don't like my work, I won't invoice you.
Hire me

This equation was described in the 1970s by Robert May, George Oster, and Jim Yorke. You can read about it here.
The gist is it models a population over time,
a population at generationg+1 being affected by the population at generation g.
If there is no overcrowding then each member of the population at generation g, denoted Pg, produces α offspring, all of whom survive.
So the population at generation g+1, denoted Pg+1 equals α Pg.
The additional term, (1 - Pg ) represents feedback from overcrowding.
Some interesting things happen depending on the value of α

α < 1: The population goes extinct.

1 < α < 3 : The population rises to a value and then stays there.

3 < α < 3.57 : The population alternates between boom and bust.

3.57 < α : The population appears to fluctuate randomly.

In biological systems each generation has a natural lifespan.
The cycle of death naturally helps to reduce overcrowding.
But even with the inevitable death of each generation, the system's behaviour
is delicately poised.
Once α gets into the 3 - 3.57 range the growth starts to outpace the death leading to a rising population, but this leads to overcrowding which reduces the growth leading to a falling population. That reduces overcrowding, and growth rises again.
The population repeats in a stable up/down cycle. But only because of the inevitable death. And only while the rate of death is sufficiently high to maintain the cycle. Once α gets beyond 3.57 the rate of death can no longer regulate the increased rate of growth and the system destabilises.

You can think about the process of writing software with this equation.

You can think of over-crowding as being analogous to over-coupling.
We feel that a codebase is hard to work with, difficult to live in, if it resists our attempts
to work with it. When it resists it is the coupling that is resisting.

You can also think of death as being analogous to refactoring.
Just as death reduces overcrowding, so refactoring reduces coupling.

Refactoring is a hugely important dynamic in software development.
Without refactoring a codebase can grow without check.
Growing without check is bad.
It leads to overcrowding. Overcrowding hinders growth.