GrapheneOS has the functionality "Contact Scopes" in the same vein as "Storage Scopes" that only provides access to the specific contacts and files you allow.
Seems pretty cool, but I would probably object to `--best-effort` being enabled by default. This is a sandbox and a security boundary, and degrading security should probably be opt-in rather than opt-out.
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.
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.
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.
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?
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.
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...
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.
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.
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.