News for hackers. Stuff that matters.
Re:In Defense of Linked Lists by andrewflnr on Friday November 04, 2022 @06:39PM (#33474971)
In the Rust ecosystem philosophy, linked lists are the kind of thing you want to write once, very carefully, then re-use a lot. That's exactly the kind of code where unsafe can be reasonable. It's not like it would actually be safer in any other language that didn't have an explicit unsafe keyword. More aesthetically pleasing, perhaps, but not safer.

You're acting like it's some epic burn on Rust that there's some ugly code in its stdlib. It's not. Stdlibs are like that. Furthermore, as others have pointed out, linked lists in particular are a pathological case for Rust, meaning you're pointing and snickering at a special case of a special case. Most people never have to write or look at that kind of code.

Re:In Defense of Linked Lists by svnpenn on Friday November 04, 2022 @06:48PM (#33475082)
this comes off as extremely defensive. I don't feel like the person you're responding to, intended any kind of "sick burn". Calm down dude.
Re:In Defense of Linked Lists by andrewflnr on Friday November 04, 2022 @07:06PM (#33475297)
Whatever. They're definitely pointing and snickering. I don't think there's any way to read their post but as a criticism of Rust the language based on this one piece of stdlib code, and that's nonsense. That irritates me. So sue me.

There are reasonable arguments to be had about Rust. I wish people would do those instead of all the nonsense you usually see.

Re:In Defense of Linked Lists by svnpenn on Friday November 04, 2022 @08:01PM (#33475915)
on the contrary, I think more and more people are unwilling to hear any criticism, even constructive criticism, of "their thing".

Rust is not perfect. I wont go into its faults, but you know what they are. I think overall, Rust is a great language, but you have to be realistic and understand that some stuff you ignore in favor of the holistic view, others might not be able to. So sometimes maybe just take the criticism and deal with it, or if you're in the position, do something to fix the problem.

Re:In Defense of Linked Lists by andrewflnr on Friday November 04, 2022 @09:33PM (#33476744)
Contrary to what exactly that I said?
Re:In Defense of Linked Lists by svnpenn on Friday November 04, 2022 @09:54PM (#33476912)
to this:

> I wish people would do those instead of all the nonsense you usually see

you seem to want to place the blame squarely on the critics, when the reality is that many people in your position are seemingly intolerant of any criticism of "their thing", even constructive criticism.

Re:In Defense of Linked Lists by andrewflnr on Saturday November 05, 2022 @12:00PM (#33482692)
Ah, I see, since I'm defending Rust in this sub-thread, it's impossible for me to ask for constructive criticism instead of bullshit without it being "seemingly intolerant", while you're the reasonable one for doing the exact same thing. Basically just assuming I'm an idiot and/or arguing in bad faith. Lovely.
Re:In Defense of Linked Lists by svnpenn on Saturday November 05, 2022 @12:22PM (#33482922)
they linked to the source code. What bar do they have to reach, before you honor it with being constructive? the point is, there is no bar. unless its praise to Rust, then its trolling in your eyes.
Re:In Defense of Linked Lists by Dylan16807 on Saturday November 05, 2022 @04:57PM (#33485649)
The source code of the standard library is usually an awful way to show off any language. Pointing and gawking at such a thing as criticism is very bad criticism.
Re:In Defense of Linked Lists by andrewflnr on Saturday November 05, 2022 @06:56PM (#33486821)
Yeah, I already made that point in my root comment. It was pretty much my whole thesis, in fact. Doesn't matter, apparently! svnpenn is determined to confuse me for someone dumber. :)
Re:In Defense of Linked Lists by kragen on Saturday November 05, 2022 @12:14AM (#33477893)
Functional programming languages like Haskell, ML, and Lisps use linked lists very extensively and rarely have safety problems as a result. On the contrary, because linked lists allow you to build a list up efficiently without mutation, they give you a good way to avoid all the safety problems that come from mutation. In general just about any kind of data structure in these languages is some sort of weird linked list.

This isn't the best solution for all cases! Sometimes performance is more important than safety, and there are things you can't do as efficiently without mutable data. And sometimes (especially for systems that are reactive rather than transformational, in Harel and Pnueli's terms, or for libraries) a garbage collector is an unacceptable cost.

And Rust is actually reasonably good at singly-linked lists; it's just doubly-linked lists (which inherently feature mutation) that are troublesome. Singly-linked lists with sharing through Arc are a little more expensive in Rust than in something like GHC, Ikarus Scheme, or OCaml, but that's hardly a damning criticism of Rust.

But you seem to be claiming that linked lists are unsafe in any language, and to anyone familiar with functional programming, that claim is obvious nonsense. Did you intend it?

Re:In Defense of Linked Lists by andrewflnr on Saturday November 05, 2022 @12:10PM (#33482803)
I should have been more specific about doubly linked lists. And I think the implicit context for comparisons with Rust is usually pointer-heavy non-GC languages, especially given OP, but maybe I should have specified that, too. It's certainly true that DLL's are tricky to write, and tricky to mechanically prove correct, which is mainly what 'unsafe' actually means.
Re:In Defense of Linked Lists by kragen on Saturday November 05, 2022 @04:51PM (#33485558)
Thank you for clarifying!

I would think that the implicit context for safety comparisons with Rust would be other languages designed with safety as a goal. Those languages are almost all GCed! ML, Haskell, Scheme, Oberon, Coq, Erlang — all GCed. That's because GC helps enormously with type- and memory-safety. In the example in question, it ensures that your doubly-linked list manipulation cannot cause undetected type errors, use-after-free errors, double-free errors, or memory leaks; this last guarantee goes beyond what Rust can offer in this case. In ML, Haskell, and Oberon, it even ensures that all type errors are detected at compile time instead of run time.

There are a few languages designed with safety as a goal that do not normally use GC: Pascal, Ada, COBOL, and MISRA C. But they suffer enormously in expressivity, are not pointer-heavy, and are generally only viable alternatives in restricted domains.

The usual pointer-heavy non-GC languages are C and C++, and these have no concern whatsoever for safety, so it seems like a weak-man argument to target linked-list manipulation in them as unsafe relative to Rust.

The correctness criteria for doubly-linked lists are indeed not within the capability of Rust's (or Haskell's, or ML's, or Oberon's) static checking. That doesn't imply that it's impossible to statically verify doubly-linked-list manipulation code, and in fact I think Ada SPARK is capable of doing it. Certainly it's within the scope of what you can prove with Coq or Isabelle/HOL.

Re:In Defense of Linked Lists by andrewflnr on Saturday November 05, 2022 @07:28PM (#33487040)
I did say tricky, not impossible. ;) IIRC proving pointer-pushing code is an active research area, but I could easily be out of date. Not cheap enough to be mainstream yet, anyway.

We're deep into semantics territory with "what's the right context for comparing Rust", but I would strongly argue that yet another language safe via GC is not interesting for its safety. As you point out, it's been done a lot. Rust is interesting because it pushes safety into a new level of runtime performance and (to some extent) lower hardware abstraction. AIUI that's the motivation for Rust, where most of the marketing and enthusiasm is, etc. And if you don't need that speed/control, Rust isn't much of an improvement: just use a GC and have more fun (unless you just think Rust is neat, I guess, but whatever).

So it's the languages already in that "low level" domain (broadly defined) that are its real competition IMO, C/C++, upstarts like Zig/Nim/Crystal, etc, languages where linked lists are on the cards. Especially for the problems where safety has previously been seen as too costly in either runtime or development time (no one is coding to fast moving web standards in Ada/SPARK, methinks).

And I don't think I implied that those languages' list manipulation is less safe than Rust's, rather that Rust's isn't any worse, besides being uglier. I made almost the same point from the other direction in another sub-thread: there's no use denying that Rust code for DLL's is uglier for no safety benefit on that particular task.

As others have pointed out, the whole question of linked lists in Rust is a huge distraction from its actual benefits and weaknesses.

Re:In Defense of Linked Lists by kragen on Saturday November 05, 2022 @08:36PM (#33487484)
Well, Rust can offer some kinds of guarantees that GCed languages can't, in the cases where its type system applies. It can allow you to safely share mutable data between threads, for example, or to guarantee that opened files get closed in a timely way. So I don't think it's interesting only because it pushes safety into a new level of runtime performance, though often that is also true.

I think it's noteworthy that, not only in the doubly-linked-list case but even in cases that use Arc (which doesn't require `unsafe`), Rust is less safe than mainstream GCed languages like Java (and arguably Haskell and OCaml). Rust can leak memory; those other languages can't. Its safety guarantees in those cases are a proper subset of theirs.

Unless I'm misunderstanding the situation? I've only written very small amounts of Rust.

Re:In Defense of Linked Lists by andrewflnr on Sunday November 06, 2022 @12:46AM (#33489078)
Fair point about other kinds of guarantees, I suppose. Now that you mention it, there has been some speculation about what a GC'd Rust would offer (worth remembering that IIRC early versions of Rust had a GC, until they figured out they could do without it). However I don't think that significantly changes my main point about where Rust primarily competes today, and its primary value proposition.

Re safety: Rust has, um, a very specific idea of what "safety" means. It's basically things that could cause RCE, or at least incorrect writes I guess. Memory leaks are specifically not considered "unsafe". :) And really, the worst you can do with a memory leak is DoS, until the target reboots. Handling mutable data across threads is included, though, which Java at least is somewhat famously not great at; it's really easy to write Baby's First Race Condition Demo in Java. So it feels really weird to say Rust's safety guarantees are a strict subset of Java's.

OTOH I agree it's hard to imagine Rust beating out Haskell for raw safety guarantees by any measure, and I have no idea for OCaml (despite having written a lot more Ocaml, heh).