This document summarizes a presentation given by Luka Zakrajšek on using the Go programming language for Rubyists. Some key points: - Go is a new programming language from Google that is statically-typed, compiled, and has built-in concurrency features like goroutines and channels. - Go offers benefits for Rubyists like easy and cheap concurrency to take advantage of multiple CPUs, low memory overhead, and easy deployment with single binary executables. - Popular Go web frameworks like Martini and Revel were presented that are similar to Ruby frameworks like Sinatra and Rails respectively. - Core Go concepts like packages, imports, functions, variables, types, interfaces,

1. GO FOR RUBYISTS?
Luka Zakrajšek
CTO @ Koofr
@bancek
Slovenia Ruby User Group, January Meetup
January 29, 2015

2. ABOUT ME
FRI graduate
CTO and cofounder at Koofr
Python developer in previous life
now mostly Scala, Go and JavaScript

3. GO @ KOOFR
Koofr is white-label cloud storage solution for ISPs
backend
content server (downloads, uploads, streaming ...)
FTP server
...
desktop application
GUI application
sync
remote filesystem access

4. WHAT IS GO
new programming language from Google
low level
C-like syntax
fast compilation (for large codebases)
compiles to single binary
cross platform (Windows, Linux, Mac)

5. WHAT IS GO
statically-typed
managed memory (garbage collection)
type safety
dynamic-typing capabilities
built-in types (variable-length arrays and key-value maps)
large standard library

6. GO IS C
#include<stdio.h>
main()
{
printf("HelloWorldn");
return0;
}
packagemain
import"fmt"
funcmain(){
fmt.Println("HelloWorld")
}

7. GO IS PYTHON
importre
importos
importImage
importcsv
importjson
importgzip
importurllib
importunittest
import(
"regexp"
"os.exec"
"image/jpeg"
"encoding/csv"
"encoding/json"
"compress/gzip"
"net/http"
"testing"
)
import"github.com/koofr/go-koofrclient"

8. GO IS NODE.JS
varhttp=require('http');
http.createServer(function(req,res){
res.writeHead(200);
res.end('HelloWorld');
}).listen(1337,'127.0.0.1');
console.log('Serverrunningathttp://127.0.0.1:1337/');
packagemain
import(
"fmt"
"net/http"
)
funcmain(){
http.HandleFunc("/",func(whttp.ResponseWriter,r*http.Request){
fmt.Fprintf(w,"HelloWorld")
})
http.ListenAndServe(":1337",nil)
fmt.Println("Serverrunningathttp://127.0.0.1:1337/");
}

9. GO FOR RUBYISTS

10. EASY AND CHEAP CONCURRENCY
easy to have dozens (or even thousands) of concurrent
operations
it will even take advantage of all the CPUs available
Ruby has threads, but there is GIL in Ruby MRI
Ruby has green threads, but will use single CPU

11. LOW MEMORY OVERHEAD
Go programs can be compiled to a few megabytes binary
memory efficient while harvesting the power of the entire
machine

12. EASY DEPLOYMENT
Go programs are compiled in a few seconds into small
executables
no dependencies in production

13. USE GO FROM RUBY
Go:
packagemain
import"fmt"
import"encoding/json"
funcmain(){
mapD:=map[string]int{"apple":5,"lettuce":7}
mapB,_:=json.Marshal(mapD)
fmt.Println(string(mapB))
}
Ruby:
JSON.parse(`gorunjson.go`)
#=>{"apple"=>5,"lettuce"=>7}
https://antoine.finkelstein.fr/go-in-ruby/

14. BASIC CONSTRUCTS

15. PACKAGES
libraries structured in packages
programs start running in package main

16. IMPORTS
local imports (GOPATH env. variable)
import directly from web (http, git, mercurial)
capitalized identifiers are exported
import(
"fmt"
"github.com/koofr/go-koofrclient"
)

17. FUNCTIONS
take zero or more arguments
a function can return any number of results.
types come after variable names
named return values
funcmyfunction(x,yint)(xint,yint){
tmp:=x
x=y
y=tmp
return
//returny,x
}

18. VARIABLES
var statement declares a list of variables
type comes after name
varc,python,javabool
funcmain(){
variint
fmt.Println(i,c,python,java)
}
short variable declarations
funcmain(){
variint=1
k:=3//typeinference
}

19. BASIC TYPES
bool
string
int, uint, int8, uint, int16, uint16, int32, uint32, int64, uint64,
uintptr
byte // alias for uint8
rune // alias for int32, represents a Unicode code point
float32, float64
complex64, complex128

20. OTHER CONSTRUCTS
pointers
structs
arrays
slices
maps

21. INTERFACES
typeReaderinterface{
Read(p[]byte)(nint,errerror)
}

22. INTERFACES
typeSizeReaderstruct{
rio.Reader
sizeint64
}
func(sr*SizeReader)Read(p[]byte)(nint,errerror){
n,err=sr.r.Read(p)
sr.size+=int64(n)
return
}
funcconsumeReader(rio.Reader){
//...
}
funcmain(){
varsr*SizeReader=&SizeReader{myFile,0}
consumeReader(sr)
fmt.Println(sr.size)
}

23. GOROUTINES AND CHANNELS
funcdoSomethingExpensive()int{
time.Sleep(10*time.Second)
return42
}
funcdoItAsync(){
godoSomethingExpensive()
}
funcdoItAsyncAndGetResult()<-chanint{
ch:=make(chanint,1)
gofunc(){
ch<-doSomethingExpensive()
}()
returnch
}

24. ERROR HANDLING
funccopyFile(srcstring,deststring)(i64,error){
r,err:=os.Open(src)
iferr!=nil{
returnerr
}
deferr.Close()
w,err:=os.Create(dest)
iferr!=nil{
returnerr
}
deferw.Close()
bytesCopied,err=io.Copy(w,r)
returnbytesCopied,err
}

25. GO COMMAND
//fetchdependencies
goget
//runtests
gotest
//buildbinary
gobuild
//formatcode
gofmt
//checkforerrorsincode
govet

26. CODE STRUCTURE

27. LIBRARY STRUCTURE
.gitignore
LICENSE
README.md
cache.go
cache_test.go

28. APPLICATION STRUCTURE
src/
github.com/
koofr/
go-ioutils
myapp/
internallib/
lib.go
main/
main.go
config.go
myapp.go
bin/
myapp
pkg/
build/
dist/

29. TESTING
packagenewmath
import"testing"
funcTestSqrt(t*testing.T){
constin,out=4,2
ifx:=Sqrt(in);x!=out{
t.Errorf("Sqrt(%v)=%v,want%v",in,x,out)
}
}
$gotest
ok github.com/user/newmath0.165s

30. DEPLOYMENT
gobuild-obin/myappsrc/myapp/main/main.go
scpbin/myappmyserver.com:myapp
sshmyserver.com'supervisorctlrestartmyapp'

31. WEB FRAMEWORKS

32. MARTINI
Classy web framework for Go
similar to Sinatra

33. FEATURES
Flexible Routing
VeryflexibleandextremelyDRY.Nameparameters,stackhandlers,
injectthedependencies.
Comprehensive
Comeswithagreatsetofstockmiddleware:
Logging,Recovery,Staticfileserving,Authentication,Routingandmore!
Reuse Existing Code
FullycompatiblewithGo'shttp.HandlerFuncinterface.
LeveragethemanyawesomeopensourcewebpackagesbuiltinGo

34. MARTINI EXAMPLE
packagemain
import"github.com/go-martini/martini"
funcmain(){
m:=martini.Classic()
m.Get("/",func()string{
return"Helloworld!"
})
m.Get("/hello/:name",func(paramsmartini.Params)string{
return"Hello"+params["name"]
})
m.Run()
}

35. REVEL
A high-productivity web framework for the Go language.
similar to Rails

36. FEATURES
Hot Code Reload
Edit,save,andrefresh.
Comprehensive
routing,parameterparsing,validation,session/flash,
templating,caching,jobrunning,atestingframework,internationalization...
High Performance
BuiltontopoftheGoHTTPserver,threetotentimesasmanyrequestsasRails

37. FRAMEWORK DESIGN
Synchronous
TheGoHTTPserverrunseachrequestinitsowngoroutine.
Writesimplecallback-freecodewithoutguilt.
Stateless
Providesprimitivesthatkeepthewebtierstatelessforpredictablescaling.
Sessiondatainstoredcookies,cachebackedbyamemcachedcluster.
Modular
Composablemiddlewarecalledfilters,whichimplementnearlyall
request-processingfunctionality

38. REVEL PROJECT STRUCTURE
myapp Approot
app Appsources
controllers Appcontrollers
init.go Interceptorregistration
models Appdomainmodels
routes Reverseroutes(generatedcode)
views Templates
tests Testsuites
conf Configurationfiles
app.conf Mainconfigurationfile
routes Routesdefinition
messages Messagefiles
public Publicassets
css CSSfiles
js Javascriptfiles
images Imagefiles

39. QUESTIONS?