Many software developers are confronted with certain challenges in the software localization department that they might have trouble overcoming. Instead of trying to find an adequate solution to their problem, they just leave it as it is and hope for the best, which often results in a product that is full of bugs and glitches. It should not be forgotten that the process of localization is a complex one and requires a great deal of planning, patience and coordination, so we’ve made a list of things that should help you with L10n of your product.
1. Planning is everything
As every software developer knows, not everything goes as planned and it is necessary to think ahead and consider possible difficulties before they occur. First and foremost, software localization is not something that can be done last minute. It needs to be planned in advance, along with translation, compatibility and regression testing and other crucial stages of software development. It has been shown time and again that localization process runs the best when it is integrated into the software development process from day one. Finding a localization partner who can integrate the language solutions into software development and work with you on agile localization projects can save you a lot of headache.
2. Cutting the code
It’s always a good idea to separate the main code from translatable strings and keep those strings in their own document. This helps translators focus on actual translation instead on finding what needs to be translated. It also doesn’t hurt to identify those strings and describe them as precisely as possible (i.e. title, button, image, etc.) Doing this at the very beginning makes job a lot easier and saves a lot of time and resources in advance.
3. Expanding the space for translatable strings
Some languages require more space than English – some of them even up to 30% more!
However, simply leaving extra space after each label might cause them to appear far apart from each other in compact languages. To avoid that, it is possible to align labels to the right or even place them above the controls. Other solution would be to use layout managers that understand how locale affects user interface.
4. Avoiding concatenated strings
Simplifying code by using placeholders in software development is nothing unusual, but when it comes to translation and localization, concatenated strings are better left behind. It just presumes grammar and sentence structure, which makes order of words and phrases in some way hard-coded. Obviously, that’s not the most wanted case so maybe it would be better to break sentences up into several smaller pieces.
5. Rooting out hard-coded text
Dates, time, currencies and other culturally specific features should definitely not be hard-coded since their format and use varies from culture to culture. Instead, it is better to have localizable strings and let translators decide what would be the best choice for their language. Also, it’s a smart move to store this type of data in a standard ISO format and use a library to format them for the given locale.
6. Encoding the data
It’s not a secret that different languages use different encoding system, but it is often hard to decide which one to use, since choosing wrong character encoding may cause translation to break, which leaves you with extra work to fix it. To avoid confusions and complications, use UTF-8 whenever possible. Ideally, every part of your project should use UTF-8, from HTML and HTTP server to database and the application itself.
7. Testing the software
Of course this is the logical and obligatory step in software localization so skipping it would be a terrible decision. Localized software versions should be tested as rigorously as the original one. Seeing a foreign language in context within your software might be an eye-opener for overlooked details and possible mistakes.
8. Localizing documentation
Every software comes hand in hand with its documentation so it’s very important to localize it as well. Users will eventually experience some problems when using your software and will probably try to find a solution under Help or User’s guide documents. Having that in mind, try to be as consistent as possible with usage of terminology and localization in general.
Software localization is a seemingly never-ending process. Each new project comes with new challenges and problems that require unique solutions and this short guide surely can’t predict every single one of them. However, it should serve you as a good springboard for getting to know the whole process and a guiding light through the chaotic world of background code.