Pitfalls of Safe Rust

Golang might be better for writing robust software, if that is the goal. Robust services that don't go down.

Hell, just go full erlang at that point and you get loads of services for "free".

And why is that? I already don’t agree, but I’d love to hear your take.

Mentioning golang is a rust article comment section is just bait. People just live comparing the two even though it's somewhat boring comparison

First they have to improve the memory model due to possible races when sharing slices due to their fat pointers implementation.

Golang will panic with a runtime error index out of range if you index out of bounds. There doesn't seem to be a nice built in way to do `arr.get(3)` like in Rust.

    slice := []int{1, 2, 3}
    i := slice[3]
    fmt.Println(i)

I don't think so. Rust has much stronger typing than Go which allows you to prevent more classes of bugs than just memory errors.

The coolest one I've heard is that Fuchsia's network stack managed to eliminate deadlocks.

But even on a basic level Rust has that "if it compiles it works" experience which Go definitely doesn't.

> The coolest one I've heard is that Fuchsia's network stack managed to eliminate deadlocks.

Is there a write up on this? That's very cool

IIRC it is just having locks with exclusive constructors, which take previous locks’ guards (by ownership?).

That way you can never lock lock B if you have not received a guard aka lock from lock A prior. Ensured on the type level.

I suppose doing this at scale is a real challenge.

I think that example comes from the talk "Safety in an Unsafe World" [0, slides at 1].

There are some crates which implement lock ordering as well (e.g., [2, 3]). lock-ordering states it's inspired by the technique discussed in the talk as well, for what it's worth.

[0]: https://youtu.be/qd3x5MCUrhw?t=1001 (~16:41 in case the timestamp link doesn't work)

[1]: https://joshlf.com/files/talks/Safety%20in%20an%20Unsafe%20W... (deadlock prevention example starting slide 50)

[2]: https://github.com/akonradi/lock-ordering

[3]: https://github.com/alaric/lock_order

That's a weird thing to say about a language that doesn't have null safety.

Both have their place but after writing both extensively, I much prefer Rust - despite the pitfalls.

My biggest critisim of Rust (in comparison to Go) is the lack of a powerful standard library while Go's standard library is outstanding. I would also like to see standardized interfaces in Rust (like AsyncWrite) and in general the async story could be better - though I appreciate the versatility.

Not to be outdone here, Go introduces multiple null values that are considered distinct, yet they all exhibit the same problem.

The general term for this is "Session types." The Par crate is probably the most mature attempt at this to date.

https://github.com/faiface/par

I'm still new to Go so I don't know much about this other than empty slices. Can you give me some hints?