Kenneth at 15:11, 17 May 2014

2014-05-17T15:11:17Z

New page

by Brian G. Merrell

--

Compile first:
go help

test.go:
<pre>
package main

import "fmt"

func main() {
fmt.Println("test")
}
</pre>

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:
<pre>
package main

import (
"fmt"
"net/http"
)

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

func Hello(w http.ResponseWrite, r *http.Request....
???
</pre>

--

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
<pre>
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)
}
</pre>

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

[[Category:Go]]

OpenWest 2014/Python to Go - Revision history

Kenneth at 15:11, 17 May 2014