[hactually]

> Rust is a lot nicer to work with than C

What? How??

[gpm]

Modern conveniences such as compiler support for

- Tagged unions so you can easily and correctly return "I have one of these things".

- Generics so you can reuse datastructures other people wrote easily and correctly. And a modern toolchain with a package manager that makes it easy to correctly do this.

- Compile time reference counting so you don't have to worry about freeing things/unlocking mutex's/... (sometimes also called RAII + a borrow checker).

- Type inference

- Things that are changed are generally syntactically tagged as mutable which makes it a lot easier to quickly read code

- Iterators...

And so on and so forth. Rust is in large part "take all the good ideas that came before it and put it in a low level language". In the last 50 years there's been a lot of good ideas, and C doesn't really incorporate any of them.

[ironhaven]

The borrow checker better described as compile time rwlock with all possible deadlocks caught as compiler errors

[simonask]

I agree with your points, except that "compile time reference counting" is not a thing. I'm not sure what that would even mean. :-)

[kybernetyk]

I think Rust speaks to people who don't "play" with their code during development. Moving stuff around, commenting things out, etc. When I try to do this in Rust, the borrow checker instantly complains because $something violates $some_rule. I can't say "yeah I know but just for now let's try it out this way and if it works I'll do it right".

I work this way and that's why I consider Rust to be a major impediment to my productivity. Same goes for Python with its significant whitespace which prevents freely moving code around and swapping code blocks, etc.

I guess there are people who plan everything in their mind and the coding part is just typing out their ideas (instead of developing their ideas during code editing).

[whytevuhuni]

That might be true. In my case, it is precisely because I do play a lot with my code, doing big 2-day refactors sometimes too. With Rust, when it finally compiles, it very often tends to run without crashing, and often correctly too, saving me a lot of debugging.

But it's also because of all the things I'm forced to fix while implementing or refactoring, that I would've been convinced were correct. And I was proven wrong by the compiler, so, many, times, that I've lost all confidence in my own ability to do it correctly without this kind of help. It helped me out of my naivety that "C is simple".

[heavyset_go]

You eventually don't even think about the borrow checker, writing compiling code becomes second nature, and it also has the side effect of encouraging good habits in other languages.

[maxbond]

> I guess there are people who plan everything in their mind and the coding part is just typing out their ideas (instead of developing their ideas during code editing).

I don't think there are, I think Gall's law that all complex systems evolve from simpler systems applies.

I play with code when I program with Rust. It just looks slightly different. I deliberately trigger errors and then read the error message. I copy code into scratch files. I'm not very clever; I can't plan out a nontrivial program without feedback from experiments.

[Avamander]

I enjoy the ability to do massive refactors and once it builds it works and does the expected. There are so few odd things happening, no unexpected runtime errors.

I've written probably tens of thousands of lines each in languages like C, C++, Python, Java and a few others. None other has been as misery-free. I admit I haven't written Haskell, but it still doesn't very approachable to me.

I can flash a microcontroller with new firmware and it won't magically start spewing out garbage on random occasions because the compiler omitted a nullptr check or that there's an off-by-one error in some odd place. None. Of. That. Shit.

[IshKebab]

So many ways it's hard to list them. Better tooling, type system, libraries, language features, compile-time error checking.

I'm a bit surprised that you are surprised by this. I sometimes think Rust emphasizes memory safety too much - like some people hear it and just think Rust is C but with memory safety. Maybe that's why you're surprised?

Memory safety is a huge deal - not just for security but also because memory errors are the worst kind of bug to debug. If I never have to a memory safety bug that corrupts some data but only in release mode... Those bugs take an enormous amount of time to deal with.

But Rust is really a great modern language that takes all the best ideas from ML and C, and adds memory safety.

(Actually multithreading bugs might be slightly worse but Rust can help there too!)