LCA2014 - Introduction to Go

Introduction to Go
a tutorial for developers

Hello! While you’re sitting down, please make

sure your Go environment is set up.

!

Grab a USB stick that’s ﬂoating around and copy

the gostick directory somewhere local.

!

Then read the included README please!

Autobiography
•

Mark Smith <mark@qq.is> @zorkian

•

Site Reliability Engineer at Dropbox

•

Contributes to Dreamwidth Studios

•

github.com/xb95

Today’s Plan
•

What is Go? Where does it ﬁt?

•

Obligatory Hello World

•

Contrived example program

•

Anti-unicorns

•

Wrap-up

Go in a Nutshell
•

Designed for building systems

•

Statically compiled, garbage collected

•

Static typing (w/some duck typing)

•

Built-in maps (dicts) and strings

Go in a Nutshell
•

Multi-core support

•

Concurrency primitives

•

Closures, etc. etc.

•

“Somewhere between C and Python”

The Go Way
•

Go is an opinionated language

•

gofmt, mixedCaps, capitalization for privacy…

•

Simple is better than complex

•

The compiler should help with the heavy lifting

Hello World
package main
!

import "fmt"
!

func main() {
fmt.Println("Hello, LCA 2014!")
}

Building Hello World
# Do this in your gostick/ copy
# You did follow the README? :-)
cd helloworld/
go build
./helloworld

Getting Real
•

Go is particularly suited for network services

•

The standard library is fairly comprehensive

•

Let’s build an echo server!

Echo Server
1. Listen on port for TCP connections

2. Accept connections

3. Read text from connection

4. Write it back to connection

Standard Library
•

Go has a decent standard library

•

The ecosystem is still fairly young, so it has some
holes and some things aren’t well optimized

•

Well built for network services

•

http://golang.org/pkg/

Tip: Searching

When you search the Internet for
information, “Go” is a bad keyword;
everybody uses “golang”.

Echo Server



Listening for Connections
In the “net” package, you’ll ﬁnd many useful things, including:
func Listen(net, laddr string) (Listener, error)


package main
!

import "net"
!

func main() {
!

}


package main
!

import "net"
!

func main() {
... := net.Listen("tcp", ":9000")
}

Variable Deﬁnition
•

Go has two ways of declaring variables, explicit and implicit

•

Explicit: 
var foobar uint64

•

Implicit (type is inferred automatically): 
foobar := thingThatReturnsUint64()

•

Go strives to save on typing redundant information that
the compiler can ﬁgure out

Error Handling
•

Using multiple return values to get errors

•

Idiomatically, you will write this a lot: 
 
results, err := pkg.DoSomething(1, 2) 
if err != nil { 
log.Fatalf(“Failed: %s”, err) 
} 
// carry on and use results

•

Yes, this gets very verbose… oh well

Echo Server



Connection Pump
func Accept() (Conn, error)
func main() {
listener, err := net.Listen("tcp", ":9000")
!
!
!
!
!
!
!
!
!
!
!
}

Connection Pump
func main() {
if err != nil {
panic(err)
}
!
!
!
!
!
!
!
!
}

Connection Pump
func main() {
if err != nil {
panic(err)
}
!
for {

!
!
!
!
}
}

Connection Pump
func main() {
if err != nil {
panic(err)
}
!
for {
client, err := listener.Accept()
!
!
!
!
}
}

Connection Pump
func main() {
if err != nil {
panic(err)
}
!
for {
if err != nil {
continue
}
!
}
}

Connection Pump
func main() {
if err != nil {
panic(err)
}
!
for {
if err != nil {
continue
}
handleClient(client)
}
}

Echo Server



Client Handler
func Read(b []byte) (int, error)
func handleClient(client net.Conn) {
for {
// read from our client
// write it back to our client
}
}

Client Handler
for {
// read from our client
// write it back to our client
}
}

Okay, so what’s a []byte?

Primitive Go Types
•

All of the usual suspects (ints, uints, ﬂoats)

•

Built-in string type (Unicode, immutable)

•

int and uint are architecture-width

•

byte is just a synonym for uint8

More Types
•

arrays: of a declared, ﬁxed length

•

slice: a segment (“slice”) of an array

•

map: key/value storage

•

pointer: much like C (uses & and *)

•

(more to come later)

So, []byte…
•

Let’s make an array of bytes: 
var ary [4096]byte

•

What if we don’t know the size? Or don’t care?
Slices solve this problem: 
var aryslice []byte

•

This is great, but what is it?

Slices Explained
var a [16]byte is

Slices Explained
var a [16]byte is
a[3] is

Slices Explained
var a [16]byte is
a[3] is
a[6:8] is

Slices Explained
var a [16]byte is
a[3] is
a[6:8] is
var s []byte is nothing to start with.

Slices Explained
var a [16]byte is
a[3] is
a[6:8] is
s = a[6:8]; s is

Slices Explained
var a [16]byte is
a[3] is
a[6:8] is
s = a[6:8]; s is
s[0] is the same as a[6], etc!

A slice is simply a window into a backing array.

Slices pt. 2
•

Slices are internally a tuple of (array, start, length)

•

A slice can be moved around (a sliding window)
and resized (limited to the backing array size)

•

Slices are reference types; great for passing to
functions

Client Handler

for {
!
!
!
!
!
!
}
}

Client Handler

for {
buf := make([]byte, 4096)

!
!
!
!
}
}

Client Handler

for {
numbytes, err := client.Read(buf)
!
!
!
!
}
}

Client Handler

for {
if numbytes == 0 || err != nil {
return
}
!
}
}

Client Handler

for {
if numbytes == 0 || err != nil {
return
}
client.Write(buf)
}
}

Build & Test
cd part1/
go build
./part1 &
telnet localhost 9000
# say something and hit enter

More Power
•

The echo server is great, but can only serve one
user at a time!

•

Concurrent network programming… should we
fork for each child? use a threading library? maybe
we can implement it using non-blocking I/O…

•

Stop, stop, stop!

Concurrent, Go Style
Remember our main accept loop? Let’s tweak it from this…
func main() {
if err != nil {
panic(err)
}
!
for {
if err != nil {
continue
}
handleClient(client)
}
}

Concurrent, Go Style
…to this!
func main() {
if err != nil {
panic(err)
}
!
for {
if err != nil {
continue
}
go handleClient(client)
}
}

Goroutines
•

A goroutine is a function executing concurrently
with other goroutines

•

Go multiplexes M goroutines onto N processes,
and scales to 100,000+ goroutines (millions
possible, use case dependent)

•

N is by default only 1, you can tune it

Goroutines pt. 2
•

Everything in Go is designed to be blocking, in
essence, and the idea is to use goroutines

•

This makes reasoning about software much easier

•

Go also provides deadlock detection and
backtraces all living goroutines

Echo v2.0, “Chat”
•

Let’s make a chat server out of our echo server

•

Design goal: any text from one client is echoed
immediately to all connected clients

•

Well, clearly, our goroutines have to communicate

Communication
•

The common idiom for communicating between
threads in most languages is shared memory

•

This kind of work is notoriously racy, error prone,
and hard to implement correctly

Communication in Go
•

“Don’t communicate by sharing memory; share
memory by communicating!”

•

Enter the concept of channels

•

A built-in goroutine safe method of passing data

Basic Channel Use
ch := make(chan int)

Create a new channel

ch <- 5

Write to a channel
Read from a channel

i := <-ch

The channel in this example is an unbuffered
channel. Reads block until data is available, writes
block until someone reads. Synchronous.

Buffered Channels
ch := make(chan int, 10)

Create a new channel

ch <- 5

Write to a channel
Read from a channel

i := <-ch

The difference: buffered channels won’t block when
inserting data (unless they’re full).

Chat Server
•

We have to make three main modiﬁcations:

1. Store a list of connected clients

2. Get input out of the clients

3. Write each input back to every client

•

Note: this implementation is a reduced example, so it’s a
little unsafe in one place :-)

Chat Server
•




•


Connected Clients
func main() {
...
!
!
!
for {
if err != nil {
continue
}
!
}
}

Connected Clients
func main() {
...
!
var clients []net.Conn
!
for {
if err != nil {
continue
}
clients = append(clients, client)
}
}

Build a slice of clients
and then append
each new client to
the slice.

!

The append built-in
handles automatically
allocating and
growing the backing
array as necessary.

Chat Server
•




•


Getting Input
func main() {
...

!
for {
...
}
}
!
for {
...
client.Write(buf)
}
}

Getting Input
func main() {
...
input := make(chan []byte, 10)
!
for {
...
}
}
!
for {
...
client.Write(buf)
}
}

Getting Input
func main() {
...
!
for {
...
go handleClient(client, input)
}
}
!
for {
...
client.Write(buf)
}
}

Getting Input
func main() {
...
!
for {
...
}
}
!
func handleClient(client net.Conn, input chan []byte) {
for {
...
client.Write(buf)
}
}

Getting Input
func main() {
...
!
for {
...
}
}
!
for {
...
client.Write(buf)
input <- buf
}
}

Getting Input
func main() {
...
!
for {
...
}
}
!
for {
...
client.Write(buf)
Removed the Write!
input <- buf
}
}

What is Happening?
•

handleClient still is a blocking read loop, but
instead of writing back to the client it writes the
bytes onto a channel

•

main now has a list of all clients and a channel
that everybody is writing input to

•

Final piece: somebody to read from the channel!

The Chat Manager
func main() {
...
!
!
!
!
We’ve
!
!
!
!
...
}

seen this all before…

The Chat Manager
func main() {
...
go func() {

!
!
!
!
!
}()
...
}

You can create goroutines
out of closures, too.

!

The Chat Manager
!
func main() {
...
go func() {
for {
message := <-input

!
!
}
}()
...
}

!
!

This is all blocking!

The Chat Manager
!
func main() {
...
This
go func() {
for {
message := <-input
for _, client := range clients {
!
}
}
}()
...
}

!
!

is all blocking!

range and _
for _, client := range clients {..}

•

The range keyword iterates over maps/slices/
arrays and returns the key (or index) and value

•

Underscore (_) is the anonymous variable (“blank
identiﬁer”), you can use it to discard results

The Chat Manager
func main() {
...
go func() {
for {
message := <-input
for _, client := range clients {
client.Write(message)
}
}
}()
...
}

Build & Test
cd part2/
go build
./part2 &
# say something and hit enter, now connect
# again in another window and chat! :-)

Echo 3.0, “Frotzer”
•

We’re entering the land of extremely contrived
tutorial examples, but…

•

Let’s give our chat server some behaviors!

•

When a user chats, we apply some formatting
rules before sending it out to other users

But First: More Type Talk!
•

Go doesn’t have classes (or objects, really)

•

However, you have named types, and methods are
attached to named types: 

 

 

 
type Uppercaser struct{}
!
func (self Uppercaser) Frotz(input []byte) []byte {
return bytes.ToUpper(input)
}

Um, struct{}?
•

Go supports structs, very much like any other
language that has structs

•

The empty struct is often used for hanging methods

•

Instantiating a struct type: 
foobar := Lowercaser{} 
foobar.Frotz(“HELLO”) // “hello”

Interfaces
•

In Go, an interface speciﬁes a collection of
methods attached to a name

•

Interfaces are implicit (duck typed) 

 

 

 

type Frotzer interface {
Frotz([]byte) []byte
}
!
}

Implementing Frotzing
func chatManager(clients *[]net.Conn, input chan []byte
) {
for {
message := <-input
for _, client := range *clients {
client.Write(message)
}
}
}

This is the input handler loop we built a few minutes ago,
except now we pulled it out of main and made it a
function.

Implementing Frotzing
func chatManager(clients *[]net.Conn, input chan []byte,
frotz Frotzer) {
for {
message := <-input
for _, client := range *clients {
client.Write(frotz.Frotz(message))
}
}
}

Now it takes a third argument: an interface. Any type that
implements Frotzer can be used!

Making Frotzers
These are both named types, and both implement
(implicitly!) the Frotzer interface. Thanks, compiler!
}
!
type Lowercaser struct{}
func (self Lowercaser) Frotz(input []byte) []byte {
return bytes.ToLower(input)
}

A New Main
func main() {
...
go chatManager(&clients, input)
!
!
for {
if err != nil {
continue
}
}
}

A New Main
func main() {
...
go chatManager(&clients, input, Lowercaser{})
go chatManager(&clients, input, Uppercaser{})
!
for {
if err != nil {
continue
}
}
}

A New Main pt. 2
•

The chatManager functions are spawned into
separate goroutines

•

Channels are goroutine safe, so they end up
interleaving reads (not guaranteed!)

•

chatManager doesn’t know what you’re passing it
as a Frotzer, it just knows it can call Frotz on it

Build & Test
cd part3/
go build
./part3 &
# say something and hit enter, your text
# should alternate UPPER/lower

Review
•

A multi-user chat server demonstrating many core
parts of the Go programming language

•

Built-in concurrency that is easy to use and trivially
allows relatively powerful constructions

•

A classless, statically type system that still enables
many OO concepts

Go is Awesome :-)

This slide should have unicorns and bunnies on it

Things That Aren’t Unicorns Yet
•

The GC is generally pretty solid, but if you are
doing many allocations and need performance, you
have to do the usual tricks

•

Standard library is pretty young and not optimized

•

Overall ecosystem is small (but growing, hi!)

Also: The Scheduler
•

It’s new and has room for improvement

•

Heavy use of channels between goroutines is
probably faster in one process

•

You’ll have to play with GOMAXPROCS and
understand your application

Topics Undiscussed
•

Building your own packages (it’s easy)

•

Importing from external repositories 
import pcap “github.com/akrennmair/gopcap”

•

Using gofmt (do it!)

•

switch, select, etc.

•

Type assertions, reﬂection, even more etc.

Thank you!

Mark Smith <mark@qq.is> @zorkian 
SRE at Dropbox (we’re hiring!)

•

Some recommended reading: 
Effective Go golang.org/doc/effective_go.html 
FAQ golang.org/doc/faq

•

Many more talks and presentations: 
code.google.com/p/go-wiki/wiki/GoTalks

•

The Go Playground! play.golang.org

LCA2014 - Introduction to Go

Related slideshows

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

Recommended for you

More Related Content

What's hot

What's hot (20)

Similar to LCA2014 - Introduction to Go

Similar to LCA2014 - Introduction to Go (20)

More from dreamwidth

More from dreamwidth (16)

Recently uploaded

Recently uploaded (20)

LCA2014 - Introduction to Go