* 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.
Block scoping, too?
Block scoping is confusing for many people coming from the dynamic languages where scoping is usually function level.
If you want a feature that allows you to signal and catch errors, than:
* you can return Error as the second parameter from a function,
* you can panic and later defer a recover call (more info: http://blog.golang.org/2010/08/defer-panic-and-recover.html )
Just as importantly, what's bad about it? Or if you don't want to say something like (e.g.) syntax can be "bad", what do you dislike? What changes would you make if you were designing it?