@joel_linux @ljs there's no good heuristic, either you have write fair or write unfair. There's one good alternative, and you already know what that is. 😉

@joel_linux @ljs
It's not about performance, it's about not locking up the system. rwlocks are short and fast because they can't be preempted so new readers can still block writers. rwsems can sleep so it's much more likely to have writer starvation.

Happy New Year to the new force of social media!

I also want to state that I do not dislike Rust. This is just me ranting about things I have grown accustom to as a developer who’s main programming language has been C for over 3 decades!

@jose_exposito As Rust is really good at inferring logic, I’m surprised that it couldn’t just infer the PartialEq trait for simple enums.

@michaelphamct @acmel I will admit that I should have just started to learn to program Rust before learning the details of its implementation. But, here I am ;-)

@michaelphamct @acmel

Yes, your book is probably better to learn the language. And I wouldn’t recommend the book I’m using to just learn to program in Rust. But I like the book, because I am interested in how rust works. I want to get as good at rust as I am with C. With most C programs, I can usually visualize what the assembly output would be. I don’t have that with Rust. And this book is useful to have in order to get that kind of understanding of the language.

@jose_exposito That should be the default. I’m finding that I’ll be adding lots of #[derive(...)] all over the place.

@vbabka OK, i got recursion working. I don’t know what went wrong before. Perhaps it detected right away that a bug in my code would do an infinite recursion and failed out. Unfortunately, it didn’t quite tell me what that infinite condition was :-(

Although I’m ranting here, I also want to add what I really like. The RUST_BACKTRACE environment variable creating a nice backtrace on assert!() errors, is really nice!

Another annoyance is that you can’t compare enums.

use self::Direction::*;
enum Direction { UP, DOWN, LEFT, RIGHT};

fn foo (dir: Direction) {
     if (dir == DOWN) { ... }  <<--- Error!
}

But instead you must do:

   if matches!(dir, DOWN) { ... }

@aissen Moves something ;-)

@vbabka I immediately got a “Stack overflow” and the println! only went 3 deep. Maybe it was smarter to know it would go further?

@acmel Rust is very much becoming dominate (especially by my employer). I like the guarantees that Rust brings, so I’m working on learning it. I bought a book on Rust, which really gets into the details of the language, but honestly, isn’t a good way to learn the language. I found that learning by example is a much better approach.

I have a non trivial program I’m writing (it was one of the programs I had to write for my interview), and I’m hitting all the fun corner cases with it. I’m trying hard to keep an open mind, but for someone that’s been programming C for over 3 decades, it’s really hard to do so. ;-)

@ljs @acmel I thought that cover said SYSTEM ADMIN

And today I learn that Rust does not like recursive functions :-(

(In user space, I’m recursive function happy!)

@acmel @ljs I was thinking of shimmy()

Continuing my Rust Rants :-)

It’s unfortunate that move is a keyword. As I write my little programs, I found that that’s a common function name I use. Now I need to come up with something else. adjust ?

@mripard also, this is really the exception and not the norm. I find saving these programs in subversion (svn) is more convenient than git. It's best with a central repository than trying to keep several machines in sync.

@mripard I totally agree, and why I've been an advocate. But I like to write these small programs, sometimes to just learn and sometimes to do a small job. All these are mostly throwaway code (but I keep for reference). In this case C/make is so much more convenient than Rust/cargo.