I Want Off Mr. Golang's Wild Ride

Post by ainiriand » Sat, Feb 29, 2020, 1:04 AM UTC

klohto wrote: post #156

ainiriand wrote: post #14

If somehow we had a way of checking Golang's source and submit our desired changes...

I seriously hate this argument. Go and have a look at the issue the golang is discussing currently. Do you seriously think that everything can be fixed by a simple request? Most of the time it wouldn't fit with the way Golang is going. It's not a critique of some bugs in Golang source code but the mentality and flow surrounding changes. Do you except the author that submitted change overhauling the whole way Golang h…

Post by buckminster » Sat, Feb 29, 2020, 1:18 AM UTC

foota wrote: post #377

buckminster wrote: post #364

Earlier quoted context omitted.

Rust still doesn't get this right. If I'm calling an NFS library, say, on Windows I need to use UNIX paths. Rust needs WindowsString and UnixString on every platform, with OsString as a synonym for whichever is most useful locally.

In that case... You wouldn't be using the rust file system libraries though, right? It seems like the simplest definition of an OsString is "the type used to interact with the OS file system API as implemented in rust".

Post by [deleted] » Sat, Feb 29, 2020, 1:48 AM UTC

buckminster wrote: post #393

foota wrote: post #377

Earlier quoted context omitted.

In that case... You wouldn't be using the rust file system libraries though, right? It seems like the simplest definition of an OsString is "the type used to interact with the OS file system API as implemented in rust".

Rust has a policy of keeping the standard library minimal and this is completely reasonable. But sometimes they overdo it. In this case it's nuts that I need to implement my own UnixString because the standard library doesn't expose it, and when I run on Linux I have two incompatible versions of the same thing. Another example: I wrote a command line app which takes a hostname/ip address plus an optional port number…

Post by a1369209993 » Sat, Feb 29, 2020, 2:07 AM UTC

Animats wrote: post #253

btilly wrote: post #190

Earlier quoted context omitted.

And the other one is the tendency for Go's design to say "exceptions are allowed for me but not for thee". When I worked at Google I used other languages by some of the same authors and they showed the same design philosophy. Make things with an enforced simplicity, and where there were more special use cases that the language designer needed, they created escape hatches for themselves but not the language users.

And the other one is the tendency for Go's design to say "exceptions are allowed for me but not for thee". Yes. Exceptions are kind of a pain, but the workarounds for not having them are worse. Passing back "result" types tends to lose the details of the problem before they are handled. Rust is on, what, their third error handling framework? Exceptions have a bad reputation because C++ and Java botched them. You need…

Post by dilap » Sat, Feb 29, 2020, 2:20 AM UTC

joshuamorton wrote: post #379

dilap wrote: post #319

Earlier quoted context omitted.

Setting aside any terminology for a second, consider this rust program: fn main() { let x = 1; let capture = || x; let x = 2; println!("{}", capture()); println!("{}", x) } This will print 1 and then 2, whereas python would print 2 and 2. Hence, you can see that the formulation "let mut" is equivalent to python, not "let" followed by "let". Here's the rust program that prints 2 and 2: fn main() { let mut x = 1; let p…

Actually hmm, I may want to take back my earlier comment. There are multiple things at play. There's scoping (where rust will copy across scope boundaries for non-ref types, which allows closing over something as in your first example above). Then there's mutable refs and mutable variables, which as hope-striker mentioned I was confusing, possibly because I was using ints in my example. If instead we used a vec: fn m…

    fn main() {
       let mut x = 1;
       x = "foo";
    }

    fn main() {
       let x = 1;
       let x = "foo";
    }

    x = 1
    x = "foo"

  def mystery_py():
    x = 1
    capture = lambda: x
    x = 2
    return x * capture()

  fn mystery_a() -> i32 {
     let x = 1;
     let ptr = &x as *const i32;
     let capture = || unsafe{ *ptr };
     let x = 2;
     return x * capture();
  }
  
  fn mystery_b() -> i32 {
    let mut x = 1;
    let ptr = &x as *const i32;
    let capture = || unsafe{ *ptr };
    x = 2;
    return x * capture();
  }