I missed the edit window on this but: I don't think you're going to get computers to not be messy and full of huge time sinks. That's just the nature of humanity being reflected in a silicon mirror.

I like the idea of focusing first and foremost on debuggability, on manipulating program execution histories as first-class objects. There are a huge number of interesting tradeoffs there with performance.

What I mean by "power" is that Unix makes it easy enough to do things like "interactive text chat in three lines of code" (untested, and quality at best "usable prototype" rather than "production ready")

    #!/bin/bash
    ch="${2?Usage: $0 /tmp/channelfile}"
    touch "$ch"; chmod 666 "$ch"; tail -f "$ch" &  # chat of the beast
    while read -e line; do echo "<$USER> $line"; done >> "$ch"

or "which other English words might be Greek neuters, plural and all, like automaton/automata"

    grep "on$" /usr/share/dict/words | sed 's/..$/a/' | sort |
      join - <(sort /usr/share/dict/words)

or "which directory is growing in my home directory and filling up the fucking disk"

    du -k ~ > tmp.du.1
    du -k ~ > tmp.du.2
    diff -u tmp.du.[12]

or "build the thumbnails for any images I haven't thumbnailed yet", at least as long as none of them have spaces in the names, using GNU make (untested, but adapted from real code):

    thumbnails: $(patsubst %.jpg,thumbs/%.jpg,$(wildcard *.jpg))
    thumbs/%.jpg: %.jpg
            convert -geometry 80x160 $< $@

or "incrementally update my web pages, making an incremental backup on my server with cryptographically strong checksums" (presupposing something like http://canonical.org/~kragen/sw/dev3.git/hooks/post-update)

    git push

or "incrementally back up this directory onto my USB pendrive with cryptographically strong checksums"

    git push usbkey

or "find out what executables get transitively invoked by compiling a program with this C compiler" (warning, doesn't work if one of your files is called ENOENT)

    strace -ff -e execve cc hello.c 2>&1 | grep execve | grep -v ENOENT

or "show me a treemap of my disk usage so I can see where I can free up some space"

    k4dirstat

or "bring the focus to the URL bar of Firefox"

    xdotool search "Mozilla Firefox" windowactivate --sync key --clearmodifiers ctrl+l

or "bring up the latest version of MongoDB on my fresh laptop"

    docker run mongodb

or "find out which day we were talking about the Spanish Succession"

    grep --color -i succession 2022-10-*

or "share my screen on this server with someone else for remote pair programming"

    tmux -S /tmp/pair attach -t shared

I agree that these tools are messily executed, their scalability needs a lot of work (though don't underestimate https://adamdrake.com/command-line-tools-can-be-235x-faster-...), and their composability is not that great. Also, their usability could be vastly improved. But they're still leaps and bounds ahead of anything available on Android, in the browser, or most other alternative systems.

Simple, hackable data formats and protocols are one thing that enable this kind of thing. But I think the Unix terminal and filesystem is actually the major integration point, not pipes. Too bad they both suck. It would be nice to see successor systems that do better instead of worse; this ought to be feasible but we keep failing at it.

What would a system look like which gave you that kind of power, but to implement Valgrind-style bounds checking or profiling or AFL-style fuzzing with backtracking, and have it run with reasonable efficiency? Valgrind itself, DTrace, LuaJIT, Smalltalk-80, Emacs's "advice", videos of Symbolics Genera, aspect-oriented programming, the CLOS metaobject protocol, Maru, and the Self papers (Ungar etc.) might be places to start looking for inspiration.