Aria Beingessner

> It seems unlikely [Apple] would throw away that investment and move to Rust. Apple has invested in Swift, another high level language with safety guarantees, which happens to have been created under Chris Lattner, otherwise known for creating LLVM. Swift's huge advantage over Rust, for application and system programming is that it supports an ABI [1] which Rust, famously, does not (other than falling back to a C ABI, which degrades its promises). [1] for more on that topic, I recommend this excellent article: https://faultlore.com/blah/swift-abi/ Side note, the author of that article wrote Rust's std::collections API.

I recommend the following reading (from https://news.ycombinator.com/item?id=36478892). https://faultlore.com/blah/text-hates-you/

Hmm, the article is a bit hard to follow and lacks any elaboration on which cases this data structure is better or worse than other hash tables As swiss tables are new to me I looked around a bit and found this to be a better explanation https://faultlore.com/blah/hashbrown-tldr/

Oh yeah Aria’s writing is excellent. https://faultlore.com/blah/

> - Assume our language has a specification, even if it's entirely in your head It does not, and at the current pace, it might never have a spec. The reason there is no spec - not even an hypothetical spec in my head - is that the exact semantics of Rust has not been settled. With the constraints the Rust project are operating with, the only way forward I can think of is following the ideas laid out in post https://faultlore.com/blah/tower-of-weakenings/ With the understanding that you can have multiple specs if one is entirely more permissive than the other (and as such, programmers must conform to the least permissive spec, that is, the spec that allows the smallest number of things) But the problem is, Rust doesn't even have this least permissive spec. Or any other.

This is a must read for you then if you don't understand the role C plays in modern operating systems: https://faultlore.com/blah/c-isnt-a-language/

How Swift Achieved Dynamic Linking Where Rust Couldn't: https://faultlore.com/blah/swift-abi/ Many programming languages list Swift as inspiration: https://www.val-lang.dev/ Rust's optional bindings are inspired by swift: https://doc.rust-lang.org/reference/influences.html (Many people who worked on Rust also worked on Swift, like the creator of rust) The SwiftUI framework you mentioned uses inspiring syntax, which has been tried do be emulated (Jetpack Compose, Druid). However, nobody got it as magical as Swift did. The way SwiftUI Syntax combines pl theory and developer usability is amazing.

> there are ABI breaks, but I only remember only one really bad one with std::basic_string and C++11 ABI breaks are everywhere in C++... consider a class class foo { public: foo(); void do_something(); private: int x; } and an impl in the dynamic library: #include "foo.h" foo::foo() { this->x = 0; } void foo::do_something() { std::cout << this->x << std::endl; } You build a libfoo.so and clients use it, calling `foo f; f.do_something();`, it calls your library and it's great. But as soon as you ship a new version that adds a new field to foo (still source-code compatible): class foo { public: foo(); void do_something(); private: int x; int y; }; With a new function body in your shared object: void foo::do_something() { std::cout << this->x << this->y << std::endl; } You're hosed. Clients have to recompile, or they get: $ ./main 0, 0 *** stack smashing detected ***: terminated [1] 2625391 IOT instruction (core dumped) ./main Because the size information for an instance of foo is only known at compile-time, so the clients aren't allocating enough space on the stack for it (ditto the heap if you're using `new foo();`) The way around this is awkward and involves the pimpl pattern and moving all your constructors out-of-line... but you also need to freeze all virtual methods (even just adding a new one breaks ABI), and avoid using any template-heavy std:: types (not even std::string), since those…

Vastly oversimplified, that'd be because fonts are individual strokes of varying width and free layout that get rendered on a array of pixels with fixed sizes and fixed layout. Resampling comes with some aliasing/information loss. Font rendering is about picking which losses you're willing to take. And you can't just "ask designers" because the trade-offs are different based on resolution and pixel layout. And they change as you scale the font up and down. ("Font hinting" tries to fix issues with that scaling. It's got its own downsides) And because it's fun, there's also a perception component, where different people can just look at the same font and process it differently. Font rendering is the art of making compromises that offend the least amount of people. A good starting point on the subject: "Text rendering hates you" - https://faultlore.com/blah/text-hates-you/ (I could swear there was also a great post by Raph Levien, but I can't find it)

I’m not sure whether those toolkits abstracted over native GUI interfaces or whether they attempted to recreate a native look and feel or whether they attempted to provide their own look and feel across platforms, but in any case the problem isn’t languages and compilers, it’s that the expectations for a GUI toolkit are dramatically greater now than then. Here are a few things that are (I think) expected from GUI toolkits today, but not 30 years ago: * Hardware acceleration (in particular abstracting over metal, opengl, direct x, vulkan, etc) * More complex layouts * Animations * Much hateful text rendering (e.g., right-to-left language support): https://faultlore.com/blah/text-hates-you/ * Accessibility And if you want to emulate a native experience, getting keyboard shortcuts, focus behavior, and a billion other details correct is nearly impossible. And by the way, today we have web engines that take care of most of these things for free and a huge pool of people who know how to build for them, so it’s often easier to leverage that capability than to essentially reinvent them. And if people can contain their knee-jerk anti-electron reaction for a moment, I think that’s a pretty reasonable approach. I would really like to see something like an unlocked ChromeOS where the browser is the native interface, but unlike electron, we don’t ship a web browser with each app. Especially as webasm takes form, I could see this as a more compelling solution for cross-platform…

This is on point. I work on small-ish embedded Linux systems and I would really like to use Rust there, but a single Rust binary takes up enough space for 10 C programs, so it's prohibitive. You can dynamically link your libraries (especially since these systems are usually built as full images, so ABI compatibility does not really matter) and it helps a little, but nowhere close to the order of magnitude you need. Alas, there is little interest in/awareness of the middle ground between the no_std world and the "size doesn't matter" world in the Rust community right now. I've asked a bunch of people for pointers as to where to start working towards supporting those cases but I mainly got shrugs. There were attempts at more lightweight stdlibs and so on, but they all seem to have fizzled out. I wonder how much of this is inherent in the language design. Rust heavily leans on monomorphization, so as a first approximation, you will always generate more code (before maybe optimizing that away again). Famously, the Swift people went to great lengths to avoid these problems: https://faultlore.com/blah/swift-abi/. But while running Swift on Linux is possible, this is even more niche.

OS and CPU combination define their ABI as "whatever our most popular / default compiler did in 90s". That's the problem with C-based ABIs. OS ABIs aren't independent of the language. So any new language must include a C compiler within for ABI access. See https://faultlore.com/blah/c-isnt-a-language/ for more detailed analysis.

Not just interoperability with Objective C but with C (full) and C++ (increasingly better but not full) as well. Swift is also interoperable with different versions of itself courtesy of the Swift stable ABI (Application Binary Interface)[0], which they invested a significant amount of time into at the expense of adding other new features to the language, which have come along later. Rust offers a different approach: recompile everything and static linking. [0] https://faultlore.com/blah/swift-abi/

> You can look to Swift for prior art on how this can be done: https://faultlore.com/blah/swift-abi/ > It would be very hard to accomplish. Since Rust cares very much about zero-overhead abstractions and performance, I would guess if something like this were to be implemented, it would have to be via some optional (crate/module/function?) attributes, and the default would remain the existing monomorphization style of code generation.

Allow me to change your mind: https://faultlore.com/blah/text-hates-you/

hard is this: https://faultlore.com/blah/text-hates-you/ and this: https://lord.io/text-editing-hates-you-too/ those are both things most ImGUIs ignore. And, even if you pick some library that somehow handles the first you're left with all of the issue mentioned above. To be clear, if I was writing a devtool (and I am actually) i'd reach for an ImGUI (and I did). But I'd be unlikely to use one for user facing tool.

CS undergrads write parsers for some toy lisps or other straight forward syntax. C isn't as trivial https://faultlore.com/blah/c-isnt-a-language/#you-cant-actually-parse-… (a small remark, but to be clear I'm not terribly impressed by AI showcase of the c compiler, nor with browser before that, as it stands)

This is the same author who found and reported ABI incompatibilities between clang and gcc: https://faultlore.com/abi-cafe/book/trophies.html — Given these incompatibilities have since been addressed, I think it's fair to say there were indeed issues with C.

Affine types are "may use" and linear types are "must use," yeah. That is, linear types are stronger. See https://faultlore.com/blah/linear-rust/ for a (now pretty old but still pretty relevant, I think) exploration into what linear types would mean for Rust.

I think if AI can help us modernize the current state of hardware verification, I think that would be an enormous boon to the tech industry. Server class CPUs and GPUs are littered with side channels which are very difficult to “close”, even in hardened cloud VMs. We haven’t verified “frontier performance” hardware down to the logic gate in quite some time. Prof. Margaret Martinosi’s lab and her students have spent quite some time on this challenge, and i am excited to see better, safer memory models oyt in the wild. A lot of the same big ideas used in hardware are making their way into the software later too, see https://faultlore.com/blah/tower-of-weakenings/

> Is it something that can be fixed with editions? My guess is no, or at least not easily. Assuming I'm reading these blog posts [0, 1] correctly, it seems that the size_of::<usize>() == size_of::<*mut u8>() assumption is changeable across editions. Or at the very least, if that change (or a similarly workable one) isn't possible, both blog posts do a pretty good job of pointedly not saying so. [0]: https://faultlore.com/blah/fix-rust-pointers/#redefining-usize [1]: https://tratt.net/laurie/blog/2022/making_rust_a_better_fit_for_cheri_…

I really like this article "How Swift Achieved Dynamic Linking Where Rust Couldn't" https://faultlore.com/blah/swift-abi

Well, in the age of 3440x1440 displays and retina, you are forced to render high-quality fonts, not just bitmaps. In order to do that well, and fast enough, you need the GPU. Font rendering is hard: https://faultlore.com/blah/text-hates-you/ https://pandasauce.org/post/linux-fonts/ https://behdad.org/text2024/ So much that Slug is a thing: https://sluglibrary.com/

Will Carbon improve the ABI situation? Will Carbon be easier to interface with from other languages? A major role that C plays today is being the common protocol all languages speak[0]. C++ can't fill this role, and neither can Rust. There is a huge opportunity for some language to become the next common protocol, the common ABI, that all languages share in common. (Maybe Rust could do this, but they haven't stabilized their ABI yet, and I don't the details.) [0]: https://faultlore.com/blah/c-isnt-a-language/

Gankra wrote a good piece about all the work involved in this years ago (specifically, what Swift had to go through to get ABI stability) <https://faultlore.com/blah/swift-abi/>

Some differences and advantages of swift are documented here: https://faultlore.com/blah/swift-abi/

2D rendering is harder in fact, because antialiased curves are harder than triangle soup. It's an issue of code complexity, not fill rate https://faultlore.com/blah/text-hates-you/

I like Aria's writing about this https://faultlore.com/blah/swift-abi/.

The code the blog presents copied from the std, ironically it does include the line where the len is set to 0 with a in code comment (but the article fails to go into it and seems to not be quite aware of the issue, it's otherwise quite good). Also: - up to date explanation in the nomicon: https://doc.rust-lang.org/nightly/nomicon/leaking.html - from 2015 when it was realized leak must be sound: https://faultlore.com/blah/everyone-poops/

This has been linked in the comments already, but check this out: https://faultlore.com/blah/text-hates-you/