libCat VS rust

That's awesome! I'm working on something that sounds similar. https://github.com/cons-cat/libcat

I'd love to see your work if you're willing to share it here!

This runtime size bothers me a lot. So much that I've been working on a new runtime for C++ that breaks POSIX compatibility to keep binaries as small as they can be. The hello world with LTO is 330ish bytes right now, and I think that can get smaller. https://github.com/Cons-Cat/libCat

I'm working on a library that replaces both C++ and C/POSIX standard libraries (https://github.com/Cons-Cat/libCat), but even then I need to define a few std:: namespace symbols for some features. In the case of std::initializer_list, my answer is just don't use that feature, because you don't really need it.

It's worse in the standard library than it has to be. When I refactored my traits to minimize template instantiations and lean on concepts as much as possible, I measured over 30% improvement to clean build compile times. It's not possible for the standard to do this, because it would subtly change the API. For instance, you can't instantiate or take the address of a concept, but you can for a type-trait class. No reason you'd want to do that, but you can, so they can't "break" the standard library by optimizing this.

This doesn't have to be true. Over the past year I've made progress towards demonstrating how even non-freestanding C++ can be written without any C or C++ standard library headers or DLLs (with large benefits). There are a few names which the compilers require to be in the std:: namespace, though, but they're very special features like source_location and construct_at with semantics that can't be expressed otherwise.

This bit cast has no overhead in debug mode, and is a little bit more generally useful than std::bit_cast(), but cannot be constant evaluated. https://github.com/Cons-Cat/libCat/blob/main/src/libraries/utility/implementations/bit_cast.tpp

It isn't that hard to put a predicate into a type. We have lambdas in an unevaluated context, CTAD, and templated type aliases. https://github.com/Cons-Cat/libCat/blob/main/src/libraries/scaredy/cat/scaredy https://github.com/Cons-Cat/libCat/blob/main/src/global_includes.hpp#L70 https://github.com/Cons-Cat/libCat/blob/main/src/libraries/linux/cat/linux#L289 You do it like this.

But suppose that you have code with no standard library calls at all. Would it still make sense to choose this naming convention? This is actually possible, with a few special exceptions. GCC requires that an implementation of std::source_location has very particular class member names, GCC assigns special semantics to a few function names including std::construct_at and std::move (people seem to know it's inlined, but did you know std::move is required for move-related warnings?), and most intrusively of all, a promise_type must be snake_case. Other names can be worked around by using them into a different namespace with a different letter-case, but promise_type seems unavoidable.

I use C++ for a low-level Linux runtime. Other people are using it for operating systems like SerenityOS and Zircon/Fuschia. People also use C++ for making more compilers like GCC and LLVM.

If you haven't dipped your touch-typing fingers into Rust yet, you really owe it to yourself. Rust is a modern programming language with features that make it suitable not only for systems programming -- its original purpose, but just about any other environment, too; there are frameworks that let your build web services, web applications including user interfaces, software for embedded devices, machine learning solutions, and of course, command-line tools. Since a custom GitHub Action is essentially a command-line tool that interacts with the system through files and environment variables, Rust is perfectly suited for that as well.

Here's an example of someone citing a disagreement between CRT and shell32:

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

This in addition to the Rust CVE mentioned elsewhere in the thread which was rooted in this issue:

https://blog.rust-lang.org/2024/04/09/cve-2024-24576.html

Here are some quick programs to test contrasting approaches. I don't have examples of inputs where they parse differently on hand right now, but I know they exist. This was also a problem that was frequently discussed internally when I worked at MSFT.

    #include 

> instead of choosing a certain numbered version of the random library (if I remember correctly) I let cargo download the latest version which had a completely different API.

Yeah, they didn't follow the instructions and got burned. I still think that multiple things went wrong simultaneously for that experience. I wonder if more prevalent uses of `#[doc(alias = "name")]` being leveraged by https://github.com/rust-lang/rust/pull/120730 (which now that I check only accounts for methods and not functions, I should get on that!) so that when changing APIs around people at least get a slightly better experience.

Almost fixed the compiler: https://github.com/rust-lang/rust/pull/123325

Rust: A secure, efficient, and modern programming language (omitting ten thousand words). You can simply follow the installation instructions provided on the official website.

Recently did something similar in Rust but for generating SVGs. We've adopted it for snapshot testing of cargo and rustc's output. Don't have a good PR handy for showing Github's rendering of changes in the SVG (text, side-by-side, swiping) but https://github.com/rust-lang/rust/pull/121877/files has newly added SVGs.

To see what is supported, see the screenshot in the docs: https://docs.rs/anstyle-svg/latest/anstyle_svg/

We strongly believe in Rust as a powerful language for building production-grade software, especially for systems like ours that run alongside Kubernetes.

The above Assert<{N % 2 == 1}> requires #![feature(generic_const_exprs)] and the nightly toolchain. See https://github.com/rust-lang/rust/issues/76560 for more info.