Go is a C-derived language which implements a lot of modern programming language features in a clean and straightforward way.

Developed at Google by a team that includes Rob Pike and Ken Thompson.

Notable features

strongly typed

Go allows for the creation of composite types and supports the notion of interfaces. It implements the typical array of low-level types including byte, int, int64 and a native string type that is immutable as well as array and map types. This allows compile time type checking and makes defining complex types straightforward.

package namespaces

Packages declare their name and functions, variables and types can all be either private or exported so as to be available to other packages, this is declared by the capitalization of the objects name.

multiple return values from a function

Functions can return more than one value. This is declared as part of the function definition and is checked by the compiler. This allows for very clean treatment of errors and flags, and potentially a much more clean and readable way to write complex code.

type interfaces

Interfaces can be declared and functions can be defined which operate on arguments of any type that implements a given interface. This allows for relatively straightforward polymorphism of functions. In some respects similar to C++ templates, only much simpler.

standard C printf semantics

The format string syntax was mostly ported directly from C with the addition of the %T operator which prints the type of the object handed to it, and the %v operator which prints the contents of a variable regardles of it’s type (recursively for composite types).

native support for concurrency

There is a type channel which provides a message box style interface to concurrent routines, known as goroutines. Any function call can be called in a concurrent fashion. This means that expensive computations can be run in parallel or in the background. The unified thread model looks like it could be a real winner in making powerful concurrency primitives available in a clean straightforward syntax, so that they can be reasoned about with the minimal effort required. This will probably be the hardest part of the language for most programmers to understand, but most of the difficulty lies in understanding concurrency, not in the syntax of the language.

First Impressions

This is a very clean and powerful language. It’s a direct descendant of C with elements of Haskell, OCaml, python and erlang visible as influences. It seems like yet another attempt to make a “better C than C”, and from a first shallow glance it seems like a clear winner. Objective-C fans (mac programmers) will probably sniff that it’s nothing new, and that clean message passing semantics have been available to programmers for decades. In many respeccts Go is not a new language, it will seem very familiar to anyone who has used C or C descended languages; and most of the advanced features that it adds to C are implemented in other languages. Go strikes a good balance between legibility, low-level functionality and high-level programming features. It will have a strong appeal to programmmers who are interested in the type safety and concurrency friendly features of Haskell, but want to access them in a more familiar C-like syntax.