+ Follow

Go <-> Ruby

by Eleanor McHugh

4,410 views

A rambling mashup of hardcore Go hackery and occasional Ruby madness.

Accessibility

View text version

Upload Details

Uploaded via SlideShare as Apple Keynote

Usage Rights

File a copyright complaint

8 Embeds 368

http://code.kzakza.com	345
http://paper.li	12
http://www.hanrss.com	3
http://us-w1.rockmelt.com	2
http://a0.twimg.com	2
http://a0.twimg.com	2
http://www.copyscape.com	1
http://webcache.googleusercontent.com	1

More...

Statistics

Likes: 5
Downloads: 40
Comments: 0
Embed Views: 368
Views on SlideShare: 4,042
Total Views: 4,410

Go <-> Ruby Presentation Transcript

Go <=> Ruby a selection of odd lightning talks @feyeleanorhttp://slides.games-with-brains.net/

The Wild-Eyed Screamer

@feyeleanorrealtime

@feyeleanorrealtimenet working

@feyeleanorrealtimenet workingunix

@feyeleanorrealtimenet workingunixlanguages

@feyeleanorrealtimenet workingunixlanguagesvirtual machines

Hacker 101this presentation contains code

Hacker 101this presentation contains codethat code is probably broken

Hacker 101this presentation contains codethat code is probably brokenif this bothers you - ﬁx it

Hacker 101this presentation contains codethat code is probably brokenif this bothers you - ﬁx itit’s called a learning experience

Hacker 101this presentation contains codethat code is probably brokenif this bothers you - ﬁx itit’s called a learning experienceand will make you a better persontm

Google Goit’s not just for Google

meet Gordon

he’s a gopher

of very few words

who lives at google

package mainimport "fmt"const HELLO string = "hello"var WORLD string = "world"func main() { fmt.Println(HELLO, WORLD)}

packageorganisation import var, const, typedeclaration func, interface, map, struct, chan if ... else switch ... case ... fallthrough ... default select ... casecontrol ﬂow for for ... range break, continue go, goto, defer, return

boolean, numeric, array value structure, interfacereference pointer, slice, string, map, channelinvocation function, method, closure

Go Rubycompilation static AOT runtime mutable memory garbage collected syntax minimalist humanistic strong dynamic type embedding inheritance dispatch procedural invocation message passingsemantics statements expressions

Ruby typing is tricksy lies we tell ourself about type

superclass modulesclass modules message instance

superclass modules class modulestype asserted instance

instance inherited class class expressed type modules

class Counter attr_writer :count def initialize @count = 0 end def Tick @count += 1 endendclass DoubleCounter < Counter def Tick super @count += 1 endendn = new(DoubleCounter)puts n.Tickputs n.superclass.Tick

down a rabbit holeinstances are their own classes

down a rabbit holeinstances are their own classesand all classes are mutable at runtime

down a rabbit holeinstances are their own classesall classes are mutable at runtimeso inheritance pathways can be altered

down a rabbit holeinstances are their own classesand all classes are mutable at runtimeso inheritance pathways can be alteredmaking Ruby very ﬂexible

down a rabbit holeinstances are their own classesand all classes are mutable at runtimeso inheritance pathways can be alteredmaking Ruby very ﬂexibleat the cost of type uncertainty

down a rabbit holeinstances are their own classesand all classes are mutable at runtimeso inheritance pathways can be alteredmaking Ruby very ﬂexibleat the cost of type uncertaintywhich really bugs computer scientists

type in Go is safetmclearly deﬁned areas of doubt and uncertainty

memory method layout set static type embedded types

package Integertype Int intfunc (i *Int) Add(x int) { *i += Int(x)}

type Buffer []Intfunc (b Buffer) Swap(i, j int) { b[i], b[j] = b[j], b[i]}func (b Buffer) Clone() Buffer { s := make(Buffer, len(b)) copy(s, b) return s}func (b Buffer) Move(i, n int) { if n > len(b) - i { n = len(b) - i } segment_to_move := b[:i].Clone() copy(b, b[i:i + n]) copy(b[n:i + n], segment_to_move)}

package mainimport "fmt"import "Integer"func main() { i := Integer.Buffer{0, 1, 2, 3, 4, 5} b := i.Clone() b.Swap(1, 2) b.Move(3, 2) b[0].Add(3) produces: fmt.Printf("b[0:2] = %vn", b[:2]) b[0:2] = [6 4]}

package mainimport "fmt"import "Integer"func main() { i := Integer.Buffer{0, 1, 2, 3, 4, 5} b := i.Clone() b.Swap(1, 2) b.Move(3, 2) b[0].Add(3) produces: fmt.Printf(“b[0:2] = %vn”, b[:2]) b[0:2] = [6 4]}

package Vectorimport . "Integer"type Vector struct { Buffer}func (v *Vector) Clone() *Vector { return &Vector{v.Buffer.Clone()}}func (v *Vector) Slice(i, j int) Buffer { return v.Buffer[i:j]}

type Adder interface { Add(j int) Subtract(j int) Result() interface{} Reset()}

type IAdder intfunc (i IAdder) Add(j int) { i[0] += i[j]}func (i IAdder) Subtract(j int) { i[0] -= i[j]}func (i IAdder) Result() interface{} { return i[0]}func (i IAdder) Reset() { i[0] = *new(int)}func (i IAdder) Increment() { i[0]++}

type FAdder []ﬂoat32func (f FAdder) Add(j int) { f[0] += f[j]}func (f FAdder) Subtract(j int) { f[0] -= f[j]}func (f FAdder) Result() interface{} { return f[0]}func (f FAdder) Reset() { f[0] = 0}

func TestAdder(t *testing.T) { var a Adder a = IAdder{0, 1, 2} a.Add(1) if i.Result().(int) != 1 { t.Fatalf("IAdder::Add(1) %v != %v", a.Result(), 1) } a.Subtract(2) if a.Result().(int) != -1 { t.Fatalf("IAdder::Subtract(2) %v != %v", a.Result(), -1) } a = FAdder{0.0, 1.0, 2.0} a.Add(1) if a.Result().(ﬂoat32) != 1.0 { t.Fatalf("FAdder::Add(1) %v != %v", a.Result(), 1.0) }}

down a rabbit holean object has known static type

down a rabbit holean object has known static typethis ﬁxed type is determined at linking

down a rabbit holean object has known static typethis ﬁxed type is determined at linkingno new types can be created at runtime

down a rabbit holean object has known static typethis ﬁxed type is determined at linkingno new types can be created at runtimeso dynamism is bounded to a ﬁxed set

down a rabbit holean object has known static typethis ﬁxed type is determined at linkingno new types can be created at runtimeso dynamism is bounded to this ﬁxed setand computer scientists are happier

unit tests as REPL testing that doesn’t suck

func (b Buffer) Eq(o Buffer) (r bool) { if len(b) == len(o) { for i := len(b) - 1; i > 0; i-- { if b[i] != o[i] { return } } r = true } return}

package Vectorimport "testing"func TestVectorSwap(t *testing.T) { i := Vector{Buffer{0, 1, 2, 3, 4, 5}} v := i.Clone() v.Swap(1, 2) r := Vector{Buffer{0, 2, 1, 3, 4, 5}} switch { case !v.Eq(r.Buffer): fallthrough case !v.Buffer.Eq(r.Buffer): t.Fatalf("b[0:5] = %v", v) }}

include $(GOROOT)/src/Make.incTARG=integerGOFILES= integer.go vector.goinclude $(GOROOT)/src/Make.pkg

package Vectorimport "testing"import "vector"func BenchmarkVectorClone6(b *testing.B) { v := Vector{Buffer{0, 1, 2, 3, 4, 5}} for i := 0; i < b.N; i++ { _ = v.Clone() }}func BenchmarkVectorSwap(b *testing.B) { b.StopTimer() v := Vector{Buffer{0, 1, 2, 3, 4, 5}} b.StartTimer() for i := 0; i < b.N; i++ { v.Swap(1, 2) }}

$ gotest -bench="Benchmark"rm -f _test/scripts.a6g -o _gotest_.6 integer.go vector.go nominal_typing_test.goembedded_typing_benchmark_test.go embedded_typing_test.gorm -f _test/scripts.agopack grc _test/scripts.a _gotest_.6PASSinteger.BenchmarkVectorSwap 200000000 8 ns/opinteger.BenchmarkVectorClone6 10000000 300 ns/op

exceptional funbecause Go doesn’t have exceptions - honest!

func Throw() { panic(nil)}func Catch(f func()) { defer func() { if x := recover(); x != nil { panic(x) } }() f()}func CatchAll(f func()) { defer func() { recover() }() f()}

func throwsPanic(f func()) (b bool) { defer func() { if x := recover(); x != nil { b = true } }() f() return}

import "fmt"import "path"import "runtime"func StackTrace() { var stack_trace []uintptr var my_path string runtime.Callers(1, stack_trace) for i, u := range stack_trace { if f := runtime.FuncForPC(u); f != nil { file, line := f.FileLine(u) switch filepath, filename := path.Split(file); { case i == 0: my_path = filepath case my_path != filepath: fmt.Printf("%v:%v", filename, line) } } else { fmt.Println("(unknown)") } }}

reﬂections on Godynamism through run-time type manipulation

package generaliseimport "reflect"func Allocate(i interface{}, limit... int) (n interface{}) { switch v := reflect.ValueOf(i); v.Kind() { case reflect.Slice: l := v.Cap() if len(limit) > 0 { l = limit[0] } n = reflect.MakeSlice(v.Type(), l, l).Interface() case reflect.Map: n = reflect.MakeMap(v.Type()).Interface() } return}

package generaliseimport . "reﬂect"func Allocate(i interface{}, limit... int) (n interface{}) { switch v := ValueOf(i); v.Kind() { case Slice: l := v.Cap() if len(limit) > 0 { l = limit[0] } n = MakeSlice(v.Type(), l, l).Interface() case Map: n = MakeMap(v.Type()).Interface() } return}

func TestAllocate(t *testing.T) { var s2 []int s1 := []int{0, 1, 2} m := map[int] int{1: 1, 2: 2, 3: 3} switch { case throwsPanic(func() { s2 = Allocate(s1, 1).([]int) }): t.Fatal("Unable to allocate new slice") case len(s2) != 1 || cap(s2) != 1: t.Fatalf("New slice should be %v not %v", make([]int, 0, 1), s2) case throwsPanic(func() { Allocate(m) }): t.Fatal("Unable to allocate new map") }}

func Duplicate(i interface{}) (clone interface{}) { if clone = Allocate(i); clone != nil { switch clone := ValueOf(clone); clone.Kind() { case Slice: Copy(clone, ValueOf(i)) case Map: m := ValueOf(i) for _, k := range m.Keys() { clone.SetMapIndex(k, m.MapIndex(k)) } } } return}

metallic k.o.sometimes a bit-buffer is just a bit-buffer

package rawimport . "reﬂect"import "unsafe"var _BYTE_SLICE Type = Typeof([]byte(nil))type MemoryBlock interface { ByteSlice() []byte}func valueHeader(v Value) (header *SliceHeader) { if v.IsValid() { s := int(v.Type().Size()) header = &SliceHeader{ v.UnsafeAddr(), s, s } } return}

func SliceHeader(i interface{}) (Header *SliceHeader, Size, Align int) { switch value := Indirect(ValueOf(i)); value.Kind() { case Slice: Header = (*SliceHeader)(unsafe.Pointer(value.UnsafeAddr())) t := value.Type().Elem() Size = int(t.Size()) Align = t.Align() case Interface: Header, Size, Align = SliceHeader(value.Elem()) } return}func Scale(oldHeader *SliceHeader, oldESize, newESize int) (h *SliceHeader) { if oldHeader != nil { s := float64(oldESize) / float64(newESize) h = &SliceHeader{ Data: oldHeader.Data } h.Len = int(float64(oldHeader.Len) * s) h.Cap = int(float64(oldHeader.Cap) * s) } return}

func ByteSlice(i interface{}) []byte { switch i := i.(type) { case []byte: return i case MemoryBlock: return i.ByteSlice() } var header *SliceHeader switch v := ValueOf(i); value.Kind() { case Interface, Ptr: header = valueHeader(v.Elem()) case Slice: h, s, _ := SliceHeader(i) header = Scale(h, s, 1) case String: s := v.Get() h := *(*StringHeader)(unsafe.Pointer(&s)) header = &SliceHeader{ h.Data, h.Len, h.Len } default: header = valueHeader(v) } return unsafe.Unreﬂect(_BYTE_SLICE, unsafe.Pointer(header)).([]byte)}

go f(){}() / yourself / map/reduce for all the family

package mainimport "fmt"func main() { var c chan int c = make(chan int) limit := 16 go func() { for i := limit; i > 0; i-- { fmt.Print(<-c) produces: } 0110011101011010 }() for i := limit; i > 0; i-- { select { case c <- 0: case c <- 1: } }}

package mainimport "fmt"func main() { var c chan int c = make(chan int) limit := 16 go func(in chan int) { for i := limit; i > 0; i-- { fmt.Print(<-in) produces: } 0110011101011010 }(c) for i := limit; i > 0; i-- { select { case c <- 0: case c <- 1: } }}

func main() { var c chan int c = make(chan int, 16) go func() { for i := 16; i > 0; i-- { fmt.Print(<-c) } }() go func() { select { produces: case c <- 0: 0110011101011010 case c <- 1: } }() for {}}

package generalisetype SignalSource func(status chan bool)func Wait(s SignalSource) { done := make(chan bool) defer close(done) go s(done) <-done}func WaitAll(count int, s SignalSource) { done := make(chan bool) defer close(done) go s(done) for i := 0; i < count; i++ { <- done }}

type Iteration func(k, x interface{}) boolfunc (i Iteration) apply(k, v interface{}, c chan bool) { go func() { c <-i(k, v) }()}func (f Iteration) Each(c interface{}) { switch c := ValueOf(c); c.Kind() { case Slice: WaitAll(c.Len(), SignalSource(func(done chan bool) { for i := 0; i < c.Len(); i++ { f.apply(i, c.Elem(i).Interface(), done) }})) case Map: WaitAll(c.Len(), SignalSource(func(done chan bool) { for _, k := range c.Keys() { f.apply(k, c.Elem(k).Interface(), done) }})) }}

type Results chan interface{}type Combination func(x, y interface{}) interface{}func (f Combination) Reduce(c, s interface{}) (r Results) { r = make(Results) go func() { Iteration(func(k, x interface{}) bool { s = f(s, x) return true }).Each(c) r <- s }() return}

type Transformation func(x interface{}) interface{}func (t Transformation) Transform(x interface{}) Value { return ValueOf(t(x))}func (t Transformation) Map(c interface{}) (r interface{}) { r = Allocate(c) if i := MapIterator(r); i != nil { i.Each(c) } return}

func MapIterator(c interface{}) (i Iteration) { switch n := ValueOf(c); n.Kind() { case Slice: i = Iteration(func(k, x interface{}) bool { n.Elem(k.(int)).SetValue(t.GetValue(x)) return true }) case Map: i = Iteration(func(k, x interface{}) bool { n.SetMapIndex(ValueOf(k), t.GetValue(x)) return true }) } return}

func main() { s := []int{0, 1, 2, 3, 4, 5} d := Transformation(func(x interface{}) interface{} { return x.(int) * 2 }).Map(s) sum := Combination(func(x, y interface{}) interface{} { return x.(int) + y.(int) }) fmt.Printf("s = %v, sum = %vn", s, <- sum.Reduce(s, 0)) fmt.Printf("d = %v, sum = %vn", d, <- sum.Reduce(d, 0))} produces: s = [0 1 2 3 4 5], sum = 15 d = [0 2 4 6 8 10], sum = 30

ruby can do that!channels with atomic queues and thread variables

require socketrequire threadclass ThreadGroup def all_but_me &block list. delete_if { |t| t.name == Thread.current.name }.each { |t| yield t } end def select *names, &block list.delete_if { |t| !names.include? t.name }.each { |t| yield t } endend

class Thread def initialize self[:Q] = Queue.new end def send *messages messages.each { |m| self[:Q].enq m } end def bind_transmitter socket key? :XMIT ? raise ArgumentError : self[:XMIT] = Thread.new() { loop do (m = self[:Q].deq) == :EXIT ? Thread.current.exit : socket.puts m Thread.pass end socket.close exit } end def disconnect send "Goodbye #{name}", :EXIT endend

class ChatServer < TCPServer def initialize port @receivers = ThreadGroup.new @transmitters = ThreadGroup.new @deceased = ThreadGroup.new super end def register name, socket @receivers.add(t = Thread.current) t.name = name @transmitters.add t.bind_transmitter(socket) broadcast "#{name} has joined the conversation" t.send "Welcome #{name}" end def connect socket loop do begin socket.print "Please enter your name: " register socket.readline.chomp).downcase, socket break rescue ArgumentError socket.puts "That name is already in use" end end end

def send message, name = Thread.current.name @receivers.select(name) { |t| t.send message } end def broadcast message @receivers.all_but_me { |t| t.send message } end def listen socket t = Thread.current loop do message = socket.readline.chomp case message.downcase when "bye": raise EOFError when "known": list_known_users when "quit": raise SystemExit else broadcast "#{t.name}: #{message}" end end end

def run while socket = accept Thread.new(socket) do |socket| begin connect socket listen socket rescue SystemExit broadcast "#{Thread.current.name} terminated this conversation" broadcast :EXIT send :EXIT @receivers.all_but_me { |t| t.transmitter.join } Kernel.exit 0 rescue EOFError disconnect end end end endendChatServer.new(3939).run

great artists stealthe Thompson-Pike approach to legacy C assimilation

include $(GOROOT)/src/Make.incTARG=sqlite3CGOFILES= sqlite3.go database.goifeq ($(GOOS),darwin)CGO_LDFLAGS=/usr/lib/libsqlite3.0.dylibelseCGO_LDFLAGS=-lsqlite3endifinclude $(GOROOT)/src/Make.pkg

package sqlite3// #include <sqlite3.h>import "C"import "fmt"import "os"type Database struct { handle *C.sqlite3 Filename string Flags C.int}func (db *Database) Error() os.Error { return Errno(C.sqlite3_errcode(db.handle))}

const( OK = Errno(iota) ERROR CANTOPEN = Errno(14))var errText = map[Errno]string { ERROR: "SQL error or missing database", CANTOPEN: "Unable to open the database ﬁle",}type Errno intfunc (e Errno) String() (err string) { if err = errText[e]; err == "" { err = fmt.Sprintf("errno %v", int(e)) } return}

func (db *Database) Open(ﬂags... int) (e os.Error) { db.Flags = 0 for _, v := range ﬂags { db.Flags = db.Flags | C.int(v) } f := C.CString(db.Filename) if err := Errno(C.sqlite3_open_v2(f, &db.handle, db.Flags, nil)); err != OK { e = err } else if db.handle == nil { e = CANTOPEN } return}func (db *Database) Close() { C.sqlite3_close(db.handle) db.handle = nil}

func Open(filename string, flags... int) (db *Database, e os.Error) { defer func() { if x := recover(); x != nil { db.Close() db = nil e = ERROR } }() db = &Database{ Filename: filename } if len(flags) == 0 { e = db.Open( C.SQLITE_OPEN_FULLMUTEX, C.SQLITE_OPEN_READWRITE, C.SQLITE_OPEN_CREATE ) } else { e = db.Open(flags...) } return}

package main// #include "ruby.h"import "C"import "fmt"import "os"type VALUE struct { cptr *C.VALUE}func main() { var stack_frame VALUE defer func() { C.ruby_cleanup(0) }() C.ruby_sysinit(len(os.Args), &os.Args[0]) C.ruby_init_stack(stack_frame.cptr) C.ruby_init() C.ruby_init_loadpath() run_ruby()}

func run_ruby() { C.rb_require("sum.rb") C.rb_eval_string("$summer = Summer.new") C.rb_eval_string("$result = $summer.sum(10)") result := C.rb_gv_get("result") fmt.Printf("Result = %vn", C.NUM2INT(result))}

homework

homeworkembedded your favourite ruby in go

homeworkembedded your favourite ruby in goyou’ll need a dynamic shared library

homeworkembedded your favourite ruby in goyou’ll need a dynamic shared librarythe Ruby header ﬁles

homeworkembedded your favourite ruby in goyou’ll need a dynamic shared libraryand the Ruby header ﬁlesthe non-gcc go toolchain

homeworkembedded your favourite ruby in goyou’ll need a dynamic shared libraryand the Ruby header ﬁlesthe non-gcc go toolchainand some code that looks a bit like this...

ﬁnding out moregolang.org

ﬁnding out moregolang.org#golang

ﬁnding out moregolang.org#golangpledgie.com/accounts/@feyeleanor

ﬁnding out moregolang.org#golangpledgie.com/accounts/@feyeleanorgithub.com/feyeleanor

ﬁnding out moregolang.org#golangpledgie.com/accounts/@feyeleanorgithub.com/feyeleanorslides.games-with-brains.net