RubyConf Portugal 2014 - Why ruby must go!

Why Ruby Must Go!
What can Ruby incorporate from Go?
What is Programmer Awareness?
As a Rubyist, what does Go teach me?

@gautamrege
@joshsoftware
!
@rubyconfindia

Programming Paradigms
Imperative
Declarative
Procedural
Functional
Object Oriented
Symbolic

Imperative
Declarative
Procedural
Functional
Object Oriented
Symbolic
C++!
Java!
Python!
Ruby
Order of execution / steps One or more subroutines

Imperative
Declarative
Procedural
Functional
Object Oriented
Symbolic
Pascal!
FORTRAN!
C

Imperative
Declarative
Procedural
Functional
Object Oriented
Symbolic
Pascal!
FORTRAN!
C!
Go

Go Lang C on Steroids
• No more memory leaks. (Garbage collection)

• No more pointer de-referencing. (-> or . )

• Support for maps, slices and channels.

• Support for closures.

• Support for closures.
• Concurrency: closures, channels & go-routines.

Go is different !
• No exceptions, only errors.

Go is different !
• Return multiple values from functions

Go is different !
• Interfaces but no classes (only structs)

Go is different !
• Interfaces but no classes (only structs)
• No inheritance but embedded structs

Let’s get Going
And learn Go along the way!

Duck Typing in Ruby
Programming convenience.!
Implicit Type Conversions.!
No complex Type Inference

Duck Typing in Ruby
Don’t fight the Type System

Duck Typing in Ruby
Don’t fight the Type System
Code First - Resolve Issues Later

Problems with Duck Typing
No Early Warning System!
Reactive programming!
Compiler Time checks!

Type Inference

Type Inference
Code Once Correctly

Types? Who cares?
We’re !
Rubyists!

Type Checks in Ruby!
def convert_hashes_to_parameters(key, value, assign_if_converted=true)!
converted = convert_value_to_parameters(value)!
#...!
end!
!
def convert_value_to_parameters(value)!
if value.is_a?(Array) && !converted_arrays.member?(value)!
#...!
converted_arrays << converted!
converted!
elsif value.is_a?(Parameters) || !value.is_a?(Hash)!
#...!
end!
end

#...!
end!
!
#...!
converted!
#...!
end!
end
def permit!!
each_pair do |key, value|!
value = convert_hashes_to_parameters(key, value)!
#...!
end

#...!
end!
!
#...!
converted!
#...!
end!
end
def permit!!
each_pair do |key, value|!
value = convert_hashes_to_parameters(key, value)!
#...!
end
Strong Parameters!

To Duck or to Type
Best of Both worlds

To Duck or to Type
Light weight 1-level Type check

To Duck or to Type
type point int
!
func main() {
var i int = 2
var j point = 2
!
i == j
}

To Duck or to Type
type point int
!
func main() {
var i int = 2
var j point = 2
Variable name first, then the type
!
i == j
}

To Duck or to Type
type point int
!
func main() {
var i int = 2
var j point = 2
!
i == j
}
Error: invalid operation: i == j
(mismatched types int and point)

Ruby re-defines Object
Oriented Concepts,
Go re-defines
programming itself!
“
”

Programmer Awareness
%QORKNGT

%QORKNGT
4GXKGYGT

%QORKNGT
4GXKGYGT
(TCOGYQTM

%QORKNGT
4GXKGYGT
(TCOGYQTM
.CPIWCIG

Variable declaration and assignment

y
y

y := 2 // y is of type int!
y = "3"
Implicit declaration

y = "3"
Assignment

y = "3"
COMPLIER ERROR!
cannot use “3” (type string) as type int in
assignment

Programmer ERROR?
y = "3"
As a programmer, we probably re-assigned
“y” to a String by mistake!

Programmer AWARENESS
y, _ = strconv.Atoi("3")
There’s always a right way to do things!

!
Eh… what?
https://flic.kr/p/mnZgQw

Variable Re-declaration
import "os"!
!
func main() {!
! f, err := os.Open("somefile")!
! // handle error!
!
! d, err := f.Stat()!
}

import "os"!
!
func main() {!
! // handle error!
!
}
import packages

import "os"!
!
func main() {!
! // handle error!
!
}
Exported function

import "os"!
!
func main() {!
! // handle error!
!
}
I’m practical. You
can re-declare err in your
code!*
* Conditions apply

import "os"!
!
func main() {!
! // handle error!
!
}

import "os"!
!
func main() {!
! // handle error!
!
! f, err := f.Stat()!
}

import "os"!
Error: no new
!
variables on left
func main() {!
side of :=
! // handle error!
!
! f, err := f.Stat()!
} Hmm.. I think you re-used
the variable f by
mistake!

import "os"!
!
func main() {!
! // handle error!
!
! f, err = f.Open("other file")!
}
Re-assign !
explicitly.. 

With Great Power Comes
Great Responsibility

Lets Go a little more!
type Layout struct {!
! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
! Dimensions [2]float32!
}!
!
type Hotel struct {!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
! fmt.Println(hotel.Dimensions)!
!
! h := make(map[string]Hotel)!
!
! for name, _ := range h {!
! ! fmt.Println(name)!
! }!
}
Type Declaration

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
!
!
! }!
}
Exported Array

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
!
!
! }!
}
Exported Array
The size in Array is part of the type!
[2]float32 != [3]float32

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
!
!
! }!
}
Embedding!
(Not inheritance)

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
!
!
! }!
}
hotel.Dimensions and not
hotel.Hall.Dimensions

func main() {!
! hotel := Hotel{}!
! fmt.Println(hotel.Name)!
!
!
! }!
}
! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
Dimensions)!

func main() {!
! hotel := Hotel{}!
!
!
! }!
}
! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
!
!
! }!
}

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
!
!
! }!
}
Which Name should
I use?
Error: Ambiguous
selector hotel.Name!

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
! fmt.Println(hotel.Name)Hall.!
Name)!
!
!
! }!
}

! Name string!
Capacity int!
}!
!
type Hall struct {!
! Name string!
}!
!
! Location string!
! Hall!
! Layout!
}
func main() {!
! hotel := Hotel{}!
! fmt.Println(hotel.Hall.Name)!
!
!
! }!
}

Modules in Ruby
module Layout!
def manager!
p "Layout Manager"!
end!
end!
!
module Hall!
def manager!
p "Hall Manager"!
end!
end!
!
class Hotel!
include Layout!
include Hall!
end
def main!
hotel = Hotel.new!
p hotel.manager!
end

Modules in Ruby
module Layout!
def manager!
p "Layout Manager"!
end!
end!
!
module Hall!
def manager!
p "Hall Manager"!
end!
end!
!
class Hotel!
include Layout!
include Hall!
end
def main!
hotel = Hotel.new!
p hotel.manager!
end
Which language is
this dude?

Include modules
in order!
https://flic.kr/p/e7SnAa

Iterating a Hash
hotels := make(map[string]Hotel)!
!
for name, _ := range hotels {!
! fmt.Println(name)!
}

Iterating a Hash
!
}
Map of strings and Hotels

Iterating a Hash
!
}
Easy iteration syntax!

Iterating a Hash
!
} Blank Identifier - ignore value

Iterating a Hash
!
}
Bad practice! !
I’ll randomise the
order!

Pushing some
Goodies into Ruby
https://flic.kr/p/awu6ZA

Defer
mu sync.Mutex!
!
func foo() {!
mu.Lock()!
defer mu.unLock()!
// do something...!
}

Defer
func trace(s string) { fmt.Println("entering:", s) }!
func untrace(s string) { fmt.Println("leaving:", s) }!
!
func a() {!
trace("a")!
defer untrace("a")!
// do something....!
}

Concurrency
Parallelism
Multi-core Processing

Example - Relay Race
• 4 legs of the race
• Each leg does processing concurrently.
• Completion should be in order. (pass the baton)

Concurrent Example
Leg 1
Leg 2
Leg 3
Leg 4

Concurrent Processing
Leg
1
Leg
2
Leg
3 Leg
4
CPU churn - CPU time
consuming operation.

Completion Order
Leg 1
Leg 2
Leg 3
Leg 4

CSP!
Communicating Sequential
Processes
https://flic.kr/p/6MwYFo https://flic.kr/p/awu6ZA

CSP!
Communicating Sequential
Processes
since 1978 !!
https://flic.kr/p/6MwYFo

package main
!
import (
"fmt"
"runtime"
"sync"
)
!
var wg sync.WaitGroup
!
/*
* Each go-routine sleeps at random(1-5) seconds.
* This is simulating long working process
* Then we finish in order
*/
func check_baton(leg int, baton chan int) {
for value := range baton {
switch value {
case leg:
// pass the baton
fmt.Println("Finished leg ", leg)
if leg == 4 {
close(baton)
} else {
baton <- leg + 1

Channels in action
p!ackage main import (
"fmt"
"runtime"
"sync"
)! v!ar wg sync.WaitGroup /*
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
}! func run(leg int, baton chan int) {
! defer wg.Done()
fmt.Printf("Leg %d.. churningn", leg) // Massive CPU churn
for count := 0; count < 300; count++ {
for char := 0; char < 30000; char++ {
fmt.Printf("")
}
! }
fmt.Printf("Leg %d.. churned, waiting to exitn", leg) ! check_baton(leg, baton)
}! func main() {
runtime.GOMAXPROCS(4) ! baton := make(chan int)
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
} ! // start the race
baton <- 1 // wait for relay to finish
wg.Wait()
}

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func main() {
runtime.GOMAXPROCS(4)
!
baton := make(chan int)
wg.Add(4)
!
for i := 1; i < 5; i++ {!
go run(i, baton)!
}!
!
! ! ! // start the race!
baton <- 1!
!
// wait for relay to finish!
wg.Wait()!
}

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func main() {
!
wg.Add(4)
!
for i := 1; i < 5; i++ {!
go run(i, baton)!
}!
!
baton <- 1!
!
wg.Wait()!
}
A channel that accepts an int

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func main() {
!
wg.Add(4)
!
for i := 1; i < 5; i++ {!
go run(i, baton)!
}!
!
baton <- 1!
!
wg.Wait()!
}
Go Routine

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func main() {
!
wg.Add(4)
!
for i := 1; i < 5; i++ {!
go run(i, baton)!
}!
!
baton <- 1!
!
wg.Wait()!
}
Writing to a channel

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func main() {
!
wg.Add(4)
!
for i := 1; i < 5; i++ {!
go run(i, baton)!
}!
!
baton <- 1!
!
wg.Wait()!
}
A WaitGroup - wait
for 4 events!

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func run(leg int, baton chan int) {
defer wg.Done()
fmt.Printf("Leg %d.. churningn", leg)
!
! ! // Massive CPU churn!
! ! for count := 0; count < 300; count++ {!
! ! ! for char := 0; char < 30000; char++ {! ! ! ! fmt.Printf("")!
! ! ! }!
! ! }!
fmt.Printf("Leg %d.. churned, waiting to !
! ! check_baton(leg, baton)!
}

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func run(leg int, baton chan int) {
defer wg.Done()
fmt.Printf("Leg %d.. churningn", leg)
Done for WaitGroup
!
! ! // Massive CPU churn!
! ! for count := 0; count < 300; count++ {!
! ! ! for char := 0; char < 30000; char++ {! ! ! ! fmt.Printf("")!
! ! ! }!
! ! }!
fmt.Printf("Leg %d.. churned, waiting to !
! ! check_baton(leg, baton)!
}

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func check_baton(leg int, baton chan int) {!
! ! for value := range baton {!
! ! ! switch value {!
! ! ! ! case leg:!
! ! ! ! ! // pass the baton!
! ! ! ! ! fmt.Println("Finished leg ", leg)!
! ! ! ! ! if leg == 4 {!
! ! ! ! ! ! close(baton)!
! ! ! ! ! } else {!
! ! ! ! ! ! ! baton <- leg + 1!
! ! ! ! ! }!
! ! ! ! ! return!
! ! ! ! default:!
! ! ! ! ! // ignore!
! ! ! ! ! baton <- value!
! ! ! }!
! ! }!
}

Channels in action
"fmt"
"runtime"
"sync"
*/
switch value {
case leg:
// pass the baton
if leg == 4 {
close(baton)
} else {
baton <- leg + 1
}
return
default:
// ignore
baton <- value
}
}
! defer wg.Done()
fmt.Printf("")
}
! }
}! func main() {
wg.Add(4) for i := 1; i < 5; i++ {
! go run(i, baton)
wg.Wait()
}
func check_baton(leg int, baton chan int) {!
! ! for value := range baton {!
! ! ! switch value {!
! ! ! ! case leg:Read !
or block on a
! ! ! ! ! // pass the channel
baton!
! ! ! ! ! fmt.Println("Finished leg ", leg)!
! ! ! ! ! if leg == 4 {!
! ! ! ! ! ! close(baton)!
! ! ! ! ! } else {!
! ! ! ! ! ! ! baton <- leg + 1!
! ! ! ! ! }!
! ! ! ! ! return!
! ! ! ! default:!
! ! ! ! ! // ignore!
! ! ! ! ! baton <- value!
! ! ! }!
! ! }!
}

The Big Fight
https://flic.kr/p/9AeqD2

Generics?
Convenient
Too early still.
interface{}

Keywords!
Nah.. no rules,
rules!
You need’em
bro

GIL

Compiled
language
FTW

Extending & Embedding
Yeah
Nope. !
Only Cgo

Tooling
gem
bundler
go tools

Emergency Instructions !
OR !
Lecture In Aerodynamics

Traction Control!
Fuel Efficiency!
Aerodynamics!
Tyre Temperature

“ Ruby is for developers
Go is for programmers
”
@gautamrege
@joshsoftware

RubyConf Portugal 2014 - Why ruby must go!

More Related Content

What's hot

Similar to RubyConf Portugal 2014 - Why ruby must go!

More from Gautam Rege

Recently uploaded

RubyConf Portugal 2014 - Why ruby must go!