Google Git
Sign in
go / tour / eaa0bf5fceab80b0d6a0e12b9084907d9152e25a / . / talks / 2012-04-25-NewYorkMeetup / index.html
blob: eed0bc83e03e0618f937924eb304575b266f5d4c [file] [log] [blame]
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" >
<title>A Tour of Go</title>
<!-- jQuery -->
<script src="/static/jquery.js"></script>
<!-- Fonts -->
<link href='http://fonts.googleapis.com/css?family=Droid+Serif' rel='stylesheet' type='text/css'>
<link href='http://fonts.googleapis.com/css?family=Droid+Sans' rel='stylesheet' type='text/css'>
<link href='http://fonts.googleapis.com/css?family=Droid+Sans+Mono' rel='stylesheet' type='text/css'>
<!-- Playground -->
<link rel="stylesheet" href="/static/codemirror/lib/codemirror.css">
<script src="/static/codemirror/lib/codemirror.js"></script>
<link rel="stylesheet" href="/static/codemirror/theme/default.css">
<script src="/static/playground.js"></script>
<!-- Tour -->
<link rel="stylesheet" href="/static/tour.css" charset="utf-8">
<script src="/static/mode.js"></script>
<script src="/static/tour.js"></script>
</head>
<body class="loading">
<!-- Top bar -->
<h2 id="slidenum"></h2>
<div id="topnav" class="nav">
<button id="tocbtn">INDEX</button>
</div>
<h1>A Tour of Go</h1>
<!-- Loading message -->
<div id="loading">
Loading slides...
</div>
<!-- Table of Contents -->
<ol id="toc"></ol>
<div id="slides" class="slides"><!-- begin slides -->
<div class="toc">Welcome</div>
<div class="slide nocode">
<h2>Let's Go</h2>
<center>
<p>Sameer Ajmani
<p>Google NYC Tech Talk Meetup
<p>April 25, 2012
</center>
</div>
<div class="slide nocode appengineMode">
<h2>Go offline</h2>
<p>
This talk contains several examples that will only work if you run the
gotour stand-alone program on your local machine. You can flip through
the following slides to read the talk and code, but most of the examples
will fail mysteriously if you're
using <a href="http://tour.golang.org">tour.golang.org</a>.
<p>
To run the talk locally first
<a target="_blank" href="http://golang.org/doc/install/">install Go</a>,
then use
<a target="_blank" href="http://golang.org/cmd/go/">go get</a> to install
<a target="_blank" href="http://code.google.com/p/go-tour/">gotour</a>:
<pre> go get code.google.com/p/go-tour/gotour</pre>
<p>
and run the resultant <code>gotour</code> executable. Finally, navigate
to <a href="http://127.0.0.1:3999/talks/2012-04-25-NewYorkMeetup">
http://127.0.0.1:3999/talks/2012-04-25-NewYorkMeetup</a>
to access this talk locally.
<p>
Otherwise, click the "next" button or type PageDown to continue.
<p>
<i>(You may return to these instructions at any time by clicking the
"index" button.)</i>
</div>
<div class="slide nocode">
<h2>Why Go?</h2>
<p>Statically typed languages are efficient, but typically bureaucratic and
overly complex.
<p>Dynamic languages can be easy to use, but are error-prone, inefficient, and
break down at scale.
<p>Concurrent programming is hard (threads, locks, headache).
<p>"Speed, reliability, simplicity: pick two." (sometimes just one)
<p>Can't we do better?
</div>
<div class="slide nocode">
<h2>Go 1</h2>
<p>Go began in September 2007.
<blockquote>"Consensus drove the design. Nothing went into the language
until [Ken Thompson, Robert Griesemer, and myself] all agreed
that it was right. Some features didn't get resolved until after
a year or more of discussion." -- Rob Pike</blockquote>
<p>The first release of Go was in November 2009.
<p>Go version 1 (Go 1) was released March 28, 2012.
</div>
<div class="slide nocode">
<h2>What is Go?</h2>
<p>Go is ...
<ul>
<li>a general-purpose, open source programming language
<li>concise, expressive, and readable
<li>statically-typed, with "duck typing" via implicit interfaces
<li>garbage-collected
<li>compiled to native machine code: compiles fast, runs fast
<li>especially good for concurrent programming
</ul>
<p>Start at <a href="http://golang.org">http://golang.org</a>
</div>
<div class="slide">
<h2>Hello, 世界</h2>
<p>Here's "Hello, world" in Go.
<p>I'm running a modified version of <a href="http://tour.golang.org">http://tour.golang.org</a>.
<div>
package main
import "fmt"
func main() {
fmt.Println("Hello, 世界")
}
</div>
</div>
<div class="slide">
<h2>Hello, world 2.0</h2>
<p>Serving "Hello, world"
at <a href="http://localhost:8080/world">http://localhost:8080/world</a>
<p><code>import "net/http"</code> imports the named package as <code>http</code>;<br>
<code>http.HandleFunc</code> references <code>HandleFunc</code> from that package.
<p>In <code>handler</code>, what's the type of <code>name</code>?
<div>
package main
import (
"fmt"
"net/http"
)
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
func handler(w http.ResponseWriter,
r *http.Request) {
name := r.URL.Path[1:]
fmt.Fprint(w, "Hello, "+ name)
}
</div>
</div>
<div class="slide">
<h2>Simple type system</h2>
<p>Go is statically typed, but type inference saves repitition.
<p>Java:<br>
<code>Date now = new Date();</code>
<p>C/C++:<br>
<code>time_t now = time(NULL);</code>
<p>Go:<br>
<code>now := time.Now()</code><br>
<code>i := 1</code><br>
<code>pi := math.Pi</code><br>
<code>greeting := "Hello!"</code><br>
<div>
package main
import "fmt"
var w int
var (
x = 1
y, z = 2, 3
)
func main() {
var c = true
python, java := false, "no!"
fmt.Println(w, x, y, z, c, python, java)
}
</div>
</div>
<div class="slide">
<h2>Types and Functions</h2>
<p>Declare a type with <code>type</code>, and declare a function
with <code>func</code>.
<div>
package main
import "fmt"
type Vertex struct {
X, Y float64
}
func VertexToString(v Vertex) string {
return fmt.Sprintf("(%f, %f)", v.X, v.Y)
}
func main() {
var v Vertex
v.X, v.Y = 3, 4
fmt.Println(VertexToString(v))
}
</div>
</div>
<div class="slide">
<h2>Composite Literals</h2>
<p>
Go provides excellent composite literals. These makes it easy to
declare values for structs, maps, arrays, and slices, including nested
values.
<div>
package main
import "fmt"
type Vertex struct {
X, Y float64
}
func VertexToString(v Vertex) string {
return fmt.Sprintf("(%f, %f)", v.X, v.Y)
}
func main() {
v := Vertex{3, 4}
fmt.Println(VertexToString(v))
}
</div>
</div>
<div class="slide">
<h2>Methods</h2>
<p>
Go does not have classes. However, you can define methods on struct
types.
<p>
The <i>method receiver</i> appears as an argument between
the <code>func</code> keyword and the method name.
<div>
package main
import "fmt"
type Vertex struct {
X, Y float64
}
func (v Vertex) String() string {
return fmt.Sprintf("(%f, %f)", v.X, v.Y)
}
func main() {
v := Vertex{3, 4}
fmt.Println(v.String())
}
</div>
</div>
<div class="slide">
<h2>Methods</h2>
<p>
In fact, you can define a method on <i>any</i> type you define in your
package, not just structs.
<p>
You cannot define a method on a type from another package, or on a
basic type.
<div>
package main
import "fmt"
type Celsius float32
type Fahrenheit float32
func (c Celsius) String() string {
return fmt.Sprintf("%.2f&deg;C", c)
}
func (f Fahrenheit) String() string {
return fmt.Sprintf("%.2f&deg;F", f)
}
func (c Celsius) Fahrenheit() Fahrenheit {
return Fahrenheit(c*9/5 + 32) // conversion
}
func main() {
c := Celsius(100)
fmt.Println(c, "==", c.Fahrenheit())
// Celsius, Fahrenheit, and float32
// are different types!
// tryMe := c + Fahrenheit(32)
}
</div>
</div>
<div class="slide">
<h2>Interfaces</h2>
<p>
Did you notice I forgot to type <code>c.String()</code> in
the <code>fmt</code> calls on the previous slide? The <code>fmt</code>
package automatically calls <code>String</code> on anything that
implements <code>fmt.Stringer</code>.
<p>
But I didn't have to say "implements Stringer" anywhere.
<p>
<i>There is no explicit declaration of intent.</i>
<p>
An interface type is defined by a set of methods.
<p>
A value of interface type can hold any value that
implements those methods.
<p>
This decouples implementation packages from the packages
that define the interfaces: neither depends on the other.
<div>
package main
import "fmt"
type Stringer interface {
String() string
}
func main() {
var s Stringer
v := Vertex{3, 4}
c := Celsius(100)
s = v // Vertex implements Stringer
s = c // Celsius implements Stringer
fmt.Println(v, c, s)
}
type Vertex struct { X, Y float64 }
func (v Vertex) String() string {
return fmt.Sprintf("(%f, %f)", v.X, v.Y)
}
type Celsius float32
func (c Celsius) String() string {
return fmt.Sprintf("%.2f&deg;C", c)
}
</div>
</div>
<div class="slide">
<h2>Hello, world 2.1</h2>
<p>Serving "Hello, world"
at <a href="http://localhost:8081/world">http://localhost:8081/world</a>
<p>
<a target="_blank" href="http://golang.org/pkg/net/http/">Package http</a> serves HTTP requests using any value
that implements <code>http.Handler</code>:
<pre>
package http
type Handler interface {
ServeHTTP(w ResponseWriter,
r *Request)
}
</pre>
<p>And <code>fmt.Fprint</code> can write to any value that implements <code>io.Writer</code>:
<pre>
package io
type Writer interface {
Write(b []byte) (n int, err error)
}
</pre>
In this example, the type <code>Hello</code>
implements <code>http.Handler</code>, and the
type <code>http.ResponseWriter</code>
implements </code>io.Writer</code>.
<p>
<code>Hello</code> can contain state, but beware: calls to ServeHTTP may
run concurrently.
<div>
package main
import (
"fmt"
"net/http"
)
type Hello struct {
greeting string
}
func (h Hello) ServeHTTP(w http.ResponseWriter,
r *http.Request) {
name := r.URL.Path[1:]
fmt.Fprint(w, h.greeting, ", ", name)
}
func main() {
h := Hello{"Namaste"}
http.ListenAndServe("localhost:8081", h)
}
</div>
</div>
<div class="slide nocode">
<h2>Concurrency</h2>
<p>Based on Communicating Sequential Processes (CSP), first described in 1978 by
C.A.R. Hoare.
<p>In UNIX we think about <b>processes</b> connected by <b>pipes</b>:
<p><code>find ~/go/src/pkg | grep _test.go$ | xargs wc -l</code>
<p>Each tool is designed to do one thing and to do it well.
<p>In the real world, we assign tasks to <b>individuals</b> connected by <b>communication</b>:<br>
factory assembly lines, phone trees, software projects.
<p>The Go analogue: <b>goroutines</b> connected by <b>channels</b>.
</div>
<div class="slide nocode">
<h2>Goroutines</h2>
<p>
Goroutines are like threads:
<ul>
<li>They share memory.</li>
</ul>
But cheaper:
<ul>
<li>Smaller, segmented stacks.</li>
<li>Many goroutines per operating system thread.</li>
<li>Managed by the Go runtime.</li>
</ul>
</div>
<div class="slide">
<h2>Goroutines</h2>
<p>
Start a new goroutine with the <code>go</code> keyword:
<pre>go f(x, y, z)</pre>
<p>
starts a new goroutine running
<pre>f(x, y, z)</pre>
<p>
The evaluation
of <code>f</code>, <code>x</code>, <code>y</code>, and <code>z</code>
happens in the current goroutine and the execution of <code>f</code>
happens in the new goroutine.
<p>
Goroutines run in the same address space, so access to shared memory
must be synchronized. The <code><a href="http://golang.org/pkg/sync/"
target="_blank">sync</a></code> package provides useful primitives,
but you don't need them so much in Go thanks to channels.
<div>
package main
import (
"fmt"
"math/rand"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
fmt.Println(s)
}
}
func main() {
rand.Seed(time.Now().UnixNano())
go say(" world")
say("hello")
}
</div>
</div>
<div class="slide">
<h2>Channels</h2>
<p>
A channel is a typed conduit through which you can send and receive
values with the channel operator, <code>&lt;-</code>.
<pre>
ch <- v // Send v to channel ch.
v := <-ch // Receive from ch, and
// assign value to v.
</pre>
<p>
(The data flows in the direction of the arrow.)
<p>
Channels must be created using <code>make</code>:
<pre>
ch := make(chan int)
</pre>
<p>
By default, sends and receives block until the other side is ready.
This allows goroutines to synchronize without explicit locks or
condition variables.
<div>
package main
import "fmt"
func sum(a []int, c chan int) {
sum := 0
for i := 0; i < len(a); i++ {
sum += a[i]
}
c <- sum // send sum to c
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(a[:len(a)/2], c)
go sum(a[len(a)/2:], c)
x, y := <-c, <-c // receive from c
fmt.Println(x, y, x + y)
}
</div>
</div>
<div class="slide">
<h2>Buffered Channels</h2>
<p>
Channels can be <i>buffered</i>. Provide the buffer length as the
second argument to <code>make</code> to initialize a buffered channel:
<pre>
ch := make(chan int, 100)
</pre>
<p>
Sends to a buffered channel block only when the buffer is full.
Receives block when the buffer is empty.
<div>
package main
import "fmt"
func main() {
c := make(chan int, 2)
c <- 1
c <- 2
fmt.Println(<-c)
fmt.Println(<-c)
}
</div>
</div>
<div class="slide">
<h2>Range and Close</h2>
<p>
A sender can <code>close</code> a channel to indicate that no more
values will be sent. Receivers can test whether a channel has been
closed by assigning a second parameter to the receive expression: after
<pre>
v, ok := &lt;-ch</pre>
<p>
<code>ok</code> is <code>false</code> if there are no more values to
receive and the channel is closed.
<p>
The loop <code>for i := range c</code> receives values from the
channel repeatedly until it is closed.
<p>
<div>
package main
import "fmt"
func fibonacci(n int, c chan int) {
x, y := 1, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x + y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
</div>
</div>
<div class="slide">
<h2>Select</h2>
<p>
The <code>select</code> statement lets a goroutine wait on multiple
communication operations.
<p>
A <code>select</code> blocks until one of its cases can run, then it
executes that case. It chooses one at random if multiple are ready.
<p>
A <code>select</code> can have a <code>default</code> case that runs if
the others would block. This lets you write non-blocking channel ops:
<pre>
select {
case c1 <- x:
// sent x
case y := <-c2:
// received y
default:
// nothing ready
}
</pre>
<div>
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 1, 1
for {
select {
case c <- x:
x, y = y, x + y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go fibonacci(c, quit)
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}
</div>
</div>
<div class="slide nocode">
<h2>Example: Google Search</h2>
<p>Q: What does Google search do?
<p>A: Given a query, return a page of search results (and some ads).
<p>Q: How do we get the search results?
<p>A: Send the query to Web search, Image search, YouTube, Maps, News,
etc., then mix the results.
<p>How do we implement this?
</div>
<div class="slide">
<h2>Example: Google Search 1.0</h2>
<p>The <code>Google</code> function takes a query and returns a slice
of <code>Results</code>.
<p><code>Google</code>
invokes <code>Web</code>, <code>Image</code>,
and <code>Video</code> searches serially, appending them to
the <code>results</code> slice.
<div>
package main
import (
"fmt"
"math/rand"
"time"
)
type Result string
type Search func(query string) Result
var (
Web = fakeSearch("web")
Image = fakeSearch("image")
Video = fakeSearch("video")
)
func Google(query string) (results []Result) {
results = append(results, Web(query))
results = append(results, Image(query))
results = append(results, Video(query))
return
}
func fakeSearch(kind string) Search {
return func(query string) Result {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
return Result(fmt.Sprintf("%s result for %q\n", kind, query))
}
}
func main() {
rand.Seed(time.Now().UnixNano())
start := time.Now()
results := Google("golang")
elapsed := time.Since(start)
fmt.Println(results)
fmt.Println(elapsed)
}
</div>
</div>
<div class="slide">
<h2>Example: Google Search 2.1</h2>
<p><code>Google</code> invokes <code>Web</code>, <code>Image</code>,
and <code>Video</code> searches concurrently, and waits for the expected
number of results.
<p>No locks. No condition variables. No callbacks.
<div>
package main
import (
"fmt"
"math/rand"
"time"
)
type Result string
type Search func(query string) Result
var (
Web = fakeSearch("web")
Image = fakeSearch("image")
Video = fakeSearch("video")
)
func Google(query string) (results []Result) {
c := make(chan Result, 3)
go func() { c <- Web(query) } ()
go func() { c <- Image(query) } ()
go func() { c <- Video(query) } ()
for i := 0; i < cap(c); i++ {
result := <-c
results = append(results, result)
}
return
}
func fakeSearch(kind string) Search {
return func(query string) Result {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
return Result(fmt.Sprintf("%s result for %q\n", kind, query))
}
}
func main() {
rand.Seed(time.Now().UnixNano())
start := time.Now()
results := Google("golang")
elapsed := time.Since(start)
fmt.Println(results)
fmt.Println(elapsed)
}
</div>
</div>
<div class="slide">
<h2>Example: Google Search 2.2</h2>
<p>Don't wait for slow backends.
<p>No locks. No condition variables. No callbacks.
<div>
package main
import (
"fmt"
"math/rand"
"time"
)
type Result string
type Search func(query string) Result
var (
Web = fakeSearch("web")
Image = fakeSearch("image")
Video = fakeSearch("video")
)
func Google(query string) (results []Result) {
c := make(chan Result, 3)
go func() { c <- Web(query) } ()
go func() { c <- Image(query) } ()
go func() { c <- Video(query) } ()
timeout := time.After(80 * time.Millisecond)
for i := 0; i < cap(c); i++ {
select {
case result := <-c:
results = append(results, result)
case <-timeout:
fmt.Println("timed out")
return
}
}
return
}
func fakeSearch(kind string) Search {
return func(query string) Result {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
return Result(fmt.Sprintf("%s result for %q\n", kind, query))
}
}
func main() {
rand.Seed(time.Now().UnixNano())
start := time.Now()
results := Google("golang")
elapsed := time.Since(start)
fmt.Println(results)
fmt.Println(elapsed)
}
</div>
</div>
<div class="slide nocode">
<h2>Example: Query failover</h2>
<p>Q: How do we avoid timing out our requests to slow backends?
<p>A: Replicate the backends. Send requests to multiple replicas, and
use the first response.
</div>
<div class="slide">
<h2>Example: Query failover</h2>
<p><code>First</code> runs searches on the replicas
concurrently and returns the first result.
<div>
package main
import (
"fmt"
"math/rand"
"time"
)
type Result string
type Search func(query string) Result
func First(query string, replicas ...Search) Result {
c := make(chan Result, len(replicas))
searchReplica := func(i int) {
c <- replicas[i](query)
}
for i := range replicas {
go searchReplica(i)
}
return <-c
}
func main() {
rand.Seed(time.Now().UnixNano())
start := time.Now()
result := First("query",
fakeSearch("replica 1"),
fakeSearch("replica 2"))
elapsed := time.Since(start)
fmt.Println(result)
fmt.Println(elapsed)
}
func fakeSearch(kind string) Search {
return func(query string) Result {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
return Result(fmt.Sprintf("%s result for %q\n", kind, query))
}
}
</div>
</div>
<div class="slide">
<h2>Example: Google Search 3.0</h2>
<p>Reduces tail latency using replicated search backends.
<div>
package main
import (
"fmt"
"math/rand"
"time"
)
type Result string
type Search func(query string) Result
var (
Web1 = fakeSearch("web1")
Web2 = fakeSearch("web2")
Image1 = fakeSearch("image1")
Image2 = fakeSearch("image2")
Video1 = fakeSearch("video1")
Video2 = fakeSearch("video2")
)
func Google(query string) (results []Result) {
c := make(chan Result, 3)
go func() { c <- First(query, Web1, Web2) } ()
go func() { c <- First(query, Image1, Image2) } ()
go func() { c <- First(query, Video1, Video2) } ()
timeout := time.After(80 * time.Millisecond)
for i := 0; i < cap(c); i++ {
select {
case result := <-c:
results = append(results, result)
case <-timeout:
fmt.Println("timed out")
return
}
}
return
}
func First(query string, replicas ...Search) Result {
c := make(chan Result, len(replicas))
searchReplica := func(i int) {
c <- replicas[i](query)
}
for i := range replicas {
go searchReplica(i)
}
return <-c
}
func fakeSearch(kind string) Search {
return func(query string) Result {
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
return Result(fmt.Sprintf("%s result for %q\n", kind, query))
}
}
func main() {
rand.Seed(time.Now().UnixNano())
start := time.Now()
results := Google("golang")
elapsed := time.Since(start)
fmt.Println(results)
fmt.Println(elapsed)
}
</div>
</div>
<div class="slide nocode">
<h2>There's a lot more to Go</h2>
<ul>
<li>arrays, maps, slices</li>
<li>struct and interface embedding</li>
<li>defer, panic, recover</li>
<li>type switches and reflection</li>
<li>the go tool</li>
</ul>
</div>
<div class="slide nocode">
<h2>Where to Go from here...</h2>
<ul>
<li><a href="http://golang.org">http://golang.org</a> - Go Home Page</li>
<li><a href="http://golang.org/ref/spec">http://golang.org/ref/spec</a>
- Language Spec</li>
<li><a href="http://golang.org/pkg">http://golang.org/pkg</a> -
Package Documentation</li>
<li><a href="http://golang.org/doc/codewalk">http://golang.org/doc/codewalk</a> - Codewalks</li>
<ul>
<li>Share Memory by Communicating - Go concurrency model</li>
<li>First Class Functions in Go - Go's function types</li>
</ul>
<li><a href="http://blog.golang.org">http://blog.golang.org</a> -
especially "Defer, Panic, and Recover".</li>
</ul>
</div>
</div><!-- end slides -->
</body>
</html>