Go <-> Ruby

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

2. The Wild-Eyed Screamer

3. @feyeleanor realtime

4. @feyeleanor realtime net working

5. @feyeleanor realtime net working unix

6. @feyeleanor realtime net working unix languages

7. @feyeleanor realtime net working unix languages virtual machines

8. Hacker 101 this presentation contains code

9. Hacker 101 this presentation contains code that code is probably broken

10. Hacker 101 this presentation contains code that code is probably broken if this bothers you - ﬁx it

11. Hacker 101 this presentation contains code that code is probably broken if this bothers you - ﬁx it it’s called a learning experience

12. Hacker 101 this presentation contains code that code is probably broken if this bothers you - ﬁx it it’s called a learning experience and will make you a better persontm

13. Google Go it’s not just for Google

14. meet Gordon

15. he’s a gopher

16. of very few words

17. who lives at google

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

22. package organisation import var, const, type declaration func, interface, map, struct, chan if ... else switch ... case ... fallthrough ... default select ... case control ﬂow for for ... range break, continue go, goto, defer, return

23. boolean, numeric, array value structure, interface reference pointer, slice, string, map, channel invocation function, method, closure

24. Go Ruby compilation static AOT runtime mutable memory garbage collected syntax minimalist humanistic strong dynamic type embedding inheritance dispatch procedural invocation message passing semantics statements expressions

25. Ruby typing is tricksy lies we tell ourself about type

26. superclass modules class modules message instance

27. superclass modules class modules type asserted instance

28. instance inherited class class expressed type modules

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

38. down a rabbit hole instances are their own classes

39. down a rabbit hole instances are their own classes and all classes are mutable at runtime

40. down a rabbit hole instances are their own classes all classes are mutable at runtime so inheritance pathways can be altered

41. down a rabbit hole instances are their own classes and all classes are mutable at runtime so inheritance pathways can be altered making Ruby very ﬂexible

42. down a rabbit hole instances are their own classes and all classes are mutable at runtime so inheritance pathways can be altered making Ruby very ﬂexible at the cost of type uncertainty

43. down a rabbit hole instances are their own classes and all classes are mutable at runtime so inheritance pathways can be altered making Ruby very ﬂexible at the cost of type uncertainty which really bugs computer scientists

44. type in Go is safetm clearly deﬁned areas of doubt and uncertainty

45. memory method layout set static type embedded types

49. package Integer type Int int func (i *Int) Add(x int) { *i += Int(x) }

53. type Buffer []Int func (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) }

56. package main import "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] }

57. package main import "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] }

61. package Vector import . "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] }

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

69. type IAdder int func (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]++ }

72. type FAdder []ﬂoat32 func (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 }

75. 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) } }

82. down a rabbit hole an object has known static type

83. down a rabbit hole an object has known static type this ﬁxed type is determined at linking

84. down a rabbit hole an object has known static type this ﬁxed type is determined at linking no new types can be created at runtime

85. down a rabbit hole an object has known static type this ﬁxed type is determined at linking no new types can be created at runtime so dynamism is bounded to a ﬁxed set

86. down a rabbit hole an object has known static type this ﬁxed type is determined at linking no new types can be created at runtime so dynamism is bounded to this ﬁxed set and computer scientists are happier

87. unit tests as REPL testing that doesn’t suck

88. 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 }

95. package Vector import "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) } }

103. include $(GOROOT)/src/Make.inc TARG=integer GOFILES= integer.go vector.go include $(GOROOT)/src/Make.pkg

104. package Vector import "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) } }

110. $ gotest -bench="Benchmark" rm -f _test/scripts.a 6g -o _gotest_.6 integer.go vector.go nominal_typing_test.go embedded_typing_benchmark_test.go embedded_typing_test.go rm -f _test/scripts.a gopack grc _test/scripts.a _gotest_.6 PASS integer.BenchmarkVectorSwap 200000000 8 ns/op integer.BenchmarkVectorClone6 10000000 300 ns/op

115. exceptional fun because Go doesn’t have exceptions - honest!

116. 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() }

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

134. 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)") } } }

145. reﬂections on Go dynamism through run-time type manipulation

146. package generalise import "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 }

147. package generalise import "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 }

148. package generalise import . "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 }

161. 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") } }

170. 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 }

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

184. package raw import . "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 }

202. 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 }

222. 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) }

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

243. package main import "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: } } }

250. package main import "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: } } }

258. 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 {} }

262. package generalise type 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 } }

270. type Iteration func(k, x interface{}) bool func (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) }})) } }

279. 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 }

289. 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 }

309. 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 }

326. 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

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

340. require 'socket' require 'thread' class 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 } end end

341. 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 end end

342. 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

343. 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

344. 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 end end ChatServer.new(3939).run

345. great artists steal the Thompson-Pike approach to legacy C assimilation

346. include $(GOROOT)/src/Make.inc TARG=sqlite3 CGOFILES= sqlite3.go database.go ifeq ($(GOOS),darwin) CGO_LDFLAGS=/usr/lib/libsqlite3.0.dylib else CGO_LDFLAGS=-lsqlite3 endif include $(GOROOT)/src/Make.pkg

351. 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)) }

358. 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 int func (e Errno) String() (err string) { if err = errText[e]; err == "" { err = fmt.Sprintf("errno %v", int(e)) } return }

368. 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 }

381. 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 }

389. 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() }

397. 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)) }

398. homework

399. homework embedded your favourite ruby in go

400. homework embedded your favourite ruby in go you’ll need a dynamic shared library

401. homework embedded your favourite ruby in go you’ll need a dynamic shared library the Ruby header ﬁles

402. homework embedded your favourite ruby in go you’ll need a dynamic shared library and the Ruby header ﬁles the non-gcc go toolchain

403. homework embedded your favourite ruby in go you’ll need a dynamic shared library and the Ruby header ﬁles the non-gcc go toolchain and some code that looks a bit like this...

404. ﬁnding out more golang.org

405. ﬁnding out more golang.org #golang

406. ﬁnding out more golang.org #golang pledgie.com/accounts/@feyeleanor

407. ﬁnding out more golang.org #golang pledgie.com/accounts/@feyeleanor github.com/feyeleanor

408. ﬁnding out more golang.org #golang pledgie.com/accounts/@feyeleanor github.com/feyeleanor slides.games-with-brains.net

Go <-> Ruby

More Related Content

What's hot (20)

Similar to Go <-> Ruby (20)

More from Eleanor McHugh (20)

Recently uploaded (20)

Go <-> Ruby

Editor's Notes

Go &lt;-> Ruby

More Related Content

What's hot (20)

Similar to Go &lt;-> Ruby (20)

More from Eleanor McHugh (20)

Recently uploaded (20)

Go &lt;-> Ruby

Editor's Notes

Go <-> Ruby

Similar to Go <-> Ruby (20)

Go <-> Ruby