News for hackers. Stuff that matters.
Re:Rust and Go by jaekwon on Friday November 07, 2014 @07:28PM (#8575437)
Well this is how I'd write it in Go:

  descending_squares := []uint{}
  for x:=4; 0<=x; x-- {
    descending_squares = append(descending_squares, uint(x*x))
  }
Re:Rust and Go by pcwalton on Friday November 07, 2014 @07:32PM (#8575453)
Use unsigned integers for your index and values. That's what makes it hard to use a for loop. (Sure, you could cast a signed integer loop index to unsigned inside the loop to avoid the underflow problem in this specific case, but I'd argue that the functional style is so much clearer than code that has to work around unsigned underflow gotchas.)
Re:Rust and Go by gorhill on Friday November 07, 2014 @08:54PM (#8575715)
> functional style is so much clearer

There is something that makes me uncomfortable in there:

> let descending_squares = range(0u, 5u).rev().map(|x| x * x).collect();

The overhead. I wonder about it. I am unable to get a sense of what it is. With a simple for-loop, it's rather easy to see it, but with the version above I have no idea. So "much clearer" is not what I see with the piece of code above. I see what it does, but what is not so clear is what code will be generated, something which matters when trying to write efficient code.

Re:Rust and Go by dbaupp on Friday November 07, 2014 @10:51PM (#8575932)
There is not much overhead with Rust iterators at all. They are essentially concrete versions of the deforestation that Haskell can do to avoid constructing intermediate lists, and compile to code that is close to the equivalent C (the functionality is all statically dispatched, so the compiler can inline and optimise the calls). This is a case of having experience with and trusting one's tools.

I wrote a blog post a while ago that used iterators heavily http://huonw.github.io/blog/2014/06/comparing-knn-in-rust/ , as you can see the performance is good.

Re:Rust and Go by gorhill on Saturday November 08, 2014 @10:40AM (#8577151)
I am definitely going to have to look more into Rust.
Re:Rust and Go by kinghajj on Friday November 07, 2014 @10:54PM (#8575935)
Well then, good news! Such usages of iterators in Rust are almost always result in the same code that would be generated by old-fashioned, hand-written loops. The 'trick' is that the methods (and the closure!) are inlined, and generics are specialized at compile time.
Re:Rust and Go by jaekwon on Friday November 07, 2014 @07:58PM (#8575557)
All I did was take your for-loop code and translated into idiomatic Go code. My point is the for-loop in Go isn't as terrible as the loop example you wrote.
Re:Rust and Go by pcwalton on Friday November 07, 2014 @08:16PM (#8575609)
Your version infinite loops: http://play.golang.org/p/uglbTETE6d

See why for loops are tricky? :)

Re:Rust and Go by jaekwon on Friday November 07, 2014 @08:58PM (#8575723)
Doh! I fell straight in :)

Overflows in general are tricky. How does Rust deal with it?

Re:Rust and Go by pcwalton on Friday November 07, 2014 @09:20PM (#8575766)
We have special checked types you can use if you want checked arithmetic. The default is to not check, because CPUs currently make it expensive to check (although I would love it if that could change--we need hardware support though).
Re:Rust and Go by acqq on Saturday November 08, 2014 @04:35AM (#8576442)
But CPU's have the overflow flag, that is actually set if the operation overflows?

You can't write that check explicitly in C, but you can in assembler. Available now, across the different hardware.

Re:Rust and Go by dbaupp on Saturday November 08, 2014 @06:39AM (#8576577)
As you say, detecting the overflow is easy, but efficiently handling it is not. It adds a branch to every single arithmetic operation, and it makes it much harder for the compiler to optimise things e.g. it is hard to vectorise a loop summing an array, if every + has a conditional branch on the overflow flag.

(Also, I believe it introduces a lot of data dependencies, getting in the way of the out-of-order execution of modern CPUs.)

Re:Rust and Go by acqq on Saturday November 08, 2014 @09:14AM (#8576896)
To handle the overflow on the places where you want to handle them, modern processor doesn't have any problem with an additional jump instruction. Also, modern compilers could optimize the checks away if they aren't used. In effect, implementing overflow checks definitely won't turn your C speed (1s) code in a Python speed (40s) code. I estimate it wouldn't be even two times slower in most of the use cases. It's certainly not the problem of the CPU's.

It can be the problem of the certain compilers if they don't have the infrastructure to reason about overflow flags though. But it's not a hardware problem.

Re:Rust and Go by masklinn on Saturday November 08, 2014 @11:26AM (#8577305)
> I estimate it wouldn't be even two times slower in most of the use cases.

In his "We Need Hardware Traps for Integer Overflow"[0], Regher quotes 5% to 100% overhead for languages such as JS or Racket, and that a "highly tuned" checker would likely be in the 5% range. Playing with arithmetics-heavy programs and Rust's checked_* (which are backed by LLVM's overflow intrinsics[1]) I got anywhere from 5 to 40% performance loss IIRC.

That's not a lot, but at the same time when you're competing with languages specifically not paying those 5%, a 5% hit on all computations is not going to get you much love.

Which is why Rust currently lets you do that (via num::Checked* and num::Saturating) but uses overflowing default semantics.

[0] http://blog.regehr.org/archives/1154

[1] http://llvm.org/docs/LangRef.html#arithmetic-with-overflow-i...

Re:Rust and Go by masklinn on Saturday November 08, 2014 @03:15PM (#8578015)
OTOH I must note that Swift, on the other hand, has opted to error on overflow and have a second set of overflowing operators: https://developer.apple.com/library/mac/documentation/swift/...
Re:Rust and Go by acqq on Monday November 10, 2014 @06:28PM (#8587321)
And that's the best approach I can imagine: programmer should be able to control if he wants 5% penalty or speed. It's a win-win.
Re:Rust and Go by dbaupp on Saturday November 08, 2014 @07:05PM (#8578594)
> To handle the overflow on the places where you want to handle them, modern processor doesn't have any problem with an additional jump instruction

This isn't just a jump, it is a branch. Especially when the body of the loop is 6 instructions, adding an extra branch is going to be noticable.

> Also, modern compilers could optimize the checks away if they aren't used

This is equivalent to the halting problem, and most code will not be able to optimise them away. Suggesting otherwise is invoking "sufficiently smart compiler", which is invalid.

In any case, you haven't addressed the problem of missed optimisations (especially vectorisation) caused by having to maintain semantics.

> It's certainly not the problem of the CPU's.

Yes, it partly is: the data dependencies and linearisation caused by checking the CPU flags is bad.

Re:Rust and Go by jaekwon on Saturday November 08, 2014 @12:18AM (#8576109)
Nice. :)
Re:Rust and Go by hit8run on Saturday November 08, 2014 @02:21AM (#8576279)
Just use int and it works fine: http://play.golang.org/p/nZcd3M5aL_

To me golang is readable while even small rust examples don't feel quite right right.

Re:Rust and Go by masklinn on Saturday November 08, 2014 @03:11AM (#8576328)
> Just use int and it

is a completely different piece of code.

Re:Rust and Go by codygman on Saturday November 08, 2014 @01:00AM (#8576175)
I love when arguments are decided by/proven by runnable code examples.
Re:Rust and Go by jksmith on Sunday November 09, 2014 @12:17AM (#8579188)
Or if Go and Rust had a FOR loop guaranteed to stop at 0, as with a Wirthian language, no?