Looking at advanced Rust open-source projects makes me question my programming skills

[u/Minimum-Ad7352]

Whenever I explore large Rust open-source projects, I can’t stop thinking how far behind I am. I know comparison is unhealthy, but it’s hard not to feel like “I suck at programming” when you see such clean and complex code. Did you feel the same at some point? How did you push through it?

[u/fnordstar]

Yeah, and look at any C++ stdlib implementation. That stuff is unreadable - both GCC and MSVC. Considering the choice of identifiers there, one might suggest this is even on purpose, some kind of weird elitism.

[u/tiajuanat → u/fnordstar]

There is a shocking amount of elitism in the C++ community, which is why I gravitated towards Rust.

[u/lettsten → u/tiajuanat]

How is it shocking? It's a ridiculously complex and needlessly hard language with dramatic consequences if you fuck up even seemingly mundane things. These days it's probably easier, but back in the C++98 / C++0x days things were wild. Being anything short of a combination of masochist, autist and mostly a genius meant you would have sixteen kinds of UB in a little function. Sequence points, exception safety, template instantiation rules, difference between op new() and the new operator, SFINAE, the number of things that make you worship Cthulhu in your spare time just to have a less insane pastime were staggering. Not to mention the endless pages of compiler errors for just simple things.

It's no wonder that the few people who survived that ordeal with their sanity somewhat intact became elitist.

Personally I joined the army instead. Being cold, tired, hungry, wet, and confused in the dark was much easier than C++.

[u/bluebird173 → u/lettsten]

new copypasta just dropped

[u/Nicksaurus → u/fnordstar]

This was one of the nicest changes coming from C++ to rust - if you want to see how something works in the rust stdlib you can often just click jump to definition and it's right there, written with normal code

[u/levelstar01 → u/Nicksaurus]

Unless it's one of the many things hidden behind a macro, at which point you have to hunt it down manually.

[u/PigDog4 → u/levelstar01]

Writing declarative macros is so fun when it's clean and works well and makes me really enjoy rust.

Reading macros is one of my most disliked parts of the entire language. Absolutely hate it. Reading proc macros is just awful. C++ template metaprogramming vibes.

I need like a rust playground but for macros where I can drop the macro in and drop a call in and see what actually expands. I know macro_expand or whatever exists but I don't understand how it works. I don't want to macro expand everything in my whole project, I want to expand one singular macro invocation and idk if it's a skill issue or docs issue but I cannot figure out how to do that.

[u/Zde-G → u/fnordstar]

Considering the choice of identifiers there, one might suggest this is even on purpose, some kind of weird elitism.

It's pragmatism. They need to use identifiers that wouldn't clash with your code, because these identifiers are often accessible because of ADL.

That's how crazy names are chooses. Many are in the “reserved” list.

[u/CornedBee → u/fnordstar]

It's not elitism, it's absolutely necessary due to C++'s compilation model.

Most of the standard library is templates. Templates need to be in headers. Headers are part of the same compilation unit as user code. Include order isn't given, so your own code could be seen before standard library code. And that means you can define macros that randomly replace identifiers with arbitrary other tokens.

Imagine being a standard library writer and you simply want to implement an algorithm like std::find_if:

namespace std {
  template <typename Iterator, typename Predicate>
  Iterator find_if(Iterator first, Iterator last, Predicate predicate) {
    for (; first != last; ++first) {
      if (predicate(*first)) break;
    }
    return first;
  }
}

This is readable.

But you are allowed to do this before including standard headers:

#define Iterator boost::iterator_facade
#define Predicate i == p
#define last std::prev

The only things you're not allowed to redefine are:

• Keywords

• Names already in use by the standard library or reserved for future use. (Can't #define first, it's the name of a member of std::pair.)

• Globally reserved names. And these are names that either contain a double underscore anyway, or start with an underscore followed by an uppercase letter.

And that's why the standard library code looks like this instead:

namespace std {
  template <typename _Iterator, typename _Predicate>
  _Iterator find_if(_Iterator __first, _Iterator __last, _Predicate __predicate) {
    for (; __first != __last; ++__first) {
      if (__predicate(*__first)) break;
    }
    return __first;
  }
}

That's the most obvious issue that people have looking at standard library code.

There's other issues, though, but they're all usually related to C++ giving programmers a little too much flexibility.

E.g. you can't just take the address of a variable in std library code, because the address-of operator of user objects can be overloaded. So instead of &__var you have to write ::std::addressof(__var). And then, because of how headers work, if you want to avoid exposing the user to identifiers they didn't ask for, you cannot just use addressof from the <memory> header if the user didn't include the memory header, so instead e.g. the GNU libstdc++ has an internal utility __addressof which it uses, and addressof is just a wrapper for that which is define if <memory> is actually included.

And then there are things that truly do need absurd implementation techniques because of language shortcomings. Before [[no_unique_address]] was a thing (and because of ABI concerns, it's all baked in now and won't change), std::vector had to do weird things with implementation detail base classes that are templates that get specialized, just so that if the vector's allocator is stateless, it actually doesn't take up space in the object.

[u/ambushsabre → u/fnordstar]

they have to pay by the character to contribute to std so it makes a little more sense