This presentation tries to introduce people that are familiar to ruby with Go.

1. Go for Rubysts
Thiago Pradi
RubyConf Argentina - 2013

2. whoami
•
Thiago Pradi
•
Brazilian!
•
Software Developer @ JobScore
•
Bachelor of Computer Science @ FURB
•
Octopus author / maintainer

3. Thiago was a happy
Ruby developer...

5. that wanted to learn
something new!

6. Why not a new
language? ...
... Maybe Go!

7. Google trends - Golang

8. What is Go?

9. Go
•
Initially developed at Google
•
Created by Ken Thompson (Unix), Rob Pike
(Plan 9), and Russ Cox (libtask)
•
Development started in 2007
•
First release in 2009 (Fairly new!)

10. Go is an open source
programming environment
that makes it easy to build
simple, reliable, and
efficient software.
Source: golang.org

11. Features
•
New
•
Concurrent
•
Compiled
•
Garbaged-collected
•
Simple & Fun!

12. Language focus
•
System programming
•
Networked / multi-core
•
Fast
•
Compatible with C
•
Best of static typed language and dynamic
languages

13. Basic Concepts

14. package main
import "fmt"
func main() {
fmt.Println("Hello World")
}

15. C-Like Syntax
func main() {
fmt.Printf("Animal with name %s and age %d",
"Anaconda", 32)
}

16. Compiled language

17. Typesystem

18. Strong types
func main() {
var str string
var value int
str = "abc"
value = 123
str + value
}

19. Static Typed
// types.go
func main() {
var a string
a = 123
}

20. with dynamic casting
package main
import ( "fmt" )
func main() {
a := 123
fmt.Printf("Value of a: %d", a)
}

21. User defined types
package main;
type Animal struct {
Name string
Age int
}
func main() {
var anaconda Animal
}

22. Compiler
•
Uses GCC as back end
•
Checks for unused packages and variables
•
Checks types and return values

23. Go tools
•
go fmt -> format your source code (cool!)
•
go get -> manage and install your
dependencies
•
go build / run -> compile and run your
program
•
go test -> run your tests

24. Organizing code
package string_processing;
func Process(str string) {
// Code code code
}
package main
import "string_processing"
func main() {
string_processing.Process("foobar")
}

25. Workspace
•
The default way to organize code in Go
•
Build to work with OpenSource repositories
•
Directories src, bin and pkg

27. Encoding
•
Source code: UTF-8
•
Strings: UTF-8

28. Comparing it to Ruby..

29. Disclaimer

30. Object Orientation
•
Ruby uses classes / methods
•
Golang uses Interfaces, adding methods to
data structures.

31. Objects in Ruby
•
Ruby Object model
•
Module / Class with methods
•
Support for inheritance and composition
•
Everything is an object

32. class Animal
attr_accessor :name
def initialize(name)
self.name = name
end
def say_something
puts "HEY HEY"
end
end
!
a = Animal.new("Duck")
a.say_something

33. Objects in Go
•
No inheritance
•
Data types to define content
•
Methods define the operations
•
Interfaces define the behavior of the
“object” (data type)

34. package main
import "fmt"
type Animal struct {
Name string
}
!
func (a *Animal) SaySomething() {
fmt.Println("HEY HEY")
}
!
func main() {
a := new(Animal)
a.Name = "Duck"
a.SaySomething()
}

35. Error Handling
•
Ruby uses Exceptions, with begin / rescue /
ensure
•
Golang use return values with error code (!!!)

36. Error handling - Ruby
•
Errors inherit from Exception class
•
Flow control with begin / rescue / ensure
•
Don’t need to treat every exception

37. file = File.open("/tmp/mel.txt", "w")
!
begin
# does some file processing
rescue
puts "Failed to process"
ensure
file.close
end

38. Error Handling - Go
•
No exceptions
•
Errors should implement “Error” interface
•
Erros should be returned as additional value
•
Every error should be treated (unless you want
to do a “Gambiarra”)

39. Off-topic: Gambiarra

40. func main() {
fmt.Println("Starting MEL server")
!
listener, err := net.Listen("tcp",
"0.0.0.0:2653")
!
if err != nil {
fmt.Println("Error starting the server")
os.Exit(1)
}
}

41. defer / panic / recover
•
Defer is compared to “ensure” in ruby
•
Panic / recover are similar to exception, but
only should be used for internal APIs, never
for external APIs.
•
Panic is used for runtime errors, like array out
of bound

42. func EchoFunction(connection net.Conn, ss
*command_parser.ServerStorage) {
defer connection.Close()
!
buf := make([]byte, 1024)
n, err := connection.Read(buf)
// Heavy logic
}

43. func main() {
PanicFunction()
fmt.Println("This will not be printed")
}
!
func PanicFunction() {
defer func() {
fmt.Println("Called defer function")
}()
panic("PANIC PANIC PANIC")
fmt.Println("This will not be printed")
}

44. func main() {
PanicFunction()
fmt.Println("This will be printed")
}
!
func PanicFunction() {
defer func() {
if e := recover(); e != nil {
fmt.Printf("Recovered from %s n", e)
}
}()
panic("PANIC PANIC PANIC")
fmt.Println("This will not be printed")
}

45. Concurrency
•
Ruby -> Threads / Fibers / EventPool / Actors
•
Go -> Goroutines

46. Concurrency - Ruby
•
Threads (with shared memory)
•
Fibers
•
EventMachine (Event loop / Reactor pattern)
•
Celluloid (Actor based)

47. require 'net/http'
!
content = []
!
thread = Thread.new do
uri = URI("http://triremi.com/")
content << Net::HTTP.get(uri)
end
!
thread.join

48. Concurrency - Go
•
Goroutines!
•
Lightweight thread implementation
•
Communications between goroutines using
channels
•
Managed by the Go Scheduler
•
Mapped to a few different OS processes

49. for {
connection, err := listener.Accept()
!
if err != nil {
fmt.Println("Error accepting the
socket")
os.Exit(2)
}
!
EchoFunction(connection, ss)
}

50. for {
connection, err := listener.Accept()
!
if err != nil {
fmt.Println("Error accepting the
socket")
os.Exit(2)
}
!
go EchoFunction(connection, ss)
}

51. import "fmt"
!
func main() {
messages := make(chan string)
!
go PingFunction(messages)
!
msg := <-messages
!
fmt.Println(msg)
}
!
func PingFunction(messages chan string) {
messages <- "ping"
}

52. // Make the channel with the number of
connections
channels := make(chan ChannelResult,
number_of_connections)
!
// Start the request in a new goroutine
go makeRequest(address, start_byte, end_byte,
out, channels)
!
//Wait for the result of the goroutine in the
channel
for(loop_var < number_of_connections) {
chan_res := <-channels
// Process the result and save to the file
}

53. Testing
•
Ruby has a built in framework (Test::Unit) and
a lot of alternatives
•
Go also has a default framework for testing,
and some early-stages alternatives

54. Testing in Ruby
•
Lots of frameworks: Test::Unit, rspec, MiniTest,
Bacon…
•
Frameworks with lots of assertions and predefined macros
•
Easy to describe behavior (BDD)
•
Everyone tests.. (RIGHT?)

55. require "spec_helper"
!
describe Octopus::Model do
describe "#using method" do
it "should return self" do
User.using(:canada).should
be_a(Octopus::ScopeProxy)
end
end
end

56. Testing in Go
•
Light framework with the language, with a few
new options
•
Don’t come with assertions / macros
•
Tests have the same package as the
application code
•
Tests stay in the same directory of the
application code

57. package command_parser;
!
import ( “testing" )
!
func Test_parseSetCommand (t *testing.T) {
ss := new(ServerStorage)
!
str := ss.ParseCommand("SET thiagopradi
valor")
!
if ss.Dict["thiagopradi"] != "valor" {
t.Error("failed to set thiagopradi key")
}
}
}

58. But, what about some
real use cases?

59. Companies
•
Google (dl.google.com, youtube)
•
SoundCloud
•
Heroku
•
CloudFlare
•
Ubuntu

60. Open Source
•
https://github.com/youtube/vitess - Process
and tools for scaling MySQL
•
https://github.com/dotcloud/docker - Open
Source application container engine
•
https://github.com/burke/zeus - Rails
preloader

61. Mine
•
YADM - Yet another download manager
(https://github.com/tchandy/yadm)
•
Brainfuck compiler (https://github.com/
tchandy/bf_compiler_go)
•
Mel - key-value database (https://github.com/
tchandy/mel)

62. Wrapping up…
•
Cool language
•
Concurrent and networked
•
Benefits from both dynamic and static
languages
•
Modern
•
Give it a try!

63. One more thing..

64. GOLang!

65. GOLang!

66. Thank you!
•
www.thiagopradi.net
•
twitter.com/thiagopradi
•
thiago.pradi@gmail.com