Why you should care about Go (Golang)

5/14/2015 Go
http://127.0.0.1:3999/go-why-care/pres.slide#1 1/37
Go
Where it's going and why you should pay attention
14 May 2015
Aaron Schlesinger
Sr. Engineer, Iron.io

5/14/2015 Go
About Me
Currently a database & backend systems engineer at Iron.io
Writing Go for 1.5 years
Worked on server side and distributed systems for 5 years
Go is my favorite language. I'm most productive and happiest here

5/14/2015 Go
Today
Why Go is powerful
Why it's important
Why it's worth your attention

5/14/2015 Go
About Go
A programming language that started at Google. From golang.org(http://golang.org):
Goisanopensourceprogramminglanguagethatmakesiteasytobuildsimple,
reliable,andefficientsoftware.
Very good choice for:
Cloud & microservices
Web servers
Systems utilities
Databases
Monitoring tools

5/14/2015 Go
Why Go?
Efficient runtime
Simple & powerful primitives
Extremely productive
Great tools
Fun

5/14/2015 Go
Simple program
packagemain
import"fmt"
constnumIters=10
funcmain(){
fori:=0;i<numIters;i++{
fmt.Printf("HiGophers!(#%d)n",i+1)
}
} Run

5/14/2015 Go
Simple (concurrent) program
packagemain
import(
"fmt"
"sync"
)
constnumIters=10
funcprintHello(iterNumint,wg*sync.WaitGroup){
deferwg.Done()
fmt.Printf("HiGophers!(#%d)n",iterNum+1)
}
funcmain(){
varwgsync.WaitGroup
fori:=0;i<numIters;i++{
wg.Add(1)
goprintHello(i,&wg)
}
wg.Wait()
} Run

5/14/2015 Go
Concurrency
It's built into the language. I believe this is the #1 most powerful feature of Go.
You define concurrent units of execution inside goroutines (concurrently executing
functions)
Goroutines can communicate & synchronize using channels
You write your programs as if they do blocking I/O
Applications use all cores

5/14/2015 Go
Concurrency details
Goroutines have dynamically sized stacks
Runtime multiplexes your Goroutines onto threads
Runtime automatically context switches for you on I/O, etc...

5/14/2015 Go
The current state of Go
Real Go programs are in production at Google, Square, The New York Times, Github,
Digital Ocean, Iron.io and many more.
Active & growing community
Core team focuses mostly on perf & tools
Very few new lang features
"The Go Way"

5/14/2015 Go
My predictions
Go's usage will steadily grow
More high profile open source projects will be written in Go
Go will be the best language for cloud computing environments
Go will be the default stack for many new software businesses
Other programing languages will need to improve to:
Keep pace with growing cloud computing requirements
Compete with Go

5/14/2015 Go
Evidence
I will present evidence for the following:
Why Go's adoption will grow
Why Go is the right choice for large scale applications today

5/14/2015 Go
Adoption
Why the Go developer base will grow.

5/14/2015 Go
1. Buzz
Before a programmer chooses Go, he/she will probably hear about it primarily via blog
posts, articles or word-of-mouth (conferences, meetups, friends).
Many developers of all experience levels are writing and reading about Go today.

5/14/2015 Go
1.1. Example
Travis Reeder, co-founder of Iron.io posted about his experience replacing existing
software with Go.
blog.iron.io/2013/03/how-we-went-from-30-servers-to-2-go.html(http://blog.iron.io/2013/03/how-we-went-
from-30-servers-to-2-go.html)
To date, it is one of Iron's most popular blog posts. It generated a large discussion on
Hacker News.
news.ycombinator.com/item?id=5365096(https://news.ycombinator.com/item?id=5365096)
Similarly, there is significant, growing interest (and debate) around Go in the
community at large.

5/14/2015 Go
2. First line of code
Anybody can try Go by going to play.golang.org(http://play.golang.org).
There are no other requisite steps to execute Go code.

5/14/2015 Go
3. Installing Go
Setup for non-trivial development requires the following steps:
Create and setup your GOPATH
Download the go binary to your executable path
This process is by far the simplest I have encountered across any language. Go makes
an excellent first impression.

5/14/2015 Go
4. Toolchain
The toolchain is encapsulated in a single binary. That binary contains all of the tools a
first time Go programmer will need to start building and running programs.
It scales to large codebases too. I generally use only 1 additional tool in my everyday
development.

5/14/2015 Go
5. Dev/test workflow
The language and compiler were designed to compile code quickly and they deliver.
Fast compilation enables an efficient local edit/test workflow
Fast compilation enables significant developer efficiency advantages
Additionally, build/test/deploy pipelines can complete their tasks significantly faster

5/14/2015 Go
6. Everyday development
Go enables developers to write better code faster.
The language is simple (25 keywords) but powerful. Developers focus more on
semantics, less on syntax
Documentation is accessible, centralized and well organized. See godoc.org(http://godoc.org)
Industrial grade static checking is built into the standard toolchain
Go programs are statically linked. Developers run their programs locally with no
external dependencies

5/14/2015 Go
7. Extensibility
The Go toolchain's feature set will grow primarily because the language is so simple
and powerful.
For example:
There's a Go parser built into the standard library. Developers in the community have
used this feature to quickly build high quality code generation tools, new static
checkers, etc...

5/14/2015 Go
8. Packaging
Go includes a simple packaging scheme:
The toolchain installs a dependency by downloading the code and compiling it into
your program
Packages can be hosted on major source code repositories or any server that
follows a simple HTTP request protocol
Go packaging is criticized a lot. The community has built many tools to make it more
robust, but its simplicity enables an extremely low friction release process.

5/14/2015 Go
Suitability for cloud & microservices environments
Why Go is here to stay.

5/14/2015 Go
1. Deployment
The following key features make Go programs very easy to deploy in multiple
scenarios
The Go compiler statically links its output binaries
Go binaries require no runtime/interpreter on the target. All necessary runtime
components are compiled into the binary
The Go toolchain can cross compile programs. A developer on a Mac OS X machine
can compile for a Linux target platform, for example

5/14/2015 Go
1.1. Deploying a web application
Statically linked binaries with no external dependencies (except libc if linux target) are
much easier to deploy than dynamically linked binaries or JVM applications.
Engineers won't choose Go for this feature, but they appreciate it after they do.

5/14/2015 Go
1.2. Deploying a CLI application
Some developers are beginning to use Go for CLI applications as well. Cross compiling
and static linking are both extremely important in this scenario.
Go allows CLI developers to ship a single binary without writing detailed install
instructions or worrying about dependencies on the user's machine.

5/14/2015 Go
2. Concurrency & I/O
Modern web and CLI applications alike often need to do complex I/O.
Web apps, for example, often need to interact with multiple 3rd party APIs which may
fail independently.
Go has concurrency & I/O features that enable robust applications:
Runtime-managed goroutines
Built in, typed channels for cross-goroutine communication and synchronization
select statements for doing complex operations on multiple goroutines
ability to timeout on a channel send or recv
automatic context switching on I/O syscalls
make it work, make it right, make it fast

5/14/2015 Go
2.1. Concurrency example - access a shared external resource
packagemain
import"math/rand"
funcmain(){
sigs:=make([]chanint,10)
fori:=0;i<10;i++{
sigs[i]=make(chanint)
gofunc(nint,sigchanint){
for{
<-sig
sig<-n+rand.Int()
}
}(i,sigs[i])
}
fori:=0;i<100;i++{
sigs[i%10]<-0
println("gotresourceresult",<-sigs[i%10])
}
} Run

5/14/2015 Go
2.2. Concurrency example - timeout
packagemain
import(
"fmt"
"time"
)
funcmain(){
ch:=make(chanstring)
gofunc(){
time.Sleep(1*time.Second)
ch<-"goroutine1"
}()
select{
casestr:=<-ch:
fmt.Println("gotstring",str)
case<-time.After(100*time.Millisecond):
fmt.Println("timedoutongoroutine1")
}
} Run

5/14/2015 Go
2.3. That was just a single I/O
Didn't cover
Concurrent CPU utilization
(De)multiplexing I/O
Fan-in / fan-out & pipelines
Long Tail Patterns (e.g. first one wins)
...

5/14/2015 Go
In summary
Go is a new, exciting and growing language
It's very mature for its age
Today it's being adopted primarily in systems niches
It will expand to be the de facto standard for web scale applications

5/14/2015 Go
Challenge to new Gophers
Go to http://bit.ly/1Et4O7x(http://bit.ly/1B09b3F)
Write your solution at play.golang.org(http://play.golang.org)
Click "Share" at the top and send the link to arschles@gmail.com
I will respond with feedback and we can discuss

5/14/2015 Go
Existing Gophers
Send me a code snippet (arschles@gmail.com) of the most complex concurrent Go
code you've seen.
I want to discuss how you'd make it better.

5/14/2015 Go
Companies using Go
Iron.io(http://iron.io/)
CoreOS(https://coreos.com/)
InfluxDB(http://influxdb.com/)
Docker(https://www.docker.com/)
Hashicorp(https://hashicorp.com/)
Walmart Labs(http://walmartlabs.com)
Cloudflare(http://cloudflare.com)
Google(http://google.com)(of course)

5/14/2015 Go
Major open source projects written in Go
NSQ(https://github.com/bitly/nsq)
Kubernetes(https://github.com/GoogleCloudPlatform/kubernetes)
Terraform(https://github.com/hashicorp/terraform)
Packer(https://github.com/mitchellh/packer)
Docker(https://github.com/docker/docker)
Vulcand(https://github.com/mailgun/vulcand)

5/14/2015 Go
Thank you
Aaron Schlesinger
Sr. Engineer, Iron.io
arschles@gmail.com(mailto:arschles@gmail.com)
http://github.com/arschles(http://github.com/arschles)
http://iron.io(http://iron.io)
@arschles(http://twitter.com/arschles)

5/14/2015 Go

Why you should care about Go (Golang)

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Why you should care about Go (Golang) (20)

Recently uploaded (20)

Why you should care about Go (Golang)