supergarfield

Maybe never with current technology? Looking just at the CPU and assuming you need comfortable IPC overhead for emulation, the 386 was from early in the Dennard scaling era and modern CPUs are 1000x or more faster single-thread. Since maybe 2012 that hasn't moved anywhere near that, certainly less than 10x.

Figure 6 in "A New Golden Age for Computer Architecture" is a good representation of that effect: https://dl.acm.org/doi/epdf/10.1145/3282307.

For the GPU things are potentially looking better! But since distributed shaders/kernels are higher-level compiled for your specific device, there's less of a need for emulation.

I agree that drivers should know not to reverse on a highway regardless of local signage.

But in situations that could be ambiguous, I think this is a regional difference - the US, Australia, part of the rest of the Americas use lots of text on road signs (including literal "wrong way" signs); Europe and much of the rest of the world use far less text (including purely pictographic "wrong way" signs). Especially important in Europe where drivers just can't learn 20+ languages.

If my coworker was part of a clone series of 100 million units, requesting a character sheet would be pretty reasonable

I really want to like QBE, but declaration blocks like this make it feel like 1970s Unix code more than a modern hackable piece of software:

    int t, x, r, rf, rt, nr;
    bits rs;
    Ins *i, *i1;
    Mem *m;
    Ref *ra[4];

I think it deters some users by making it hard to read and understand the relatively subtle code in the 300 line function that follows. (Skill issue, I know)

Carmack gives updating in a loop as the one exception:

> You should strive to never reassign or update a variable outside of true iterative calculations in loops.

If you want a completely immutable setup for this, you'd likely have to use a recursive function. This pattern is well supported and optimized in immutable languages like the ML family, but is not super practical in a standard imperative language. Something like

  def sum(l):
    if not l: return 0
    return l[0] + sum(l[1:])

Of course this is also mostly insensitive to ordering guarantees (the compiler would be fine with the last line being `return l[-1] + sum(l[:-1])`), but immutability can remain useful in cases like this to ensure no concurrent mutation of a given object, for instance.

> It's all fun and games until you realise you can't run a consumer economy without consumers.

If the issue is that the AI can't code, then yes you shouldn't replace the programmers: not because they're good consumers, just because you still need programmers.

But if the AI can replace programmers, then it's strange to argue that programmers should still get employed just so they can get money to consume, even though they're obsolete. You seem to be arguing that jobs should never be eliminated due to technical advances, because that's removing a consumer from the market?

The French Wikipedia page doesn't talk about it, but the quoted text from the English Wikipedia page involving an iron bird (and not a bronze owl) is accurate. Here's the official report of finding it: https://cdn.shopify.com/s/files/1/0511/4586/7430/files/pv.co... (liked from https://editions-chouettedor.com/pages/documents-officiels).

Huh, I was curious about how that was done, and it looks like it's a specialized Java to C++ converter: https://github.com/validator/htmlparser/blob/master/translat....

Looking at the source, it seems pretty easy to find Java programs that wouldn't compile correctly, but of course a fully general Java to C++ converter would be a huge undertaking. I guess with OK test coverage of the generated C++ code (which Firefox certainly has), editing the Java code remains doable.

Some laws are much easier to evade than others, and some laws have especially bad side effects when evaded. (A law about e.g. requiring a certain type of government certification before a large construction project can be undertaken, for instance, would be far harder to evade than this one, and "they can just do <x>" would probably be a bad objection)

Using non mainstream sites instead seems like a realistic way people are going to skirt this law, and those are very hard to regulate without other unpleasant side effects on Internet freedom. I think it's a reasonable concern to raise.

You can do high density without block housing! Many European cities are good examples of this. Paris, for instance, has very high density because it's packed with mid-rise (~7-8 floors) buildings[1]. Another good example is the section of Manhattan between Midtown and Lower Manhattan, which is also primarily mid-rise and very dense.

Apart from that I do think it's true that block housing separated by large parks (as shown in your picture) doesn't work well; it's discussed in e.g. Jacob's _The Death and Life of Great American Cities_.

[1]: https://images.adsttc.com/media/images/6238/5b71/3e4b/31a8/5...

Aren't m/s the correct unit for wind speed? https://en.m.wikipedia.org/wiki/Wind_speed

> Meters per second (m/s) is the SI unit for velocity and the unit recommended by the World Meteorological Organization for reporting wind speeds

> Since 2010 the International Civil Aviation Organization (ICAO) also recommends meters per second for reporting wind speed when approaching runways

What do you think the current text encoding footguns are?

In a different direction, I don't know what your problem domain is/was, but in general when I'm dealing with UTF8, I don't need to convert back to bytes very often. Was the need for conversion mostly due to the libraries that still expected strings instead of bytes?

Letrec requires either laziness (which implies some sort of internal mutability, as thunks get replaced by values at some point), or "internal" mutability that may not be visible to the programmer (like in OCaml, where in a `let rec` some variables will initially be null pointers, and get updated once other definitions have run).

In languages with no mutability at all (not even internal mutability like with these two features), you can't create cycles and refcounting becomes possible, but I'm not aware of non-academic general purpose languages that actually fall in this category.

Esoteric functional languages like Unlambda do make that guarantee, and implementations can use a ref counter as their GC.

I've written more about this here: https://terbium.io/2019/09/cyclic-immutable/

I'm always interested in understanding animal neurology, especially in the context of trying to reach more general levels of AI. I find it interesting that modern ANNs perform near human level at some difficult tasks, and yet it seems there are some tasks that insects perform that we'd have no idea how to implement. Animal nervous systems certainly have interesting things to teach us.

It also seems like understanding simpler brains will help in progressively understanding the human brain, even if these brains are very different. Developing a less human-focused toolkit might be what we need; sometimes studying a more general problem is what you need to get past blockers in a more concrete problem.

On that topic I really enjoyed _Other minds_ by Peter Godfrey-Smith, which talks about octopus behavior and some neurology, but I'm interested in recommendations for more technical readings in animal cognition / neurology.

visudo isn't a fork, it just locks the sudoers file against concurrent edits, runs whatever standard editor you want, waits for it to finish, and validate the new file before committing it to the real location.

I can agree that process is too complex, but they're not maintaining a fork of vi for that purpose.

> This requires introducing a right-handed partner for each known (left-handed) neutrino, which some people don't like because right-handed particles don't partake in weak interactions, and weak interactions are the only (known) neutrino interactions (apart from gravity), so you end up with undetectable particles.

I'd be curious to hear more about this. What mechanism forces you to add right-handed partners? Is it some conservation property? Are calculations too difficult without them?

Maybe it's also not clear if there really is a difference between saying "right-handed neutrinos exist but are undetectable" and "right-handed neutrinos are fake particles added for ease of modeling".

Edit: Wikipedia also says

> The neutral-current Z^0 interaction can cause any two fermions in the standard model to deflect: Either particles or anti-particles, with any electric charge, and both left- and right-chirality, although the strength of the interaction differs.

So could right-handed neutrinos be detected this way?

Great graph! Another one I like is this one by Eric Levenez: https://www.levenez.com/unix/. It's a little more detailed, as it includes specific releases and non-inheritance relationships, but it's only for Unix systems.

Not the OP---I agree they're very different, but there's a striking resemblance in how both countries think their political and intellectual culture is civilization's crowning achievement and the entire world should adopt it. (Of course, the US has been more able to do export theirs than France in recent decades.) IMO this shapes both countries' relationships to the rest of the world.

I have less first hand experience, but I also think the level of distrust in the government (esp. central / federal) among rural populations is particularly high in both countries by developed nation standards.

This might be somewhat subjective, as I don't know how you'd measure correlation between spoken and written, but French seems to have a much higher match between written and spoken language than English.

Going from spelling to pronunciation in French follows (admittedly complex) rules that are rarely broken except for common words (or endings such as -ent). Vowel pronunciations for a given spelling are far more variable in English, and often depend on the etymology of the word. Plus, English has word-level stress that is not marked in writing (French has none, and it's marked in Spanish), and moving the stress will usually make a word unintelligible! That alone makes writing => pronunciation very difficult.

Thanks for the links! I wasn't aware of the PyMem_ layer above, the justification for that does sound bad.

But Python runs a generational GC in addition to refcounting to catch cycles (https://docs.python.org/3/library/gc.html): isn't fine control over allocation necessary for that? E.g. to efficiently clear the nursery?

> and Python still does AFAIK

Don't you sort of have to do that if you're writing your own garbage collector, though? I guess for a simple collector you could maintain lists of allocated objects separately, but precisely controlling where the memory is allocated is important for any kind of performant implementation.

> American SUVs built for Europe

> they'll have that right-hand-drive that Postal workers love so much.

Maybe you know, but the vast majority of Europe is right-hand-traffic, left-hand-drive like the US. AFAIK only the UK and Ireland are left-hand-traffic in Europe.

Really? I feel like having an opinion based on reasoning from first principles should make discussion easier, because you can try and challenge any element in that explicit chain of reasoning. On the other hand, if someone adheres to ideology X because they feel like it's right, I wouldn't know where to start.

> The lack of .h files alone is a huge grievance for me

That's an interesting point... Besides C and its derivatives, and OCaml, do other languages have separate definition files? It seems like newer languages, even statically typed, normally don't.

I suspect the reason is that you have to duplicate all definitions, which seems like rote work. It also feels less necessary with IDE tooling: IDEs I know have a view for all definitions in a file.

Yes, that's exactly what I mean, I was replying to

> One of the great things about Latex (or raw tex) is that you can simply type it into a buffer.

and pointing out it also applies to HTML.

Sure, but it's probably possible to design something better too, that would let users do more complex things without dying. Maybe you don't need it for your usage, but this seems a bit like a Blub problem[1].

Keep the same core design of compiled source code files, but there are many things that don't make any sense. As just one example having to use the `\makeatletter` / `\makeatother` hack to change the visibility of macros seems completely insane to me when we have had languages with fine-grained visibility control for decades. This is one of the many things that make using many packages together needlessly hard.

[1] http://www.paulgraham.com/avg.html

I think the grandparent is talking about a better WYGIWYG language, like HTML generally is. You can (and most people, at least on HN, probably do) edit HTML in a buffer.

Edit: changed parent → grandparent

Not OP, but I'm a bit against using cargo (or any other language-specific dependency manager) as a general purpose package manager. It forces me to periodically run updates on many different managers, it doesn't always interface as well with other system / distribution idiosyncrasies as the native package manager, and I don't want to remember or have to care about what tool is written on what language. (Of course, they have their place for specificic use cases, just imo not system-wide installs of random binaries)

So I can see why it's a problem if it works with cargo but not with brew.

There are other purposes for taxes, the most famous one being Pigovian taxes, which attempt to price negative externalities into a market: https://en.wikipedia.org/wiki/Pigovian_tax.

The inheritance tax is not a Pigovian tax, but its purpose can also be primarily non-budgetary.

As far as I understand, the prevailing opinion is that the brain is a physical object and that its operation does not involve currently-unknown laws of physics (because we have a good understanding of what happens at the scale of an entire atom or above).

A Turing machine can run a simulation based on such physical laws to any desired level of precision (which is enough, because as mentioned in TFA, processes in the brain aren't individually very precise). This is true because of the nature of these laws, which are mostly just asking you to integrate differential equations. If you accept this, then it should follow that a Turing machine can in fact simulate a brain: just run a physics sim on a brain's initial state.

(I do realize that this is far outside the realm of what's doable today, but it seems to provide a solid justification for why it's conceptually possible).