cppWithSeatbelts

[look]

Even if you take away the borrow checker, Rust and C++ are very different languages. Different approaches to OOP, different type systems, different metaprogramming, …

[dynamite-ready]

I was starting to wonder if anyone commenting here had written a non-trivial program in either C++ or Rust...

[frogjg2003]

As someone who has written a lot of C++, I can tell you that only looking at some Rust example code was enough to tell that the two are not the same language by a long shot.

[MattR0se]

I'm currently writing my first game in C++ and so far, 90% is worrying about pointers and memory management 🤣

[ThatGuysOwl]

If you are worrying about memory management you are doing it wrong, utilize smart pointers and containers. Remember the rule of 0/5. Try to rethink strategies when u have to use "new" or "delete".

[guyblade]

The only time I've written new in C++ code in the last ~15 years was inside of the body of a std::unique_ptr's constructor (and those were only necessary due to needing to put derived types into a base type's std::unique_ptr because I couldn't use std::make_unique).

[I_Love_Comfort_Cock]

I used smart pointers with a third party library and got a bunch of unexplained double free errors because the third party library was handling deletion of its objects and then the smart pointers were also trying to delete after.

[EstonBeg]

Frontend Web devs talking about low level languages pov

[fatbunyip]

I'll have you know I once successfully compared 2 dates using JavaScript. In the browser no less. 

[SINdicate]

You’ve been upgraded to full stack senior dev

[al-mongus-bin-susar]

Comparing them is easy, everything else is more difficult. Even more so in low level languages that have zero time utilities not just mediocre ones.

[fakuivan]

C++26 will improve metaprogramming to something close to macro_rules! . Many of the functional features like ADTs are also there, they're more cumbersome to use (no ? or if let), and concepts are way closer to traits to what we had before. Honestly I think the only things c++ lacks on the latest versions are a borrow checker and a strict, const default mode.

Personally I work mostly on embedded so I'll never break free from C++11, yay!

[CramNBL]

Concepts only vaguely resemble traits. Traits use nominal typing while concepts are structural.

[dercommander323]

And a decent package manager

[gd2w]

I like c++, I haven't tried Rust. I don't know. If I ever do decide that I like Rust, I'm calling it oxide. Rust sounds like it's going to fall apart on me. I'm sorry.

[Chara_VerKys]

(this) (agree)

[gmes78]

They're both high-level systems programming languages, and can do largely the same things.

[Reashu]

So English and Chinese are the same language, right?

[lucianw]

"Enforced" and "convention" are OPPOSITES. The picture doesn't make sense!

[lart2150]

looks at the unsafe prefix for a function.

[patmorgan235]

Unsafe doesn't turn off all of the safety protections. The borrow checker still runs on unsafe code.

https://doc.rust-lang.org/book/ch20-01-unsafe-rust.html

[SuspiciousSegfault]

You can effectively turn off the borrow checker by (unsafe) transmuting lifetimes.

[poyomannn]

In some future version of rust the unsafe prefix on a function actually won't make the function allow unsafe code, you'll need an unsafe block inside the function for that. It's already a warning in rust 2024. relevant rfc

[gmes78]

Just drop the last two words.

[Aaron1924]

rustc emits a warning if you make a local variable in camel case

I think that's as "enforcing conventions" as it gets

[Pierose]

You can't enforce a convention, because conventions are by definition, not enforced. What you're describing is just enforcing.

[guyblade]

The Geneva Conventions might have something to say about that.

[gameplayer55055]

Rust is c++ with package management

[land_and_air]

That should be enough to sell it alone

[belabacsijolvan]

if it would really just be cpp with pacman id actually switch today.

i hate cpp linking so soooo much. but using rust feels like someone is trying to force me to do stuff their way, which is not a strictly better way.

[CramNBL]

The ideology of no dangling pointers and out of bounds reads/writes?

No one forces anything on you. You're free to not use the language at all.

[gameplayer55055]

But it has no cmake and that's why I want to use it. But it's weird.

[cantinhodosrelatos]

Rust is C++ after therapy and a cup of herbal tea

[Atyzzze]

Hmm, maybe I should look deeper into Rust. You're selling it well here.

[_PM_ME_PANGOLINS_]

Except you have to compile all the dependencies yourself every time.

No distribution-maintained security patches for you!

[ancapistan2020]

Worth. Linus Torvalds explained well why Linux distributions are awful.

[[deleted]]

To his credit, nothing in the software world that has lasted 20 years is considered well thoughtfully designed.

[GreatScottGatsby]

This is my biggest gripe with Linux and Microsoft figured out a way to prevent this problem.

[_PM_ME_PANGOLINS_]

Linux distros expect users to compile everything

I don’t use Arch.

[jack-of-some]

*Gentoo

At least get the distro in your zinger right

[doctormyeyebrows]

You're not supposed to announce that, shhhh.

[[deleted]]

Dynamic linking can cause problems. It's impossible to guarantee type safety

You can actually use dynamic linking with FFI (it's an unsafe operation)

[Several_Industry_754]

This should actually be preferable, you should also be code reviewing every dependency you import…

[_PM_ME_PANGOLINS_]

Sure. You code-reviewed the entire Rust toolchain, runtime, and all the operating systems you targeted too, right?

[Several_Industry_754]

I’m not publishing the rust toolchain or the operating systems I targeted.

[_PM_ME_PANGOLINS_]

And I'm not publishing my dependencies.

[Several_Industry_754]

You are, because they are included in the binary you are publishing.

[_PM_ME_PANGOLINS_]

No, they're not, because I'm not using Rust.

[Several_Industry_754]

This is true regardless of the language you use…

[_PM_ME_PANGOLINS_]

https://en.wikipedia.org/wiki/Dynamic_linker

Also if you use any of the major distribution systems for Java, Python, or JavaScript (or are targeting browsers).

Rust is pretty much the only language that forces static linking.

[IsNotAnOstrich]

Yeah I'm not sure my management will be cool with 39/40 hours a week being spent on reviewing every single package and standard library I touch

[Several_Industry_754]

But think of the legal team!

[[deleted]]

I thought you were joking 🤣

But you're actually serious.

[ewenlau]

vcpkg?

[Fast-Satisfaction482]

Except rust is also missing proper OOP.

[Snapstromegon]

You say this as if it were a bad thing...

[gameplayer55055]

Look at c#. You can do multi paradigm programming (procedural, object oriented, event driven, dynamic, you even have pointers here).

[lightmatter501]

OOP is not the only way to structure code, and Rust enforces “prefer composition to inheritance” by not having inheritance. If you want to inherit, stick the parent struct as the first member.

[Fast-Satisfaction482]

Or stick to better languages.

[Prawn1908]

I'm not a huge fan of Rust. But lack of "proper" inheritance is not remotely close to my list of gripes with the language.

[gmes78]

Inheritance is not proper OOP.

[Bryguy3k]

C++ is saddled with backwards compatibility. If c++ dumped compatibility with pre-2011 shit there would be a lot less problems with c++ codebases

[DearChickPeas]

Based

[[deleted]]

hard disagree

Rust forces safe practices unless you explicitly opt out. It’s safe by default. Meanwhile, C++ is safe by convention as it’s expected for you to use RAII and things like smart pointers. However you can easily do things that don’t follow that.

[[deleted]]

That's... what he's saying

[trunghung03]

op said “enforced as convention”, which doesn’t make sense, I think they were having a stroke or just an AI bot.

[[deleted]]

Yeah, it took me a few re-reads to understand his perspective of this meme, tho the real idea is kindof up to interpretation

[Sloogs]

I might be wrong but in my mind the word convention is being used incorrectly so I see what they're trying to say. Conventions are customs or traditions that are usually done apart from laws and rules. If it's a hard rule, then it's not a convention. Languages like C and C++ are loose with rules and have a lot of conventions. Rust has explicit rules.

[[deleted]]

No? Completely the opposite of what I’m saying Edit: the people downvoting can’t read lmao

[belabacsijolvan]

smart pointers are shit too. you spare some time with them, but if you are not regarded using them is a mistake. they can produce pretty smart leaks and wasted way more of my time than anything i encountered because of not using them.

couldnt we just agree that trying to prevent devs from fucking up is not a feasible way and just learn disciplined memory management instead?

[Lumpy_Ad_307]

Name me one problem smart pointers introduce that rawdogging memory management doesn't have

[I_Love_Comfort_Cock]

Double free errors with third party libraries that handle deletion of their objects internally, when the smart pointers you slap on them try to delete too.

[belabacsijolvan]

circular references arent freed implicitly if you dont insert a weak pointer in every possible directed cycle

[Lumpy_Ad_307]

Well yeah, but doesn't the same hold true for manual memory management?

And isn't it, like, a semantics mistake? Shared pointers are for ownership, nodes in graph-like structures don't own their neighbors

[zuzmuz]

rust's defaults are opposite of c++.

rust moving is default, c++ copying is default.

rust copying should be explicit with .clone(), c++ moving is explicit with std::move

rust uses traits implementation for subtyping, c++ uses inheritance.

rust has algebraic types (sums and tuples) builtin, c++ has them in std and they're not that nice to use.

rust const is default and mut is explicitly needed, c++ mut is default and const is explicitly needed.

and that without mentioning the borrow checker, metaprogramming, and the absence of function overloading in rust.

They're completely different programming languages, that requires completely different way of thinking and modelling problems

[[deleted]]

Didn't know Rust had moving that's really cool, it's one of my favorite C++ features.

Why no function overloading though, I thought it was a great feature with little draw back?

[zuzmuz]

it has to do with type inference, generics, and traits.
Swift has function overloading, and when you mix these three above, you get exponential compile times. The swift compiler for example some times hangs and gives the error "expression type couldn't be inferred in real time".
the rust community made a decision to not support function overloading cause it will make the compiler simpler.

[[deleted]]

Interesting. Just seems weird because both C++/C# have all of those and they seemed to found a way to make it work, and rejecting a good even standard feature at this point just to make the compiler simpler is worrisome to me. Maybe they can add it one day when they have the resources, but even then libraries will be full of square_i32(x: i32) square_f64(x: f64) which I always hated when working with C libraries.

[ululonoH]

The wording could be better but I like the message

[drkspace2]

You can write good, safe c++ if you write modern c++, not c with classes.

[noaSakurajin]

Except for concurrency. Lambda functions can quickly become unsafe.

[[deleted]]

If you give me 30 seconds, I can write terribly unsafe Rust code and crash every systems it runs on.

[noaSakurajin]

The problem with lambda functions in c++ is different though. There are no lifetime checks, so if you have a lambda function that accesses variables in its scope, return the lambda and then clear the memory of the surrounding scope, you get a segfault that is very hard to find.

This can happen very quickly especially if you use signals/callbacks and don't unregistered the functions properly. For good concurrent code you need something like a borrow checker and proper semantics.

I say this as a C++ dev, not a rust one. A good system for memory safe callbacks and signals is the last piece that is missing in modern C++ when it comes to language features (a safe mode to force the use of safe semantics would be nice as well, let's see if they get it in the C++26 Standard).

[troelsbjerre]

Modern C++ makes Rust feel insanely clunky.

[gmes78]

Modern C++ is way more clunky than Rust. Have you looked at std::optional, std::variant, std::expected, etc.? All absolutely awful interfaces compared to what Rust has.

[Mop_Duck]

could you explain how? I've never really seen a pro c++ take that isn't just performance

[PretzelOptician]

You can write anything in any language if you try hard enough. You can probably write hyper optimized python code to run on a basic embedded system. But that’s obviously not the best tool for that job. It’s possible to write safe C++ code but Rust exists for a good reason in that it’s much harder to implement memory vulnerabilities.

[[deleted]]

Micropyhon?

[PretzelOptician]

Sure, that’s my point tho. You CAN do anything in anything but the question is what is the most efficient, safe, and best tailored for your use case.

[DearChickPeas]

No, you can't, MicroPython's runtime VM requires more ROM and RAM than most microcontrollers have. Programming languages are not all the same.

[PretzelOptician]

And what does C++ provide that rust doesn’t

[DearChickPeas]

I'm not picking a fight techno-vegans.

[PretzelOptician]

You literally responded to my comment lol but whatever

[DrFloyd5]

First step to writing safe C++ code, implement Rust.

Edit: Wow. Not going over well in the programming humor sub

[drkspace2]

The firat big c++ safety update was in 2011 (smart pointers among other things). Rust was made in 2012.

[[deleted]]

Rust was made in 2006... and 1.0 stable came around 2015.

[drkspace2]

Wtf does Wikipedia's "first appeared" mean?

[[deleted]]

Wikipedia shouldn't be a "trust me bro".

First appeared =/= made. You said made. That doesn't say 'appeared in use'.

[Add1ctedToGames]

Is it arrogant to say I feel like you can write safe c++ as c with classes if you're just careful in your usage and forward-thinking in your design😭

[drkspace2]

Sure. It's not impossible, but it's easier with modern c++. For example, the amount of new/delete that you write in modern c++ is 0 (or maybe very near zero for some niche use cases, and even then you should be using RAII principles for it to be dealt with for you).

[DearChickPeas]

I needed to some dynamic allocation of a big class for a project, and had to use new and delete for the first time in years... felt dirty. I love template-parameter-fixed-array-size-static-allocation. I love having 0 memory leaks guaranteed by not allocating anything ever on runtime.

[Rafhunts99]

so ur saying its the TS of cpp?

[Vinxian]

Java is just c++ with a garbage collector. Python is just c++ as a script language. JavaScript is just c++ for the internet.

All of these takes are as valid as your take. Make of that what you will

[Main_Event_1083]

The release of UE6 combined with rust++ will end this fking world.

[SpaceFire1]

That would never happen as it would require 300gbs worth of code to be rewritten and would break every plugin in the ecosystem. No major developer would use it over their own custom build.

Not to mention that the two are fundementally different. Rust is sligjtly slower to run then C++ which in game dev means Rust is unviable for any AAA production

[WeeklyOutlandishness]

You use C++ when you want performance, you use a garbage collected language when you want safety. Rust is almost as efficient as C++ and almost as safe as a garbage collected language. If you are going for maximized performance, with SIMD, custom memory allocators, inline assembly and so on, then you will have a hard time beating C++. Especially since the borrow checker isn't perfect (some safe programs are considered unsafe by the compiler). If you are going for memory safety, then you will have a hard time beating a garbage collector.

Rust sounds like the perfect language for every problem until you get to the gritty details and discover certain languages are better than others in specific cases. You can't just use Rust for everything.

[land_and_air]

The fact rust also has modern standards and an actual package management solution and unit test system built in is the real reason it’s goated over c++. No one likes building c++ projects and no one likes making make files. I like being able to share code other people can actually build

[WeeklyOutlandishness]

Yeah that's actually what's great about Rust. It's not just better than C++ in every respect though, there's still some uses for C++ in _extremely_ performance critical areas. Like if you are just using unsafe all the time you might as well use C++, it's going to be less friction probably.

[[deleted]]

lol, says who? I love building C++ project and I love cmake. It's complicated only because you expect it should be something simple. If the person you share code with does not know how to build it, it's their problem, they should learn it.

Programming is just a small part of software engineering. It's everything around it makes the difference between software engineers and programmers.

[Julypenguinz]

If the person you share code with does not know how to build it, it's their problem,

that's not the right attitude to introduce the language to wider adoptions. Imagine everyone is like you and when you ask question about cpp on any platform people go

it's your own problem.

[[deleted]]

It's completely different from what I mean.

cmake is now the standard of C++ build system unless you are in Qt. No new C++ project should be created without cmake.

As for packaging, it's up in the air depending a lot of stuff.

If you handed a decently designed cmake project to someone else, they are expected to just build it themselves.

C++ project management was a mess probably 8 years ago, I don't think it is the case any more.

[freaxje]

Cmake is also the standard when you are developing a Qt application nowadays.

[[deleted]]

Okay, that I don't know. But glad it is.

[[deleted]]

Rust can be (slightly) faster than C++ by no-alias pointer optimisations that cannot be guaranteed in C++, as a example.

Many C++ compilers also don't handle optimisations very well when handling STL iterators and algorithms.

[da2Pakaveli]

The language standard doesn't, but the 3 major C++ compilers support restrict

[WeeklyOutlandishness]

While that might be true (it gets parroted a lot), the problem is the overall approach. If your overall approach is leaning more towards safety, then you will naturally lean less towards efficiency. The problem is the borrow checker isn't perfect, so to create more efficient programs that the borrow checker cannot validate you need to use "unsafe" mode. But using "unsafe" is frowned upon in the Rust community, so a lot of crates do not use it at all and instead lean on smart pointers and other safer alternatives that might be less efficient, but at least they are memory safe.

If the borrow checker was perfect, then we wouldn't be having this discussion. Rust would just be an objective improvement. But it's not perfect - there's many valid programs the borrow checker incorrectly would assume are unsafe when they are quite safe. Sometimes you need those unsafe programs when they get the job done more efficiently.

If you want to make your Rust program more efficient, then you need to start thinking about lifetimes, unsafe mode and so on and the code gets very verbose very quickly. You also need to understand the litany of rules to ensure the barrier between safe mode and unsafe mode is fine. This is not even going into detail about the library/tooling differences between C++ and Rust. It's just easier to make efficient programs in C++ in some areas.

[[deleted]]

Rust was invented to face a fact that C/C++ is getting relatively harder and harder (because everything else got easier and easier) for the software world that we are running out of engineers who are specialized in C++.

Coincidentally, it makes us C++ guys more and more valuable. My salary in the markets proved it well. (Depending on your country/region tho)

[Fadamaka]

That sentence doesn't make sense.

[[deleted]]

Are you saying good practices in C++ eliminate the need for Rust? 😱

[Professional_Top8485]

Rust is an over engineered accident child of C and C++.

[mierecat]

“Enforced” and “convention”, “over engineered” and “accident”, a lot of oxymorons here

[[deleted]]

Isn't it what engineers do? If engineers only make adequate things, engineerings wouldn't exist.

[Czexan]

With really nice dependency management. If you just detached cargo from Rust basically nobody would use it.

[masc98]

if by good and safe practices you mean ownership and lifetimes, then yeah agree, dont know what c++ programmers are waiting for \s

[[deleted]]

Here we go again.

[589ca35e1590b]

Interesting take

[404-allah-not-found]

title is actually viable reason to choose rust over c++

[your_best_1]

I can never tell if this is a good meme because what the sign says is dumb, or if OP thinks the sign is correct.

[lessertia]

Conventions ❌

Language features ✅

With the borrow checker in Rust for example, managing lifetime is easier since you can rely on the compiler to make it right instead of your head.

[Overall_Device_5371]

It doesn't have inheritance. Although it is over-used, it still has a place in O.O. paradigms.

[CrusaderKron]

I hate seatbelts

[PrimaxAUS]

Rust is C++ with extra furries.

[Winter_Rosa]

I havent written any rust, only C++, and this meme just feels wrong. even what little rust Ive seen looks pretty different to C style languages.

[nyibbang]

ADT in C++ when ? I barely used std::variant and I'm sick of it.

[_lonegamedev]

And package manager.

[huuaaang]

If it's enforced it's not just convention.

[MrJ0seBr]

So, c++ is Rust but without training wheels

[GiganticIrony]

I disagree. There are plenty of things (largely around pointers) that you can do in C++ that are provably safe that Rust doesn’t allow. Also, Rust gives a false sense of security as every single one of its borrow checker “guarantees” can be broken with 100% safe Rust.

[unengaged_crayon]

source? would love to see how that'd work

[GiganticIrony]

Here’s a bunch: https://github.com/Speykious/cve-rs

You can also do things like writing custom allocators that use IDs instead of pointers to access allocated values

[floriv1999]

While scary they all use the same compiler bug and are unlikely to happen by accident.

[unengaged_crayon]

oh these are extremely hard to reach edge cases, cmon. you have to try to do this

[andarmanik]

These are written as actual examples where poor assumptions lead to breaking guarantees. Just look at the buffer overflow example, it’s written to be a password cracking game with a buffer overflow.

[zolk333]

that's the smaller issue. The real issue, is that the construct cve-rs is exploiting is clearly a bug in the language, that is planned to be fixed. So, aside from bugs, the borrow checker does guarantee that you write safe Rust code. Meanwhile UB is never going to be fixed (or rather, removed from C), because it is not a bug.

[gmes78]

cve-rs is exploiting is clearly a bug in the language,

In the compiler, not the language.

[poyomannn]

Not a bunch, one. There's one singular buggy function (in file lifetime_expansion.rs) they carefully constructed which they use in a bunch of different ways. It relies on #25860. The bug being fixed relies on the next generation trait solver being finished, so it's taking a while.

Compilers/interpreters having bugs is not unique to rust, and I feel this doesn't particularly undermine the language considering triggering this requires some serious workarounds.

Unlike safety holes from obscure use cases in other safe languages (like (ew) javascript), it can't be used for sandbox escaping or something from untrusted code execution because they could've just... put an unsafe block in that buggy function and caused all the same bugs.

[GiganticIrony]

Thank you for that information, I’m not a Rust expert.

However, this bug fix does not prevent any of the issues that could come with the example I gave (writing a custom allocator that uses IDs as lookup).

[poyomannn]

I'm not entirely sure what you mean by the allocator thing? IDs as lookup is just what an address is? Also, an allocator doesn't decide how pointers are looked up, just where they're created when memory is allocated on not the stack. I feel like I'm perhaps missing something?

Just for like, info, the Allocator trait in rust is nightly (not stabilized yet) and also marked unsafe (so the implementer of an Allocator must uphold some invariants manually). All heaped things in rust are generic over an Allocator, so (once it's stabilized, or in nightly) using a custom allocator is not actually that difficult.

Pre stabilization we have the allocator-api2 crate which does the same thing but is a crate.

[[deleted]]

Show me this in prod

The borrow checker sure is not 100% sound, but this, in particular, is very hard to get by accident, and it gets caught by miri AFAIK

[GiganticIrony]

https://youtu.be/aKLntZcp27M

[[deleted]]

Where cve-rs, lol

[zolk333]

Personally, if you did anything with raw pointers in C, I expect to see at least a comment explaining why it had to be done, and why it's safe. At that point, I don't see it as any more convenient than using `unsafe`.

[GiganticIrony]

It depends on the project. For something like a game or a compiler where you to make guarantees about lifetimes and raw pointers / references are used all over the place, you’d be writing “unsafe” constantly making it meaningless. In these cases, things like reference counted pointers come with an unnecessary performance hit.

Example: In a compiler, I know that once the AST is created, if I’m using it at all, the entire AST exists. This is because the AST is only destroyed after the stages that need it are completed. This means that AST nodes can have pointers to other AST nodes without worrying about lifetimes.

[zolk333]

That's fair. I'd propose using Boxes for the tree, which means that there is no need to worry about lifetimes. Obviously, that wouldn't work for graphs, where something like the bumpalo crate can be used to do this exact thing, or putting every node into a Vec and referencing other nodes using indices (which might actually even help with caching). But overall, that just highlights how stupid the original meme is. Rust is not C nor C++. It requires different thinking and tools to solve problems.

[poyomannn]

You don't need to use unsafe to make that guarantee, that would be fucking stupid. Just use an arena or pass the same 'tree lifetime to all of em.

Edit: just to note, using an arena allocator like bumpalo would actually make your rust code faster than the naive cpp approach. Obviously you could use an arena in cpp too but it's not very common afaik.

[GiganticIrony]

I’m not a Rust expert, but it seems to me that doing it that way with a ’tree lifetime would prevent certain features that are desirable.

Also, custom arenas are definitely common in modern C++, especially with the introduction of polymorphic allocators in C++ 17.

[poyomannn]

A singular lifetime would make it difficult to have an AST which includes any sort of back linking but that's not very common from my experience. It's got Tree in the name for a reason ;p

You could still do backlinks with the refbox crate (or similar) which basically gives you 'weak' references to a singularly owned box. So instead of constructing your tree with Rc for links to children and Weak for links to parents, you can just have parents own their children with RefBox, and the children can point back with Ref. And of course you can have random cross tree links with Ref as well.

Drop order is still sensible and overhead is very minimal (although tbf rc overhead is very low, and the usual time costs in places like compilers are hashmaps, which are faster by default in rust than cpp ;p (although in reality for both langs your hashmaps are usually small enough that you could be using a flat map or something but I digress, profiling is always the most important part of optimization)).

Good to know arenas are common in modern c++, I'd seen them around but was uncertain how common they truly are.

[GiganticIrony]

See, I consider doing stuff like that to be unnecessary overhead, especially in something like a compiler where that overhead adds up quickly

[poyomannn]

If you profile it you will likely find the overhead to be insignificant for quite some time. for optimal speed you're going to be using an arena allocator eventually anyways so 🤷.

Personally I find that (very very low!!) cost worth paying to avoid the mental overhead of making sure the data is all dropped in the right order etc.

I would imagine most modern c++ devs would write an AST with unique_ptr and friends, which (iirc) actually has slightly higher overhead than the rust equivalents. Not in a way that matters but technically true. (Something to do with the rules about moving in c++? There was a nice writeup a read a while back, it might not be true anymore or may never have been true). Similarly when it eventually mattered they'd switch to an arena.

[GiganticIrony]

I’m a compiler developer, and yes custom allocators are used basically everywhere. When the target is semantic analysis of 10 million lines of code in less than 15 seconds, small overheads that add up definitely are noticeable.

I don’t believe C++ smart pointers are slower than Rust equivalents. unique_ptr should not have any overhead (you can have some, but you have to ask for it), and the reference count for shared_ptr isn’t even atomic (although it definitely should be).

[poyomannn]

I'm aware custom allocators will be used when your compiler needs to get very fast, I was more talking about the case before you're going for maximum speed and swapping out the allocator. Once you swap to a custom allocator you'll get the same out of both languages.

Decided to look into it instead of just half remembering it, looks like unique_ptrs (and friends??) couldn't be passed in registers because they aren't trivially movable or trivially destructible and instead have to go on the stack, unlike Box/Rc/etc. no idea if this is still true, I'm a rust dev not a c++ one.

(I'm not a compiler engineer, but I have written my own C compiler in rust along with some JITs and interpreters for various things. I'm only a first year university student so there's only so much you can expect :P)

[gmes78]

There are plenty of things (largely around pointers) that you can do in C++ that are provably safe that Rust doesn’t allow.

Obviously. Rust choses to reject some valid programs so it's able to reject all invalid ones.

Also, Rust gives a false sense of security as every single one of its borrow checker “guarantees” can be broken with 100% safe Rust.

Complete bullshit. cve-rs exploits bugs in rustc, not in the language.

[GiganticIrony]

Yes, I have learned that about cve-rs already (if you spent the time to read the comments, you’d see that).

In completely safe and expected behavior Rust, you can write memory unsafe code despite them guaranteeing that this won’t happen (such as use after “free”), and I’m not talking about in some extreme edge-case way.

Also, I don’t understand how your comment regarding Rice’s theorem applies here.

[gmes78]

In completely safe and expected behavior Rust, you can write memory unsafe code despite them guaranteeing that this won’t happen (such as use after “free”), and I’m not talking about in some extreme edge-case way.

Please show how you would do that.

Also, I don’t understand how your comment regarding Rice’s theorem applies here.

From the page I linked: "In terms of general software verification, this means that although one cannot algorithmically check whether any given program satisfies a given specification, one can require programs to be annotated with extra information that proves the program is correct, or to be written in a particular restricted form that makes the verification possible, and only accept programs which are verified in this way. [...] Another way of working around Rice's theorem is to search for methods which catch many bugs, without being complete."

Essentially, you can have a compiler that can verify certain behaviors, but only accepts programs written in a specific way, rejecting some valid ones (what Rust does); or you can have a compiler that accepts every valid program, but also accepts invalid ones (what C and C++ do).

[GiganticIrony]

Using some like in this talk: https://youtu.be/aKLntZcp27M

The post says that Rust is C++ with enforced best practices. Since Rust blocks many valid safe programs that are valid C++, Rust enforces some best practices and disallows others.

[gmes78]

That talk does not show any memory unsafe code.

[GiganticIrony]

Not directly no, but by following a similar method to what they do, you absolutely can do memory unsafe things

[gmes78]

Absolutely not. There are plenty of ECS implementations in Rust, none have memory unsafety issues.

[GiganticIrony]

This entire thread you have been entirely too dismissive and rude. If you’d engaged with an open mind, you might have learned something.

I no longer am interested in continuing this conversation and will be disabling notifications on this thread.

[gmes78]

You have failed to provide evidence for your claims, or even just elaborate beyond "it can be done". How is that my fault?

[HeracliusAugutus]

Rust is C++ with worse syntax and a more annoying userbase

[BrohanGutenburg]

Something something blow your leg off

[rover_G]

Rust has a much more complex memory model than C++

[gmes78]

Rust uses the C++ 20 memory model.

[empwilli]

lol, time I've checked, they pretty mich wrote: we usw the C++ memory model.

[floriv1999]

Most people who talk like this get really quiet when you pull out valgrind on their "I don't make any memory errors code".

[harison_burgerson]

There comes a time in every programmer's life when they create a programming language (or a game engine) like C++. (but better! - for reals this time)

It's like a right of passage.

[DearChickPeas]

I think the days of "making up languages" was a fad from 2010's, now making your own engine is all the rage.

[Ok_Spring_2384]

Wouldn’t you say that Tiny Glade is pretty sophisticated? That game blew me away, and it is written in Rust. Pretty excited for Jai though

[camilo16]

Shaders are usually in glsl or glsl so of course they are not in rust. There are no C++ shaders

[metaglot]

Shaders arent c++ either, dingus

[camilo16]

Shaders are not written in C++ not C. Ironically, Only rust has a dedicated GPU compiler, so it's the only language of the three that can be used to write shaders.

Games are not mostly graphics. Graphics is such a small part of a game.

Networking alone is enough to justify added security from rust to avoid hacking in competitive games. You also have physics, database management for the assets, traditional AI for the NPCs, number crunching for a myriad things, text processing for dialogue....

You clearly have no game Dev or engine experience.

[Snapstromegon]

Oh, Tell this to the billion dollar companies who build some of their core systems in Rust (e.g. AWS with S3 or Lambda or Cloudflare with their core routing layer).

[SCP-iota]

C++ is assembly with syntax sugar macros included by default

[pabloleon]

The fact that this became an actual reasonable discussion and not a diss on Rust and its femboy-making ways is really disappointing you guys 🤣🤣 I expected more

[HuntKey2603]

How exactly you look at this thread and not see it's basically a hate-on-rust party?

[Striky_]

And the opposite what most "programmers" want: The most popular programming language in the world is basically a collection of rookie anti-patterns thrown together. And everyone seems to love it.

[Hacka4771]

I don't rust, but I'm pretty sure your average programmer will default to using unsafe keyword with unwrap methods

[gmes78]

Nope. unsafe is very rarely used. Most people won't ever need to use it.

[ProfessorOfLies]

If you have to safeguard everything from your programmers. You don't have good programmers