Google's Go programming language

Google recently released a "systems" programming language called Go (not to be confused with the existing programming language called Go!) that is designed to be simple, fast, safe and concurrent.

Google give an impressive feature list:

  • Accurate concurrent garbage collection.
  • Goroutines and channels for parallelism and concurrency.
  • Multiple return values.
  • Fast compilation times.
  • Structurally-typed object oriented programming.
  • First-class functions.

There are two different kinds of compiler available to Go programmers. The more common 8g and 6g compilers for the x86 and x86-64 architectures, respectively, are simple "splat" compilers that translate source directly into assembler. These compilers offer fast compilation but the generated code is not optimized and is generally quite slow, often several times slower than C. Moreover, in the absence of an accurate way to traverse the heap, these compilers use a GC that resorts to conservative collection (blindly traversing the entire heap looking for pointer-like ints) and the current allocator and collector implementations are extremely slow and never return memory to the OS. The gcc-go compiler is a Go front-end for the GCC compiler that offers optimization but currently has no garbage collection at all.

The use of goroutines and channels is really the defining characteristic of the Go language. This feature stems from previous work by Go's creator, Rob Pike, on the Limbo programming language that was released in 1995. Goroutines are similar to tasks in Cilk or the Microsoft TPL except that tasks return a value whereas goroutines do not. Channels are a mechanism for synchronized communication using message passing.

Go may become an interesting language in the future but, for now, the only available implementations are nowhere near competitive and the language itself is missing many common features (non-null references, generics, exceptions and union types). Our impression is that Google are developing the Go programming language largely for itself, first as a language for high-performance web programming but also potentially as a language for Google's proprietary NaCl Chrome plugin that allows x86 code to be downloaded over the web and executed by a browser.

Comments

Post a Comment

Popular posts from this blog

Bjarne Stroustrup is catching up

Bjarne Stroustrup, creator of the C++ programming language, once famously said "There are only two kinds of languages: the ones people complain about and the ones nobody uses". Interestingly, Bjarne has gone on the defensive in his recent lectures, completely changed his tune and is catching up with the conclusions that most former-C++ developers have arrived at. In a recent lecture Bjarne made many eyebrow-raising assertions. He is happy that people are no longer talking about C++ because that means it has succeeded. In reality, C++ demand in the job market has been in freefall for years and few new software projects are choosing it. He attacked computer scientists for copying data and said that "even babies don't do that", a very strange statement to make in a technical presentation. He also implied that other languages deep copy 10,000x10,000 matrices and claimed that a shared_ptr is "like an old fashioned garbage collector except it gets resource relea...
Read more

Does reference counting really use less memory than tracing garbage collection? Mathematica vs Swift vs OCaml vs F# on .NET and Mono

Image
Our previous post caused some controversy by questioning the validity of some commonly-held beliefs. Specifically, the beliefs that reference counting (RC) always requires less memory than tracing garbage collection (GC) and that tracing GCs require 3-4x more memory in order to perform adequately. We presented a benchmark written in Swift and OCaml and noted that the RC'd Swift implementation ran over 5x slower and required over 3x more memory than the tracing GC'd OCaml implementation. This observation disproves these beliefs in their strong form and even brings into question whether there is even any validity in the weak forms of those beliefs. After all, we have never seen any empirical evidence to support these beliefs in any form. We received a lot of criticism for that post. The vast majority of the criticism was not constructive but two valid points did arise. Firstly, although our result was anomalous it would be more compelling to see the benchmark repeated across a w...
Read more

Benchmarking in the web age

The TechEmpower website contains some fascinating benchmarks of servers. The results on this benchmark of multiple requests to servers provide some insight into the performance characteristics of .NET on a modern problem. Specifically, the C# on ASP.NET Core solutions range from 2.5-80× slower than fastest solution which is written in Rust. In fact, C# is beaten by the following programming languages in order: Rust Java Kotlin Go C Perl Clojure PHP C++ Furthermore, .NET Core is Microsoft's new improved and faster version of .NET aimed specifically at these kinds of tasks. So why is it beaten by all those languages? I suspect that a large part of this is the change in workload from the kind of number crunching .NET was designed for to a modern string-heavy workload and I suspect .NET's GC isn't as optimised for this as the JVM is. As we have found, .NET has really poor support for JSON compared to other languages and frameworks, with support fragmented across many non-stand...
Read more