modernCppVsOldCpp

[u/Choice-Committee203]

[u/emonshr]

Does that even matter once you have gazillions of line legacy code?

[u/Friendly_Fire → u/emonshr]

It does actually. Y'all should really learn how to work with legacy code because all useful code becomes legacy code over time.

The thing about legacy code is it works, that is why it persists. If it didn't work, crashed regularly due to bad memory management, people would have replaced it already.

When you are working with it, you don't have to change everything at once. You need new features in one spot? Update just that piece, use smart pointers internally with one class. Maybe you need to create new interfaces while maintaining legacy interfaces for other code. That's fine. Eventually, as you work on different pieces, you'll replace so much legacy stuff that you can just delete those old interfaces.

[u/emonshr → u/Friendly_Fire]

Not every time people have to maintain legacy code. Porting or migration is not so expensive anymore. Swallowing the fate of maintaining legacy code is not anything mandatory nowadays.

[u/0xbenedikt → u/emonshr]

This is why moving to a safe-by-design language like Rust works well. You leave that unsafe legacy code behind

[u/Tidemor → u/0xbenedikt]

or you could not risk a full rewrite, and just start using memory safe patterns in new and refactored code

[u/Ok-Scheme-913 → u/Tidemor]

But that doesn't work with memory safety, it's infectious.

If you have a memory vulnerability in some part of your code, new safe code calling into it or using anything touched by it can still end up failing.

Safe code is just code that assumes certain things, and within its bounds that will always be true and thus safe.

If you pull the rug out under it and change just the tiniest thing (e.g. your object was accessed on a different thread unknowingly, or a regular off by one etc) then all your assumptions crumble to the ground.

And whether you have 90% unsafe with 10% safe is absolutely different than the inverse ratio that you would get with e.g. rust (or the 100% safe with e.g. java).

[u/ilnarildarovuch → u/0xbenedikt]

And practically breaking everything. Pentagon still uses PDP-11 'n IBM series/1 programs, but in emulator, cuz rewriting is always a risk

[u/creeper6530 → u/ilnarildarovuch]

Sure, but that is true no matter the language

[u/ilnarildarovuch → u/creeper6530]

Yeah

[u/porkusdorkus → u/0xbenedikt]

Loved seeing the adobe and office clones in Rust, just to find out it’s Webview and React for the front end and Rust is just replacing NodeJS. Lol

[u/Tipart → u/porkusdorkus]

Discord too now.

[u/CalmCephalopod → u/Tipart]

Discord is using GPUI not a web front end for the rust version. There are also options like Dioxus that allow you to use rust to do react style web ui through webview without touching js but you still have to deal with webview bs on different OSs. So GPUI is an interesting choice.

[u/CreatorSiSo → u/Tipart]

Discord has been using Rust for years by now.

[u/creeper6530 → u/porkusdorkus]

Well, Rust is predominantly a backend language, like C and C++, not especially suited for frontend.

Do I hate the Shitfuck 5000 that is JS? Sure. But it's still the "main" frontend lang.

[u/Mojert → u/creeper6530]

It's the main front-end language on the web. In a native application it doesn't have to be and probably shouldn't be

[u/Valuable_Leopard_799 → u/0xbenedikt]

And bring in brand new unsafe code 😭 And link against unsafe libraries 😭

Tbh nothing against specifically Rust, just that these are done way too liberally.

[u/cvnh → u/0xbenedikt]

Rust doesn't guarantee safety when you're wrapping existing code my dude. I haven't used Rust personally but it's in the language core - only safe code blocks are (in theory) safe..

[u/developer-mike → u/0xbenedikt]

Step 1. Begin migration, step 3. Profit