Reflections on Rust, and the Sand Castle Metaphor

Post by eeereerews » Fri, Apr 27, 2018, 5:29 PM UTC

IshKebab wrote: post #5

I do think the difficulty of Rust is brushed aside by its proponents. This week I wrote a little script to read an XML file, get a path from it, read a file at that location, do some regexes on it, and then update the XML and write it back to disk. I'd estimate it took me about 10 times longer to implement in Rust than Python. And I don't exactly know Python well - it wasn't just extra time Googling how to do things.…

Post by v_lisivka » Fri, Apr 27, 2018, 5:45 PM UTC

IshKebab wrote: post #5

I do think the difficulty of Rust is brushed aside by its proponents. This week I wrote a little script to read an XML file, get a path from it, read a file at that location, do some regexes on it, and then update the XML and write it back to disk. I'd estimate it took me about 10 times longer to implement in Rust than Python. And I don't exactly know Python well - it wasn't just extra time Googling how to do things.…

    extern crate xpath_reader;
    extern crate regex;
    
    use std::io::prelude::*;
    use std::fs::File;
    
    use xpath_reader::Reader;
    use regex::Regex;
    
    fn main() {
      let mut contents = String::new();
      File::open("test.xml").expect("Unable to open the file").read_to_string(&mut contents).expect("Unable to read the file");
      //println!("File contents: {}", contents);
    
      let reader = Reader::from_str(&contents, None).expect("Cannot parse XML file");
      let files: Vec = reader.read("//file").expect("Cannot find file entries in XML file");
      //println!("Files: {:?}", files);
    
      for file in files.iter() {
        println!("File: {}", file);
        let mut contents = String::new();
        File::open(file).expect("Unable to open the file").read_to_string(&mut contents).expect("Unable to read the file");
        //println!("File contents: {}", contents);
    
        let re = Regex::new(r"foo bar").expect("Cannot compile regex");
        let replaced = re.replace_all(&contents, "baz").to_string();
        //println!("File contents: {}", replaced);
    
        File::create(file).expect("Unable to overwrite the file").write(replaced.as_bytes()).expect("Unable to write to file");
      }
    }

Post by pjmlp » Fri, Apr 27, 2018, 6:03 PM UTC

vvanders wrote: post #60

pjmlp wrote: post #31

Earlier quoted context omitted.

I had the same experience with any programing language with a rich set of libraries since the 16 bit days.

Oh come now, anyone who's worked with C or C++ knows there's a million pitfalls in porting code across platforms. Heck, C doesn't even guarantee that a byte is exactly 8 bits. The point I was making is that I was able to do this without a single ifdef/platform specific code without even planning for it(since it was the first time I'd cross-compiled for more than one other platform). While that's common in the VM lang…

Post by lossolo » Fri, Apr 27, 2018, 6:55 PM UTC

Animats wrote: post #55

epage wrote: post #53

Earlier quoted context omitted.

From the article > This is especially true when it comes to the more complicated ones like moves and futures, but also true for simpler ones like borrows. What I didn’t know when I wrote about it in frustration a month ago is that it doesn’t take a little longer longer to be effective in Rust compared to other languages, it takes 10 to 20 times longer. I think futures might be exacerbating the authors problems. There…

Too many articles about Rust talk about why the current language sucks, but some feature in progress will fix it. Rust started out with roughly the complexity level of C++, and it's become more complex from there.

Post by jlg23 » Fri, Apr 27, 2018, 7:22 PM UTC

simias wrote: post #36

jlg23 wrote: post #17

This is not at all specific to rust: OP is just grateful for the compiler to find lots of problems one would have to write tests for in dynamic languages.

I agree with you if we replace "dynamic language" by "not as strongly typed". C is not exactly dynamic but its type system is prehistoric compared to Rust. For instance C's equivalent of Rust's enum would be tagged unions, however the compiler cannot enforce the semantics of tagged unions and will gladly let you access random members regardless of the tag. Same story with the borrow checker compared to C's "whatever…