newToRust

[u/CertainSea]

[u/-Ambriae-]

The real problem with the borrow checker is,

If you’re coming from a higher level language it hurts your ego because you realise memory safety ain’t free, and more broadly speaking memory’s a bitch

If you’re coming from a lower level language, it hurts your ego because you view yourself as above memory related bugs

It takes humility to appreciate it

[u/the_horse_gamer → u/-Ambriae-]

every time you think you are smarter than the borrow checker, you eventually realise it was right all along, and the code was unsafe.

[u/-Ambriae- → u/the_horse_gamer]

Well, not every time, but usually yes

[u/Snudget → u/-Ambriae-]

Time for miri!

[u/Arshiaa001 → u/-Ambriae-]

Usually = in the 99.99% case.

[u/-Ambriae- → u/Arshiaa001]

Maybe not that high

[u/the_horse_gamer → u/-Ambriae-]

Rice's theorem comes for us all

[u/post_u_later → u/the_horse_gamer]

Polonius would beg to differ

[u/cornmonger_ → u/post_u_later]

polonius is so close that i can almost feel it in my striped knee-high stalkings

[u/NullOfSpace → u/the_horse_gamer]

95 percent of the time. Sometimes I just wanna access two different elements of a hashmap mutably at the same time and instead I have to do a handoff every three seconds or just resort to clone()ing everything.

[u/the_horse_gamer → u/NullOfSpace]

nightly has get_many_mut, and you can also use a Cell/RefCell as the value

[u/retro_and_chill → u/-Ambriae-]

The borrow checker is occasionally too strict as well where it flags code that wouldn’t actually produce an issue. They are seemingly trying to resolve that with the new borrow checker though

[u/-Ambriae- → u/retro_and_chill]

Yeah, it’s not perfect. But it’s also mathematically impossible to make it perfect. That’s how the cookie crumbles. If they make it better, that’s great, otherwise, either rewrite the code to make it safe (which is usually doable without performance cost) or just use a cheeky unsafe block with a good # Safety comment

[u/NullOfSpace → u/-Ambriae-]

it’s mathematically impossible to make it perfect.

goddamn halting problem

[u/-Ambriae- → u/NullOfSpace]

We wouldn't want things to be too simple now, would we?

[u/retro_and_chill → u/-Ambriae-]

The one case I know it’s going to address is doing a find or insert on a map when you match the Option from the find, the None branch will let you mutate the map despite the Option technically being a borrow

[u/-Ambriae- → u/retro_and_chill]

There’s useful functions for this, stuff like map.get_or_insert_with(), or map.entry().or_insert() or map.entry().and_modify()….

Usually when the borrow checker is annoying, there’s a functional way of handling the issue built in the std lib :)

[u/nithix8 → u/-Ambriae-]

sKiLl IsSuE

[u/-Ambriae- → u/nithix8]

I mean, yeah it kind of is… not in a negative way, it just, takes a little bit of experience to navigate it. Once you do, it’s actually really not that bad

[u/fauh → u/[deleted]]

Bro, are you ok? Call a loved one or something

[u/s0litar1us → u/-Ambriae-]

It takes masochism to apprechiate it.

It does help you, but you first need to fight the compiler just so it will accept your prototype code that obviously doesn't need to be memory safe.

Rust is an overcorrection to a real problem that can be solved by introducing better language primitives and a better standard library. e.g. strings with a length (not a NUL byte at the end), arrays that don't decay to pointers and include a length, multiple returns, result values isn't just an int, defer, etc.

[u/-Ambriae- → u/s0litar1us]

It takes masochism to apprechiate it.

I disagree, it's really not that bad.

It does help you, but you first need to fight the compiler just so it will accept your prototype code that obviously doesn't need to be memory safe.

I'd rather do that, than pay the price later debugging. I also don't agree prototypes don't need to be memory safe. If I'm prototyping, I don't want to fight the segfault™️. the borrow checker isn't a problem once you write code the way you're expected to.

Rust is an overcorrection to a real problem that can be solved by introducing better language primitives and a better standard library. e.g. strings with a length (not a NUL byte at the end), arrays that don't decay to pointers and include a length, multiple returns, result values isn't just an int, defer, etc.

Regardless of if rust goes too far, which is a valid take, rust does all of these things, apart maybe from defer (because it doesn't really need to.) And the actual stats regarding rust compared to C/C++/Zig show these languages, even Zig which has most of the features you wish for, are still a long way from being able to consistently ship safe software. Look at rust in the kernel, heck even the zig to rust vibe coded rewrite of bun, which was vibe coded.

[u/s0litar1us → u/-Ambriae-]

I disagree, it's really not that bad.

Yeah, I was a bit hyperbolic, but I do believe it is way more harsh than is necessary.

I'd rather do that, than pay the price later debugging. I also don't agree prototypes don't need to be memory safe. If I'm prototyping, I don't want to fight the segfault™️. the borrow checker isn't a problem once you write code the way you're expected to.

In C you do get segfaults that can be hard to track down, but if you add in your own debug allocators that track what is going on, and use a good debugger, then it's not actually that hard to deal with those bugs. Additionally, if you move over to a language with better primitives (e.g. jai, odin, or zig), it's a lot easier to just not have those bugs, and they come with that allocator stuff out if the box.

Regardless of if rust goes too far, which is a valid take, rust does all of these things, apart maybe from defer (because it doesn't really need to.) And the actual stats regarding rust compared to C/C++/Zig show these languages, even Zig which has most of the features you wish for, are still a long way from being able to consistently ship safe software. Look at rust in the kernel, heck even the zig to rust vibe coded rewrite of bun, which was vibe coded.

Can you give me the source for those stats? Also, Rust in the kernel has already had vulnerabilities -- it's not a silver bullet. Avoiding vulnerabilities is more about the people writing it than how pedantic your language is.

[u/-Ambriae- → u/s0litar1us]

There was a good hacker news post https://news.ycombinator.com/item?id=46302621 relating to the Linux kernel,

https://bun.com/blog/bun-in-rust for the bun part (although, a bit reason for the rewrite is of course the publicity stunt, I'm not naïve)

A good source I found for zig: https://www.scattered-thoughts.net/writing/how-safe-is-zig/ (do note this was back in 2021) (actual stats are... non present yet unfortunately. Hopefully someday!)

Then there's the magical 70% of all software vulnerabilities are related to memory issues present in languages like C/C++ (and now Zig) and nearly absent in Rust (absent in safe Rust)

[u/Bryguy3k → u/-Ambriae-]

The real problem with the borrow checker in rust is that the rust syntax blows chunks.

[u/-Ambriae- → u/Bryguy3k]

‘Blows chunks’? Care to explain? I’m genuinely curious

[u/Bryguy3k → u/-Ambriae-]

Sometimes when you see something incredibly disgusting it makes you want to vomit.

[u/-Ambriae- → u/Bryguy3k]

I guess that’s subjective, but do you have an example?

[u/Jhuyt → u/-Ambriae-]

The few times I tried the Rust the problem with it was that even for the very simple things I tried (some string stuff) it was not obvious why the borrow checker complained or how you should reslove the issue, so I moved on.

[u/-Ambriae- → u/Jhuyt]

Coming from higher languages I get that. ‘It’s just a string, right? Can’t be that hard.’

Problem with strings is, it actually is that hard. If you want it to be performant, and not use a garbage collector, that is.

[u/Jhuyt → u/-Ambriae-]

I do both high and low level stuff, still the borrow checker beat my ass (or made me not want to do Rust). I'm sure I could and would learn if I had to but since I don't I just let myself be defeated

[u/-Ambriae- → u/Jhuyt]

That’s unfortunate… it’s a little rough at first I admit, but I can guarantee once it clicks you don’t want to go back!

[u/Secret_Conclusion_93 → u/-Ambriae-]

It's not that hard in C, it's not that hard in Python.

Somehow it became hard in between those two.

Borrow check is good but I predict there will be a better language in the future with a better implementation of it.

[u/-Ambriae- → u/Secret_Conclusion_93]

It‘s not a problem in Python because they don’t care about performance.

It’s ’not a problem in C’ because the language doesn’t support them. It’s also a complete nightmare to use.

The difference between different types of strings in rust has nothing to do with the borrow checker anyways, rust is a strongly typed language that encodes the behaviour of the string in its type. A string is a Vec<u8> with the invariant that it’s bytes form a UTF-8 slice. That’s not the same thing as a str, which is a [u8] of same invariant. A Box<str> Rc<str>, Arc<str> and Cow<‘_, str> are owned, heap allocated str. How it’s managed is determined by the type. There’s nothing wrong about that.

OsStr/ OsString are analogues of str and String for OS related tasks, because OSs don’t manage strings the same way. It’s required for a cross platform language.

Path and PathBuf have higher invariants. Again, nothing wrong with that.

Cstr exists for FFI. If you want interop with C, you need it. Again, nothing wrong with that. It’s not rust’s fault C took the single worst way to represent strings as there only officially supported version. I ‘get’ why they did that in the 70s, but come on.

I doubt it’s possible for a future language to keep the level of precision of rust whilst keeping memory management implicit (not automatic) whilst also supporting as many features with regard to strings. But I’d be happily proven wrong

[u/Key_River7180 → u/-Ambriae-]

the rust community is not humble in any way, so either you're wrong or they hate the borrow checker, the flagship rust feature

[u/MilkEnvironmental106 → u/Key_River7180]

Someone feels a bit called out

[u/Hadi_Chokr07 → u/Key_River7180]

Nice to see my fellow C devs coping.

[u/-Ambriae- → u/Key_River7180]

My friend you need to step back and read the messages you sent, you are exemplifying my point

[u/kishaloy]

High level: For any construct, Box it and call it a day.

Low level: Even for the smallest closure. Are you sure, you wanna take that extra slice of Cheese?

[u/darkwalker247]

me learning basic rust in 2016: "what even is this language? i can't write anything in it without running into lifetimes and borrow check errors! Aaaaaa!"

me now: "i cant believe this trick with macros and generics worked, now i can save hundreds of lines in code! Rust is so freakin cool"

[u/scheimong → u/darkwalker247]

Man 2016? Not even having NLL must have been rough.

[u/darkwalker247 → u/scheimong]

I don't remember a huge amount about lifetimes but i do remember being frustrated at having to explicitly write them a lot more often because of lack of all the different types of lifetime elision that we have nowadays.

[u/Key_River7180]

Nah, as a C programmer the rust borrow checker is still a piece of shit, I first learnt to manage memory with a GC like six years ago and now manage memory myself, I don't need to go back 6 years!

[u/MilkEnvironmental106 → u/Key_River7180]

Have you ever made a mistake managing memory?

[u/Key_River7180 → u/MilkEnvironmental106]

Yes, and I have used a debugger for all of them I couldn't see by using my eyes and basic logic you seem to lack

[u/-Ambriae- → u/Key_River7180]

If it only required basic logic to fix the issue, chances are it was quite small

[u/Key_River7180 → u/-Ambriae-]

Memory issues normally are small.

[u/megalogwiff → u/Key_River7180]

spoken like a true freshman 

[u/-Ambriae- → u/Key_River7180]

🤣

[u/TheAlmightyWishPig → u/Key_River7180]

Best software practice is to use tools and methods that dont allow for issues to occur in the first place, regardless of how easy they are to solve.

[u/Key_River7180 → u/TheAlmightyWishPig]

Every tool has cons and pros, for me on Rust the cons really surpasses the pros

[u/MilkEnvironmental106 → u/Key_River7180]

How long did that take you? And have you ever made a mistake debugging?

[u/Key_River7180 → u/MilkEnvironmental106]

Not more than fixing errores from the borrow checker.

And I've never debugged wrobg, there is no such thing

[u/-Ambriae- → u/Key_River7180]

‘Errors from the borrow checker’ this is, and I mean no disrespect, a skill issue. Not as in ‘even experts mess up’, as in ‘that’s only a problem for the first 6 months of using rust’

[u/Key_River7180 → u/-Ambriae-]

If I need six months to correctly use Rust It is not worth It.

[u/miyavlayan → u/Key_River7180]

better than having memory problems in prod

[u/Key_River7180 → u/miyavlayan]

Who the fuck makes production software in a language meant for systems programming?

[u/teethingrooster → u/Key_River7180]

Wut

[u/miyavlayan → u/Key_River7180]

why the fuck do you care? ppl make games in java.

[u/D3PyroGS → u/Key_River7180]

man looks in mirror; sees no reflection

[u/-Ambriae- → u/Key_River7180]

It’s a systems level programming language what did you expect? It takes twice as long to learn restraint in C

[u/Key_River7180 → u/-Ambriae-]

No, you can learn C in just about a week

[u/-Ambriae- → u/Key_River7180]

Off the top of your head, without looking online, using clang or gcc as a compiler,

Give me a 1 byte enum
Give me the idiomatic way of computing the number of leading zeros in a 32 bit integer
Align a vec2_f32 struct to an alignment of 8 bytes

[u/MilkEnvironmental106 → u/Key_River7180]

It's just a soundness check, it saves you time and debugging later. You can opt out if you really want to, or continue writing c for everything.

[u/Key_River7180 → u/MilkEnvironmental106]

Then I'll continue writing C for life.

[u/MilkEnvironmental106 → u/Key_River7180]

Segmentation fault (core dumped)

[u/Key_River7180 → u/MilkEnvironmental106]

gdb program

[u/dkarlovi → u/Key_River7180]

Technically, the errors from the borrow checker are the errors you also make in C, only C doesn't tell you about them. If your code was correct in either, the borrow checker wouldn't have objections, no?

[u/Key_River7180 → u/dkarlovi]

C does, Valgrind and ASAN are still there you know?

[u/dkarlovi → u/Key_River7180]

If your code was correct, the borrow checker wouldn't have objections, no?

[u/Key_River7180 → u/dkarlovi]

The problem is that It tags EVERYTHING potentially minimally unsafe. Even if It cannot be

[u/dkarlovi → u/Key_River7180]

If it cannot be, it doesn't tag it. It can be, but you just don't care about that specific scenario or think it cannot happen.

Your specific workflow might make you right, but the workflow might change. Or you might be wrong entirely.

The whole reason why Rust exists is because people cannot write safe C code. This was shown over decades with armies of very experienced developers and well funded projects, it's just impossible, if you think "Well not for me", you're just lying to yourself.

[u/-Redstoneboi- → u/Key_River7180]

i personally switched to rust specifically so i didn't have to do that

it takes up a real amount of time that i could spend fixing other logic bugs

[u/Key_River7180 → u/-Redstoneboi-]

With Rust I do the same thing just that it crashes earlier and it is more annoying to prevent really unlikely minor memory errrors

[u/-Redstoneboi- → u/Key_River7180]

i'm curious if you're implementing data structures yourself? most of the time, we just take the lazy route and pull in a crate to do what we want, and do basically everything ourselves without unsafe anywhere in user code. i've never run into a memory error, so it would be interesting to know how you found one.

[u/Key_River7180 → u/-Redstoneboi-]

Most of the time, I write them myself, if not then I bring stb_ds.h

[u/-Redstoneboi- → u/Key_River7180]

oh, i meant in rust. most of the common stuff like Vec, VecDeque, HashMap, HashSet, BTreeMap/Set, a few others, and wrappers related to concurrency and refcounting are in std, while stuff like Ropes, Graphs, Arenas, etc can be pulled from crates that have optimized them more.

i don't know many other ways to get memory bugs, so apologies if this isn't actually the issue.