I wrote a non-programmer summary to some of my friends, because my mind is blown. Here it is (warning: it's very informal). This is some next level 80/20 stuff

I wrote a non-programmer summary to some of my friends, because my mind is blown. Here it is (warning: it's very informal). This is some next level 80/20 stuff, I'd argue it's even 99/1 (consultant speech for "being efficient" by seeing if you can exploit Pareto's principle [0]). A guy on YT [1] simulates in 7 minutes how the two biggest operating systems were built in the sixties (Multics by IBM and Unix by 2 guys in a garage). Nowadays we only have descendants of Unix, this simulation shows IMO two things: 1. How a chain of command screws up productivity (I doubt that anyone at IBM had the power/autonomy to change complete structure of the product. This was needed, but such change management is insane). 2. How the pipe command in Unix changed the mathematical nature of developing an operating system (in fact, it's even better than 99/1, when you think about it). In normal human language, the difference is: IBM programmed modular blocks. Unix programmed modular blocks. IBM then programmed how those modular blocks should interact. Unix created a pipe command and allowed computer users themselves to implement how these modular blocks should interact. At the time, computer users were all savvy enough like that. Result: when IBM created a feature, it needed to integrate it with all the other features that came before. When those 2 guys in a garage (Unix) created a feature, all they needed to do was create that feature. So mathematically you could say (where each term is the amount of work required for one new feature + integrating it with the operating system): IBM/Multics: (0 features_before + 1 new_feature) + (1 features_before + 1 new_feature) + (2 features_before + 1 new_feature) + (3 features_before + 1 new_feature) + (4 features_before + 1 new_feature) + (5 features_before + 1 new_feature) + (6 features_before + 1 new_feature) ... + (n_features_before + 1 new_feature) --> simplifies to my favorite formula which is: n(n−1)/2 --> you can also see it as --> 0.5n^2 - 0.5n --> So, roughly this is n^2. Just count the amount of numbers, it comes down to: 28 units at the 7th term/timestep. Unix/2 garage guys: 1 new_feature + 1 new_feature + 1 new_feature + 1 new_feature --> simplifies to n_new_features At term/timestep, you'd get 7. At the 100th feature, you'd literally 100^2 amount of coding work at IBM whereas at the Unix place you'd simply need 1 unit ... This isn't 80/20 or 99/1. This is n^2/n (meaning: what one needs n^2 time for, the other could do in n time). [0] https://en.wikipedia.org/wiki/Pareto_principle https://en.wikipedia.org/wiki/Pareto_principle [1] https://www.youtube.com/watch?v=3Ea3pkTCYx4&ab_channel=FOAM https://www.youtube.com/watch?v=3Ea3pkTCYx4&ab_channel=FOAM