This is applicable to almost any piece of software with text in it. When starting your new app, you should make sure you are using a separate language file for the strings in your app. This makes text reusable, and you can change it all in one place.
Once your app gains a community, if you did this, you can also get translators!
With Photon i made the massive mistake of hardcoding everything up until the app became massive, and my PR for un-hardcoding all the strings looks like this:
It was worth it though! Because the community has translated it into 11 languages!
Alternative interpretation cause i find i18n extremely boring and hate the indirection it adds to a code base : you’re telling me I can start making an app without this hassle, and it will only cost me a 2Kloc PR some time in the future. That’s a totally manageable price to pay and makes the early dev experience much better (which can have a lot of impact on momentum).
Also: shouldn’t the process of searching and replacing strings be quite easy to automate?
Edit to clarify: I meant searching and replacing hard-coded strings into whatever library handles translateable strings. Not hard-coding different languages.
Fantastic recommendation.
There’s two approaches you can use here.
You can use a list of strings used in the app and have each string only occur once. Then using translation files you can translate each of those strings into another language.
This usually works fine, but has the downside of losing the context of a string. Context can matter a lot when translating, you often see this when the wrong translation is used, which is a correct translation but not for the context it’s in. It can also be tricky when two strings are the same not by definition, but by chance. When in another language those strings should not be the same, this can’t be resolved easily.
So for situations where a better translation is required another approach is used. Instead of strings directly, placeholders are used. These placeholders should be structured in such a way, the context is obvious and people could find where it’s used easily. These placeholders are also unique, where two strings that are the same by chance don’t use the same placeholder. Then for each language, including the “primary” language, a translation file is used. That translation file translates the placeholders into the correct string. For translating the translator uses the placeholders and the primary language file to translate the strings. Good tools for this exist that allow the same strings to be translated once, but show the context so the translator can decide to use different translations for the same string in a different context.
Using the placeholder approach is a bit more work and adds some overhead, but I’ve seen it used to produce awesome results. It prevents the pitfalls of the simpler approach.
Is it really more effort to just extract relevant strings later, rather than worrying about it the whole time? Asking beyond lemmy apps too.
Once you have this set up, you won’t worry about it again. It will just become “the way it is done”. And it’s just the correct way to build software IMHO, even if you have no plans right now to offer multiple languages.
Extrapolation takes quite a while, and there are other benefits to having a language file, like reusability.
for things like translation it is obviously required, but it will be ongoing as the app changes over the years
so it’s just about realising that text in the UI is just another kind of content that has to be managed so there will need to be infrastructure and process to make that easier
We use I18n at work and it’s great. It’s a bit more cumbersome to write strings but then again I could write a key mapping for that I guess.
