Every project must colonize a valley of the language, declare a dialect, and bit-fiddle their own thing.
It might be a measure of popularity, but not of unity.
When projects choose a subset of language features, it's dictated by their needs (like embedded programs disabling the standard library, or safety-critical libraries forbidding "unsafe" code out of caution). There are some people who vocally hate async, but their complaint is usually that everyone uses async even where it's unnecessary (meaning that it actually has very broad adoption).
This feels very different than having an unwanted C subset, some '98 features that were replaced in '11 and '13, with fixes for them in '20 and '26 and then projects taking years to settle on a new baseline, and still bickering whether exceptions may be allowed or not.
Rust has "editions" that let new projects disable old misfeatures (which it hasn't got many yet). Rust ecosystem is fully on board with the latest version.
However, once you bootstrap it (or willing to trust someone who did), it's a breeze to build Rust projects with Cargo: `cargo build` just works with no extra flags for the majority of projects. The only finicky builds are ones that rely on C or C++ deps.
“idiot end user”?
Why sign up to be a maintainer when you think so highly of the end user.
(I assume you use mrustc, and you're not going the masochist route of recreating all the development steps starting from a 15-year-old Ocaml-based prototype of a language that wasn't Rust yet).
It's fair to say that bootstrapping of Rust sucks. It really does. The non-Rust bootstrap compiler doesn't get even a fraction of the polish that rustc and Cargo get. But it's not representative of how Rust and Cargo work for basically everyone in the world except you (and a couple of other maintainers who chose to do an independent bootstrap from scratch). Bootstrapping is a one-off pain, and then building Rust with a Rust-based compiler is nice and easy.
It'd be nice to have a cleaner bootstrap story for Rust, but it will take a while (waiting for gccrs C++ reimplementation to advance enough to replace mrustc).
Rust is pragmatic about its implementation. The goal isn't some ideological purity (despite the reputation Rust has), but to empower users to make safe and efficient systems software. LLVM works well for that, so replacing it isn't a priority. The cranelift backend exists to make debug builds faster.
I like C++ because I like the fairly unique high performance low level feature set, not because I particularly like most of the detailed design decisions that went into it. Rust has the same goals, but is better thought out IMO. I'm sure that I will find some more trouble in Rust as I use it more, but so far the impression is quite good. I have become pretty good at writing C++ code that works after fixing one or two stupid bugs, and that works even better in Rust, mostly without the stupid bugs because you can't forget to null-check a pointer to another subsystem while starting up etc.
I also call C++ a high level low level language.
Saying LLVM is written in C++ doesn't really bring much to the discussion. It was released 25 years ago, and C++ was released 40 years ago (hey, it's older than me lol). Rust was released like 10 years ago. So, yeah... I guess it makes sense that they used C++ back then? I'd have picked C++ back then too.
I've written C++ for about 15 years, and I don't have a blind hatred for the languge, but going back to it doesn't fill me with joy either, especially after having written Rust for the past few years.
The module system is more intuitive to use than the preprocessing file concatenation. There's also a nice package manager. I know some people find this a downside though, but I prefer it to fighting autoconf or CMake.
Syntax highlighting for Rust code doesn't lag 10+ seconds.
Symbol search doesn't require three different third-party tools to work.
Documentation is built in AND nice (no doxy doesn't count as nice, not in any universe).
Testing is built in. There's a (mostly) homogeneous build system
The borrowing rules are things you think about in C++ anyway, but Rust just makes it so you don't forget them; there's some clang lints that help with this in C++ anyway.
The syntax, while sometimes a bit noisy, is nicer in the average case, but C++ has been getting better in that regard.
There's much fewer API gotchas with Rust than with C++ (from the top of my head: closures, std::optional, std::variant, iterators, {a..z}values, a managerie of constructors, SFINAE, all these things have pain in the ass built in as a core principle). I also despise function overloading.
The macro system, while I don't like it too much in Rust, makes things
The type system in Rust is so much better it's not even comparable.
But anyway, Rust has some downsides. It requires you to change how you design solution sometimes. The compilation times are crap (but the compilers also does so much).
Due to an evil entity called the military industrial complex, you are going to be using Rust in the future.
Javascript is even more dramatic, where it will tell you to fix every single variable declaration, as people decided "var" was a mistake, and there is a whole new way of defining classes.
this is really not true in my experience. I don't remember last time I worked a project which outright banned specific C++ features or had a "dialect".
Neither of which are great measures probably. What about usefulness?
Lambdas are nice to have, just don’t nest them more than once.
I kinda wish things like std::variant had shorter syntax.
if anything i’m not a fan of c++ introducing language features as long verbose functions than to confidently make it an operator or a keyword.
However it would be imperative for a push such as Carbon[1] to be similar to the kotlin to Java. A modernisation that simplifies , maintains backwards/forwards compatibility and reuses established libraries and tooling.
This however will need a entity that can champion and push it forward with a strong enough project to anchor it in the mainstream.The transitions are doable ,like Android dev from plain java to kotlin , or in OSX moving from Objective-C to Swift.
Additionally borrowing a robust batteries type standard library to reduce the sprawl of coding options and funnel greenfield projects into best practices and less boilerplate.
[1] https://www.infoworld.com/article/2337225/beyond-c-the-promi...
I take a very different view about the trajectory of languages given the current trends in software development. The more people rely upon agentic coding processes, the more they will demand faster compilation which will increasingly become a significant bottleneck on product velocity. The faster the llms get, the more important it is for the tools they use to be fast. Right now, I still think we are in an uncanny valley where llms are still slow enough that slow tooling does not seem that bad, but this is likely to change. People will no longer be satisfied asking their agent to make a change and come back in a minute or an hour. They will expect the result nearly instantaneously. C++ (and rust) compile times are too slow for the agent to iterate in the human reaction window so I believe that one of two things will happen over the next few years: llm progress will stall out or c++ and rust will nosedive in popularity.
Every language popular enough is like that.
with the caveat that i know it could be better. at this point i just think it's simpler than some of the stuff out there from a 'whats happening underneath the hood' perspective
That's not really plausible. Unfortunately this is all you get on the methodology:
> Our methodology is based on two main pillars. First, we make use of reliable sources of developer numbers or direct indicators of their activity. This includes the number of GitHub accounts, Stack Overflow accounts, and employment statistics from the USA and the European Union. Second, we rely on our Global Developer Survey data, where we directly measure developer activity. So far, we've run 29 waves of this large survey, and in each, we reach more than 10,000 developers globally. We combine these two main sources to derive our estimates.
Plenty of space for them to screw up I think.
- The current CPP version is extremely bloated
- CPP is not going away anytime soon
- The rise of Rust/Go/Zig is not fighting for CPP's seat
- You can target CPP code using any of these aforementioned languages
- Rust has never claimed to be "safer", it just makes it harder to write unsafe code
Of course they are. Go less so, and Zig is really aiming for C. Rust is definitely meant to be a better alternative to C++.
> Rust has never claimed to be "safer"...
What? Of course it has (or Rust developers have; a language can't claim anything). And it is much safer.
Until current computers cycle out, people will largely keep their 1-3 year old machine with sane amounts of memory. If we start seeing large numbers of machines in the wild with 4GB of memory, then maybe software will adapt. But that won't be for several years yet.
Projecting into the future, hardware expenses have always been dwarfed by salaries. I don't expect that will change enough for it to be noticeable.
Galen is a super smart guy, but he's not a decision maker. I have yet to hear that this is actually the official direction Microsoft as a whole is taking, across any of their business segments.
Since it's no longer New Years Eve, I'm a bit more sober :p
Programming language to programming language conversions seems to be one of the things LLMs are actually good at. Whether they can actually do it or not is an open question.
CEOs will mandate security so the CSOs will mandate Rust over C/C++ and so Rust will slowly take over C++ in next 20 years. Can't see anything in C++'s defense other than it's legacy. The drawback of sticking every feature from every language into your language is that it becomes a massive security hazard.
huh? I'm currently at $1500 Monthly Recurring Revenue, so I'm currently between seeing if I can increase that or if need to get a job. I'll find out in a couple of months.
I lack a degree though
I get regularly contacted my them, but they don't hire me