dochtman

I wonder if someone could create a GitHub account using my name and claim ownership of them...

AIUI the crates are actually linked to the account via a different identifier, not directly to the username.

GitButler now employs/has hired the gitoxide maintainer, I think? So no doubt they’re aware.

I guess they found that gitoxide isn’t good enough and/or to expensive to extend/improve for their use cases?

A lot of Let’s Encrypt is not the software but a bunch of auditing and process that ensure compliance and make it legible to the required auditors.

That's the policy, but we've been a bit more conservative in practice. `main` currently targets 1.88, but that's only because a security issue in the time crate has forced our hand (one reason I don't like the time crate all that much). Before that, it was 1.83 (from November 2024). Our last release targets 1.71 (from July 2023).

I'd bet a supermajority of Swift commits comes from Apple developers. Pretty sure the rust-lang/rust commit authors would be much less centralized.

See also:

https://github.com/1jehuang/mermaid-rs-renderer

Just submitted a HN thread about it:

https://news.ycombinator.com/edit?id=46807750

I think the way Rust checks borrows also makes it a lot more feasible to avoid allocations/copies; not because it is impossible to do in C, but because doing it in C requires writing very careful documentation and the caller to actually read that documentation. In (safe) Rust this is all checked by the compiler such that libraries can leverage it without blowing their complexity budget.

There’s also a compounding effect: I’ve heard from a hardware vendor that they spend a lot of time optimizing OpenSSL to get the most out of their silicon, so for their customers they suggest using OpenSSL to get the most out of the hardware.

How is the HiDPI situation, and font rendering? Last time I tried it on my M1 Max with Asahi it still looked substantially worse.

I'm pretty sure private PKIs are an option that is pretty straightforward to use.

Security is still a lot better because the root is communicated out of band.

When I asked about financial support, the Senior Principal Software Engineer from Mozilla I talked to said "Mozilla has no money".

To be fair, we've gotten a great amount of code contributions from the Mozilla folks, so it's not like they haven't contributed anything.

(I am one of the Quinn maintainers.)

I would argue that regexes are often more complex than simple parsers.

(2021)

CRLite is awesome, and it deserves more usage; notably most non-browser clients on Linux machines don’t get any revocation handling at all.

Tauri seems interesting. It combines a Rust core with the platform-native browser engine for presentation. Of course a potential downside is rendering incompatibilities between engines/platforms.

No, they don’t.

Selling support contracts is actually hard.

GPL/AGPL preclude widespread adoption (these days) — the grandparent explicitly mentioned “permissive” licenses.

IIRC derive and attribute macros via declarative macro definitions are coming soon, which probably obviates this?

https://github.com/rust-lang/rust/issues/143549

Does this work on macOS?

On mobile (Firefox on iOS) why does this site keep putting animations in my face?

We tried this when we were benchmarking and it was not significantly better than the Arc<RwLock<_>> that we're using now.

Did you file an issue or ask in the rustls Discord channel? We're happy to help.

Curious what this would look like written in Rust, using the windows-rs bindings.

Typst is the modern LaTeX.

https://typst.app/

Async is a language feature to enable scalability, but an alternative approach is just to spawn a bunch of threads and block threads when waiting for I/O to happen. That is the approach used by this framework.

Part of the fingerprint is stuff like the ordering of extensions, which Chrome could easily do but AFAIK doesn’t.

(AIUI Google’s Play Store is one of the biggest TLS fingerprinting culprits.)

But the difference is that Signal has been architected from the start to retain much less (meta)data on the server, so that even if the Signal Foundation is compelled to share the data they have, that data will be extremely limited to the point of being mostly useless.

How does performance compare to running native code?

zlib-rs is faster than C:

https://trifectatech.org/blog/zlib-rs-is-faster-than-c/

Makes sense that this is the only way to compete with Microsoft.

(See also how MS attacked Slack by including Teams for “free”.)

git absorb is great, use it all the time.

How so? What standards do you need support for?