[fovc]

Not sure which generation you're in and which generation you'd (relatively) consider Alan Key in, but here is a much more principled approach to what the OP is trying to do: https://youtu.be/NdSD07U5uBs

The TLDW is that Kay thinks we haven't discovered all the fundamental rules of computing, a la Maxwells Equations for physics. If you are able to figure these out, you can substantially cut down your accidental complexity.

FWIW, my unscientific view is that achieving simplicity is really hard and doesn't scale people-wise. Instead of C99 without a bunch of stuff, I'd probably use Scheme to create very dense (lots of bespoke abstractions and idioms) but simple software. That approach works reasonably well, but try onboarding a new developer!

[pron]

I've yet to watch Kay's talk, but I take issue with the fundamental claim that rules necessarily lead to "simplicity". If there is one thing computer science tells us is that this is not the case. For example, orbit equations are very simple, yet if you put more than 2 objects in gravitational interaction, their behavior is completely unpredictable (and very complex) even though the rules that govern it are simple. I'm personally interested in (and practice) formal methods for software verification, and I saw these nice slides in a talk [1] by a formal methods researcher that say:

> Computers have been invented to surprise us

> If we knew what computers do, we would not use them, and we would not have built any.

This means that computers are most useful precisely where the complexity of the problem is beyond our efficient reasoning powers. Like Brooks, I think that our accidental complexity is already quite low (no more than 50%), and while it's always good to decrease it, what we're left with will still be very complex -- that's why it's useful.

[1]: https://shemesh.larc.nasa.gov/NFM2018/talks/Dowek.pdf

[fovc]

If you don't like videos, you can also look up his papers from STEPS circa 2010.

I think the 3 body problem is indicative of what Kay says. One simple rule produces very rich behavior. Why not have something like that for your network stack?

[pron]

> Why not have something like that for your network stack?

In a way, it is like that already. After all, all computation can be described as a repeated application of, say, the very simple reduction rules of the lambda calculus. How does that help? Does the fact we know what the gravity equation help us predict the system's behavior (e.g. to ensure that some bad state is never reached)?

[chaosite]

> Instead of C99 without a bunch of stuff, I'd probably use Scheme to create very dense (lots of bespoke abstractions and idioms) but simple software. That approach works reasonably well, but try onboarding a new developer!

I understand what you're getting at, but I'd argue that what you're suggesting isn't actually simple by any means.