It's surprisingly hard to use 9P and get good performance because the design sort of inherently forbids caching for "real" file data. Trying to add that on top pretty much sacrifices the simplicity and starts looking a lot more like NFSv4.
I struggle to take such an article seriously when it cites Brainfuck as an example. A common use of Brainfuck isn't to write programs, but rather to prove that it is possible to write programs. This isn't exactly comparable with small Lisps or Forth.
You can write a program that takes BF code as input and outputs valid C source that would execute it in less than 20 lines of well formatted ANSI C using nothing more than putchar, getchar, while, pointer inc/dec and dereference, so I can imagine a full compiler for it would be super simple too.
(Though I bet an optimising compiler would be a _little_ more complicated) ;)
Yes, I've been following it for a while - it's exactly the kind of research that I had on my mind. I don't necessarily agree with some of the design choices (I don't think we need a middle layer underneath VT100 emulation to make TUI apps, TUI is IMHO just terrible as a concept to begin with), but SHMIF has the mark of a battle-tested protocol, and many other concepts are very interesting.
They treat CLIs as a subclass of TUIs. Underneath it all it is just a high-level decoupling API to replace ncurses/readline/.... The output becomes a window with a packed-text buffer format. You can mix and match graphical windows with TUI(CLI) ones in the same client.
The problem with optimising exclusively for oneself is that you definitionally optimise at the expense of others. Gaps are easily widened, and your balancing idea falls apart when the scales are tipped from the start.
It is not as simple as "my profit" vs. "others' expense". The elegance of the invisible hand theory is that it also accounts for the cases where others' expense is my expense and others' benefit is my benefit just as well as the others.
The scales sure can be tipped on the individual level, but you are only considering the "one individual vs. one individual" case. Many cliques of extreme power have been taken down by the weaker majority, which is also one of the processes contributing to the collapse of monopolies.
No, it isn't, which is why I added "definitionally". Let's say we have a limited resource, X, that is beneficial to hold, and it is more beneficial to hold more of it. As it is limited, acquiring necessarily means depriving another of it. Assuming one has the means to acquire more without impacting oneself negatively, in which situation (taking optimising for oneself as a maxim) you not seek to acquire more?
Precisely. As of such, those with increased capacity for access will deprive access to others. No balance of care forms. Your recommended ethic is what Kant wished to address with his categorical imperative.
Of course this is a unifaceted way of posing a problem: it's a model, given we're dealing with philosophical ideas. I should hope that I needn't provide examples for the model, given the state of the world at present won't let you swing a cat without hitting one.
You need not. It's evident to any reader that some models can take more into account without overloading, including the "access" variable you introduced ex post facto.
What I suggested is an instance of Kant's categorical imperative: "Act by the maxim whereby you can at once will that it should become a universal law." The maxim in this case being "optimize for your own benefit."
This is very funny. Let's take a different approach.
You are in a situation where you have a particular benefit. You may choose to share part of this benefit with another individual, who can be said to be deprived without it. This individual lacks the capacity to gain the benefit by their own means. Said individual shall be a permanent stranger: you will never again meet, your choice here being without future consequence as a result. Sharing your benefit diminishes it, but does not lose it.
I've happily used LineageOS without gapps for years across several OnePlus devices. If I ever need a new phone I check their supported devices list to pick, and the stock ROM on my new device gets overwritten the day it arrives. Currently using a OnePlus 8T. When I move on from this device as my primary someday, I may put postmarketOS on it to extend its usefulness.
No dynamic linking locks you out of Clang+LLVM (mostly: static clang isn't an officially supported configuration, but it can probably be forced to exist. I haven't properly looked into it yet.), Firefox, Chromium, QtWebEngine, (so no alt browsers, either), and probably a lot more. Statically linking every single package out there requires a lot of patches to build systems to get them to properly do it. Many build systems don't respect LDFLAGS and CFLAGS, or respect one or the other, or only partially respect them, causing a great deal of annoyance if you have a nonstandard desired result, such as fully static builds.
> Many build systems don't respect LDFLAGS and CFLAGS, or respect one or the other, or only partially respect them, causing a great deal of annoyance
Sounds good, doesn't it? This means that efforts to produce a fully static distribution would imply a sweeping wave of fixes across a wide range of packages and build systems!
The ISA leaves something to be desired for "simplest". Simple, sure, but parameters (and unused ones, at that!)? Memory copy instructions? Multiply and no shifts? Addition _and_ subtraction?
Others have mentioned Subleq (Subtract And Branch If Less Than Or Equal To), but there's more useful designs that meet all the design constraints. They state that "It is also not intended to be as simple and elegant as it could possibly be.", but it's called "The Simplest Virtual Computer" - that kind of name is a challenge.
For what? The simplest possible ISA? Something like an OISC or a ZISC, probably. Simplest "virtual computer"? Maybe the SK(I) combinator system? Specific improvements to this architecture? My personal preference would be to ditch the three arguments that aren't always used, have two 8bit instructions per 16bit word, use a stack (to eliminate the operands). But that's just one mode of thought for a very simple computer, not the only one. This line of thought is particularly inspired by the F18 Forth chips. They're quite minimal, simple, tight CPU designs: https://www.greenarraychips.com/home/documents/greg/DB001-22...
Note: Child processes can't change the working directory of the parent. An external command (that is, not a shell builtin, shell function, or externally loaded module) cannot change the working directory, because they're launched as child processes.
Good point. I'm not sure why I was thinking that it was possible to do via some other command invoking `cd` or something, but you're right that the only examples I can think of are all using other builtins (e.g. invoking `source` to have a script change the current state).
There is a workaround I saw used by wcd, a tool for changing directories. To install it you have to add a wrapper function in your shell that executes the actual wcd binary, and after possibly interacting with the user to figure out what directory to change to the executable will print out the destination, and then the wrapper function will make the call to cd, affecting the shell it runs in.
https://doc.cat-v.org/plan_9/3rd_edition/rio/rio_slides.pdf