1. 3

  2. 1

    Sometimes you get some good manifesto fodder if you’re a cranky idealist who has little regard for the dizzyingly high local optimum peak current computing technology has climbed on.

    1. 1

      So, this is one of those interesting mixes of “hopelessly idealistic but totally correct” and “insane” that you sometimes get from people who are contrarian, principled, technically oriented, and confused about what things are for and why people do things.

      Let’s dive in.

      I – Obeys operator

      Yes. No quibble with this one. It’s inexcusable that this is ever not the case.

      II – Forgives mistakes

      This is absolutely the ideal, but note that implementing this would require a Herculean effort, all the more improbable because it would be distributed across many people, companies, etc. (For a roughly comparable, if smaller-scale, thing, see the Mac OS’s pervasive, system-wide, everything-interoperable-with-everything copy/paste and drag/drop support; to start from the idea for NSPasteboard and get to anything resembling today takes 20 years and 20 system versions, of course with various partial or weaker implementations along the way, etc.)

      III – Retains knowledge

      This seems to require that no large (multi-gigabyte) data ever be loaded wholly into RAM, nor operations on such data ever be conducted in RAM. How would following this law not result in a tremendous downgrade in performance?

      IV – Preserves meaning

      This is unrealistic. No closed-source software? Ok, good luck accomplishing anything in the real world.

      V – Survives disruptions

      Who the heck wants to interactively debug crashes? Also, what on earth is “an error condition requiring the operator’s intervention”?

      VI – Reveals purpose

      Again with the debugger… Well, this is an ok ideal, but it seems largely irrelevant to me, for most people in most cases.

      VII – Serves loyally

      This I agree with wholeheartedly.

      Here’s the crux of the matter:

      Most people aren’t programmers and don’t want to be.

      Any ideal, or plan, or design, that asks users to be programmers, or expects that they’ll be programmers, etc., is fundamentally confused and doomed to failure, as well as actually not being “ideal” in any meaningful sense.

      1. 1

        It’s important to note that the whole ‘debug any crash’ thing comes from Lisp Machines. People who used lisp machines really liked that they could in principle recover from any error if they wanted, even if in practice they might decide to just let the thing go. It’s also where things like needing access to the source code come from, as the Lisp Machine allowed introspection abilities that were simply beyond what’s available on a modern *nix based system.

        You can read more in this vein in the Unix Haters Handbook:


        1. 1

          My handwavy thought about the forgives mistakes / retains knowledge thing is that if we stick to human workstation use instead of scientific computing and similar data crunching, the amounts of data involved in something like video editing can be huge, but the data to describe the user inputs that led to the state should be small enough to serialize without much effort. So for the video editing case, you’d need to treat the source video file as sacrosanct, save user inputs, and then have the user operations be implemented in a way that they can be reversed or just re-walk the input sequence up to the earlier point from which you’d want to resume (which might be slow). Baking this so deeply into the OS+programming language layer that doing things like this would be a no-brainer for any new industrial 3D modeling or photoediting application you’d develop would of course be an interesting engineering exercise.

          This wouldn’t get you quite the “up to the current state as fast as turning on a lamp” speed, but replayable operations would let you keep large complex state in RAM and be able to have the machine load the starting state and the operation sequence from non-volatile memory and then play back the operations to get you to your current state.

          No closed-source software on client machines would still let you do business with proprietary software, you’d just need to run the bits you want to stay hidden on your own server. This part is hit hardest by the thing where regular users don’t want to be programmers. Users are going to notice if you can turn the machine off and turn it on and it starts instantly with all the stuff you had on it earlier, and they’ll expect it to keep doing that. They won’t notice or care if the software code has been piped through a code obfuscator.

        Recent Comments