Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

10 reasons to be excited about go

10,407 views

Published on

A fun introduction to the Go programming language

Published in: Technology, Education
  • Be the first to comment

10 reasons to be excited about go

  1. 1. 10 Reasons to be Excited About Go Dvir Volk, Chief Architect, Everything.me
  2. 2. O HAI! I CAN HAS A GO?
  3. 3. What is Go ● New-ish programming language developed at Google (and used there) ● Targeted for high performance servers ● Focuses on easing the life of the developer ● Addresses real pains - mainly from C++ ● Object-Oriented-ish ● Statically Compiled ● Garbage Collected ● Strictly Typed ● Concurrency Oriented
  4. 4. Reason 1: The syntax ● Simple, Quick learning curve, little code to write. ● Few keywords - e.g.: do, while, for ● Multiple return values ● Public / private ● Maps, slices (vectors), queues as first class members ● Pointers - without arithmetic ● No macros ● No exceptions ● No templates ● No operator overloading ● No warnings!
  5. 5. The syntax: Hello World package main import "fmt" func main() { fmt.Println("Hello World!") }
  6. 6. The syntax: Variables, looping package main import "fmt" func main() { a, b := 1, 2 fmt.Printf("a + b: %dn", a + b) for a < 100 { a++ fmt.Println(a) } }
  7. 7. The syntax: Imports, casting package main import ( "fmt" "math" ) func main() { for i := 0; i < 100; i++ { fmt.Println(math.Pow(float64(i), 2)) } }
  8. 8. The syntax: Funcs package main import ( "fmt" // "math" ) func square(i int) int { return i*i } func main() { for i := 0; i < 100; i++ { fmt.Println(i, square(i)) } }
  9. 9. The syntax: Structs & Methods type User struct { Name string password string } // This is a method for User func (u *User) Authenticate(name, password string) bool { return u.Name == name && u.password == password } // Instead of constructors... func NewUser(name, password string) *User { return &User{ Name: name, password: password, } } // Instead of inheritence... type Administrator struct { User email string } func (a *Administrator) SendMail(msg string) { log.Println("Sending message to ", a.Name) }
  10. 10. Reason 2: Compiler Speed ● The whole SDK and compiler compiled in 19 seconds. ● Standard library - a couple of seconds. For 370 KLOC. ● My own project, 5 KLOC - 0.186 seconds. Why? ● Compiling imports only directly imported stuff. ● Compiler friendly syntax. ● The language is very small. ● Unused imports not allowed. ● Circular imports not allowed (no #IFDEF).
  11. 11. Reason 3: Execution Speed ● Go is FAST ● Slower usually than C++, not by a lot. ● More or less on par with Java ● about x10 to x100 faster than Python/Ruby ● (but let's not forget concurrency) ● Only gcc-go does machine code optimizations ● Significant performance improvements between versions.
  12. 12. Execution Speed: Go vs. C++ (Data: The benchmark game, http://benchmarksgame.alioth.debian.org/)
  13. 13. Execution Speed: Go vs. Java (Data: The benchmark game, http://benchmarksgame.alioth.debian.org/)
  14. 14. Execution Speed: Go vs. Ruby (Data: The benchmark game, http://benchmarksgame.alioth.debian.org/)
  15. 15. Reason 4: The Ecosystem ● Go Get - a pip/gem like installation system ● Compliant with Github / Google Code, Bitbucket ● Any repo can be made compliant ● The repo url is also the namespace! ● Can be automated to run on compile time ● Excellent repo search engines ● Friendly, useful community
  16. 16. Importing a package: Example package main import ( "github.com/dvirsky/go-pylog/logging" ) func main() { logging.Info("All Your Base Are Belong to %s!", "us") logging.Critical("And now with a stack trace") }
  17. 17. Reason 5: Simple Conventions ● Lots of convention-over-configuration: ● all tests & benchmarks in *_test.go - just hit go test ● func TestXXX(t *testing.T) {} ● func BenchmarkXXX(b *testing.B) {} ● func ExampleFoo() {} ● Excellent documentation system built-in ● Folders are packages, URLs for installed ● Public / private
  18. 18. Documentation & Examples: Input
  19. 19. Documentation & Examples: Output
  20. 20. Reason 6: Concurrency ● Goroutines and Channels are the heart of Go ● Goroutines are microthreads with an internal scheduler ● You can run 10Ks of goroutines easily ● No need for non-blocking IO. It is under the hood! ● The usual pattern: One goroutine per server connection ● Locks are available but not encouraged
  21. 21. Concurrency: Channels ● Channels are synchronized message queues between goroutines. ● They are strictly typed first-class citizens. ● Delegate state through channels instead of sharing it. ● Buffered channels for non blocking pushes. ● They can be iterated on.
  22. 22. Channels: Over-simplified example... func producer(c chan string) { for i := 0; i < 100; i++ { c <- fmt.Sprintf("Message #%d", i) } close(c) } func main() { c := make(chan string) go producer(c) for s := range c { fmt.Println(s) } }
  23. 23. Channels: Slightly more complex #1 package main import ( "fmt" "runtime" ) type result struct { in int out int } //worker getting numbers and sending back their sqaure func squarer(in chan int, out chan result) { for i := range in { out <- result{i, i * i} } } //take in the results and print them func aggregator(res chan result) { for s := range res { fmt.Println(s) } } // TO BE CONTINUED ON NEXT SLIDE ------>
  24. 24. Channels: Slightly more complex #2 func main() { //utilize all CPUs runtime.GOMAXPROCS(runtime.NumCPU()) //create the channels inChan := make(chan int) outChan := make(chan result) //fire up the workers for i := 0; i < 10; i++ { go squarer(inChan, outChan) } //aggregate results go aggregator(outChan) //push the input for i := 0; i < 1000; i++ { inChan <- i } //there are prettier ways of blocking here... :) var input string fmt.Scanln(&input) }
  25. 25. Reason 7: The standard library ● Excellent, rich standard library ● More like Python's than C++'s ● Very well documented ● Great source for idiomatic code ● Excellent serialization
  26. 26. Reason 7: The standard library ● The "Batteries" include: ○ Robust HTTP Web Server + template library ○ Compression, encryption, JSON / XML / CSV ○ Profiling, debugging, source parsing ○ Reflection library ○ Image manipulation ○ Plus the usual suspects ○ No GUI Toolkit :)
  27. 27. The standard library: A Web Server package main import ( "fmt" "net/http" ) func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hi there, I love %s!" , r.URL.Path[1:]) } func main() { http.HandleFunc( "/", handler) http.ListenAndServe( ":8080", nil) }
  28. 28. Reason 8: C is never too far ● CGo is part of the standard library ● Makes binding C libraries trivial ● You can also trivially call Go code from C ● BTW: A JVM based Go exists ;) package rand /* #include <stdlib.h> */ import "C" func Random() int { return int(C.rand()) } func Seed(i int) { C.srand(C. uint(i)) }
  29. 29. Reason 9: Implicit Interfaces ● Implementing an interface simply means you implement it, no declaration needed. ● Example: any struct that has a method String() string can be used for "%s" fmt ● You can mix and match interfaces as you go ● The empty interface, interface{} is super useful. ● Interfaces can be safely cast into structs, or called directly.
  30. 30. Reason 10: Procrastination It's Fun! ● Go is fun to work on and read about ● Beware: productive procrastination :) ● "Code is compiling" is no longer valid! ● Thank God we have a new excuse
  31. 31. Before we get too excited ● Lack of complete, real IDE ● Debugging: GDB Works great - but no real frontend ● No dynamic linking/loading ● Implicit interfaces are cool but can be confusing ● No exceptions - a matter of taste.
  32. 32. Wanna write some Go code? We're hiring! :) We're introducing Go to our backend and data crunching stack, where C++ used to roam, or where Go could kick Python's ass. Email jobs@everything.me
  33. 33. A Few Good Resources ● The official website: http://golang.org/ ● Excellent introductory book: http://www.golang-book.com/ ● GoDoc: Package search http://godoc.org/ ● Migrating from Python to Go: http://blog.repustate.com/migrating-code-from-python- to-golang-what-you-need-to-know/2013/04/23/

×