Go for Rubyists

46d1ebbb28ce0f4a8f2c77b6d3d95829?s=47 Conrad Irwin
February 17, 2015

Go for Rubyists

A tech-talk I gave at Omada Health about why you as a ruby programmer should be excited by Go!

46d1ebbb28ce0f4a8f2c77b6d3d95829?s=128

Conrad Irwin

February 17, 2015
Tweet

Transcript

  1. Go for Rubyists* *Or really any curious programmer @ConradIrwin

  2. None
  3. Pry The featureful development console for ruby aws‑name‑server A DNS

    server for easy EC2 management
  4. Go for rubyists: Compare and contrast Go in 5 minutes

    Duck typing Concurrency
  5. Compare and contrast — Rob Pike* Go is efficient, scalable,

    and productive. Some programmers find it fun to work in; others find it unimaginative, even boring. * co‑creator of Go
  6. Compare and contrast — Matz* Ruby is designed to be

    human‑oriented. It reduces the burden of programming. It tries to push jobs back to machines. * creator of Ruby
  7. Similarities Duck typing Garbage collection Designed for productivity Imperative

  8. Differences Go is compiled ahead‑of‑time Goroutines vs. threads Everything is

    an object in Ruby Ruby has object‑oriented inheritance
  9. Go in 5 minutes

  10. Hello world! / / m a i n . g

    o / / E v e r y f i l e i s i n a p a c k a g e . I f y o u ' r e w r i t i n g a n a p p u s e " m a i n " , / / o t h e r w i s e i t ' s t h e n a m e o f y o u r l i b r a r y . p a c k a g e m a i n / / Y o u h a v e t o i m p o r t t h e p a c k a g e s y o u n e e d i n e v e r y f i l e . i m p o r t " f m t " / / T h e m a i n f u n c t i o n d e f i n e s w h e r e t h e p r o g r a m s t a r t s . f u n c m a i n ( ) { / / C a l l t h e P r i n t l n m e t h o d i n t h e " f m t " p a c k a g e f m t . P r i n t l n ( " H e l l o W o r l d ! " ) } g o r u n m a i n . g o
  11. Loops, Arrays, etc. f u n c m a i

    n ( ) { / / n o i s y T h i n g s i s a l i s t o f s t r i n g s c o n t a i n i n g " D o g " a n d " C a l t r a i n " n o i s y T h i n g s : = [ ] s t r i n g { " D o g " , " C a l t r a i n " } / / n o i s e s i s a m a p f r o m s t r i n g t o s t r i n g c o n t a i n i n g . . . n o i s e s : = m a p [ s t r i n g ] s t r i n g { " D o g " : " W o o f " , " C a l t r a i n " : " P A A A A A R P " } / / I t e r a t e o v e r t h e r a n g e o f a l l t h e n o i s y T h i n g s . / / T h e _ i s t h e a r r a y i n d e x o f e a c h t h i n g . f o r _ , t h i n g : = r a n g e n o i s y T h i n g s { f m t . P r i n t l n ( t h i n g , " g o e s " , n o i s e s [ t h i n g ] ) } } $ g o r u n m a i n . g o D o g g o e s W o o f C a l t r a i n g o e s P A A A A A R P
  12. Structs / / D e f i n e s

    a n e w t y p e c a l l e d u s e r t h a t h a s t h e f o l l o w i n g f i e l d s . t y p e U s e r s t r u c t { N a m e s t r i n g H o m e p a g e s t r i n g / / p a s s w o r d H a s h s t a r t s w i t h a l o w e r c a s e b e c a u s e i t i s p r i v a t e . p a s s w o r d H a s h [ ] b y t e } / / D e f i n e s a m e t h o d c a l l e d F i r s t N a m e o n t h e u s e r . f u n c ( u s e r * U s e r ) F i r s t N a m e ( ) s t r i n g { / / I n G o s t r i n g s a r e n o t o b j e c t s . / / M e t h o d s a r e o n t h e s t r i n g s p a c k a g e i n s t e a d . r e t u r n s t r i n g s . S p l i t ( u s e r . N a m e , " " ) [ 0 ] } u s e r : = & U s e r { N a m e : " C o n r a d I r w i n " , H o m e p a g e : " h t t p s : / / c i r w . i n " } f m t . P r i n t l n ( u s e r . F i r s t N a m e ( ) )
  13. ?

  14. Duck typing! If it walks like a duck, and it

    quacks like a duck, itʹs pretty much a duck.
  15. Duck typing! Ruby is: strongly‑typed, dynamically‑typed, duck‑typed. Go is: strongly‑typed,

    statically‑typed, duck‑typed.
  16. In Ruby c l a s s D o g

    d e f s o u n d " W o o f " e n d e n d c l a s s C a l t r a i n d e f s o u n d " P A A A A A A A A A A A A R R P " e n d e n d # I s o b j e c t a D o g o r a C a l t r a i n ? p u t s o b j e c t . s o u n d
  17. In Go t y p e D o g s

    t r u c t { . . . } f u n c ( d o g * D o g ) S o u n d ( ) s t r i n g { r e t u r n " W o o f " } t y p e C a l t r a i n s t r u c t { . . . } f u n c ( c a l t r a i n * C a l t r a i n ) S o u n d ( ) s t r i n g { r e t u r n " P A A A A A A A A A A R P " } / / I s o b j e c t a D o g o r a C a l t r a i n ? f m t . P r i n t l n ( o b j e c t . S o u n d ( ) )
  18. Static duck typing Functions declare which methods they call using

    i n t e r f a c e s Compiler checks that objects passed in implement the interface Itʹs just like ruby, but: Errors show up in vim before I even run my program :)
  19. Interfaces / / A n y o b j e

    c t t h a t h a s a S o u n d ( ) m e t h o d c a n b e u s e d a s a S o u n d e r . t y p e S o u n d e r i n t e r f a c e { S o u n d ( ) s t r i n g } / / F o r e x a m p l e , I c o u l d p a s s e i t h e r a C a l t r a i n o r a D o g : f u n c L i s t e n T o ( s S o u n d e r ) { f m t . P r i n t l n ( " I h e a r d a " , s . S o u n d ( ) ) } L i s t e n T o ( f i d o ) L i s t e n T o ( n o r t h b o u n d 2 3 7 ) $ g o r u n m a i n . g o I h e a r d a W o o f I h e a r d a P A A A A A A A A A A R P
  20. ?

  21. Concurrency In Javascript: (tableflip). In Ruby: Donʹt do that :/.

    In Go: Well‑designed language features :)
  22. Channels f u n c P a y A t

    t e n t i o n ( ) { / / t o d o i s a c h a n n e l t h a t c a n h o l d u p t o 1 0 0 t h i n g s t o d o : = m a k e ( c h a n S o u n d e r , 1 0 0 ) / / F i n d e v e r y t h i n g t o l i s t e n t o i n t h e c u r r e n t e n v i r o n m e n t . f o r s o u n d e r : = r a n g e c u r r e n t E n v i r o n m e n t ( ) { t o d o < - s o u n d e r } / / T h e n l i s t e n t o i t f o r s o u n d e r : = r a n g e t o d o { L i s t e n T o ( s o u n d e r ) } }
  23. Channels Act like a queue (push on one end, pop

    off the other) Writing to a full queue waits until thereʹs space Reading an empty queue waits until someone writes Designed to communicate between goroutines
  24. Goroutines f u n c P a y A t

    t e n t i o n ( ) { / / t o d o i s a c h a n n e l t h a t c a n h o l d u p t o 1 0 0 s o u n d e r s t o d o : = m a k e ( c h a n S o u n d e r , 1 0 0 ) / / L i s t e n t o t h i n g s a s t h e y b e c o m e a v a i l a b l e g o f u n c ( ) { f o r s o u n d e r : = r a n g e t o d o { L i s t e n T o ( s o u n d e r ) } } ( ) / / F i n d e v e r y t h i n g t o l i s t e n t o i n t h e c u r r e n t e n v i r o n m e n t . f o r s o u n d e r : = r a n g e c u r r e n t E n v i r o n m e n t ( ) { t o d o < - s o u n d e r } }
  25. Goroutines Light‑weight threads N goroutines run concurrently using M real

    threads. (M defaults to 1!) Designed to use channels to communicate
  26. Aside: Control f u n c P a y A

    t t e n t i o n ( ) { / / d o n e i s a c h a n n e l t h a t i s u s e d t o s i g n a l w h e n i t ' s d o n e . d o n e : = m a k e ( c h a n b o o l ) t o d o : = m a k e ( c h a n S o u n d e r , 1 0 0 ) g o f u n c ( ) { . . . d o n e < - t r u e } ( ) . . . c l o s e ( t o d o ) / / w a i t u n t i l t h e g o r o u t i n e i s d o n e < - d o n e }
  27. In summary: Go lets you run many things concurrently Go

    lets you hide the concurrency No callbacks required
  28. Why I like go Minimal language Features all work together

    Very powerful abstractions Cross‑compiles everywhere
  29. ?