remexre

The post linked in the article as "shouldn't use RSA" has a few examples: https://blog.trailofbits.com/2019/07/08/fuck-rsa/

Something's definitely "up with" the RISC-V GCC port; in principle maybe there are just some passes or backend options that need to be flipped on in some way?

https://godbolt.org/z/cvc6j1sM6

There's a difference between features that need to be implemented as part of the engine such as Web Workers and those that can be implemented as a library, such as sorting; the latter can be shared between implementations much easier.

Kinda funny that instead of NVLink, they're just using (presumably standard) 100GbE as their connector/protocol; wonder if this also lets you wire up larger and more complex topologies of these cards across servers using normal 100GbE switches

Googling suggests Intel's A770M has 16.79 TFLOPS, M3 Max's GPU has 16.4 TFLOPS?

Should the line

    Z_encoder_decoder = layer_norm(Z_encoder_decoder + Z)

in Decoder step 7 instead be

    Z_encoder_decoder = layer_norm(Z_encoder_decoder + Z_self_attention)

? Also, is layer_norm missing in Decoder step 8...

Matlab still doesn't handle f(10)(2)... (The _(_) syntax is both function calls and indexing there.)

I wonder if it might be practical to bootstrap such a thing off of Wikifunctions, with a process to vouch for a function as "important enough to merit inclusion" and tooling to ensure that the Wikifunctions implementations actually agree, plus something to synthesize/translate a first-pass implementation in the desired language?

The standard joke about my university's grad-level programming languages course is that its formalization unit does a great job of identifying undergrads by discussing Peano naturals and Hoare logic in the same lecture...

Does cargo test run unit tests in the file you're expecting to be formatted that isn't?

The "It's" in the quote (from the article) was referring to a particular snippet in the article, not the .as_ref() method.

unsafe does not disable the borrow checker, it allows calling functions that could not be otherwise written in code that is OK'd by the borrow checker.

You might be interested in CodeProber: https://www.youtube.com/watch?v=lkTJ4VL0xtY

I think the "It’s not unsound; it’s not even incorrect." is wrong... Clearly, it's unsound -- the problem in this post was documented[0] as a safety precondition of the one function they call in that block!

In code I'd consider high-quality, there'd be a comment like this [1]:

    // SAFETY: inner is only mutated by foo, bar, and baz, all of which
    // ensure the pointer is valid.

[0]: https://doc.rust-lang.org/std/primitive.pointer.html#method....

[1]: https://std-dev-guide.rust-lang.org/policy/safety-comments.h...

> In Java, the compiler inserts null checks before every single dereference and throws an exception for null references.

Doesn't OpenJDK install a SIGSEGV handler, and generate the exception from that on a null dereference?

(AFAIK, a lot of runtimes for GC'd languages that support thread-based parallelism do so anyway, because they can use mprotect to do a write barrier in hardware.)

But we're not expecting that the produced C (or LLVM IR) has already had target-specific optimization applied, so as long as the C compiler is an optimizing compiler, that's not a problem?

I don't believe Scheme as standardized has delimited continuations, only call/cc; it's just that Scheme implementations have often been the laboratories in which experiments on delimited control have been performed.

After you knock out those and exceptions, what's left in (C++98 - C99)? Destructors and templates?

98 won't have moves, so I'd imagine you'd end up boxing most of your structures to avoid needing to copy construct then all over the place.

You still have to manually delete things but now there's extra indirection.

Templates might be nice, but having STLy containers is where the kernel would need them most, but then above boxing issues start to exist.

Well, Wayland+Xwayland would be easy, just pipe the X11 out to a host-side Xwayland

I thought FreeBSD fully supports Wayland?

Doesn't the article talk about how they're adding centralized KYC?

In what way is RISC-V more suited for writing assembly than, say, AArch64?

From what I know of each, they're fairly close together, but a few small things like the clever encoding of logical immediates (e.g. and x1, x1, 0x3fff70000000 is a single instruction; you don't need to waste a register to load the immediate) in AArch64 make it seem friendlier to me.

The VK_NN_vi_surface extension seems to imply that Nintendo does.

What does it mean to assert in this context? I assume not the same thing as C's assert macro; is it the EE sense of "pulling a pin high / low"?

I think they meant, can't a visitor just ignore that your cert is self-signed and view the page anyway, _without_ adding it to the trust store. Firefox, at least, has this as the default "ignore the cert error" action.

Better than writing them in the sudoers language, whose definitions are annotated...

Does removing ERMS actually make life easier? I thought it was the "do the simple thing" option, and an emulator could just turn it into a memcpy on the emulator's side.

I think that was meant to be understood in context as "meant to be actively developed" (as opposed to maintained) for a long time. The practices the author lists are ones that in larger programs would typically be criticized for damaging maintainability as the program grows.

mm, no, not unless you're doing some LIKE-specific optimization (and even then, I think you'd want "positive%").

So like, at the end of all the decoders, the model gives you an output vector; you multiply this by your embeddings to get your token probabilities, then you sample from them to choose a token.

Instead of sampling, you could just look at the probabilities for the tokens "positive" and "negative" and return whichever of those two is highest.

Probably not the point, but shouldn't you be able to choose to sample only the tokens for "positive" and "negative" (they're both one token!) instead of (or in addition to) needing to put a request for model to restrict its responses in the context?