OpenWest 2014/Python to Go

by Brian G. Merrell

--

Compile first:

go help

test.go:

package main

import "fmt"

func main() {
  fmt.Println("test")
}

go build -o test test.go

To just run the script:

go run test.go

--

Justifications:

• C++ too complex
• compilation too slow
• programming to difficult
• programmers choosing easy over safety and efficiency

--

Python bad because:

• actually quite complex
• runtime errors
• performance
• doesn't scale

--

Go has:

• concurrency is a breeze
• no exceptions
• no type hierarchies
• no classes

Go good because:

• small language (fit all in your head, have read the spec)
• compile time checks (fast)
• fast enough for even more things
• benefits at little cost
• dynamic feel with compiled performance
• rich standard library
• libraries are all written in Go
• great bundled tooling
• seems to scale well
• cross compiling in Go is simple
• Go syntax is very light and simple

--

Hello World Web server:

package main

import (
 "fmt"
 "net/http"
)

func main() {
 http.HandleFunc("/", Hello")
 http.ListenAndServer("kicakhost:800", nil)
}

func Hello(w http.ResponseWrite, r *http.Request....
???

--

Don't like about Go:

• Naked return statements (optional)

x,yz, =1,2,3
return

• scoping rules specific case
• not faster than java
• new vs &T{} vs make
• len("foo") vs "foo".Len() - but keeps lanuage simple
• Name "Go" is ungoogable / hastagable (use golang) *** MOST ANNOYING ***
• No dynamic linking in Go - makes binaries huge
  • two compilers - may work with gccgo, just not with google's gc compiler
  • no dlopen in Go

Python vs Go

• Interpreted vs Compiled
• Strongly typed vs Strongly typed
• Dynamically typed vs statically typed
• Garabage collected
• Unique syntax vs Similar to C
• Open Source
• Python Foundation vs Google
• more platforms vs fewer platforms
• 1991 vs
• ???

Go does not have:

• Classes
• Exceptions
• Assertions
• Templates / generics (for now)
• Operator overloading

Zen of Python

>>> import this

Go does not have:

• decorators
• static methods
• class methods
• properties
• iterators
• generators
• exceptions
• meta classes
• class decorators
• multiple inheritance
• list comprehensions
• ternary operator (expression?true:false)

--

Errors should never pass silently - sure beats runtime error

package main

import (
 "fmt"
 "net/url"
)

func main() {
 u := url.Parse("http://foo.org/index%.html") // notice bad '%'
 /* fix
 u, err := url.Parse("http://foo.org")
 if err != nil {
   fmt.Println("got error")
 }
 */
 fmt.Println(u.Host)
}

Zero Values

Encapsulation - capitalized names are exported

Slices vs Lists

Arrays

Slicing syntax is very similar to python

Maps, Dicts and Sets

Duck typing - Go uses interfaces to solve

Exception handling - uses interfaces and type assertions to check

Calling C code from Go

go get - similar to pip

Unit testing and Code coverage

go test ./...
go test -cover ./...

Other tools (included)

http://play.golang.org