It was meant to displace C++ for server code at Google. Not for all the other stuff C++ does. And Pike said later they were somewhat successful at that but not as much as they wanted. More on reddit.com

They are particularly similar in style. Ken Thompson and Rob Pike worked at Bell Labs after all, with Ken having been one of the first users of C in general. Rob wrote his notes on programming in C in the late 80s, which IMHO is still great advice for writing good C code. Much of the most beautiful C I've seen is from the source code of Plan 9, an operating system they developed at Bell Labs. So when they created Go, they came from a C background, in the sense that they hadn't only used C for decades, but also helped shape it from the very beginning. One of the best aspects of C is how orthogonal it feels. You write your structs that are plain data. You write your functions that are plain code. Your functions do what you see written. No more, no less. Go feels very similar to that. It doesn't try to retain any kind of compatibility with C, but rather tries to distill its spirit even further, with even fewer keywords (none of which are adjectives, which means you don't get tons of weird interactions of modifiers like e.g. in Java). It's definitely higher level than C. Your indices are bounds checked, memory is automatically allocated and freed as you use it, etc. So no dangling pointers and segfaults to worry about, but it still gives you the ability to have a pointer point at some value inside another data structure. There's no pointer arithmetic but there are slices which can often be used in similar ways. More on reddit.com

Some people like to blame all of the slowness of languages like Go, C#, and Java on garbage collection, but that isn't a very complete story. People will correctly tell you that normally garbage collection takes up a very very small % of total runtime, and that is true, so what else is going on? There are some indirect and related things as well.

• Languages that have garbage collection are attempting to be memory safe languages, so:

  • They will also tend to have array bounds checks when the compiler can't prove they can be elided

  • They will tend not to allow as many clever casts

  • They will tend not to allow pointer arithmetic

  • Providing ways to leverage SIMD instructions by hand is hard (Go gives access only through Go assembler at the moment)

  • They will tend not to have a way for the compiler to do floating point optimizations that can change results like --ffast-math in C compilers

• Garbage Collection has some indirect effects aside from how much time is spent doing GC

  • Every time the GC runs it pollutes the CPU caches, slowing down code that runs later

  • GC will normally imply a degree of overhead when doing FFI (interop with other languages). Go has even more overhead due to how it manages it's stack, which facilitates goroutine features. Lots of things require FFI still (3d rendering, for example) so those things will always be slower.

  • The control you get over memory layout of your data is usually limited to some degree. For instance in Go you can't explicitly control whether data goes on the stack, or heap, or *where* to goes on the heap. On the bright side in Go you can at least work with any type you create as a value or a reference, so you can at least control things like making sure your array is an array of values in contiguous memory vs an array of references, which you can't in Java. Accessing RAM is very slow, controlling memory layout on modern computers can be a big deal, assuring that you hit the L1 and L2 cache as much as possible.

There are also just some cultural things, people working on the C and C++ ecosystems are doing so because performance is priority one. People working on ecosystems of memory safe languages obviously have a bit of priority for safety, correctness, or productivity or they wouldn't want the GC!

None of these things in isolation is normally a very big deal but they can add up.

More on reddit.com

Yes, it is memory allocator and probably the fact that bottomUpTree() is called a lot, recursively.

That being said, making sweeping statements (like "Go's GC is immature") based on a single benchmark is not exactly right. Both Go and Java have state-of-the art garbage collectors but they are tuned for different scenarios and this benchmark has a workload that heavily favors Java's GC.

Why? Because Java's collector is generational. That means that allocation is extremely cheap (bump of the pointer). The downside is that generational GCs use more memory and when objects are moved from nursery to tenured heap, there's additional work of copying the memory.

Go's GC is not generational, so allocation requires (comparatively speaking) much more work. It's also tuned for low latency (smallest pause when GC has to stop the program) at the expense of throughput (i.e. total speed). This is the right trade-off for most programs but doesn't perform optimally on micro-benchmarks that measure throughtput.

I've made a Go version that allocates nodes in bulk https://gist.github.com/kjk/4620bf60315d3fdd3f210e4590bdf1cb using a pool allocator of nodes.

On my machine it goes from 17s to 9s (if I allocate 1024 nodes at a time) or 7s (if I allocate 32*1024 nodes at a time).

In this particular program the number of nodes could be calculated up-front so it could be sped up even more.

Another thing where Java probably has an advantage is the fact that almost all the time is spent calling bottomUpTree() a lot, recursively.

Why is it worse than in Java?

To make goroutines cheap, Go starts each goroutine with very small stack (~4kb). As a result, Go has to expand the stack when needed. Go does that by checking stack size at the beginning of every function call. When it detects it needs more stack, it creates a new, bigger stack and copies the old stack to new one.

The cost is usually very small (few instructions for each function call) but if there is a function like bottomUpTree() that does little work and is called very often, even small cost adds up.

Additionally, this is deeply recursive call, so stack is being copied several times when it needs to be expanded.

I'm pretty sure that if you rewrote bottomUpTree() to be non-recursive (non-trivial but possible) and used pool allocator for nodes, Go version would be as good (if not better) than Java.

More on reddit.com