Go

New

Experimental

Concurrent

Garbage-collected

Systems

Language

Hello, world

package main

import "fmt"

func main() {
	fmt.Printf("Hello, 世界\n")
}

History

Design started in late 2007.

Implementation starting to work mid-2008.

Released as an open source project in November 2009.

Work continues.

Robert Griesemer, Ken Thompson, Rob Pike, Ian Lance Taylor, Russ Cox, many others

Goals and Motivation

Go fast!

Make programming fun again.

Targeted at systems software, broadly.

Why isn't programming fun?

Can we combine the best of both?

Why a new language?

Go

Make the language fast.

Make the tools fast.

Compilation Demo

Build all standard Go packages: ~120,000 lines of code.

Go in one slide

Lightweight syntax.

Static types: enough to compile well, but inferred much of the time.

Methods: on any type, orthogonal to type system.

Abstract types: interface values, relations inferred statically.

Visibility: inferred from case of name.

First-class functions.

Garbage collection.

Lightweight feel of a scripting language but compiled.

Go, concurrently

Cheap to create a new flow of control (goroutine):

func main() {
	go expensiveComputation(x, y, z)
	anotherExpensiveComputation(a, b, c)
}

Two expensive computations in parallel.

Go, concurrently

Cheap to create a new flow of control (goroutine):

	for {
		rw := l.Accept()
		conn := newConn(rw, handler)
		go conn.serve()
	}

Concurrent web server.

Network connections multiplexed onto epoll.

• many blocked Read calls != many blocked OS threads

Go, synchronized

Use explicit messages to communicate and synchronize.

func computeAndSend(ch chan int, x, y, z int) {
	ch <- expensiveComputation(x, y, z)
}

func main() {
	ch := make(chan int)
	go computeAndSend(ch, x, y, z)
	v2 := anotherExpensiveComputation(a, b, c)
	v1 := <-ch
	fmt.Println(v1, v2)
}

Notice communication of result in addition to synchronization.

Go, synchronized

RPC client

func (client *Client) Call(method string, args, reply interface{}) os.Error {
    // Send RPC message.
    call := client.Go(method, args, reply, nil)
	
    // Read reply from Done channel.
    <-call.Done

    return call.Error
}

Go, synchronized

RPC client demux

func (client *Client) input() {
	for {
		resp := client.readResponse()
		client.mutex.Lock()
		c := client.pending[resp.Seq]
		client.pending[resp.Seq] = c, false
		client.mutex.Unlock()
		if resp.Error != "" {
			c.Error = os.ErrorString(resp.error)
		}
		resp.Decode(c.Reply)
		c.Done <- c
	}
}

Go, synchronized

RPC client demux

func (client *Client) input() {
	for {
		resp := client.readResponse()
		client.mutex.Lock()
		c := client.pending[resp.Seq]
		client.pending[resp.Seq] = c, false
		client.mutex.Unlock()
		if resp.Error != "" {
			c.Error = os.ErrorString(resp.error)
		}
		resp.Decode(c.Reply)
		c.Done <- c
	}
}

Read response from network.