Minimal Viable Programs (2014)
joearms.github.io
joearms.github.io
Many systems tried to be this, but people too frequently side-step these solutions for decomposition because they aren't complete enough. Unix wasn't enough, now we have Docker, etc.
OOP tries to achieve this from a different level on the inside of complex systems, but still falls short. (e.g. you have to do IPC or have a message-passing VM where objects~=processes to be able to do live code replacement and allow multiple independently-developed implementations of the same concept to run simultaneously and collect behavior on which does a better job, so this type of thing is not common.)
It'd be nice if the progress towards building smaller systems that avoid complexity begins to outpace the progress toward building larger systems which defend against complexity within my lifetime, but I can't say I'm hopeful.
We have Docker et al. because people kept pursuing ever-more-complex and ever-more-intertwined dependencies and silliness.
The people failed Unix (and its successor, Plan 9), and not the other way around.
So then we got some of the former with system package managers designed for system administrators and some of the latter with version control/build systems/dependency tools designed by and for software developers, but they don't meet in the middle.
Docker is mostly used to just bridge the gap and force the system package manager to be a per-app-namespaced dependency/build support tool.
That's a big problem right there. Why are systems large in the first place? http://vpri.org/ already showed we can do smaller —likely by 2 to 4 orders of magnitude. Solving the problems of large systems will only mitigate the symptoms. The root cause is size. We should solve that instead.
Why solve problems you can bypass?
We're fixing it (efforts like Kubernetes, Hadoop, Mesos), but it's tough and we have a long way to go.
I place the highest value on small programs and the lowest value on large, complex programs. But I suspect this is not the norm, whether among end users, authors, or both.
I also recall some comment from Kernighan about how back in the early days of AWK he was amazed at the sizes of the scripts people were writing. He had never expected AWK to be used to write large, complex "programs".
Maybe small programs are boring? Maybe people cannot manage to simplify their problems by subdividing them into smaller tasks? Maybe they do not believe the problems can be simpflied? Maybe adding features is how authors attempt attract or retain users? Who knows?
> If you want a job done find the busiest person you know and give them an extra job. This is because the reason they are busy is that lots of people want them to do things because they are good at doing things and that’s why they are busy.
A problem is rarely well-defined. Alternately, you can encapsulate small and beautiful programs into classes, and connect objects at runtime to solve more complex problems. OO reinvented.
In his case, he prefers to use the shell to do the plumbing instead of another language.
Then in order to ease the integration between those classes you start reshaping them a little bit (adding things that "would not be essential") and thus they are gaining in this regard something very similar to the same features that we were talking about.