727 karma · joined October 4, 2015
(Hah, I just looked around a bit more, and Wikipedia cites an archived mailing list message that I don't remember seeing before: https://web.archive.org/web/20181027195101/http://blade.naga... I remember at some point Emacs Lisp specifically being cited as an inspiration, but I might be confabulating that, I didn't find a source for it.)
Also, here's a fun paragraph from the opening comments of quail.el (lightly reformatted):
> [There was an input method for Mule 2.3 called ‘Tamago’ from the Japanese ‘TAkusan MAtasete GOmen-nasai’, or ‘Sorry for having you wait so long’; this couldn't be included in Emacs 20. ‘Tamago’ is Japanese for ‘egg’ (implicitly a hen's egg). Handa-san made a smaller and simpler system; the smaller quail egg is also eaten in Japan. Maybe others will be egged on to write more sorts of input methods.]
As someone who had ongoing formal musical training from childhood through university, I can attest that multiple teachers used a similar technique, focusing on finding a group of commonly-heard melodies such that the first intervals encountered in them cover as much of the set as possible.
Haven't tried the game yet, but looking forward to checking it out later to see if I can offer it to some of my friends who want to learn music better!
This is drifting some from the original specific topic toward the broader conflict, but, not for everyone involved, surely? Will the audience run your server binary, under normal circumstances? Or will they say “Wow, you couldn't even be bothered to put up some basic servers for free? Jeez, you're saying I have to set up a whole account somewhere else and pay them just so I can have a multiplayer game, or set up weird-looking technical shit on my computer that might expose me to hackers? Nobody else asks me to do this, what is this bullshit”? Of course there are intermediary options here (one of which I describe below), but those don't necessarily let you do the “we didn't want to be in the hosting business” plan straightforwardly, so you might still have to take on a lot of the fixed planning costs.
The incentive gradient among consumers tilting so hard in the direction of indefinite active support becoming table stakes seems to be a core part of the vicious cycle here. “I shouldn't have to set stuff up” implicitly cedes control; if they're not doing the coordination, then someone is, and that someone gets hidden responsibility and power without compensation or effective voice, which is an unstable combination by default. This is a similar issue to what happens with convenient, centralized, subsidized social media and chat platforms.
Minecraft is actually an interesting borderline case here: the player license authentication and name/appearance binding is all centralized, and that could suddenly go away and leave everyone in the dark, but individual world servers can be run independently and there are a number of third-party hosting businesses based on this. Microsoft later felt compelled to offer Realms as a first-party means of setup, but IIRC those do take a recurring fee so it's not in the same unstable zone. But then we have a separate issue where, as far as I can dimly tell, a lot of people started expecting “game companies do the work to keep us safe on Their Platform” as, again, table stakes, and so they implemented non-repudiable digital signatures in chat to allow people on non-centrally-hosted servers to still report each other's chat messages to central moderation, which I must assume is another ongoing cost. (In the modded world there are mods that strip this.)
So partly due to that, I think if you wanted to do full robotic cookery with a microwave beyond the TV-dinner stage you'd still need control over the other objects rather than just switching the magnetron. Stirring for even heat distribution is another thing.
And then it's separately interesting how, in a really skew way, “deliver heat using RF energy” came back from a different angle with the rise of induction stoves!
What I'm imagining for my curiosity about the dynamic case would look more like “JS/Lua/whatever engine detects that in frob(x) calls, x is always shaped like { foo: ‹string› } and its object identity is unused, so it replaces the calling convention for frob internally, then propagates that to any further callers”, and it might do the same thing when storing one of those in fields of other objects of known shapes, etc. until eventually it hits a boundary where the constraint isn't known to hold and has to be ready to materialize the wrapper object there.
Kotlin and Scala sound like they're doing the Rust/C++ thing at the bytecode level, if it's being “erased”, so just the static case again but with different concrete levels for machine vs language.
That part is (de facto) required for dynamically typed languages, but not for statically typed ones where the newtype constructor/deconstructor can be elided at compile time. Rust and C++ especially both do the latter by having true value types available for wrappers that evaporate into zero extra machine code.
But then just this moment I wondered: do any major runtimes using models with no static type info manage to do full newtype elision in the JIT and only box on the deopt path? What about for models with some static type info but no value types, like Java? (Java's model would imply trickiness around mutability, but it might be possible to detect the easy cases still.) I don't remember any, but it could've shown up when I wasn't looking.
Ah… yes, okay, I see what they did there… chuckle, sigh. Well, it's arguably in the same grand cultural tradition as EINE and ZWEI at least!
¹ I don't remember which implementations are subject to this or what the actual terms are.
However, the use case under discussion touches on things like handling kernel-level anti-cheat requirements, which is exactly the kind of place where I'd expect you to get in trouble trying to jigger around with virtual machines. Even before that point, I get the general feeling games and game platforms can get tetchy when you're not on Real Recognizable Hardware.
As for Secure Boot, maybe? I haven't thought through how that would help in this context, but my instinct is to ask how you'd do the binding between “I intend to boot Y instead of X” and “only accept the boot signature for Y instead of X”, so that malware can't try to unexpectedly substitute X. It feels like there's probably places for attackers to mess around here unless you're very careful.
… wait, I've made a different mistake here while trying to explain the difference, haven't I? I was describing it as a sum type, but it's not really a sum type, it's really just set-theoretic union, right?
Which also means OneOrMore is unsound in a different way because it doesn't guarantee that T and IEnumerable<T> are disjoint; OneOrMore<object> initialized from [x] will always return [[x]] from AsEnumerable, won't it? If I'm interpreting the switch expression correctly and the first case predominates, since a list is-an object? I don't have a test setup handy; someone with actual C# experience, please tell me whether that's correct or whether the compiler signals an error here or something…