News for hackers. Stuff that matters.
Re:Things that make Go fast by vanderZwan on Saturday June 07, 2014 @04:45AM (#7861644)
> The comparison between GO and Java seems unfair, given they compare a primitive variable with an object... which has methods and a bunch of other things to increase it's size (for good reason).

Honest question: will it be JIT'ed to the point where you no longer need 24 bytes to store an Integer in a List on a 64 bit JVM? Because if not, that comparison doesn't strike me as unfair, given that he explicitly mentions memory bound situations. Furthermore, will an array of Integers be a tightly packed set of integers, or value references to Integers? In general Go's equivalent to objects are structs, which seem to avoid this overhead of Java objects. Again, honest question; if Java can JIT all that away, awesome! :)

For the record, the people on the Go-nuts board are pretty adamant about microbenchmarks not being all that representative, and that people should give the JVM some time to do its optimisation (Robert Griesemer was one of the original programmers on the HotSpot compiler after all).

Re:Things that make Go fast by pron on Saturday June 07, 2014 @05:24AM (#7861690)
Well, the JDK's ArrayList, for example, will box ints into Integers, but there are primitive int lists that won't. With Go, AFAIK, the problem is exactly the same. Can you write, say, a heap or a read-black tree that can store wither ints and strings, that will embed the ints? Also, value types are making it into the JVM in Java 9. I don't think that will solve the packed representation in a generic data structure problem, but neither does Go. OTOH, Java does optimizations that Go never can. For example, Java can inline interface calls, which Go can't (and due to the way Go defines interfaces, method calls are slower than Java even when not inlined in either).

Having said that, there are things about Go that I like better than Java: 1) no implicit primitive promotions (widening conversions), 2) a small standalone executable, 3) excellent start up time. The latter two make Go suitable for quick, small programs, like command line tools etc.

However, there are more things I like about Java the Go doesn't have: 1) dynamic linking, 2) final variables, 3) concurrent data structures, 4) awesome monitoring and profiling tools, 5) generics, 6) state-of-the-art GC, 7) a polyglot VM (I also prefer Java's exceptions and explicit interface implementation, but these are minor considerations). So whenever I need serious, long-running, server-side software, I'd stick with Java over Go. Particularly now that Java has fibers (goroutines)[1] (I'm the main author).

[1]: https://github.com/puniverse/quasar

Re:Things that make Go fast by vanderZwan on Saturday June 07, 2014 @05:51AM (#7861735)
> Can you write, say, a heap or a read-black tree that can store wither ints and strings, that will embed the ints?

I'm not sure I understand this sentence. Do you mean a union type? Or a generic datastructure? We all know Go doesn't have generics - that topic has been beaten to death, so let's not derail the discussion and just say this can be a valid reason for Go not fitting your use-case. But just for comparison, here's an implementation of a "generic" LLRB Tree in Go using interfaces and runtime reflection:

https://github.com/petar/GoLLRB

I suppose you could hand-write it to fit the value type of choice? Does that answer your question?

Re:Things that make Go fast by seanmcdirmid on Saturday June 07, 2014 @10:56AM (#7862231)
> We all know Go doesn't have generics - that topic has been beaten to death, so let's not derail the discussion and just say this can be a valid reason for Go not fitting your use-case.

Parents point was that Go will still box primitives in a generic collection class...just like Java does. So this isn't a special advantage of Go at all (it has nothing to do with Go not having type parameters). The only languages that don't box in generic collections is C++ and perhaps C# (it doesn't have to because of its template-like type parameter semantics, but still might to reduce code duplication).

Re:Things that make Go fast by pron on Saturday June 07, 2014 @12:01PM (#7862350)
Right. Although the template method has its own issues. For example, once the element type size exceeds 64 bits, you can no longer assume an atomic write/read. This isn't a big problem considering that concurrent data structures don't usually rely on the write/read atomicity of the elements themselves (though they do rely on atomicity of modifying internal, structural data), but that's just something to think about.
Re:Things that make Go fast by dbaupp on Saturday June 07, 2014 @11:54AM (#7862337)
Rust doesn't, and (I think) D doesn't.
Re:Things that make Go fast by seanmcdirmid on Saturday June 07, 2014 @12:26PM (#7862395)
Right. I should have qualified my statement with languages that I'm aware of.
Re:Things that make Go fast by NateDad on Saturday June 07, 2014 @05:59AM (#7861744)
You couldn't write a generic tree that packs the ints closely together, no. But you could write a non-generic tree that does.

Also, Dave was talking about Lists, which you certainly can have packed with ints trivially in Go. And every piece of software I've worked on uses approximately a million times as many lists as trees. Obviously, this is application-specific, but I think it's pretty fair to say that most programs will use a lot more lists than trees. If your application uses a lot of trees, Go is probably the wrong language for you, unless you're willing to make a tradeoff by using code generation to generate type-specific implementations.

Re:Things that make Go fast by pron on Saturday June 07, 2014 @06:08AM (#7861753)
> But you could write a non-generic tree that does.

As you could in Java.

> Also, Dave was talking about Lists, which you certainly can have packed with ints trivially in Go.

What lists? Array lists? Linked lists? Skip lists? Concurrent array lists? Concurrent linked lists? Concurrent skip lists? Go gives you packed ints for only one kind of list.

> If your application uses a lot of trees, Go is probably the wrong language for you.

Or if it uses any advanced data structure that Go simply doesn't have, let alone concurrent data types (Java has such a rich collection of data structures, usually with state-of-the-art implementations). Or if you need dynamic code loading. Or embedding a scripting language.

I actually think Go is a very nice language, but Java is much more appropriate for serious, long-running, high-performance server-side apps.

Re:Things that make Go fast by pjmlp on Saturday June 07, 2014 @05:25AM (#7861693)
That not, but most Java native code compilers (both JIT and AOT) do a relative good job of escape analysis and transform those new into stack allocations if possible.

Additionally, value types are already available as extensions in some JVMs like IBM's J9.

http://www.websphereusergroup.org.uk/wug/files/presentations...

Oracle is also pursuing their metacircular VM project Graal[1], formerly Maxime, which has an improved escape analysis algorithm.

https://wiki.openjdk.java.net/display/Graal/Graal+Partial+Es...

A big mistake many people do when talking about Java, is equating Java with the OpenJDK, when there are lots other implementations to choose from.

[1]Graal is planned to eventually replace Hotspot and is being used for GPGPU support in Java 9