Internationalisation in Software Development: Why and How to Prepare for Localisation

Developing multilingual software can be a great way to reach new markets and expand your customer base. Software localisation – making your product available for multiple markets – is key to achieving international growth, but it’s not always straightforward. And when done poorly, you can end up with a sub-par user experience that drives customers away.

That’s why localisation needs to be part of a wider global growth strategy from the very beginning. Leaving it as an afterthought can be costly and time-consuming, and it’s hard to step back and make changes to code that’s already been written.

With that in mind, let’s look at what internationalisation is and how you can future-proof your software development process by following software internationalisation best practices prior to setting a continuous localisation workflow in motion.

In this article, we’ll discuss:

• What is internationalisation in software development?
• Internationalisation vs localisation
• Software internationalisation best practices
• Benefits of software internationalisation

What is internationalisation in software development?

In software development, internationalisation (often abbreviated to “I18N”) is the process of making your codebase ready for localisation. In other words, it’s about preparing your software to support multiple languages without having to re-write large chunks of code from scratch. To localise software, you need to build localisable software in the first place.

Through internationalisation, by designing and developing a piece of software that can be easily adapted to various languages and regions without major changes, you make the localisation process much simpler (and less costly) down the line.

Software internationalisation can deal with many different aspects of software development, including user interfaces, data formats, and workflows. Internationalisation involves things such as:

• Making the app language independent – i.e., not hard-coding text into the source code
• Ensuring that user interface elements such as buttons and menus can be displayed correctly in right-to-left languages (like Arabic and Hebrew) as well as left-to-right ones (like English and French)
• Storing user-facing content in separate strings to facilitate their translation later on
• Using Unicode to support a wide range of languages in your software
• Creating flexible layouts that can adapt to different text lengths
• Allowing users to input dates, times, and currencies in their own format

And these are just a few examples. Ultimately, the goal of software internationalisation is to make it as easy as possible to adapt your software for multiple markets without having to change the underlying code.

Localisation vs internationalisation

It’s a common misconception that internationalisation and localisation are the same thing, but they aren’t. It’s important to understand the difference between internationalisation and localisation, as they are two distinct processes.

Internationalisation is all about making your software ready for localisation, while localisation is the process of actually translating and adapting your software for a specific market.

In other words, internationalisation is a proactive approach that’s carried out during the development process to future-proof your code and make it easier to localise later on. Localisation, on the other hand, is the reactive process of translating and customising your software for a specific market once the code is complete.

Localisation can involve:

• Translating user-facing text into the target language
• Adapting graphics, such as images and videos, for the target market
• Choosing a domain name and creating country-specific URLs
• Providing users with local payment options
• Creating customer support materials in the target language
• Setting up country-specific social media accounts
• Customising keyboard usage
• Removing or replacing text and graphics containing references to objects, actions, or ideas that, in a given culture, may be subject to misinterpretation

And much more. As you can see, localisation is a much more involved process than internationalisation. However, by taking care of the internationalisation stage upfront, you can make life a lot easier for yourself (and your team) when it comes to localisation.

For example, suppose your software includes forms where users have to input their full name and you foresee expansion into Spain. In that case, you might want to consider allowing for the possibility of multiple surnames. In Spain, it’s common for people to have two or even three surnames, whereas in most other countries, people only have one. Internationalisation would involve making changes to the code so that it can accommodate multiple surnames, while localisation would then be about actually translating the form labels into Spanish.

The W3C Group refers to localization as follows:

“Localisation refers to the adaptation of a product, application, or document content to meet the language, cultural and other requirements of a specific target market (a locale). Often thought of only as a synonym for translation of the user interface and documentation, localisation is often a substantially more complex issue. Localisation may even necessitate a comprehensive rethinking of logic, visual design, or presentation if the way of doing business (e.g., accounting) or the accepted paradigm for learning (e.g., focus on individual vs. group) in a given locale differs substantially from the originating culture.”

Internationalisation best practices

Now that we’ve covered the basics of internationalisation and localisation, let’s take a look at some best practices for internationalising your software.

1. Use locales

A locale is a set of parameters that defines the user’s language, country, and any special variation or dialect that might be used. For example, en-US defines American English, while fr-FR defines French as it’s spoken in France.

Using locales allows your software to automatically adjust certain elements, such as date formats and currency symbols, to match the user’s preferences. As explained by IBM:

“A locale is a collection of data that encodes information about the cultural environment. Localization is an action that establishes the cultural environment for an application by selecting the active locale. Only one locale can be active at one time, but a program can change the active locale at any time during its execution. The active locale affects the behavior of the locale-sensitive interfaces for the entire program. This is called the global locale model.”

The use of locales is good practice for two reasons. First, it saves you from having to hard-code specific values into your code for each supported country. Second, and more importantly, it means that your software will always use the correct formats for dates, times, and currencies regardless of where in the world it’s being used.

For example, if a user in the United States enters their date of birth into a form on your website, the software will automatically format this as MM/DD/YYYY. However, if a user in Europe enters their date of birth, the software will format it as DD/MM/YYYY instead.

2. Store user-facing content separately from the code

One of the most important things to do when internationalising your software is to store all user-facing text, as well as software components (user interface controls, user messages, user input methods), in separate files or databases, rather than hard-coding it into the source code.

This might seem like a lot of extra work, but it’s essential for making your software easy to translate later on. If all of your user-facing text is stored in one place, translators will be able to access it easily and make changes as needed, without having to wade through lines of code.

What’s more, if you ever need to make changes to your user-facing text, you’ll only have to update it in one place, rather than having to search through your code for each individual instance. This can save you a lot of time and effort in the long run.

3. Use Unicode

Another important thing to do when internationalising your software is to use Unicode throughout your code. Unicode is a standard for encoding, storing, and handling text in different languages.

Using Unicode will ensure that your software can support any language, as well as any character set. This is important, as some languages use non-Latin characters, such as Arabic, Chinese, and Cyrillic.

UTF-8 is the most common encoding for Unicode, and it’s a good choice for most software projects because it’s compatible with a wide range of character sets.

4. Allow for text expansion

When internationalising your software, it’s important to allow for text expansion. This means making sure that there’s enough space in your user interface (UI) elements, such as buttons and form fields, to accommodate translated text.

In some languages, translated text can be up to 30% longer than the original text. This is due to a variety of factors, such as differences in grammar and word order. As a result, it’s important to leave enough room in your UI elements so that they can accommodate longer text. One way to do this is to use flexible layouts that can expand and contract as needed.

Here’s how text length typically changes when localising from English into some of the most common target languages:

• English to Arabic: text expands by 25%.
• English to Korean: text shrinks by 10-15%.
• English to Spanish: text expands by 20-25%.
• English to German: text expands by 10-35%.
• English to French: text expands by 15-20%
• English to Italian: text expands by 10-25%

Moreover, some languages like Japanese and Chinese need larger font sizes to be legible. So not only should you leave room for translated text to expand horizontally, but you should also make sure that your UI elements can shift vertically to accommodate larger font sizes.

5. Support right-to-left languages

If you’re planning on expanding your software into markets where users speak right-to-left (RTL) languages, such as Arabic and Hebrew, it’s important to make sure that your UI elements are designed to support these languages.

UI elements such as menus and tabs should be displayed in reverse order, from right to left, while text should be aligned to the right. What’s more, it’s important to make sure that your software can handle RTL characters, such as those used in Arabic and Hebrew.

Failing to support RTL languages properly could alienate users and damage your software’s reputation.

6. Allow for different data formats

Another thing to consider when internationalising your software is the fact that different languages use different formats for dates, times, and currencies.

Culturally-dependent data, such as dates, numbers, and currencies, almost always need their formatting adapted, or they need to be converted. With dates and times, this involves time zone adjustments. With money, it is converting from one currency to the equivalent value in another.

For instance, let’s focus on country-specific numbers. They have various decimal and thousand separators:

• 102,300.45 (United States)
• 102 300,45 (Poland)
• 102.300,45 (Germany)

There are different date formats as well:

• Monday, January 1, 2018 3:20:34 PM CET (United States)
• lundi 1 janvier 2018 15 h 20 CET (France).
• 2018年1月1日 星期一 下午03时20分34秒 CET (China)

What’s more, different countries have unique currency symbols:

• £1,200.60 (United Kingdom)
• € 1.200,60 (Italy)
• 1 200,60 € (France)
• $1,200.60 (United States)

An important fact to know is that even if countries have the same currency and currency symbol – like France and Italy – the position of their currency symbol could be different.

7. Don’t use text in images

Embedding text in images might seem like a quick and easy way to display text in your software, but it’s not a good idea for several reasons.

Firstly, it’s not possible to translate text that’s embedded in an image. This means that users who speak languages other than the one the image is in will be unable to understand it. Secondly, text in images can’t be resized, which means that it might not be legible on different screen sizes. And finally, text in images isn’t accessible to users who are visually impaired.

A better idea is to use CSS to put text over images if necessary. This way, you can translate and resize the text as needed.

8. Avoid string concatenation

Linking strings together to form a sentence, or “string concatenation”, is a common programming practice. However, it can cause problems when translating text. The reason for this is that different languages have different word order. This means that a sentence that makes perfect sense in one language might not make any sense at all in another.

When we turn syntax into programmatic code, we’re assuming that all languages will organise words in the same way. For example, if your software displays the message “You have X new messages”, a concatenated string would look something like this: {user} + “have” + {number} + “new” + {object}.

This would work fine in English, but it wouldn’t work so well in a language where the adjective “new” would take different forms depending on the gender and number of the following noun, {object}. Treating grammatical elements as variable data means that translators would have to rearrange them, which would be time-consuming and error-prone.

Benefits of software internationalisation

We’ve gone over some of the things you need to do to internationalise your software. But what are the benefits of going through all this effort?

Simpler localisation

The most obvious benefit of internationalising your software is that it makes localisation easier. Once you’ve internationalised your software, all you need to do is provide translated text for each language you want to support. This is much simpler than trying to localise a piece of software that wasn’t designed with translation in mind.

Faster time to market

Another benefit of internationalising your software is that it enables you to enter new markets quickly. If you want to launch your software in a new country, you’ve got the foundation in place to do so. All you need to do is provide translated text, and you’re good to go.

Improved user experience

Finally, internationalising your software leads to a better user experience for users who speak languages other than the one your software is in. Software internationalisation ensures that your product considers the needs of users from all over the world, not just those in your own country. From rendering prices in the correct currency to displaying the correct date format, internationalisation makes your software more user-friendly for everyone.

Easier maintainance

Software internationalisation also has the added benefit of making your software easier to maintain. This is because you only need to write code once to support multiple languages. If you hard-code text into your software, you’ll need to update each instance of that text every time you want to make a change. But if you store text in separate files, you can make changes in one place, and they’ll be reflected across all languages.

Software internationalisation is just another name for readiness

Preparedness is key in any area of life, and software development is no different. By internationalising your software, you’re preparing it for a future in which users from all over the world can use it. This not only makes good business sense (as you’ll be able to enter new markets more easily), but it also leads to a better user experience for everyone.

So there you have it! These are just a few things to keep in mind when internationalising your software. By following these guidelines, you can be sure that your software will be ready for localisation – and that users from all over the world will have a positive experience using it.