An alternative to Axum.

Now with Firefox support

Seeds data automatically for databases. It's marketing tells it's more automated than fakerJS.

Rust provides a single binary (lightweight compared to JS and more cache-efficient for Docker layers)

(via https://www.reddit.com/r/rust/comments/1r1emah/rewrote_my_nodejs_data_generator_in_rust_20x/ which seems generated by AI)

It feels wrong to write HTML that way, but maybe I am too used to the HTML we daily use as web developer.

I like the research though.

NetBSD integrated Lua, but Rust is a non-starter in the core of NetBSD because: rust does not compile verywhere, keeping rust working is quite a bit of work, the bootstrap relies on a binary package of the previous version, the compiler would have to be part of the base system and the release cycle of Rust is not compatible with the NetBSD ones.

Issues with SQLite:

1. The test suite is not open source
2. External contributions are not welcomed
3. It's written in C, which is nowadays prone to easily-avoidable bugs, hard to maintain and add new features
4. SQLite does not support concurrent writes
5. Columns are weakly typed

Note the SQLite documentation hints Rust as a potential language for a rewrite under conditions listed at the end of the page.

Where Turso is good: scaling (instead of switching to PostgreSQL). Also it's simple to build an extension for it

Chacha20 can sue 192-bit nonces with a 256-bit key. A single function returns the key, the authentication key and the nonce.

The name changes in order to avoid arguing why ChaCha12 is as secure as ChaCha20, because the implementation is compatible with it.

The final specification https://kerkour.com/chacha20-blake3 and the research used https://kerkour.com/chacha20-blake3 can be helpful.

Utile peut-être pour plus tard

Note that the Rust uses C bindings under the hood.

A Rick-roll in the source code

Rust is the best language so far to replace today's most used crypto libraries: OpenSSL, BoringSSL and libsodium.

C libraries often contain a lof of assembly code making them really fast, but potentially unsafe.
pure-Rust libraries benefit from Rust strong typing and generally offer a better API, compile for all platforms including WebAssembly.

It's important to note that pure-Rust libraries might be slightly slower than C and assembly wrappers, but still fast enough for most use cases.

• aws-lc-rs is a cryptograhy create
• libcrux is a Rust wrapper for formally verified C, Assembly and Rust code.
• ring is focused on the implementation, testing, and optimization of a core set of cryptographic operations exposed via an easy-to-use (and hard-to-misuse)
• boring is a safe wrapper around google's boringssl
• dalek-cryptography is a Github organization about pure-Rust elliptic curve cryptography, used by Signal and Diem
• graviola is promising because it's faster than other projects, but not mature enough yet.

There is also blake3

In short, RustCrypto to get pure-Rust implenentations, or aws-lc-rs for linux-servers and best perforamances with FIPS certification.

RustPython is a Python interpreter written in Rust. RustPython can be embedded into Rust programs to use Python as a scripting language for your application, or it can be compiled to WebAssembly in order to run Python in the browser. RustPython is free and open-source under the MIT license.

It would be to go to to use Python in the browser because RustPython can compile in WebAssembly.

The playground: https://rustpython.github.io/demo/

I’m currently building an app that pulls a ton of data from an external API. If you use Rust, you know the drill: you get a UserDTO from the API, but you want a User in your domain. This usually leads to writing the same From trait implementation over and over again.

What’s in the sandbox so far? I built a macro called FromDTO. Instead of manually mapping dozens of fields, I can just do this:

Note the serde create do that for JSON and other formats

Rust devs who want async.
Rust devs who understand Rust's type system.
People who like BSDM.

13 references one pointing to another. It's the maximum Rust ensure to support.

So why 14?
Seems like because Rust thinks that 13 references ought to be enough for anybody.

More about https://www.computerworld.com/article/1563853/the-640k-quote-won-t-go-away-but-did-gates-really-say-it.html