When someone says there is a single right answer.

Particularly when it is an answer that makes a set of tradeoffs which doesn't fit some common situations.

Immutable strings can have a simpler structure and are faster to access (to allow resizing you need to allow moving the string). However if you are incrementally building up a large string using strings, immutable strings require recopying, and recopying forces you into an n*n algorithm.

Now, you say, just use a StringBuffer (or whatever the current flavour is) object. Well yes. That works. If you try to implement it in code, though, you will eventually hit other bottlenecks as the garbage collector tries to garbage collect on a huge number of little strings. This happens much later, but I have been there, done that. Collecting lots of little objects eventually becomes its own problem. If it is not natively implemented, then it becomes important to do some sort of naive scaling operation. (Having done this in JavaScript I can report that a good heuristic is that when you push a StringBuffer onto a StringBuffer, you resolve the smaller one. Now create one buffer per row, push those onto the ones per table, scalability is now acceptable.)

You know, this is really a headache. I have been there, done that, and don't like it.

Back to the mutable string. OK, it is an immediate significant overhead. Hrm. But go to incrementally build up a string and it bloody works! The first time. The first thing you try. No need to show how good of a programmer you are, how smart you are. You can go off and be smart about something else.

If that initial overhead is acceptable, you don't ever get into having to waste your time worrying about this cr*p. Been there, done that as well. And given current CPU power, I really prefer always wasting some computer time and not having to take out a day or 3 doing performance profiling so I can figure out how to rewrite code that should work the first time.

So I would say that there is no truly "right answer". There are cases where mutable strings make sense. Cases where immutable strings make sense. For me, most of the time, I prefer having mutable strings that work out reasonably well for any access problem, that is good enough. If it isn't good enough some time, then I will make the hard decisions.

Cheers,
Ben