One difference is that the returned []byte can be potentially
reused to hold another/new data (w/o new memory allocation), while
string cannot. Another one is that, in the gc implementation at
least, string is a one word smaller entity than []byte. Can be
used to save some memory when there is a lot of such items live.
Casting a []byte to string for logging is not necessary. Typical 'text' verbs, like %s, %q work for string and []byte expressions
equally. In the other direction the same holds for e.g. %x or % 02x.
Depends on why is the concatenation performed and if the result is ever
to be again combined w/ something/somewhere else afterwards. If that's the case then []byte may perform better.
I've gotten the sense that in Go, more than in any other non-ML style language, the type is used to convey meaning and intended use. So, the best way to figure out which type to use is to ask yourself what the data is.
A string represents text. Just text. The encoding is not something you have to worry about and all operations work on a character by character basis, regardless of that a 'character' actually is.
An array represents either binary data or a specific encoding of that data. []byte means that the data is either just a byte stream or a stream of single byte characters. []int16 represents an integer stream or a stream of two byte characters.
Given that fact that pretty much everything that deals with bytes also has functions to deal with strings and vice versa, I would suggest that instead of asking what you need to do with the data, you ask what that data represents. And then optimize things once you figure out bottlenecks.
EDIT: This post is where I got the rationale for using type conversion to break up the string.