This document introduces the Go programming language, which was announced by Google in 2009. It summarizes Go's key features, including being a concurrent, garbage-collected systems programming language. It also provides instructions on installing Go and a simple "Hello World" program example. The document argues that Go has substantial features for systems programming in today's networked, multi-core world.

1. Let’s Go:
Introducing Google's New Programming Language
Google's announcement of Go programming language during October 2009 has created lots of interest in
programming community. This article introduces Go to system programmers and cover some of the
novel/useful features of the language.
S G Ganesh, sgganesh@gmail.com
This is an article to introduce Go language. Readers will have lots of questions when they come
across a new (and promising) language, but because of limited space, I’ll cover only most important
aspects of Go in this article.
What is Go?
Go is a new, experimental, concurrent, garbage-collected, systems programming language.
new: It is a new language, and was publicly announced during the end of 2009.
experimental: It is still at experimental stage with tools, packages etc. still in development. There is no
production system implemented in Go as I write this article.
concurrent: It is a concurrent language which supports 'communication channels' which is based on
Hoare's Communicating Sequential Processes (CSP).
garbage-collected: The memory is automatically garbage collected, which relieves of the programmer
from manual bookkeeping of memory (as done in C/C++).
for systems-programming: It is intended for writing things like web servers. Still, we can use it as a
general purpose language.
Robert Griesemer, Ken Thompson (of Unix fame), and Rob Pike are the creators of the language.
All of Go’s toolset (compilers, packages, runtime libraries, tools etc) are made open source under
BSD license.
Goals and motivation
Let us first see what motivated Go’s creators for coming up with this new language. In last decade,
much has changed in computing world: Libraries have become bigger with
lots of dependencies which makes enterprise software development unbearably slow; internet and
networking has becoming pervasive; multi-core processors becoming mainstream and so on.
Systems programming languages (like C) were not designed with these in mind.
Concurrency features. The creators of the language found that there is a genuine need for a systems
programming language that is suitable for this new world. Go is suitable for use in multi-core and
networked world: Go is a concurrent language. It has ‘communication channels’ feature which is
much safer and different from threads and lock-based concurrency (like Java or Pthreads).
High-speed builds. It is faster to build applications with Go: The language is designed for fast
compilation in mind. Examples: the compiler does not need a symbol-table(!); the parser does not

2. need any look-ahead of tokens(!). Package dependencies are made explicit; dependent packages
require recompilation only if really needed: features like this enables quick builds. This approach is
unlike other languages like C, C++, Java etc.
Safe to use. Low-level languages like C are bug prone, particularly with manual memory management
and pointer manipulation. Go is garbage collected and is memory safe. It is a strictly typed language
and disallows unsafe programming (pointer manipulation is not allowed, for example), so it is also
type-safe.
Efficiency. Performance of Go code is within 10%-20% of the equivalent C code. Given the fact that
it supports features like reflection and garbage collection, the ability to execute write such efficient
programs is interesting (and impressive).
Ease of use. Go brings the ease of programming of a dynamically typed language, like Ruby and
Python. This is a surprising feature given the fact that it is a type-safe, statically typed language. The
code is also less verbose, with its features like type-inference (unlike Java, for example).
‘Hello world’ Example
It is a tradition to introduce a language by giving a ‘Hello world’ example, so here it is:
package main
func main() {
print("Hello world")
}
It prints ‘Hello world’ if you run it, as you would expect. Now, let us discuss about the program.
All the programs in Go should be in a package. In Go, the execution starts with ‘main.main()’
function. In other words, our ‘main’ function should be provided in ‘main’ package; that is what the
first statement does.
All functions are defined using ‘func’ keyword. The ‘main’ function takes no arguments and returns
nothing. We will not cover how to process command-line arguments in this article.
Go has a set of ‘built-in functions’ and ‘print’ is one of them. Alternatively, we could have used C-
like ‘Printf’ function from ‘fmt’ package (which provides formatted input/output functions).
Note that there are no semicolons in this program. This is a nice feature of Go: In most of the cases,
semicolons is optional. However, in few cases, we have to explicitly use semi-colons, and we’ll not
cover that issue in this article.
Novel features of Go
When I started learning Go, I found that it has many novel features. One of the best features is its
interface feature (not to be confused with ‘interface’ keyword in Java/C#). Any structure that
implements a set of methods given by an interface is considered to implement that interface! I saw

3. sample code in the Go source packages and was impressed by the simplicity and beauty of the
feature. Note that many dynamic languages support ‘duck typing’ which is more sophisticated and
flexible. However, Go achieves limited form of ‘duck typing’ with type-safety and flexibility, in a
statically typed language and that too meant for systems programming!
Go has an elegant declaration syntax different from most C-based languages. Go supports
‘goroutines’ (not same as ‘threads’ or ‘coroutines’ as in other languages), which is a powerful feature
for writing concurrent programs. We can use reflection in Go (remember it is a systems programming
language!). The support for packages and the way methods are imported/exported is simple and
straight-forward (no keywords like ‘public’, ‘export’ etc are needed, for example). There are more,
but I’ll leave it to you to discover them yourselves.
Installing Go
Currently, Go implementations are available for two platforms: Linux and Mac OS X. There are two
implementations for these platforms: One is a stand-alone implementation of Go compiler and
runtime, written by Ken Thompson. Another is a GCC front-end, implemented by Ian Lance
Taylor.
You can download and install Go by following the instructions given in Go’s official website:
http://golang.org/doc/install.html.
What about Windows? There is no official port of Go available for Windows and we can use
“unofficial ports” as of now (check unofficial Go site: http://go-lang.cat-v.org/os-ports).
I tried installing both Windows and Linux versions, and the installation was easy and smooth.
Wrapping up
With my experience in trying Go for last few months and writing non-trivial programs, I think there
is lots of substance behind hype: Go is certainly a language that has some unique features that will
make it as a useful systems programming language in this age of internet and multi-core processors.
So, it is not a surprised when I came to know that Go won Tiobe’s ‘language of the year award 2009’
(it won the award just after few months of its announcement!).
The best feature like liked in Go is its simplicity (yes, I am considering it a feature)! In just a couple of
days I have started learning Go, I was able to write non-trivial programs and started liking it. It was
fun learning and playing with the language. I would recommend Go to any systems programmer and
encourage trying it out.