The main reason Linux succeeds is network effects. Once everyone has been coding to Linux APIs for upwards of 35 years, the ability to move to something else is incredibly limited. Even if a new OS attracted 100% mind share for all new development, it'd take many, many years for it to approach even the beginnings of ubiquity that Linux had in the early 2000s.
Replacing Linux (and likely having to change some parts of POSIX as well) would be an even taller order than rewriting C code in some other language. At least for userland rewrites, you have parity and an API (POSIX, other libraries in userland) to code to.
It might still be a good idea to do both of those, mind you. But let's not fool ourselves: the main reasons the incumbents are the incumbents is that it's hard, likely-to-fail, and incredibly slow work to replace them.
That's not true at all. Political factions routinely take steps to try to discourage their opponents from voting at all. They run campaigns on opponents' media with the goal of building cynicism. Voter registration laws are inconsistently enforced to raise barriers to certain people voting. Employers (illegally, but often) discourage employees from having the time/availability to vote if they're worried about what they'll vote for. Hell, other countries interfering in elections often do so by spreading misinformation with the goal of getting people who would otherwise vote for a given agenda to just give up.
Those things wouldn't happen if "too lazy to care" was the only reason people didn't vote. A lot of people who don't vote absolutely should be counted for a given side; they don't (or can't) vote due to reasons much more externally engineered than laziness.
That seems impossible, unless you’re using a very unusual definition of “bug related to a variable type”.
You’ve never had a bug caused by None showing up in code that didn’t expect it? Or getting an object of the wrong type that didn’t have the method you tried to call on it?
Reproducible builds only solve small slice of the problem. Build attestation in general solves more, but is useless unless a credible entity is (conceptually) attesting that a package is OK.
The growth of centralized authorities arises from the reality that the vast majority of devs do not and will not independently vet or attest to the quality of libraries they use. That’s not great, but it is what we have and doesn’t look likely to change.
Given that, and given that people still want as much security as they can conveniently get, centralized control (from “we run a security scanner and trust its findings” to “packages can only be downloaded from pypi/debian stable/whatever”) is a natural result.
I think both are true. Agile/SCRUM as these vaunted “hire a coach and certified scrum masters and your process blockers go away” org-wide religions are on the wane.
But they left behind a few practices that were easy to adopt and lots of people liked (whether that makes them “the good parts of agile” or “lazy process theater” depends on who you ask). Sprints, boards, paying attention to velocity, and so on.
I think the typical answer from political science is:
Because enforcing laws based on spirit rather than text has proven, again and again throughout history, to be a pretty direct path to selective enforcement (including subjective variance leading to legal unpredictability, favoritism, and persecution). When the rule of law is selective, corruption and authoritarianism increase.
Like, that's not the only way to get corruption and authoritarianism: our existing system of regulatory capture and massive-resources-required-for-legal-action is a case in point of that.
But "let's make it OK to arrest people when everybody knows that they're doing something illegal, even if it can't be proven under specific laws" is pretty much textbook descent into vibes-based authoritarian rule. And yeah, one of the big drawbacks of that approach is that it creates a class of experts at navigating the boundaries of the law. But the alternative is much, much worse.
I'd argue that HTTP 1.1 is simpler than Thrift (especially if you include the serialization formats), but more underspecified. The underspecified-ness is where the complexity in handling HTTP 1.1 in correct and secure ways comes from.
Not to be That Guy, but WINE doesn't use those techniques, and thus isn't an emulator.
It lightly translates binary formats (Windows executables) into Linux-compatible executable code, and then runs that code against libraries that implement Windows APIs in terms of Linux underneath. It's not an emulator in the same way that your libc isn't emulating lockf(3) in terms of fcntl(2) underneath. In web-dev parlance, we'd call WINE a polyfill.
Rosetta and QEMU on the other hand are emulators--emulators, in this instance, being a term of art that implies interpreting bespoke meaning from machine code instructions written in another program. Some emulators translate instructions 1:1, some have optimized stencils, some (like Rosetta) have kernel support for emulating very quickly, and some (maybe like Rosetta; sources disagree) also have hardware support as well.
WINE emulates an ABI, rather than a CPU or such, but I'd happily argue that that's an emulator. (In fairness, though it's not generally described that way, I would call web polyfills API emulation)
It "emulates a behaviour" and natural language is fluid, so sure, you could call WINE an emulator and I wouldn't be mad at you. But WINE is very different compared to what most emulators are. Usually the term is reserved for when you emulate in software what used to be hardware.
> It lightly translates binary formats (Windows executables) into Linux-compatible executable code,
Does this not involve transpilation? I guess I was grouping that in under dynamic recompilation and AOT techniques.
Regardless, I don't think that there's a benefit from defining emulation from an implementation rather than an empirical perspective. If it runs a chunk of code as if it were in a different environment, I'm kind of ok to call it an emulator. To the sibling's point, a polyfill would also fit as an emulation layer here.
Not necessarily. It could just rewrite the outer portion to be an ELF loader that then calls into a runtime that actually shims the syscalls for example. I don't think WINE does exactly this but it's not really transpiling either.
You don't even need that, really; just have wine load the PE binary into memory and hand it a bunch of DLLs that use Linux syscalls under the hood. It's less transpiler and more of a funky dynamic linker+loader plus libraries.
I believe WINE doesn't actually translate any instructions; it's a Windows PE loader and a bunch of libraries that implement Windows APIs using Linux equivalents.
Windows apps don't use syscalls directly; they call into kernel32.dll, which is convenient for Wine. (Microsoft enforces this by scrambling the syscall numbers on OS updates [1].)
Yes. Linux is the only major operating system where there is even a convention to directly access system calls. For macOS, everything goes through libSystem.
This article makes an “ok” case for social science being in its infancy (I think it is in some ways, but is more mature than widely thought in others), and a very good case for most social interventions being ineffective due to their being undertaken in methodologically flawed ways.
Most interventions are embarked upon by working backwards from unproven (often political) theories and an extremely limited range of possible tools (“give money”, “take money”, “physically punish”). That leads to the mother of all searching-only-under-the-streetlight fallacies.
But that doesn’t necessarily indict the social science academy/frontiers of understanding (which, again, are plenty flawed—just perhaps not quite as stone-aged as the author suggests). Usually, it indicts the state/designers of the intervention in question. Blaming the sciences sometimes sounds like blaming car airbag designers for motorcyclist deaths.
I’m reminded of the conservation efforts for the spotted owl. Famous academic naturalists were asked to design a conservation plan that worked with logging. They did. The state replied “fine, but we need to clear-cut 90% of the forest you asked for, so make do with 10% of the habitat”. The program did poorly, but not because the academic understanding of how to address the problem was as flawed.
Replacing Linux (and likely having to change some parts of POSIX as well) would be an even taller order than rewriting C code in some other language. At least for userland rewrites, you have parity and an API (POSIX, other libraries in userland) to code to.
It might still be a good idea to do both of those, mind you. But let's not fool ourselves: the main reasons the incumbents are the incumbents is that it's hard, likely-to-fail, and incredibly slow work to replace them.
reply