The bad parts of Go are mostly the tradeoffs you have to make for a systems programming language. They have benefits but also some unfortunate downsides. Some are just implementation details that will get solved over time.
* integers overflow
* sharing memory between threads isn't safe
* mutable state/ shared state
* nil pointers
* block scoping can lead to multiple different variables with the same names within a function. Sometimes confusing.
* Error handling can become quite verbose if you don't design your code to limit the places errors can come from.
* gofmt is awesome, but in some rare situations the default format makes code less clear, so you have to change your style of code to fit the formatting.
* 'go get' is awesome, but it's lack of centralisation makes it harder to find the good 3rd party libraries amongst the bad/incomplete ones.
* The current goroutine scheduler is really simple and moves goroutines between threads and CPUs. This leads to lots of cache misses, so running on many threads can become slower than running on a single thread.
* integers overflow
* sharing memory between threads isn't safe
* mutable state/ shared state
* nil pointers
* block scoping can lead to multiple different variables with the same names within a function. Sometimes confusing.
* value types limit certain conversions. eg. you can't convert an []int to an []interface{} directly because an int and an interface{} are different sizes in memory.(http://golang.org/doc/go_faq.html#convert_slice_of_interface)
* Error handling can become quite verbose if you don't design your code to limit the places errors can come from.
* gofmt is awesome, but in some rare situations the default format makes code less clear, so you have to change your style of code to fit the formatting.
* 'go get' is awesome, but it's lack of centralisation makes it harder to find the good 3rd party libraries amongst the bad/incomplete ones.
* The current goroutine scheduler is really simple and moves goroutines between threads and CPUs. This leads to lots of cache misses, so running on many threads can become slower than running on a single thread.