remexre

Why? I don't think of SBCL's problems as being particularly related to the language it's implemented in, but a lot more related to the complexity of making an optimizing non-JIT compiler for a language as complex as CL.

Do annual checkups involve blood tests where you are? I've only had blood taken as part of one once, and that was in direct response to a new diagnosis of a health condition in a grandparent.

malloc() and the kernel would need to conspire to know this before you call read, when malloc() gives you back the memory in the first place

Huh, I was proficient in Rust before "properly" learning C++, so maybe that accounts for it, but I didn't realize C++11 was controversial. Is it just move semantics, or are there some library things that are hard to implement?

What's c++xx?

Agda does too! https://plfa.github.io/ for examples

I run FreeBSD for networking purposes -- I still find PF much more comprehensible and reviewable than nftables.

I thought we tried this with Google's NaCl and nobody liked it; the WASM problems don't seem to be particularly related to the instruction set, but rather to its lack of OS services; you'd need to reinvent those for a NaCl-like.

You said in another thread it's in "the Microsoft paper" -- could you point me at which one you were referring to? I didn't see it in https://cdn.openai.com/papers/gpt-4.pdf , but it's possible that I missed it.

> I personally think the end is in sight for C++ but the consensus seems to be it'll live forever.

As the office Rust shill, I'm actually pretty excited about a lot of Herb Sutter's work [1]; I think there's a reasonable argument to be made that a hypothetical C++29 will be as ergonomic as unsafe Rust, with the not inconsiderable benefit of being able to speak the C++ ABI. I don't think large projects like LLVM or Unreal would dream of rewriting to Rust in that time, so people will still be writing it in some form or another.

[1]: My top 3 would probably be cppfront's argument passing semantics, metaclasses, and deferred_heap, in that order. The latter two, IMO, are improvements on what Rust provides in the area.

Humans are a lot better at "I don't know how to do this; hey Alice, can you look this over if you've got a sec and tell me if I'm making a noob mistake"

I didn't see it in https://cdn.openai.com/papers/gpt-4.pdf -- which paper are you referring to? (Or if I missed it, what page number?)

Does this actually work for nontrivial functions, e.g. a hashtable lookup function?

I was clarifying the kind of non-commodity that decommodification of resources refers to

I think the idea is to make water like air, not to make it like art.

Not too knowledgeable about macro -- is that tantamount to saying that monetary policy doesn't work? And what's the windfall in this case, given that the dollar is the reserve currency; RMB-denominated assets?

The improved sandboxing model is supposed to be why this one's going to turn out better (and why it's worth losing some of the ease of development of the old ones...)

Then I'm running their code outside of the world-class sandbox the browsers provide.

Isn't it more likely that if there never was first-party GC, everyone who wants GC is just going to bundle a bad one instead, making those sites _slower_?

More likely, no bet would be placed.

It didn't sound like the FT was privy to this at the time?

My understanding was that the UB was defined such that:

    int i = 0;
    float f = 1.0f;
    void* p;
    
    if(rand() & 1)
      p = &i;
    else
      p = &f;
    
    int j = *(int*)p;
    assert(i == j);

could legally be compiled to a no-op (or a single call to rand() with an ignored result, I suppose), despite there being no "weird" pointer stores, since the ill-typed-at-runtime load "can't happen," so the compiler can reason that (int*)p must equal &i, and hence j = i.

EDIT: And, in fact, gcc does this: https://godbolt.org/z/WM33vzzdo

Not sure if that applies to vector loads, and the gcc docs don't specify, though.

Is the code actually compiled with -fno-strict-aliasing (which IME is rare for userspace code, but I don't work with numerical code very much), or are you saying this is because of the types involved in the cast? I didn't see anything in [0] about a change in pointer semantics from using the vector extensions in the compilation unit?

[0]: https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html#Ve...

Iunno, for this example, isn't this actually UB according to standard C? I don't think it'd be that objectionable to put e.g. a semantic comment saying "yeah no this is actually not UB because we check in ./configure that your compiler is one known to not do bad things," *if* such a thing were standardized across linting tools.

Of course, that's a heckuva if.

Oh, I read that as "you can send the links to community managers, sales, and PMs rather than making them run the app locally," since that's like, the main usecase.

What makes this seem like a non-developer tool? You need a server you control, you need to mess with YAML files, "configure Caddy" is one step that's assumed to be easy, etc.

"Every possible entity consistent with the distribution of input data it's been trained with," perhaps?

Simulating as in, having equivalent (or "similar enough") input-output behavior, I'd assume.

The probability that the broken clock is right is straightforwardly 2/1440 = 0.001 = 0.1%, innit?

The source code of the JDK itself, not the input it accepts.

I bet it'd be more work on the side of the game developer and streaming platform, but IMO Zoom, Google Meet, Jitsi, etc. aren't a ton better at streaming text than it looks like Twitch is from TFA. Even in the absence of effects (just small text on a monitor of differing resolution), things can be plenty hard to read.

I suspect that it should be possible for at least the streaming platforms that have native applications to tie into the OS's screen-reading APIs to grab text and provide it out-of-band, e.g. by streaming rectangles of the background color and render text over it on the viewer's client. Then it'd be copy-pastable by the viewer too, and their own assistive technologies could work on it.