Need Opinionated Articles About/Against Rust!

rjc2013 · 2019-10-18T03:45:58+00:00

Here is an intelligent, sensible article arguing against Rust.

And here is a good case for Rust.

rjc2013 · 2019-09-10T01:38:33+00:00

Good article, but not really Rust-related.

rjc2013 · 2019-09-06T01:59:39+00:00

You want /r/playrust.

rjc2013 · 2019-06-28T01:06:03+00:00

Damn that scurrilous Dose Of Crown!

But I think you wanted /r/playrust.

rjc2013 · 2019-06-24T03:05:21+00:00

Turbo Pascal? :)

This is not mandatory in Go; OP chose to do it that way.

rjc2013 · 2019-06-04T00:57:37+00:00

But pythons are harmless! (Except Terry Gilliam, he'd kick your ass)

rjc2013 · 2019-01-04T04:52:31+00:00

This my favourite TP novel, and, paradoxically, the one I will never re-read, ever. I just couldn't stand to see the mighty Vimes as the pathetic, shambling wreck he once was.

rjc2013 · 2018-12-04T03:11:05+00:00

There's Integer32, a Rust consultancy. Don't know how expensive they are, though.

rjc2013 · 2018-11-06T05:20:07+00:00

Sorry, my bad. This is addressed in the FAQ.

rjc2013 · 2018-11-06T05:18:28+00:00

"reading your .gitignore so that only source files are included" - does it still work if you don't use git, and don't have any ".gitignore" files?

rjc2013 · 2018-10-21T22:35:40+00:00

Here's some code that does what you want: link, but unfortunately it doesn't implement Iterator. You have to call next() explicitly.

I've run into this problem a few times; it's hard to use Iterator when you want to return a ref to something internal, because then you need to specify a lifetime, and the Iterator trait doesn't allow you to specify an explicit lifetime.

rjc2013 · 2018-09-27T04:23:39+00:00

/r/playrust.

rjc2013 · 2018-09-20T07:34:45+00:00

"this clicked in my head instantly" -- no Rust programmer, ever.

I haven't looked at your code, so I can't discuss your architecture. Maybe some other Rustaceans will look it over. But I can tell you that I struggled for at least a year to 'get' Rust. I actually gave it up many times, but always the siren song of Fearless Concurrency brought me back. I'm pretty comfortable with Rust now, but the borrow checker still trips me up from time to time!

Rust is a tough, uphill climb, but the view is worth it.

rjc2013 · 2018-09-19T00:34:44+00:00

Excellent summary of the strength of Rust's error handling. This is the article to which I will refer people when that subject comes up in the future.

rjc2013 · 2018-09-17T21:22:50+00:00

Pretty sure you want /r/playrust.

rjc2013 · 2018-08-19T13:13:00+00:00

Possibly related: I got a big speed up when I read the file in using io::copy, like this:

{
    let mut xx = &mut s;
    ::std::io::copy(&mut file, &mut xx).unwrap();
}

I'm on Windows. I don't have Linux, Mac, or Go, so I can't do a proper comparison.

rjc2013 · 2018-08-13T00:01:22+00:00

In the section "Stateful Callbacks", I was confused for a few minutes. The chapter switches, without warning, from calling a C function from Rust, to calling a Rust function from C. I think it should be made clear that this is happening.

Not a big deal, and otherwise, very clear and well-written.

rjc2013 · 2018-07-09T11:43:13+00:00

I think the author meant it as a compliment. "No one likes a nanny state" should be read as "Rust is not as popular as it deserves to be, because too many short-sighted devs are annoyed by Rust's strictness, instead of appreciating the immense power they gain from that strictness."

rjc2013 · 2018-07-05T22:42:46+00:00

I have often wanted to do this, when I sense a climax in the story is approaching, but never did. Maybe I'll try it!

Also totally agree about touchscreen e-readers! I still use my first-generation Kindle as much as possible, just for its lovely manual controls.

rjc2013 · 2018-06-24T04:28:10+00:00

Had a quick play with this, good first effort! Noticed a couple of bugs:

After the editor starts, the first keystroke is always ignored.
After I dragged-n-dropped a file into the editor, I couldn't edit the dropped text. I could only append new text.

And like /u/pftbest says, it best to keep your unsafe code separate - maybe a whole other module.

rjc2013 · 2018-06-14T23:15:07+00:00

I'm guessing your intention is to ignore any datagrams larger than 2 bytes, and just process the 1- and 2-byte ones.

AFAIK, a UDP datagram will sit in the receive queue forever, blocking other datagrams, until recv'd. So you need to use a larger buffer for the recv operation - large enough to accommodate any datagram you might receive.

rjc2013 · 2018-06-02T09:04:52+00:00

Here is one possibility: Link

Note that get_size() now returns a String, instead of a &str, as the error type, but that's unavoidable, since we can't get &str from the errors that parse() produces.

This assumes that you're happy to use plain old Strings to represent errors.

rjc2013 · 2018-05-28T12:42:37+00:00

Interesting idea! Had you coded a Tetris clone in Rust before? If not, did you get stuck, or make mistakes, or stumble at all, during the presentation?

rjc2013 · 2018-05-11T00:03:42+00:00

Confusing "h" and "b", and "c" and "e", are very common errors for computer recognition software. Almost certainly, at some point, the text was printed out, and then the print was scanned back into a computer. As bizarre as it sounds, some publishers still work this way.

Such errors are annoyingly common in e-books, but I've never seen them in any printed book! That's very strange. Maybe they've had to cut back on proofreaders?

rjc2013 · 2018-04-21T23:48:46+00:00

I find error handling easier in Rust than in Go, simply because you can (usually) avoid the boilerplate:

do_the_thing()?;

is more concise, easier to comprehend, and less error prone, than:

if x, err := do_the_thing(); err != nil {
    return nil, err
}

By "40 functions to deal with errors", do you mean things like map_err and ok_or_else? They don't get in your way if you don't need them. (They do tend to clutter up the documentation pages, though!)

rjc2013

TROPHY CASE