A Recovering Java Developer Learns to Go
Matt Stine (@mstine) Cloud Foundry Platform Engineer at Pivotal
[email protected] http://www.mattstine.com
OFFICE HOURS Wednesday, 2:30 - 3:10 PM
Expo Hall (Table A)
I am not a Go expert.
I’m just learning to Go.
CF Architecture - January 2013
DEA Pool
Router
Cloud Controller
BOSH Director BOSH Agent
UAA/Login Servers Health Manager
Service Broker Node(s)
Messaging (NATS)
CLI Client
Ruby
Java/Spring
Go
CF Architecture - January 2014
Ruby
Java/Spring
Go
Loggregator
DEA Pool (Diego - Coming soon!)
Router
Cloud Controller
BOSH Director BOSH Agent
UAA/Login Servers Health Manager
Service Broker Node(s)
Messaging (NATS)
!
CLI Client
–Matt Stine
“Hey, wait! I just got done learning Ruby!”
• Mike Gehard: “Go Within Cloud Foundry”https://www.youtube.com/watch?v=d5aHr8VGU-8
• Onsi Fakhouri: “Diego: Re-envisioning the Elastic Runtime”https://www.youtube.com/watch?v=1OkmVTFhfLY
Go in Cloud Foundry
✓Hello World ✓Why Go? ✓Contrasts with Java:
- Features and Idioms - Packaging / Modularity - Types / OOP / Interfaces - Concurrency
Agenda
package main !import ( "fmt" ) !func main() { fmt.Println("Hello World") }
Hello WorldAll code goes in a package.
Give access to exported
stuff from other packages.
Function definition, main() is entrypoint.
Call an exported function!
Why Go?
Iron Triangle of Language Design
Effic
ient
Com
pilat
ion
Ease of Programming
Efficient ExecutionSystems Programming
• 2007-09-21: Go invented at Google by Robert Griesemer, Rob Pike, and Ken Thompson
• 2009-11-10: Go released as OSS
• 2012-03-28: Go 1.0 is Released
A History Lesson
Software Engineering in the LARGE
http://talks.golang.org/2012/splash.article
“Go is a programming language designed by Google to help solve Google's problems, and Google has big problems.”
Software Engineering in the LARGE
http://talks.golang.org/2012/splash.article
“Go is a programming language designed by Google to help solve Google's problems, and Google has big problems.”
✓ Safety and efficiency of astatically-typed, compiled language
✓ Productivity and feel of a dynamic,interpreted language
✓ Address modern compute environments:
- Multicore Processors
- Networked Systems
- Massive Computational Clusters
- Web Programming Model
Goals
https://www.flickr.com/photos/slackpics/4289782818
A Kit for
Systems Software
https://www.flickr.com/photos/pmiaki/6657150957
Differences from Java
https://www.flickr.com/photos/yukop/6778321940
• Features and Idioms
• Packaging / Modularity
• Types / OOP / Interfaces
• Concurrency
Contrasts with Java
Features and
Idioms
https://www.flickr.com/photos/yukop/6778321940
Multiple Return Valuesfunc vals() (int, int) { return 3, 7 } !func main() { a, b := vals() fmt.Println(a) fmt.Println(b) ! _, c := vals() fmt.Println(c) } GBE
Return a pair of values.
I
Ignore the first value returned.
Assign to multiple variables.
Closures
func intSeq() func() int { i := 0 return func() int { i += 1 return i } }
GBE
Closes over this state.
Closures
func main() { nextInt := intSeq() ! fmt.Println(nextInt()) fmt.Println(nextInt()) fmt.Println(nextInt()) ! newInts := intSeq() fmt.Println(newInts()) }
GBE
Captures its own value for i.
Increments own value of i.
Captures the value of i again!And increments it.
Where’s my java.util.List? Slicess := make([]string, 3) fmt.Println("emp:", s) !s[0] = "a" s[1] = "b" s[2] = "c" fmt.Println("set:", s) fmt.Println("get:", s[2]) !s = append(s, "d") s = append(s, "e", "f") fmt.Println("apd:", s)
GBE
Create an empty slice of strings (zero-valued).
Set value at index.
Get value at index.
Append function (not mutate in-place!).
Where’s my java.util.List? Slicesc := make([]string, len(s)) copy(c, s) fmt.Println("cpy:", c) !l := s[2:5] fmt.Println("sl1:", l) !l = s[:5] fmt.Println("sl2:", l) !t := []string{"g", "h", "i"} fmt.Println("dcl:", t)
GBE
Length function.Copy function.
Slicing function: index 2 (inclusive) to index 5 (exclusive).
Slicing function: index 0 (inclusive) to index 5 (exclusive).
Slice literals!
Where’s my java.util.Map? Mapsm := make(map[string]int) !m["k1"] = 7 m["k2"] = 13 !fmt.Println("map:", m) !v1 := m["k1"] fmt.Println("v1: ", v1) !fmt.Println("len:", len(m))
Create an empty map of string ! int.
Put values.
Get value.
Length function.
GBE
Where’s my java.util.Map? Mapsdelete(m, "k2") fmt.Println("map:", m) !_, prs := m["k2"] fmt.Println("prs:", prs) !n := map[string]int{"foo": 1, "bar": 2} fmt.Println("map:", n)
Delete function.
Optional second return indicating “presence.”
Map literals!GBE
Looping with Rangenums := []int{2, 3, 4} sum := 0 for _, num := range nums { sum += num } fmt.Println("sum:", sum) !for i, num := range nums { if num == 3 { fmt.Println("index:", i) } } !kvs := map[string]string{"a": "apple", "b": "banana"} for k, v := range kvs { fmt.Printf("%s -> %s\n", k, v) }
Discard first (index), sum second (value).
Keep both returns!
With maps, first = key, second = value.
GBE
We don’t need no stinkin’ exceptions…func f1(arg int) (int, error) { if arg == 42 { return -1, errors.New("can't work with 42") } return arg + 3, nil } !func main() { for _, i := range []int{7, 42} { if r, e := f1(i); e != nil { fmt.Println("f1 failed:", e) } else { fmt.Println("f1 worked:", r) } } }
Conventional: last return is error.
Makes an error with the provided message.
Return nil if there was no error.
Idiomatic inline error check.
GBE
(Semi)automatic Resource Managementfunc createFile(p string) *os.File { fmt.Println("creating") f, err := os.Create(p) if err != nil { panic(err) } return f }
func writeFile(f *os.File) { fmt.Println("writing") fmt.Fprintln(f, "data") !} !func closeFile(f *os.File) { fmt.Println("closing") f.Close() }
GBE
(Semi)automatic Resource Management
func main() { f := createFile("/tmp/defer.txt") defer closeFile(f) writeFile(f) }
Run after the function completes.
GBE
Packaging/Modularity
https://www.flickr.com/photos/yukop/6778321940
TL;DR
COMPLEX
SIMPLE
• Every class in a package
• Import classes explicitly
- import java.util.Map
• Import all classes in a package
- import java.util.*
• Statically import class static members:
- import static java.lang.Math.PI
- import static java.lang.Math.*
Java Packaging
• All types and functions belong to a package.
• Every source file must declare its package.
• Import packages to gain access to exported members.
Go Packaging
• public - any class in same package, or any importing class in a different package, can see
• default (“package private”) - any class in same package can see
• protected - any class in same package, or any subclass in a different package, can see
• private - no class other than this can see
• Scope indicated by prefixing name at declaration time.
Java Scoping
• exported - any code in an importing file can see
- exported names start with uppercase letter
- func Copy(src *[]byte, dest *[]byte)
• non-exported - only code in the same package can see
- non-exported names start with _ or lowercase letter
- func copy(src *[]byte, dest *[]byte)
- func _Copy(src *[]byte, dest *[]byte)
Go Scoping
• Conventional correspondence to directory paths (e.g. com.ms.foo should be at src/com/ms/foo) - tools expect this!
• Package paths do not have to be unique at compile or runtime (first dependency found/loaded wins!)
• Conventional correspondence to URL of author (e.g. my domain is www.mattstine.com, so my packages names start with com.mattstine) - but no actual relationship to source code location!
Java Naming
• Conventional correspondence to directory paths (e.g. github.com/go-martini/martini should be at src/github.com/go-martini/martini) - tools expect this!
• Package paths MUST BE UNIQUE across a $GOPATH.
• Package names do not have to be unique.
• Referring to imported names must be qualified by package name (e.g. sql.DB not just DB)…can locally alias (e.g. import dbstuff “database/sql”)
• Conventional correspondence to URL of code location (e.g. import http://github.com/joefitzgerald/cfenv as import “github.com/joefitzgerald/cfenv").
• Can “go get” remote packages - supports Git, SVN, Mercurial, Bazaar.
Go Naming
• Java admits:
- circular package dependencies
- dead imports
• Go rejects:
- circular package dependencies
- dead imports
Miscellany
Types/OOP/Interfaces
https://www.flickr.com/photos/yukop/6778321940
For realz this time…
structs FTW
type Point struct { X, Y float64 }
Define a type. Give it a name.
This type is a struct. (you can actually define others!)
Add stuff! (upcase exports apply here too!)
Methods are Functions!
func (p Point) Translate(xDist float64, yDist float64) Point { return Point{p.X + xDist, p.Y + yDist} }
Receiver argument!
Can define methods on pointers or values.
composition FTWtype Point struct { X, Y float64 } !const ( BLUE = iota RED = iota GREEN = iota ) !type ColorPoint struct { Point Point Color int }
Define an enumerated constant (closest to Java enum).
A ColorPoint has-a Point!
• I have Points.
• I have ColorPoints.
• ColorPoints are like Points, but they are not Points.
• But I want to compute the euclidean distance between them.
• What to do?
Problem
Interfaces Group Behaviors
type Positioner interface { Coordinates() Point } !type Distancer interface { DistanceTo(p Positioner) float64 }
It’s all about satisfaction…
Java = explicit !Go = implicit
Calculating Distancefunc distanceBetween(a Positioner, b Positioner) float64 { p := a.Coordinates() q := b.Coordinates() sqOfXDist := math.Pow(p.X-q.X, 2) sqOfYDist := math.Pow(p.Y-q.Y, 2) return math.Sqrt(sqOfXDist + sqOfYDist) }
Point Satisfies Distancer and Positioner
func (p Point) Coordinates() Point { return p } !func (p Point) DistanceTo(pos Positioner) float64 { return distanceBetween(p, pos) }
ColorPoint Satisfies Distancer and Positioner
func (cp ColorPoint) Coordinates() Point { return cp.Point } !func (cp ColorPoint) DistanceTo(pos Positioner) float64 { return distanceBetween(cp, pos) }
Behavior Not Taxonomy
Animal Satisfies Distancer and Positionerfunc (a Animal) Coordinates() point.Point { return point.Point{X: a.X, Y: a.Y} } !func (a Animal) DistanceTo(pos point.Positioner) float64 { thing := pos.Coordinates() sqOfXDist := math.Pow(a.X-thing.X, 2) sqOfYDist := math.Pow(a.Y-thing.Y, 2) return math.Sqrt(sqOfXDist + sqOfYDist) }
Go!p = point.Point{X: 1, Y: 2} q := point.ColorPoint{Point: point.Point{X: 1, Y: 4}, Color: point.BLUE} !fmt.Printf("Dist b/w p and q = %v\n", p.DistanceTo(q)) fmt.Printf("Dist b/w q and p = %v\n", q.DistanceTo(p)) !penguin := animal.Animal{Name: "penguin", X: 1, Y: 1} seal := animal.Animal{Name: "seal", X: 1, Y: 4} !fmt.Printf("Dist b/w penguin and seal = %v\n", penguin.DistanceTo(seal)) fmt.Printf("Dist b/w penguin and point = %v\n", penguin.DistanceTo(p))
Concurrency
https://www.flickr.com/photos/yukop/6778321940
• Parallelism = leveraging simultaneous execution of work to perform many things at once. Limited to number of processors/cores you have.
• Concurrency = composition of work to manage many things at once. No theoretical limit.
• Rob Pike: “Concurrency is Not Parallelism”http://www.youtube.com/watch?v=cN_DpYBzKso
Concurrency vs Parallelism
• Java - Threads - OS managed - Share address space with other threads in same process
• Go - Goroutines - user-space managed by language runtime - multiplexed onto pool of OS threads
Parallelism - How?
• Java - Shared memory - Locking
• Go - Can share memory (see http://golang.org/pkg/sync) - But there is a better way!
Synchronization?
– http://golang.org/doc/effective_go.html
“Do not communicate by sharing memory; instead, share memory by communicating.”
Goroutinesfunc f(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) } } !func main() { f("direct") ! go f("goroutine") ! go func(msg string) { fmt.Println(msg) }("going") } GBE
Synchronous
Asynchronous
Asynchronous and Anonymous
Channelsfunc main() { messages := make(chan string) ! go func() { messages <- "ping" }() ! msg := <-messages fmt.Println(msg) }
GBE
Create a new channel.
Sending
Receiving
Channel Bufferingfunc main() { messages := make(chan string, 2) ! messages <- "buffered" messages <- "channel" ! fmt.Println(<-messages) fmt.Println(<-messages) }
GBE
Make a channel that will buffer two values.
Send twice
Receive twice
Channel Synchronizationfunc worker(done chan bool) { fmt.Print("working...") time.Sleep(time.Second) fmt.Println("done") done <- true } !func main() { done := make(chan bool, 1) go worker(done) <-done } GBE
Notify receive that I’m done.
Run worker on a goroutine, pass “done” channel.
Block until msg received!
Selectc1 := make(chan string) c2 := make(chan string) !go func() { time.Sleep(time.Second * 1) c1 <- "one" }() go func() { time.Sleep(time.Second * 2) c2 <- "two" }()
GBE
Create two channels.
Create two goroutines; each sends message to different channel.
Selectfor i := 0; i < 2; i++ { select { case msg1 := <-c1: fmt.Println("received", msg1) case msg2 := <-c2: fmt.Println("received", msg2) } }
GBE
Await both messages simultaneously!
Print each as it arrives!
Closing Channelsjobs := make(chan int, 5) done := make(chan bool) !go func() { for { j, more := <-jobs if more { fmt.Println("received job", j) } else { fmt.Println("received all jobs") done <- true return } } }()
GBE
Job channel for sending work.Done channel to indicate all work complete.
Receive jobs - more will be false if jobs is closed.
If no more jobs, say that I’m done!
Closing Channelsfor j := 1; j <= 3; j++ { jobs <- j fmt.Println("sent job", j) } close(jobs) fmt.Println("sent all jobs") !<-done
GBE
Send the jobs to the worker.
Close the jobs channel.
Block until the worker is finished.
Range Over Channels
func main() { queue := make(chan string, 2) queue <- "one" queue <- "two" close(queue) ! for elem := range queue { fmt.Println(elem) } }
GBE
Pull messages off channel for each iteration of the loop.
• Features and Idioms
• Packaging / Modularity
• Types / OOP / Interfaces
• Concurrency
Contrasts with Java
Thank You!!!Matt Stine (@mstine)
Cloud Foundry Platform Engineer at Pivotal [email protected]
http://www.mattstine.com
OFFICE HOURS Wednesday, 2:30 - 3:10 PM
Expo Hall (Table A)
Code samples marked “GBE” at https://gobyexample.com are by Mark McGranaghan and are Creative Commons Attribution 3.0 Unported licensed (http://creativecommons.org/licenses/by/3.0). !
The Go Gopher logo was created by Renee French and is Creative Commons Attribution 3.0 Unported licensed (http://creativecommons.org/licenses/by/3.0). !
The Java Duke logo is BSD licensed (http://opensource.org/licenses/bsd-license.php).
