Later this week I am going to be assessing a developer on a Pair Programming TDD Programing Exercise in Go.
The problem is that I currently don’t know Go.
I do own the book Introducing Go from a Humble Bundle.
These are the notes that I have from working through the first few chapters.
I am basing the analysis upon the 7 Languages in 7 Weeks pattern.
Go is strongly typed.
Bracket style is K + R (opening bracket stays with the function declaration)
Integer size is machine (platform dependent)
Method names seem to use PascalCase.
Variable names use camelCase.
Variables can only be defined once per scope.
Variables are mutable.
Declared by var
The type follows the name if required:
var x string
I have not seen this in recent languages (this is a Pascal idea rather that the C style of type name)
Types can be implied by assigning with := (but only inside a function).
const allows the creation of things that cannot be reassigned.
Backticks allow for multiline strings.
Compiler warns about unused variables.
Variable names can be redefined at a different scope.
No implicit returns from functions. (Which is unusual for a modern language).
You can name the return variable, assign it and then call return.
You can return tuples from a function.
Does not handle overflows well.
func factorial(x uint) uint {
if x == 0 {
return 1
}
return x * factorial(x-1)
}
This fails on 100, and will return 0
It appears that a function cannot be overloaded.
Interfaces are implicit. You don’t need to state that you are using it.
The early versions of Go were really weak at package management. It requires you to have your code in a sub folder of the GOPATH called src. This completely insane! The language should not define the name of the folder structure.
Tests need to be named Test* and have a parameter of t *testing.T
I think I now know enough for the Pairing Interview.
Developer Rants 