The script itself is also a wrapper for curl | bash

It's curl | bash all the way down.

I'm mildly annoyed by line 30 in include/posix_include/stdio.h

It's only an errant tab ffs.

:P

Just for curiosity, how would YT deal with ID collision ?

Edit: Before the scheme change I mean

>base64'ed DES-encrypted primary int64

Block ciphers (such as DES) don't collide. If they did there would be no way to decrypt them because a block could be decrypted into multiple valid plaintexts.

Not sure about technical details for that but perhaps something like https://vitess.io/docs/reference/features/vitess-sequences/. Vitess itself is a project that grew out of YouTube's needs to scale and shard their MySQL DB.

Probably they just roll again. You can even implement that in a stored procedure.

Try again? Just a guess.

Unrelated, but that website ruins the back history for me. So annoying.

Same. Annoying.

Same here (chrome on ios) and my phone got extremely hot. A warning

Strange, the Back button works perfectly well (in Safari) for me.

Turn off JavaScript by default.

> In some sense, Yatima's trying to be to Rust what Haskell is to C

Can someone explain to me how C and Haskell are related here ?

Sure, if you consider Haskell's runtime (I know that technically GHC /= Haskell, but in practice it's the only Haskell that matters, except maybe something like Asterius) all the primitives are backed by C libraries: https://hackage.haskell.org/package/ghc-prim-0.4.0.0/docs/GH...

Likewise with conventions around pointers, arrays, etc. to the point where if you want to do anything really low-level or performance sensitive in Haskell, you're essentially punching a hole into C. As a random example, within the fast base64bytestring library, you find lots of use of `malloc`, `ForeignPtr` etc.: https://github.com/haskell/base64-bytestring/blob/master/Dat... And of course because this is C there aren't really many safety guarantees here.

The plan with Yatima with its primitives, and eventually when we write an FFI is to integrate with Rust in the same way that Haskell uses C. My hope is that with Yatima's affine types we might even be able to FFI to and from safe Rust (since the borrow checker uses affine types), but this is a little bit of a research project to see how much that works. Even to unsafe Rust though, we have better safety guarantees than C, since unsafe Rust's UB is still more restricted than C's is.

Haskell's GHC compiler (eventually) transforms haskell into a "fictional assembly" called C--. It has no relation to C at all except in the generic sense that it's a low-sugar low-semantics low-level language, intended to be a machine-friendly view of high level haskell. Maybe the author meant that relationship in the generic sense. (C--could be transformed to C to be read or compiled, but it could equally be transformed into LLVM IR or native.)

Some languages do compile to C (if only for the portability and compiler quality). C++'s first compiler used such a technique.

I wasn't talking about C--, more about how GHC essentially exposes C libs for its primitives. Also want to clarify that Yatima doesn't compile to Rust either.

The comparison to Haskell/C was an imperfect analogy, I was just trying to express that "functional programming language that integrates with Rust" seems like a mostly unfilled niche that Yatima could exist in