Why do people use plain english as translation pla

Question

This may be a stupid question, but here goes.

I've seen several projects using some translation library (e.g. gettext) working with plain english placeholders. So for example:

_("Please enter your name");

instead of abstract placeholders (which has always been my instinctive preference)

_("error_please_enter_name");

I have seen various recommendations on SO to work with the former method, but I don't understand why. What I don't get is what do you do if you need to change the english wording? Because if the actual text is used as the key for all existing translations, you would have to edit all the translations, too, and change each key. Or don't you?

Isn't that awfully cumbersome? Why is this the industry standard?

It's definitely not proper normalization to do it this way. Are there massive advantages to this method that I'm not seeing?

Answer 1

There's a fallback hierarchy, from most specific locale to the unlocalised version in the source code.

So French in France might have the following fallback route:

1. fr_FR
2. fr
3. Unlocalised. Source code.

As a result, having proper English sentences in the source code ensures that if a particular translation is not provided for in step (1) or (2), you will at least get a proper understandable sentence than random programmer garbage like “error_file_not_found”.

Plus, what do you do if it is a format string: “Sorry but the %s does not exist” ? Worse still: “Written %s entries to %s, total size: %d” ?

Answer 2

Quite old question but one additional reason I haven't seen in the answers yet:

You could end up with more placeholders than necessary, thus more work for translators and possible inconsistent translations. However, good editors like Poedit or Gtranslator can probably help with that.

To stick with your example: The text "Please enter your name" could appear in a different context in a different template (that the developer is most likely not aware of and shouldn't need to be). E.g. it could be used not as an error but as a prompt like a placeholder of an input field.

If you use

_("Please enter your name");

it would be reusable, the developer can be unaware of the already existing key for an error message and would just use the same text intuitively.

However, if you used

_("error_please_enter_name");

in a previous template, developers wouldn't necessarily be aware of it and would make up a second key (most likely according to a predefined wording scheme to not end up in complete chaos), e.g.

_("prompt_please_enter_name");

which then has to be translated again.

So I think that doesn't scale very well. A pre-agreed wording scheme of suffixes/prefixes e.g. for contexts can never be as precise as the text itself I think (either too verbose or too general, beforehand you don't know and afterwards it's difficult to change) and is more work for the developer that's not worth it IMHO.

Does anybody agree/disagree?