
## Table of Contents

## Introduction

If you're a novice or experienced SimpleLocalize user,
mastering keyboard shortcuts for frequently used actions can significantly enhance your productivity.
To simplify the translation process, we have compiled a list of the most useful SimpleLocalize keyboard shortcuts that you'll use regularly.
These shortcuts include frequently used actions and features that are likely to be part of your workflow.

> Note: macOS users should use the <kbd>⌘</kbd> button instead of <kbd>Ctrl</kbd>.

## Save changes

You can save your changes by clicking the Save button in the Translation Editor. You can also use the keyboard shortcut <kbd>Ctrl + S</kbd> to save your changes.

![Saving changes using keyboard shortcuts](/blog/keyboard-shortcuts/save-changes.mp4)

## Go to next/previous string

Moving from one translation to another is standard during the translation process. To make it faster, you can use the <kbd>Tab</kbd> and <kbd>Shift + Tab</kbd> buttons to go to the next or previous string.

![Going to next or previous translation using keyboard shortcuts](/blog/keyboard-shortcuts/tab-to-next-translation.mp4)

## Go to next/previous string within the same language

You can use the <kbd>Ctrl + Enter</kbd> and <kbd>Ctrl + Shift + Enter</kbd> buttons to go to the next or previous string for translation key **in the same language**.

![Going to next or previous translation within the same language using keyboard shortcuts](/blog/keyboard-shortcuts/list-view-jump-to-next-translation-for-language.mp4)

## Move around the table

Now you can move around the table without touching the mouse. Here is a table with shortcuts:

| Shortcut                        | Action                                           |
|---------------------------------|--------------------------------------------------|
| <kbd>Tab</kbd>                  | Go to the next string                            |
| <kbd>Shift + Tab</kbd>          | Go to the previous string                        |
| <kbd>Ctrl + Enter</kbd>         | Go to the next string with the same language     |
| <kbd>Ctrl + Shift + Enter</kbd> | Go to the previous string with the same language |


![Moving around the translation editor table using keyboard shortcuts](/blog/keyboard-shortcuts/table-view-movement-tab-and-ctrl.mp4)

## Open row with translations

Do you want to quickly check translations or description in [List View](/docs/general/translation-editor/#translation-editor-views)? Use the <kbd>Enter</kbd> button to open the selected row with translations.
You can also quickly jump into the translation input by clicking the <kbd>Tab</kbd> button.

![Opening a row with translation details using keyboard shortcuts](/blog/keyboard-shortcuts/list-view-open-close-edit.mp4)

## Delete translation key

Do you need to delete a translation key? You can click on the row and use <kbd>Delete</kbd> or <kbd>Backspace</kbd> buttons to delete the selected translation key.
After deleting the translation key, the translation editor will automatically select the next translation key.

![Deleting translation keys using keyboard shortcuts](/blog/keyboard-shortcuts/delete-translation-key.mp4)

## Select multiple translation keys with mouse

Select multiple translation keys by holding down the <kbd>Ctrl</kbd> button and clicking on the translation keys.

![Selecting multiple translation keys by clicking on them with 'Ctrl' button](/blog/keyboard-shortcuts/list-view-select-rows-with-ctrl-mouse.mp4)

## Select multiple translation keys with keyboard

Don't want to use the mouse? You can also select multiple translation keys with the keyboard. Use the <kbd>Space</kbd> button to select multiple translation keys.

![Selecting multiple translation keys by clicking a 'Space' button](/blog/keyboard-shortcuts/list-view-select-rows-with-space.mp4)


Keyboard shortcuts for Translation Editor



Localization is an important part of any software development project. With SimpleLocalize, you can easily localize your application and make sure that it is accessible to users all over the world. In this article, we'll share with you our tips and tricks on using SimpleLocalize. So if you are looking for ways to improve your localization process, then read on!

SimpleLocalize provides an in-app localization tools and interface designed with the goal of simplifying the localization process for everyone involved, from developers to translators. It will guide you through the localization of your app and stand by your side when reaching new clients.

Below, you can find our list of tips and tricks for efficient and effective work with translations in SimpleLocalize. These are some tips for the UI adjustments that help you customize the translation layout and adjust it to your preferences. Besides, we have some tips for developers regarding translation hosting or project translation versioning. Let's go!

## Table of contents

## Hide the top bar on the project page

Translation can be a challenging job. It requires knowledge, precision, and an understanding of not only words and grammar, but also context, culture, and people. When facing a problematic term or phrase, sometimes you need to delve into the work or phrase and forget everything else.

SimpleLocalize comes to help you to focus on your work. Open the app in full screen and work on translations only. Use the option to hide the top bar on the project page to view translations in full size.
It is a good option if you don't use the top bar a lot and want to clear up your workspace.

![Hide top bar option in settings](/blog/hide-top-bar-option-settings.png)

![View comparison with and without top bar](/blog/hidden-top-bar.jpg)


## Auto-translation: exclusion dialects

Automatic translation is one of the most used features of SimpleLocalize. As useful and easy it is to translate our texts automatically, the translation services like Google Translate or DeepL do not know everything nor read our minds (so far).

They can greatly help in translating software, yet we need to indicate them which parts we do not want them to translate. Chunks of code, given names or even our project name: these elements we do not want to change to other languages, they would lose their function and meaning.

With **exclusion dialects**, you can indicate to a translation service which and in what way you mark such texts in your translations or source language. There are three options of exclusion dialect used during auto-translation:
- none → everything is translated
- simple → texts in brackets `{}`, `[]`, `()`, or `<>` are excluded from being translated to another language
- ICU → for more advanced translation matching using [ICU formatting](/blog/posts/what-is-icu/).

The default option is Simple exclusion dialect, but you can change it according to your project needs.

![Exclusion dialect for auto-translation](/blog/translation-exclusion-dialects.png)

Additionally, you can **exclude selected words or whole phrases from automatic translation**. Put there your project name or any given name you use, to make sure it won't be translated to another language!

![Exclude words from auto-translation](/blog/translation-excluded-words-or-phrases.png)

## Incorporate webhooks to store translations on your hosting

There is no better nor easier way to automate the translation management workflow than using webhooks. [Incorporating webhooks with SimpleLocalize](/docs/general/webhooks/) allows for automatic updates of translations stored on your hosting platform.

By setting up a webhook in SimpleLocalize and configuring it to trigger on translation updates, the hosting platform can be updated with the latest translations without manual intervention. This ensures that your application always displays the most up-to-date translations.

Add webhooks for your project in the Integrations tab to take full advantage of translation automation. Get notified, update or read translations and let SimpleLocalize work for you with webhook automations.

![Webhooks sample setup](/blog/webhook-settings.png)

## Version projects using backups

SimpleLocalize allows you to create different versions of your translation projects and store them in the cloud for easy access. This way, you can always track the changes made to each version so that you know exactly when something has been updated or modified. You can also quickly restore any version with just a few clicks, making sure that all your translations are up-to-date and accurate.

Create a backup of the current translation status for your project and name it with your version. It will help you to identify the project status. Use it for regular versioning, e.g., 2.1.0, or use it for creating different translation versions for your customers' specific needs.

![translation project backup list](/blog/backup-list.png)

Restore the selected version with one click to apply it to the existing project or create a new project from it without unneeded copying of project files.

![restore translation project version](/blog/restore-backup.png)

## Change language order

A simple yet significant change for translators. If you (like me) find it hard to work with not ordered lists, this easy option will make your life complete and balanced.

After importing translations to SimpleLocalize, you can find languages in different order. If it bothers you, then fear no more. Go to the Languages tab and simply drag and drop the languages in the list to the desired order.

![Change languages order](/blog/change-language-order.mp4)

Now, the languages will appear in selected order in all views. Now you can work and translate in peace of mind. ☀️


## Keyboard shortcuts

Keyboard shortcuts are a great way to speed up your work.
They allow you to perform actions without having to use your mouse.
SimpleLocalize has a few keyboard shortcuts that can help you work faster and more efficiently.

Check out our [keyboard shortcuts blog post](/blog/posts/translation-editor-keyboard-shortcuts/) to learn how to use them.

![Going to next or previous translation within the same language using keyboard shortcuts](/blog/keyboard-shortcuts/list-view-jump-to-next-translation-for-language.mp4)

## Final thoughts

We hope that these tips and tricks will help you to improve your localization workflow and make it more efficient.
If you have any questions or suggestions, feel free to contact us at [support@simplelocalize.io](mailto:support@simplelocalize.io).

Remember to check this post regularly as we will be updating it with new tips and tricks!


SimpleLocalize: Tips & Tricks


## Table of contents

## Introduction

In this article, we will learn how to use formatting instances to format dates and numbers.
We will take a look at the `java.text` package and its classes. We will also learn how to use the `java.time` package to work with dates and times.
Finally, we will learn how to use the `ResourceBundle` object to retrieve localized messages from a properties file.

## `Locale` class changes

Since Java 19, **all constructors of the `Locale` class have been deprecated**.
Instead, you should use the `Locale.of` static constructors to create a new `Locale` instance
or use the `Locale.Builder` class to create a new `Locale` instance.

```java
// static constructors
Locale.of(language);
Locale.of(language, country);
Locale.of(language, country, variant);

// builder
new Locale.Builder()
    .setLanguage(language)
    .setRegion(country)
    .setVariant(variant)
    .build();

// deprecated constructors
new Locale(language);
new Locale(language, country);
new Locale(language, country, variant);
```


## Number formatting

The `NumberFormat` class offers a number of methods for returning different instances for formatting numbers.

 - `getPercentInstance(Locale)` - formats numbers as percentages.
 - `getCurrencyInstance(Locale)` - formats numbers as currency values.
 - `getIntegerInstance(Locale)` - formats numbers as integers.
 - `getNumberInstance(Locale)` - formats numbers as general-purpose numbers.
 - `getCompactNumberInstance(Locale, NumberFormat.Style)` - formats numbers as compact numbers.

### Percentages formatting

Different countries use different symbols for percentages. For example, in the US, the percentage symbol is `%`, while in the UK, it is `£`.

```java
NumberFormat.getPercentInstance(Locale.US).format(0.75);
// 75%

NumberFormat.getPercentInstance(LOCALE_FRANCE).format(0.75);
// 75 %

NumberFormat.getPercentInstance(Locale.of("ar", "SA")).format(0.75);
// ٪٧٥
```

### Long numbers formatting

Compact numbers are a method of formatting numbers in a more compact way. For example, instead of writing `1,000,000`
you can write `1M`.
They are useful when you want to display a large number in a small space. Every locale has its own set of compact
numbers. There are 4 different styles of compact numbers:

 - `NumberFormat.Style.SHORT` - the shortest form of the compact number. For example, `1M` for `1,000,000`.
 - `NumberFormat.Style.LONG` - the longest form of the compact number. For example, `1 million` for `1,000,000`.


```java
// NumberFormat.Style.SHORT

NumberFormat.getCompactNumberInstance(LOCALE_US, Style.SHORT).format(1_213_700);
// 1M

NumberFormat.getCompactNumberInstance(LOCALE_FRANCE, Style.SHORT).format(1_213_700);
// 1 M

NumberFormat.getCompactNumberInstance(LOCALE_POLAND, Style.SHORT).format(1_213_700);
// 1 mln


// NumberFormat.Style.LONG

NumberFormat.getCompactNumberInstance(LOCALE_US, Style.LONG).format(12_137);
// 12 thousand

NumberFormat.getCompactNumberInstance(LOCALE_FRANCE, Style.LONG).format(12_137);
// 12 mille

NumberFormat.getCompactNumberInstance(LOCALE_POLAND, Style.LONG).format(12_137);
// 12 tysięcy
```

### Numbers formatting

The `NumberFormat` class provides a number of methods for formatting numbers.

```java
NumberFormat.getNumberInstance(localeUs).format(1234567.89);
// 1,234,567.89

NumberFormat.getNumberInstance(localeFrance).format(1234567.89);
// 1 234 567,89

NumberFormat.getNumberInstance(localePoland).format(1234567.89);
// 1 234 567,89
```


### Money formatting

Currency formatting is useful when you want to display a number as a currency value. For example, instead of joining
currency symbol and number you can use the `NumberFormat` instance which does it for you in the best possible way,
taking into account the locale.

```java
NumberFormat.getCurrencyInstance(localePoland).format(123.45);
// 123,45 zł

NumberFormat.getCurrencyInstance(localeFrance).format(123.45);
// 123,45 €

NumberFormat.getCurrencyInstance(localeUS).format(123.45);
// $123.45
```

Note that different locales use different symbols for decimal separators and grouping separators. For example, in the US, the decimal separator is `.`, while in Poland and France, it is `,`.

## Symbols and currencies

`NumberFormat` are powerful tool, but what if you want to display a currency symbol or a decimal separator? You can use the `DecimalFormatSymbols` class to get the symbols for a given locale.

```java
Currency currency = DecimalFormatSymbols.getInstance(localePoland).getCurrency();
currency.getDisplayName(LOCALE_POLAND);
// złoty polski

currency.getDisplayName(Locale.FRANCE);
// zloty polonais

currency.getDisplayName(Locale.US);
// Polish zloty
```

Note that we took Polish currency (złoty polski) and `Locale.FRANCE` and Java returned the French name of the currency (zloty polonais).
If we took `Locale.US` and Polish currency, Java returned the English name of the currency (Polish zloty).

Returning symbols works in the same way:
```java
currency.getSymbol(LOCALE_POLAND);
// zł

currency.getSymbol(Locale.FRANCE);
// PLN

currency.getSymbol(Locale.US);
// PLN
```

The `DecimalFormatSymbols` class provides a set of symbols (such as the currency symbol) that are used to format numbers.


```java
DecimalFormatSymbols.getInstance(LOCALE_POLAND).getCurrencySymbol();
// zł

DecimalFormatSymbols.getInstance(Locale.FRANCE).getCurrencySymbol();
// €

DecimalFormatSymbols.getInstance(LOCALE_POLAND).getGroupingSeparator();
// ' '

DecimalFormatSymbols.getInstance(Locale.US).getGroupingSeparator();
// ,
```

## Date formatting

After previous sections, you should be familiar with formatting values using `getXXXInstance` methods and `Locale`
objects. You shouldn't be surprised if I tell you that dates formatting works the same way!

The `DateFormat` class provides a number of methods for formatting date and time.

 - `getDateTimeInstance(int dateStyle, int timeStyle, Locale locale)` - returns a `DateFormat` instance that formats dates and times.
 - `getDateInstance(int dateStyle, Locale locale)` - returns a `DateFormat` instance that formats dates.
 - `getTimeInstance(int timeStyle, Locale locale)` - returns a `DateFormat` instance that formats times.

All methods need a style of date or time and locale. The `DateFormat` class provides a number of constants for formatting dates and times, there are 4 main styles:

 - `DateFormat.SHORT` - the shortest form of the date or time.
 - `DateFormat.MEDIUM` - the medium form of the date or time.
 - `DateFormat.LONG` - the longest form of the date or time.
 - `DateFormat.FULL` - the full form of the date or time.

```java
Date wonderfulDay = Date.from(LocalDateTime.of(2005, 4, 2, 21, 37).toInstant(UTC));

DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, LOCALE_POLAND).format(wonderfulDay)
// sobota, 2 kwietnia 2005 23:37:00 czas środkowoeuropejski letni

DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, LOCALE_FRANCE).format(wonderfulDay)
// samedi 2 avril 2005 à 23:37:00 heure d’été d’Europe centrale

DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, LOCALE_US).format(wonderfulDay)
// Saturday, April 2, 2005 at 11:37:00 PM Central European Summer Time
```

Time has been automatically converted to the local time zone in the first line, where we passed local time and converted it into the UTC time zone.

## Getting messages from resource bundles

In the previous sections, we learned how to format values using `Locale` objects. In this section, we will learn how to read translated messages from the `ResourceBundle` class.

The `ResourceBundle` class is a collection of key-value pairs. The keys are strings and the values are objects. The `ResourceBundle` class provides a number of methods for getting values from the bundle.

 - `getString(String key)` - returns a string for the given key.
 - `getObject(String key)` - returns an object for the given key.
 - `getKeys()` - returns an `Enumeration` of the keys contained in this `ResourceBundle` and its parent bundles.

Put the following code in the `src/main/resources/messages_pl_PL.properties` file.

```properties
footerText=© 2023 SimpleLocalize. Wszelkie prawa zastrzeżone.
linkText=Utwórz konto SimpleLocalize
message=Dziękujemy za wypróbowanie naszego demo SimpleLocalize dla Javy!
title=Hej {0}!
```

Now, we can read the messages using `ResourceBundle` object.

```java
ResourceBundle bundle = ResourceBundle.getBundle("messages", LOCALE_POLAND);

bundle.getString("linkText");
// Utwórz konto SimpleLocalize

bundle.getString("title");
// Hej {0}!
```

As you can see, the `title` message contains a placeholder `{0}`. We can use the `MessageFormat` class to replace the placeholder with a value.

```java
ResourceBundle bundle = ResourceBundle.getBundle("messages", LOCALE_POLAND);
String title = bundle.getString("title");
String message = MessageFormat.format(title, "Jakub");
// Hej Jakub!
```

One of the advantages of using `ResourceBundle` instead just reading from text files is that it supports inheritance.
You can create a bundle that extends another bundle. In this case, the `ResourceBundle` class will look for the key in the current bundle and if it doesn't find it, it will look for it in the parent bundle.


## String normalization

Normalization is the process of converting a string to a normalized form. The `java.text.Normalizer` class provides a number of methods for normalizing strings.

The `Normalizer.Form` class provides a number of constants for normalization forms.

- `Normalizer.Form.NFC` - Canonical decomposition, followed by canonical composition.
- `Normalizer.Form.NFD` - Canonical decomposition.
- `Normalizer.Form.NFKC` - Compatibility decomposition, followed by canonical composition.
- `Normalizer.Form.NFKD` - Compatibility decomposition.

### What is canonical and compatibility decomposition?

In simple words, not technical and unprofessional words, it means that the string with diacritics will be _converted_ to the string without diacritics.
Normalizer splits the string into a sequence of characters and then combines them into a new string without diacritics.

```java
Normalizer
  .normalize("Tĥïŝ ĩš â fůňķŷ Šťŕĭńġ", Normalizer.Form.NFD)
  .replaceAll("[^\\p{ASCII}]", "")
//This is a funky String
```

When else might it be useful? When you work with strings that contain special characters, you should normalize them
before comparing them. Or you want to normalize half-width to full-width characters. Half-width characters are common in
Japanese and Chinese languages, and they were used before the computer era.

```java
Normalizer.normalize("Ｈｅｌｌｏ，　ｗｏｒｌｄ！", Normalizer.Form.NFKC);
// Hello, world!
```

## Summary

In this article, we didn't cover every problem when it comes to internationalization and localization, but we learned
how to face the most common challenges in international Java projects.
We learned how to use the `Locale` class and saw what news Java 19 brings and what it deprecates. We learned how to get
messages from resource bundles, normalize strings and format dates and numbers.

## Resources

- [Java 19: List of supported locales](https://www.oracle.com/java/technologies/javase/jdk19-suported-locales.html)
- [Java 19: Locale class](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Locale.html)
- [Java 19: NumberFormat class](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/text/NumberFormat.html)
- [Java 19: DecimalFormatSymbols class](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/text/DecimalFormatSymbols.html)
- [Java 19: Currency class](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Currency.html)
- [Java 19: Locale.Builder](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/Locale.Builder.html)
- [Billy Korando: Internationalization in Java - Sip of Java](https://inside.java/2022/08/17/sip064/)
- [Java 19: ResourceBundle class](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/ResourceBundle.html)
- [Half-width kana](https://en.wikipedia.org/wiki/Half-width_kana)
- [Java 19: Normalizer class](https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/text/Normalizer.html)
- [Sean Patrick Floyd: Normalization example](https://stackoverflow.com/a/4122207/1133169)


Java 19: Internationalization


## Table of contents

This tutorial comes with GitHub repository with the final code. You can clone it and follow along.
[https://github.com/simplelocalize/spring-boot-i18n](https://github.com/simplelocalize/spring-boot-i18n)

## Introduction

Internationalization (i18n) is the process of designing your application to be adapted to various languages, regional
peculiarities, and technical requirements of a target market.
Internationalization is a crucial step in the process of localizing your product. In this tutorial, we will show you how
to use Spring Boot to create a simple internationalized application,
how to get translated messages from `messages_xx.properties` files, render translated HTML from HTML template
using [Thymeleaf](https://www.thymeleaf.org) and how to use `LocaleResolver` to change the language of the application.

## Used technologies

- Java 19
- Spring Boot 3.0 (RC)
- Thymeleaf 3
- Maven
- SimpleLocalize Editor

![translated spring boot page](/blog/spring-boot/translated-springboot-webpages.png)

## Configuration

### 1. Create `messages_xx.properties` files

The messages are stored in the `messages_XX.properties` files. The `XX` is the language code. For
example, `messages_pl_PL.properties` is the Polish version of the messages.

```properties
footerText=© 2023 SimpleLocalize. Wszelkie prawa zastrzeżone.
linkText=Utwórz konto SimpleLocalize
message=Dziękujemy za wypróbowanie naszego demo SimpleLocalize dla Spring Boot!
title=Hej {0}!
```

If you are using SimpleLocalize, you can download the `messages_XX.properties` files providing your `apiKey`
in `simplelocalize.yml` file and invoking `simplelocalize download` command.

![Downloading messages_xx.properties files via SimpleLocalize CLI](/blog/spring-boot/java-properties-download.mp4)

### 2. Configure `messages_xx.properties` location

The default location for messages is `src/main/resources/messages`.
You can change this by setting the `spring.messages.basename` property in your `application.properties` file
or by providing your `ResourceBundleMessageSource` bean.

```java
@Bean
public ResourceBundleMessageSource messageSource() {
    var resourceBundleMessageSource=new ResourceBundleMessageSource();
    resourceBundleMessageSource.setBasenames("i18n/messages"); // directory with messages_XX.properties
    resourceBundleMessageSource.setUseCodeAsDefaultMessage(true);
    resourceBundleMessageSource.setDefaultLocale(Locale.of("en"));
    resourceBundleMessageSource.setDefaultEncoding("UTF-8");
    return resourceBundleMessageSource;
}
```

![messages_xx.properties in IDE](/blog/spring-boot/messages_in_ide.png)

### 3. Configure resolving locale from requests

The default locale resolver is `AcceptHeaderLocaleResolver` which resolves the locale from the `Accept-Language` header.
You can change this by setting the `spring.mvc.locale-resolver` property in your `application.properties` file or by
providing your `LocaleResolver` bean,
creating `LocaleChangeInterceptor` and registering it via `addInterceptors` method (see `WebMvcConfigurer` class).

```java
@Bean
public LocaleResolver localeResolver() {
    SessionLocaleResolver sessionLocaleResolver=new SessionLocaleResolver();
    sessionLocaleResolver.setDefaultLocale(Locale.of("en"));
    return sessionLocaleResolver;
}

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
    LocaleChangeInterceptor localeChangeInterceptor=new LocaleChangeInterceptor();
    localeChangeInterceptor.setParamName("lang");
    return localeChangeInterceptor;
}

@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(localeChangeInterceptor());
}
```

### 4. Create HTML template with Thymeleaf

If you want to get an HTML document with translated messages, for example, to send it via email, you can use Thymeleaf.
If you are not familiar with Thymeleaf, you can read more about
it [here](https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html).
In short, Thymeleaf is a modern server-side Java template engine for both web and standalone environments.

```html
<!doctype html>
<html xmlns="http://www.w3.org/1999/xhtml" th:attr="lang=${lang}">

<head>
  <title>Spring Boot Email Example</title>
</head>

<body>
<header>
  <h1 th:utext="#{title(${userName})}"></h1>
</header>

<article>
  <p th:text="#{message}"></p>
  <a th:href="${url}" th:text="#{linkText}"></a>
</article>
<footer>
  <p th:text="#{footerText}"></p>
</footer>
</body>

</html>
```

#### Quick Thymeleaf guide:

- `th:attr="lang=${lang}"` - sets the language of the document
- `th:utext="#{title(${userName})}"` - gets a message with `title` key and inserts the value of the `userName` variable
- `th:text="#{message}"` - gets a message with `message` key
- `th:href="${url}"` - inserts a value of the `url` variable
- You can use `th:utext` instead of `th:text` to avoid escaping HTML characters.
- You can use `th:attr` to set the `lang` attribute on the `html` tag.

You can use [https://mjml.io](https://mjml.io) to create responsive HTML emails for free.

## Localized texts

Use `MessageSource` to get translated messages. This is the default way to get translated messages in Spring Boot.

```java
import org.springframework.context.MessageSource;

@Autowired
private MessageSource messageSource;

@Test
void shouldGetTranslatedTextFromLocalFileAndLocale() {
    //given
    Locale locale=Locale.of("pl","PL");

    //when
    String titleTextWithArgument=messageSource.getMessage("title",new Object[]{"Foo Bar"},locale);

    //then
    assert titleTextWithArgument.equals("Hej Foo Bar!");
}
```

## Localized API exceptions

You can also return translated API exceptions by using standard Spring Boot `@ControllerAdvice`.
For this purposes, I created `ErrorController` with two methods annotated with `@ExceptionHandler` to catch exceptions.

- `@ExceptionHandler(Exception.class)` - catches all exceptions not caught by other methods
- `@ExceptionHandler(IllegalArgumentException.class)` - catches `IllegalArgumentException` exceptions

Both methods gets `Locale` from `LocaleContextHolder` and returns translated message from `messages_xx.properties` file
using `MessageSource` bean.

```java

@RestControllerAdvice
public class ErrorController
{
  @Autowired
  private MessageSource messageSource;

  @ExceptionHandler(Exception.class)
  @ResponseStatus(code = HttpStatus.INTERNAL_SERVER_ERROR)
  public ResponseEntity<ApiError> exception()
  {
    String message = getLocalizedMessage("exception.internalServerError");
    HttpStatus status = HttpStatus.INTERNAL_SERVER_ERROR;
    return ResponseEntity
            .status(status)
            .body(new ApiError(message, status));
  }

  @ExceptionHandler(IllegalArgumentException.class)
  @ResponseStatus(code = HttpStatus.BAD_REQUEST)
  public ResponseEntity<ApiError> badRequest()
  {
    String message = getLocalizedMessage("exception.badRequest");
    HttpStatus status = HttpStatus.BAD_REQUEST;
    return ResponseEntity
            .status(status)
            .body(new ApiError(message, status));
  }

  private String getLocalizedMessage(String translationKey)
  {
    Locale locale = LocaleContextHolder.getLocale();
    return messageSource.getMessage(translationKey, null, locale);
  }
}
```

By default, Spring Boot uses `Accept-Language` header to resolve user locale,
but in this
tutorial [we changed this behavior by registering custom `LocaleChangeInterceptor` bean](#3-configure-resolving-locale-from-requests)
.
To change the language of exception, you need to use `lang` parameter, e.g. `/api/my-health?lang=pl_PL`.

![Translated Spring Boot exceptions](/blog/spring-boot/translated-api-exceptions.mp4)

The number of ways to return translated messages is endless,
but the solution above might be one of the best ones
as we keep all the logic and translation keys for exceptions in one place.

## Localized HTML content (Thymeleaf)

Use `ThymeleafEngine` bean to render HTML with translated messages. This is _probably_ the most
popular way to render HTML with translated messages in Spring Boot.

```java
@Autowired
private TemplateEngine templateEngine;

public String renderHtmlFromTemplate(Locale locale,String userName)
{
    Context context=new Context();
    context.setLocale(locale);
    context.setVariable("userName",userName);
    context.setVariable("lang",locale.getLanguage());
    context.setVariable("url","https://simplelocalize.io");
    return templateEngine.process("my-html-template",context);
}
```

![render custom HTML with translated texts](/blog/spring-boot/ide-with-spring-boot.png)

## Localized web pages (Thymeleaf)

You can also return translated web pages (HTML) by using standard Spring Boot `@Controller`.
Spring Boot will automatically resolve user locale and render HTML from `my-html-template.html` template with translated
messages.

This is the default way to return translated web pages in Spring Boot.

```java
@Controller
public class WelcomeController
{
  @GetMapping("/welcome")
  public String renderHtmlFromTemplate(Model model)
  {
    model.addAttribute("userName", "Jakub");
    return "my-html-template";
  }
}
```

Run the application and open `http://localhost:8080/welcome` in your browser.
You can change the language by adding `?lang=pl_PL` to the URL.

![Changing the 'lang' query parameter in Spring Boot](/blog/spring-boot/change-language-parameter.mp4)

## Resources

- [Spring Boot: Internationalization](https://docs.spring.io/spring-boot/docs/2.1.13.RELEASE/reference/html/boot-features-internationalization.html)
- [Spring Boot 3.0: Internationalization using MessageSource](https://docs.spring.io/spring-framework/docs/3.0.0.M4/spring-framework-reference/html/ch03s13.html)
- [Spring Boot: WebMvcConfigurer](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/config/annotation/WebMvcConfigurer.html#addInterceptors(org.springframework.web.servlet.config.annotation.InterceptorRegistry))
- [Spring Boot: LocaleResolver](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/LocaleResolver.html)
- [Full code: simplelocalize/spring-boot-i18n](https://github.com/simplelocalize/spring-boot-i18n)


Spring Boot 3.0: Internationalization


## Table of contents

In this article, I will explain what CORS and CORS errors are and why you might run into them. I will present possible
solutions and explain
what preflight requests, CORS headers are, and why they are important in the communication between parties.
The article assumes you have some basic knowledge of web development and the HTTP protocol.
I tried to write the article in a way that is easy to understand for beginners and fill it with knowledge and try to
avoid too many technical nuances that are not tightly connected with the CORS topic.
If you spotted any mistakes or have any suggestions, do not hesitate to contact me. In some places, I made a
simplification where a service means server and vice versa.

## What is CORS?

**Cross-Origin Resource Sharing (CORS) is an HTTP-based security mechanism controlled and enforced by the client (web
browser).**
It allows a service (API) to indicate any origin other than its own from which the client can request resources.
It has been designed in response
to [the same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) (SOP)
that restricts how a website (HTML document or JS script) loaded by one origin can interact with a resource from another
origin.
CORS is used to explicitly allow some cross-origin requests while rejecting others.

CORS is implemented primarily in web browsers, but it can also be used in API clients as an option.
It's present in all popular web browsers like Google Chrome, Firefox, Opera, and Safari.
The standard has
been [accepted as a W3C Recommendation in January 2014](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing).
Based on that, we can assume that it is implemented in all currently available and other than listed web browsers.

### How does it work?

Everything starts on the client side, before sending the main request. The client sends a CORS preflight request to a
service for resources with parameters in HTTP headers (CORS headers).
The service responses using the same headers with different or the same values. The client decides, based on a CORS
preflight response, if he can or cannot send the main request to the service.
The web browser (client) will throw an error if the response does not meet the requirements of CORS preflight.

CORS preflight requests are sent regardless of the used libraries or frameworks to send requests from web browser.
That's why
you won't need to conform CORS requirements when working with API from your backend application.

> CORS is not going to prevent users from requesting or downloading resources. You can still make a successful request
> for a resource using apps like [curl](https://curl.se/), [Insomnia](https://insomnia.rest/),
> or [Postman](https://www.postman.com/). CORS is only going to prevent the browser from accessing the resource if the
> CORS policy does not allow it.

## What is a CORS preflight?

When a browser sends a request to a server, it first sends an [HTTP Options request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/OPTIONS).
This is called a CORS preflight request. The server then responds with a list of allowed methods and headers.
If the browser is allowed to make the actual request, it sends the actual request. If not, it shows an error and does not continue to send the main request.

![CORS preflight: Server-Client Requests Scheme](/blog/cors-preflight-scheme-server-client.jpg)

## CORS Headers

CORS headers are regular HTTP headers that are used to control the CORS policy. They are used in requests where the
browser sends a CORS preflight request to the server, and the server responses with:

 - `Access-Control-Allow-Origin` indicates what origin can fetch resources. Use one or more origins, e.g.: `https://foo.io,http://bar.io`.
 - `Access-Control-Allow-Methods` indicates what HTTP methods are allowed. Use one or more comma HTTP methods, e.g.: `GET,PUT,POST`.
 - `Access-Control-Allow-Headers` indicates what request headers are allowed. Use one or more headers, e.g.: `Authorization,X-My-Token`. 
 - `Access-Control-Allow-Credentials` indicates if sending cookies is allowed. Default: `false`.
 - `Access-Control-Max-Age` - indicates how long the request result should be cached, in seconds. Default: `0`.

If you decide to use `Access-Control-Allow-Credentials=true`, then you need to be aware of the fact you cannot use 
wildcards `*` in `Access-Control-Allow-*` headers. It's required to explicitly list all allowed origins, methods, and headers.


See a [full list of CORS headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#the_http_response_headers).


![cors request and response headers](/blog/browser-server-preflight-request-and-response-headers.jpg)

## Why is request blocked by CORS policy?
If you are a web developer, you have probably already seen or heard about CORS errors, and you have googled it many times
to find the solution. The most common problem is that the browser blocks the request because of CORS policy. The browser will throw an error and show a log in the console:
```properties
Access to XMLHttpRequest at 'http://localhost:8080/' from origin
'http://localhost:3000' has been blocked by CORS policy:
Response to preflight request doesn't pass access control
check: No 'Access-Control-Allow-Origin' header is present
on the requested resource.
```

The CORS error above notifies a user that the browser couldn't access a resource (`https://localhost:8080`) from an
origin (`https://localhost:3000`) because
the server didn't allow it. It happened because the server didn't respond with `Access-Control-Allow-Origin` header with
the origin or with a wildcard `*` in the CORS preflight response.

A request may be blocked by CORS policy not only because of the incorrect origin, but also incorrect HTTP header, HTTP
method or Cookie header.

## How to fix CORS error?

The fundamental idea of "fixing CORS" is to respond to "OPTIONS" requests sent from a client with proper headers.
There are many ways to start responding with the proper CORS. You can use a proxy server, or you can use middleware in
your server.

![Response to preflight request doesn't pass access control check](/blog/response-preflight-request-doesnt-pass-access-control-check.jpg)

Remember that `Access-Control-*` headers are cached in a web browser according to the value set
in `Access-Control-Max-Age` header.
Please make sure that you clear the cache before testing the changes. You can
also [disable caching in your browser](https://stackoverflow.com/questions/5690269/disabling-chrome-cache-for-website-development)
.

### 1. Configure your server

By default, if you are a server owner, you need to configure CORS responses in your server and this is the only way to
address the issue properly.
You can achieve this in multiple ways and on multiple layers of your app. The most common way is to use reverse-proxy,
API gateway, or any other routing service that offers to add headers to the responses.
There are many services that you can use to do this, some of them are: HAProxy, Linkerd, Istio, Kong, nginx, Apache,
Traefik.
If your infrastructure contains only an application without any additional layers, then you can simply add CORS support
in the application code.

![successful CORS preflight requests in Firefox Developer console](/blog/cors-preflight-requests-in-firefox-developer-console.png)

Here are some popular examples of enabling CORS:

- [Apache: modify .htaccess file](https://enable-cors.org/server_apache.html),
- [Nginx: modify configuration file](https://enable-cors.org/server_nginx.html),
- [Traefik: use middlewares](https://doc.traefik.io/traefik/middlewares/http/headers/#cors-headers),
- [Spring Boot: use `@EnableCORS` annotation](https://github.com/jpomykala/spring-higher-order-components),
- [ExpressJS: use `app.use(cors())`](https://expressjs.com/en/resources/middleware/cors.html),
- [NextJS: use request helpers](https://nextjs.org/docs/api-routes/api-middlewares#cors-support).

Here you can find more examples of enabling CORS in different frameworks and
languages: [enable-cors.org](https://enable-cors.org/).

If you cannot enable CORS in the service, but you still want to make request to it, then you need to use one of the
following solutions described below.


### 2. Install a browser extension

Using a browser extension might be a quick and easy way to solve your problems with CORS in your developer environment.
The biggest advantage of using a browser extension is that you don't need to change your code or configuration.
On the other hand, you need to install an extension on every web browser that you use for testing your web application.

![Use browser extension to overcome CORS error](/blog/cors-preflight-browser-extension-solution.jpg)

Browser extensions alter incoming preflight request by adding the necessary headers to trick the browser.
It's a handy solution to work locally with the production API that accepts requests only from the production domain.

You can find extensions in [Google Web Store](https://chrome.google.com/webstore/search/cors?hl=en-US) or
in [Mozilla Add-ons Library](https://addons.mozilla.org/en-US/firefox/search/?q=cors).
In some cases, the default extension configuration might not be enough; make sure that the installed extension is
configured properly.
You should also be aware of that leaving the extension turned on indefinitely may cause problems on some websites. It's
recommended to use them only for development purposes.

### 3. Disable browser CORS checks

You can disable CORS checks in your browser completely. To disable CORS checks in Google Chrome, you need to close the
browser and start it with the `--disable-web-security` and `--user-data-dir` flags.
By doing that, Google Chrome will not send CORS preflight requests and will not validate CORS headers.

```bash
# Windows
chrome.exe --user-data-dir="C://chrome-dev-disabled-security" --disable-web-security --disable-site-isolation-trials

# macOS
open /Applications/Google\ Chrome.app --args --user-data-dir="/var/tmp/chrome-dev-disabled-security" --disable-web-security --disable-site-isolation-trials

# Linux
google-chrome --user-data-dir="~/chrome-dev-disabled-security" --disable-web-security --disable-site-isolation-trials
```

All of those commands above start Google Chrome in an isolated sandbox. They will not affect your main Chrome profile.

![Disable security in Google Chrome to overcome CORS error](/blog/disabled-cors-preflight-in-web-browser.jpg)

See list of all [available flags for Google Chrome](https://peter.sh/experiments/chromium-command-line-switches/). 

### 4. Set up a proxy server

If you are looking for a solution that doesn't require you to change the browser settings, then you should look at the
proxy server solution.
This option helps you to overcome CORS errors without changing anything in the browser itself.
The idea of using a proxy server is to send all requests to your server, and then the server will send the request to
the actual service you want to use.
You can build a proxy server on your own in a language and framework of your choice. You will need to configure CORS and
implement a functionality to pass requests received requests to another service.

![Use proxy server to overcome CORS error](/blog/cors-preflight-proxy-server-solution.jpg)

Proxy server is a good solution if you don't have access to the service you intend to use.
There are ready to use and open-source proxy server services, but you should always ensure that they are not trying to
intercept your requests with authorization headers and pass them to any 3rd party service.
Such security breaches could be catastrophic failure for you and potential users of the service.

List of open-source CORS services that you can find on the internet:
- https://github.com/Freeboard/thingproxy
- https://github.com/bulletmark/corsproxy
- https://github.com/Rob--W/cors-anywhere

Please review the code of the newest version before using any of those services.

## How to test CORS?

Using a browser to test your CORS configuration might be a tedious task.
You can use a tool like [CORS Tester](https://cors-test.codehappy.dev), [test-cors.org](https://www.test-cors.org/), or,
if you are familiar with the command line, you can use [curl](https://curl.se/) to test your CORS configuration.

```properties
curl -v -X OPTIONS https://simplelocalize.io/api/v1/translations
```

![free open-source web-based CORS tester](/blog/free-cors-tester-web-application.png)

## Beware of false CORS errors

In some cases, when a service is behind an additional layer with rate-limiter, load balancer or authorization server,
you can get a false CORS error. Blocked or rejected requests by a server should respond with error status codes. E.g.,:

 - 401 unauthorized,
 - 403 forbidden,
 - 429 too many requests,
 - 500 internal server error,
 - any other than 2XX or 3XX.

You may see that the request is blocked due to failed preflight request, but in fact, a service just rejects it. You
should always check the status code and response body of the response to avoid unnecessary debugging.
The browser properly alerts you when a CORS preflight request fails, but the reason for the failure is not necessarily
connected to the CORS configuration.


## Conclusion

In this article, I tried to explain what CORS is, and what are the most common problems with it. I suggested 4 ways to
fix CORS issues and explained the advantages and disadvantages of each one.
I also explained how to configure CORS responses properly and how to test them. Moreover, I showed what are the most
common issues with recognizing false CORS errors.
I tried to put everything in simple terms and avoid technical nuances. If you have any questions, doubts, or
suggestions, please do not hesitate to contact me.

Happy coding!

## Resources
- https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS/Errors
- https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy
- https://enable-cors.org/
- https://stackoverflow.com/a/42024918/1133169


What is CORS?


AI translation is a technology that has been around for years, and it is getting smarter and more efficient each day. In
this blog post, you will learn how to optimize your website for AI translation and make it easier for machines to
translate your content into other languages.

The use of AI translation services is growing in popularity as the technology becomes more advanced and accessible. This
is because AI-powered translation services like DeepL or Google Translate provide a high-quality translation with
minimum human intervention. AI can translate text in real time, which can be helpful not only for instant translation,
but also for translating the whole website or app content in just a few seconds.

## AI translation options for your website

The visitors of your website usually have two options to see its content in their language. First is enabled on your
side, by creating multilingual website and an option to support different languages. Second one is using browser
extensions or built-in translation services by the user. Both can base on machine translation, and thus both need some
website optimizations and thing to consider when preparing content for AI translation.

### Website localization

Website localization involves not only translation but more importantly adapting the site to the language, culture, and
habits of the recipients. Creating your website in new languages can be challenging at first, but it has many benefits:

- users can access the website content in their mother tongue
- it is easier to find the website in different languages in search engines
- website can load instantly translated and localized to in the user language
- boosting website traffic and making it visible for users from other markets
- increasing customers base
- improving customer satisfaction and relations by more personalized content

### Translation on browser side

Most browsers, like Google Chrome, offer an option to translate pages to the recipient language using AI translation,
like Google Translate. Besides that, there ale multiple extensions also in other browsers that run the AI translation
and translate the website content automatically for the client.

It is a great tool to translate website in less used languages which do not have their version in English and other
languages. However, note that not everyone knows that there is such an option and how to use it. Those users simply
won't find nor get to your website at all. If your website is not optimized for AI translations, the results may not be
so accurate.

## Website optimization for AI translation services

For any type of website or app translation, especially those that use AI translation, it is recommended to optimize its
content and structure, for the best translation quality. Good optimization makes translation management easier and
improves the software internationalization process.

Translation of not optimized website can not be accurate, and occasionally, it can make no sense for the end user. To
avoid such inconsistency and misrepresentation of content on your website, consider the following optimization tips and
bring your website in line with AI translation services.

### UX writing and translations

User-experience writing focuses on user impressions of all your website content. The goal is to keep all forms of texts
as simple as possible, at the same time conveying the information in a precise but user-friendly manner. Users should
perceive the content as something natural, understand it and feel the website's message effortlessly.

UX writing is inseparable from translations and their accuracy. Your website must feel right in all language version,
not only in English. That is why, for the start, we need to create translation-friendly content in the website source
language.

Here are some advices that, when applied in your source language, can highly improve AI translation results in other
languages:

- **Create simple, not complex phrases** and short sentences. Texts must be easily understandable by users from
  different countries whose English in not their first language. This is also great for getting more accurate machine
  translation results.
- **Use relative pronouns** like “that” and “which” in the source language to build the complete sentence. It will make
  texts clearer and at the same time improve AI translation quality and precision.
- **Be precise** when writing the main text, focus on the meaning of the text. Choose words that have only one meaning
  if possible to avoid misinterpretation by translators or machines.
- **Avoid using passive voice**. It is great advice for content writing in general, and it helps in text optimization
  for AI translation too.
- **Avoid abbreviations**. Sometime abbreviations may not be known or recognized correctly by AI, so it is better to
  avoid them or add the expansion next to the abbreviation itself.
- **Avoid colloquialisms and idioms** as they may not be properly translated by AI, as they may not have their
  corresponding in the target language.

### Character Length and Text Wrapping

Translated texts in some languages like German or Dutch can result much longer than the English version. Keep that in
mind when creating your website UI by adjusting the site to accommodate longer words or sentences. **Decide on the
maximum characters count** that that specific key can work with, and also the width of the whole text. Try adding some
extra space for a bit longer translations.

For longer paragraphs, have in mind also how texts are displayed. A sentence in one line in English can result with two
lines in Spanish. To manage such cases of text expansion, **use text wrapping to break texts into more lines** if the
translation text is longer than the element width. Estimate text expansion and how much space it can take to decide if
text-wrapping is necessary.

### Avoid string splitting

String splitting is a situation when one block of text is divided into smaller chunks. It usually happens when there is
some value inside that block, that is taken from the database.

Let's check an example. “From $12 per night”, this block is logically coherent when in one sentence, but to make it work
in different places, with different prices, developers need to replace $12 with a value from the database. To achieve
that, they split the block into different fragments: `From`, `{roomPrice}` and `per night`.

Such string splitting creates two different translation keys, `FROM` and `PER_NIGHT`. In this case, AI will translate
them separately, not knowing that there is something between those keys that makes them one logical sentence.

In such cases, to improve AI translation results, it is better to use **{} placeholder** instead to not split the
string. The correct source text in this case would be:

`From {roomPrice} per night`

### Set up words excluded AI translations

Sometimes you don't want AI to translate some words or expressions to other languages because they are **proper nouns or
proper names**. Translating them to another language would make no sense or could entirely change the meaning of the
text. Imagine translating your company proper name in a sentence, the output would not be accurate.

In SimpleLocalize, you can create a list of words or expressions that you want to exclude from
the [auto-translation process](/blog/posts/how-to-use-auto-translation/). DeepL or Google Translate will consider them
as proper names and won't ever translate them.

## Do you need a review of machine translated texts?

AI translation, although very well-developed, also has some drawbacks. There are still some words and phrases that
cannot be translated correctly, even with AI assistance.
Currently, AI translation still cannot replicate the nuances of the original language. This is why, if you care about
translation quality and accuracy, it needs to be reviewed by a professional translator before being published.

### How to help translators in AI translation review?

Translation review is a crucial step in translation management to provide users with accurate and localized content. To
make the review easier and more efficient for professional translators, make sure to give them the following
information:

- **Context of the translation keys and where they are located on the website**, so they can verify the accuracy of the
  translated text. Note that context is not only the location, but the overall use of the text, when it appears for the
  user, on what action it shows up, in what situation it appears. This is important as the way of translating texts is
  strongly connected to its context.
- Does the translation key work as a button or heading, or maybe it is used in the footer of the website? The usage,
  **function of the key will define and affect the translation**. You can translate differently a simple key “Book Now”
  for a button (“Book Now”), for a headline (“Book now and start your experience”) or a footer (“Booking button”). It
  can have different translation for different text function, so make sure you add this information for translators.
- **Translation formality and style** – to whom is this text directed? Who is the recipient? How to address them? The
  formality differs in many languages. Your text may be very straightforward and direct in English, but should it be the
  same in German or Spanish in Spain or Chile? AI might not always be that accurate to catch those differences, but
  professional translators will be able to verify and correct the text formality to make it suitable for the recipient.
- **Length of translation** – translators can see and compare number of characters of source text and translations to
  make sure they are not significantly different.

## How to translate your website using AI translation?

Make your website multilingual with AI translation services like DeepL or Google Translate and SimpleLocalize
translation management system. It is a great way to get started with your website content translation
and [software localization](/blog/posts/software-localization/).

Start with uploading your translation keys and source language to SimpleLocalize, add new languages and use
auto-translation option to translate them in seconds!
SimpleLocalize [translation editor](/blog/posts/translation-editor-explained/) will help you to update and manage
translations and review texts translated by AI.

Using translation management system helps not only in translating your website or app, but also provides with:

- translation hosting
- seamless updates of your translation files
- intuitive and customizable translation editor
- team workflow and tools for developers, translators and managers
- easy import and export of translation files
- translation project sharing
- machine translation with DeepL and Google Translate

## Explore our simple and intuitive translation editor

Are you ready to start translating your website content with AI translation
services? [Register now to SimpleLocalize](/register/) and start managing your website translations and add new
languages with just a few clicks. **Get started with a 14-day trial** or use our free Community plan for your website
localization!


How to optimize your website for AI translation


Project translation seems like a big change and a challenge, and a great improvement at the same time. To translate your 
application you need time, research to find the most suitable framework, resources in the form of developers' time, 
and of course translators. A simple translation management system would help too. 

As you see, adding new languages might be hard at the beginning, but it definitely pays off eventually. We know what are 
the obvious benefits for adding more languages to your project, like boosting customer base, improving customer relations 
and increasing engagement. But is that all? See our list of 5 not obvious benefits from translating your application 
and check how they can help to grow yur project!

## 1. Cleaner code

Remind yourself how your code looks like when you have a 10-line text about your product on the landing page. And that's 
just one text, there are more on the same page and on their sites. That creates a giant wall of code, which makes it more 
cluttered and not so readable.

```jsx
<p> SimpleLocalize was created by Jakub Pomykała back in 2019 in response 
to the lack of simple translation management solutions. With that in mind, 
he built a simple translation editor which supports many popular frameworks 
and formats. SimpleLocalize now has two members, Jakub himself as a brain, 
heart and hands of the whole system, and the author of this post, Kinga.
We built SimpleLocalize with simplicity in mind, with the idea of a user, 
translator and developer-friendly software that is easy to integrate in 
any workflow. By checking SimpleLocalize changelog you can see new features 
and improvements that we added as a response to our customers' needs.<p/>
```

When your app is translated, you are changing those large block of texts into simple, few-words keys. Instead of writing 
a whole paragraph about your company, you just add `ABOUT_US` key. It's one less distraction in your code caused by a text element. 
Instead of very long text, **you can close the entire paragraph in a just one line of code**. Below, an example using 
`FormattedMessage` component from FormatJS.

```jsx
<p><FormattedMessage id="ABOUT_US"/><p/>
```

## 2. Same text on every button

When using translation keys, it is very easy to use existing translations and apply them to selected elements in your app! 
Instead of adding different texts for all the same buttons within your app, replace the text with key. It will help you avoid 
errors and spelling mistakes across the app, and you won't need to repeat the same texts with every use.


## 3. Easy proofreading

Proofreading can be time-consuming when done directly in the code or when the reviewer must go open all pages in your 
app to check the content. When your app is translated, the reviewer checks only a single-language file with all 
texts in one place. It can save a lot of time and there is **no chance of missing some hidden text**! It's the same when 
using SimpleLocalize, all translations are visible and available for the proofreading.

![Quick review of all translations](/assets/features/translation-manager-for-quick-review.jpg)

## 4. New languages without developers' assistance

When you have already started with translation management, and you have at least two language versions of your app, 
adding more languages is simple. To add a new language, all you need is to add the translation for the existing keys, 
and **developers are not involved in the change**.

![Add new languages to your application](/blog/project-languages.png)

With SimpleLocalize, all can be done directly from the project view. In **Languages** tab, simply [add a new language](/docs/general/languages/), 
and start translating it in the editor. Would you like to see the new language without hiring translators? Run [auto-translation](/docs/general/auto-translation/) 
for that language and get ready to go translations in one minute!

## 5. Lower chance to make a typo

When your app in translated, all texts are kept in separate JSON files, so you can better see the translated text. 
If there is only one language version directly in the source code, you need to check each file and search for texts 
between the code lines.

It's even better if you are using a translation management solution like SimpleLocalize. An intuitive online translation 
editor will make it easier to manage texts and see errors, and avoid typos. Another way is to use the [Suggestions](/docs/general/suggestions/)
feature, which can **find grammar issues in all languages in your project and correct them for you** with just one click.

![Find and fix grammar issues with Suggestions](/changelog/suggestions.png)

## Online translation management for your application

If you decided to get started with your app localization, [try SimpleLocalize](/register/) and see how it can help in the translation 
management process. Save time thanks to online editor and easy integration, and work with your team to expand your business 
to new levels. Check how it works for you during 14-day trial or use the app for free for basic translation software. [Learn 
more about SimpleLocalize](/blog/posts/what-is-simplelocalize/) and [contact us](/docs/general/support/) if you still have doubts! ☺️


5 not obvious benefits from translating your application


In this blog post, I will describe to you the most powerful feature of SimpleLocalize, the translation editor. 
It is an essential tool that helps managers, developers and translators in website, app, or any other type of digital content translations.

Localization became one of the most important steps in expanding customer bases and reaching to more people all around the world in their local language. 
It's a considerable task, but SimpleLocalize can help you to simplify the process and support you in daily translations work with great tools, that I describe below.

## Translations view

SimpleLocalize provides with two different views for editing translations. Each of them has specific features and is adjusted to user's role.

### Table View

Table view is a simple, and  at the same time powerful, default spreadsheet-like view. It can store thousands of keys and translations in multiple languages. 
It is easy to use for any type of user. To start translating, simply click on text input and enter your translation in the selected language.

![Translation manager table view](/assets/features/simple-translation-manager-table-view.jpg)

You can customize the table view with different options, to make your work more efficient. All view options you can find in the Settings button in the top-right corner of the table.

#### Languages filter
By default, the table will display all project languages. If you are a translator, you can select only languages that you need for your work, for example, source and target languages.


![Translation manager languages filter](/assets/features/translation-manager-filter-languages.jpg)

#### Key descriptions
Have you ever encountered a problem with locating the translation key and finding out where was it placed in your app? Key descriptions are great help in such cases. 

You can put some help text there, or even add a link to a screenshot with key location! The link with a screenshot of the location will be clickable, and it will open in a new tab automatically. **Key description will add more information and context to the key and save translators time**, so they don't need to search for details or ask other team members for guidance.

![Translation manager translation key descriptions](/assets/features/translation-manager-key-description-for-translators.jpg)

If you are using descriptions directly in your source code, you can also show them in the editor with **Code Description** option from view settings. 

#### Number of characters
Fitting translation texts in different languages to a fixed width element on your website or app, can be a challenging task. Use description column to determine maximum number of characters for keys in problematic locations, and translators will see their text characters count in the editor! 

![Characters count indicator in translation manager](/assets/features/translation-manager-characters-count.jpg)

Save time on counting characters, checking if texts fit well enough. Translation text summary setting in SimpleLocalize will help you control such cases from the start.

#### Auto-translation indicator
Have you already tried the [auto-translation feature](/blog/posts/how-to-use-auto-translation/)? It's **a great help in speeding-up the translation process** for all users! When a key is auto-translated, you can use the option to show the auto-translation indicator near the affected text area. It will look like this, showing the translation service:

![Auto-translation indicator in translation manager](/assets/features/translation-manager-auto-translation-indicator.jpg)

With that option, you can see which keys were auto-translated and need to be verified. Editing such a translation manually will remove the auto-translation indicator. Use that feature to revise and confirm your translations with ease!

#### Search and sort your keys
Do you care only about new or not translated keys? Use sort option to quickly see the newest keys, recently modified translations or missing ones! Search bar will help you find a key or translation text. Those simple filters help in your daily work, when you need to update specific translations, or add and translate new keys.

![Search and sort translation keys](/assets/features/translation-manager-sort-and-search-translations.jpg)

### List View

If you need a **simple list of all keys with their properties and translations**, switch to List View. It's a great option for more advanced projects that require specific information about the key or translation, like when it was created or its source file.

List view contains the list of keys separated in rows. You can expand each key to see translations for each language, key description and information when the key was created or last seen.

![SimpleLocalize translation list view](/assets/features/translation-manager-list-view.jpg)

Another option for the list view is **Side-by-side view**. It splits the view into two columns, so you can see two languages at one. Set the source at the left and target language on the ride side of the view. Below, you can show more information like key details, key or code descriptions.

![SimpleLocalize translation list view](/assets/translation-editor-interface-side-by-side.png)


#### See all your keys

In this view, you can see all your project keys at once, and it's a great option for bigger projects, as it can easily store and display multiple keys. In just one view, you can see the progress of translations to all languages for each key and quickly check translations for selected language with  view options.

![Quick translations reviewing](/assets/features/translation-manager-for-quick-review.jpg)

Moreover, list view has options to **sort and search translations**, as it works in table view.

#### For longer texts

List view is a **great option for translating longer texts**. In view settings, you make text areas bigger and choose the option to wrap text, so you can see all content without scrolling or expanding the area manually.

![Translation editor for long translations](/assets/features/translation-manager-for-long-translations.jpg)

The option to show text summary with number of characters, words and white spaces will help you to control the text length.

#### Key namespace for multi-file translations

If you are using [translations uploaded from multiple files](/docs/cli/upload-translations/), the list view can show you the key namespace (like file path). With that option, you can see from which file the key was uploaded, and that is very useful when you want to upload only the keys from your landing page (one of multiple folders) or from just one language.

![Translation management and namespaces](/assets/features/multi-file-namespaces.jpg)

Learn more about [uploading and downloading translation files with CLI and multi-file option](/blog/posts/multi-file-upload-download/).

#### Customer-specific translations

List view gives you an option to **translate your keys in multiple versions for one language**. This feature, [customer-specific translations](/blog/posts/customer-specific-translations/), allow creating different translation version for specific customer's need. With that feature, you can tailor your app to your customer's needs or requirements, without changing the text and their meaning for other users of your product.   

![Customer specific translations](/assets/features/translation-for-every-customer.jpg)

## Translation management

Wondering how to start with SimpleLocalize? [Sign in with our free community plan](/register/) and [upload your translations](/docs/general/import/). You can do it by importing an Excel file, with API or CLI. With your keys in the system, you can start translating them, adding more languages and sharing the project with your team. [Use auto-translation feature](/docs/general/auto-translation/) to quickly translate your keys to new languages. 

For any doubts, contact Jakub, the creator of SimpleLocalize at jakub@simplelocalize.io.


Translation Editor Explained


Localizing your product is a great way to reach new markets and generate more revenue. However, it will only be beneficial if you avoid the most common problems with localization.
There are some simple and easy-to-follow tips that you can utilize to make sure that your localization process is successful. 

## Give your texts enough space

If you have tight layouts, a rough rule of thumb is to double the English text and make sure it fits. 
Then you will usually have enough space for translations. 
Russian and German tend to have the longest translations, and the longest words. Get familiar with the shy-hyphen `&shy;` character. You put it in the word's HTML, and it will only break the word/show the hyphen when necessary. 
You can also Google: "[online hyphenation tool](https://www.google.com/search?q=online+hyphenation+tool)" 
so you know the appropriate places to break the word. Here are some example applications:

- [ushuaia.pl](https://www.ushuaia.pl/hyphen/?ln=en)
- [hyphenation24.com](https://www.hyphenation24.com/)
- [hyphenator.net](https://www.hyphenator.net/)
- [juiciobrennan.com/hyphenator](https://juiciobrennan.com/hyphenator/)

![number translations](/blog/number-translations-problem.jpg)

## Number translations

You need to translate numbers with decimals and commas because they are reversed in some languages.
For example: period appears as a comma, comma as a period.

If you are a JavaScript developer, then you can simply use 
[Number object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString) 
to format numbers. See example below:

```js
var exampleNumber = 123456.789;

exampleNumber.toLocaleString('pl-PL');
// output: 123.456,789

number.toLocaleString('ar-EG');
// output: ١٢٣٤٥٦٫٧٨٩
```

## Percent sign problem

The same goes for percent signs. Sometimes the % shows before the number, and not after also there might be a space between the number and percentage sign.
English style guides recommend writing the percent sign (%) following the number with no space between (e.g., 50%) however this might differ for different languages.
- In Turkish and some other Turkic languages, the % sign precedes rather than follows the number without an intervening space.
- In Persian the % sign may appear before or after the numeric value, in either case without a space.
- In Arabic, the % sign is to the left of numbers, as numbers are written from right-to-left. This means that the % sign is to the left of a number. Usually, there will not be a space between this % sign and the number.

## Watch out for Greek question marks
The Greek question mark (;) is often mistaken for a semicolon (;). 
The former marks the end of a sentence or phrase, while the latter is used to separate clauses in the same sentence.

![greek question makr](/blog/greek-question-mark-intelij-idea.png)

## Keep datetime in UTC 
- Always keep datetime in database in UTC. 
- Always return datetime from backend in UTC. 
- Adjust datetime on UI layer using timezone information from user or web browser. 
- Accept datetime in backend with any timezone.

You don't need any special library to format time from UTC to local for users. You can
use standard [JavaScript Date object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) like below:

```js
new Date('2010-10-04T09:48:11.000000Z').toLocaleString('en-US', {
  timeZone: 'Asia/Calcutta'
});
```

The main benefit to that is that the time is always guaranteed to be consistent. 
However, if you would like to reproduce some bug for a user in different timezone, it might be more challenging.
You will be forced to change timezone in your web browser to get the same data as your users sees. 


Localization: Tips & Tricks


Did you find out a smart way to handle i18n, and it didn't work again? See our 7 tips how to make your
localization better and easy to maintain. We worked for over 4 years with many companies on their i18n localization
systems. Now we are sharing our experience with the audience! 

## Use unique translation keys

For each translation, use a separate translation key. Do not try to cheat the system. This may result with changing translation 
in multiple places, which may not fit everywhere. It's hard to discover such problems later. Try to keep **one i18n key per translation**. 
This allows you to precisely edit content in place where you want.

## Don’t capitalize with CSS

When you try to cheat the system using one key in multiple places, you will notice that in some places you need
capitalized translation, and somewhere else you don’t want to use this. The solution is to use unique translation keys for every
place, and capitalize it properly. Remember that different languages have different grammar rules. Not in every language we capitalize the days of the week. 
Many **users will easily notice the grammar issues**, and this can cause they won't stick with your application for a long.

## Use same translation keys in buttons

If some action in your service does the same thing, then you should use the same translation key every button. This is one of few places where you should use the same translation key. Thanks to that, you will always keep the
context. The same wording will help your users to understand what they are doing. Be consistent, users will thank you and more easily understand the system.


![localization progress](/blog/localization-progress.jpg)

## Don’t nest translations

How many times did you tried to create fancy directory structure to get everything clean and tidy? Probably many. After
a few days, you end up with the same mess which you had because instead of searching the correct directory, you just put
files to ‘temporary’ directory. It looks like the same with the translations.

In many i18n libraries, it’s a common approach to use **nested translations** like the following:
```json
{
  "nav": { 
    "buttons": 
        { 
          "get-started": "Get Started"
        }
  }  
}
```

Don’t do this, this tidiness is artificial, and it won’t help. Imagine that your app will evolve because [the only constant in software development is
change](https://medium.com/skiplist-publication/software-principle-11-the-only-constant-is-change-5c3be83c9ec5). Moving translations
around will be a nightmare. After some time, the translation key may not belong anymore to some parent node. 
Then you will have to choose which key should go to another nested group.

## Keep flat structure

If you think that keeping translation in 'groups' is a good idea, then consider using prefixes. 
In some scenarios, it is a good idea, for example for navigation keys, or buttons. You can use category for each translation keys like following:
`nav-product-solution`
or
`nav.product-solution`

It makes sens because you will exactly know which translation will be changed.

## Consider i18n management

[Translation management](/translation-editor) is being more and more important topic when your project grows.
Many i18n libraries use JSON files to keep translation files. The structure varies, but in general, all of them looks
 similar. **The biggest i18n problem is that it’s very hard to handle without a proper tools.** Image that every of
translations are packed into separate json file named: "en.json", "de.json", "fr.json", "it.json" and every file contains structure like this:

```json
{ 
  "sign-in": "Sign In",
  "get-started": "Get Started",
  "register": "Register",
  "logout": "Logout",
  "close": "Close"
}
```

**Adding a translation to many files can be frustrating and slow down the development process.** Now you need to send it to translator or translate it on your own
using [DeepL](https://www.deepl.com/home), [Google Translate](https://translate.google.pl/) or [Microsoft Translate](https://www.microsoft.com/translator/). 
Creating localized apps or games can be really annoying in such conditions. That is why
we created SimpleLocalize. [Clean, simple, and user-friendly system for handling i18n](https://simplelocalize.io). We provide many i18n library integrations including [i18next](/docs/integrations/i18next/), [FormatJS](/docs/integrations/format-js/), Android and iOS. [Translation keys can be easily extracted](/docs/cli/get-started/) from the projects,
uploaded to [translation editor](/translation-editor/). Our localization command-line tool can simplify this
process. [Book a demo with me](mailto:contact@simplelocalize.io) to see how your life can be easier with the SimpleLocalize!

![easy localization progress](/blog/localization-progress-bonjour.jpg)

## Finding unused translation keys

One of the biggest issues in agile teams is that system changes and evolving fast! That causes a problem with
translations which must keep up with a product evolving. It’s easy to add a new translation in code and ping translators.
But what happens when your product now contains 10x times more translations keys than the beginning? Many of them are
still useful but not used, the key has been changed, but the meaning is still valid, so it’s hard to say if we can remove it or no. The solution is SimpleLocalize system, which will help you in finding out which translation keys are not used in the code. Integrate your project with our translation management service and sort translation keys by last occurrence! To extract translation keys from the project files, you can use our [Localization CLI Tool](/docs/cli/get-started/). [It’s open source](https://github.com/simplelocalize/simplelocalize-cli), so it can be
used in an enterprise project.

## Conclusions

[App localization](/react-localization) is not the easy topic. Many people tried to find out the new smart way of handling it, many of them failed due to over-engineering stuff. How about keeping everything simple, and clean? Try to always follow the KISS rule, every professional software developer will tell you that! 



7 tips to make your localization work more productive


## Reaching global audience

Did you ever wonder which apps need translation management because handling translated content is time-consuming?
Especially when you provide more than 2 languages! Continuous changes in-app translation can take a lot of resources of
your team, and at some point, everybody will stop carrying about all languages except the default one. How to stop
wasting resources on app translation, and still provide high-quality translations?

![reaching global audience](/blog/global-audience.jpeg)

## 1. Travel apps

Travel apps need content translation to reach a global audience. A good example is our second project
called [PlaceFlare](https://placeflare.com) with hand-picked places from a few countries like Italy, Great Britain,
Spain, Czech Republic, and Poland. The app contains about ~250 unique translation keys, which are gathered from the
application source code using [SimpleLocalize CLI](/docs/general/translation-hosting). All keys are
transferred to the [SimpleLocalize Web Editor](/translation-editor)
where everything can be translated by native speakers and volunteers. When they finish work, somebody (translator or
project admin) can publish changes and voilà! Everything is done, there is no need for re-deploying the app or
re-building the project. Translations are fetched in real-time from the SimpleLocalize CDN, where all translations sit.

![placeflare travel app with 5 languages](/blog/travel-app-with-5-languages.png)

## 2. eCommerce apps

The global market is one of the best things which gave us access to the Internet. Buying stuff has never been easier,
you can be based in Eastern Europe and sell your products to the locals, or the next day you will get an order from Brazil. What stops your clients more from buying your products online than long-distance? Fear that they will fill up
the order form wrong, and they will lose money. They will return to your page many times thinking about buying from you, and on the second screen, they will be looking for local stores. What can you do with it? Make them confident that in case of a problem, they will be able to get help from you. Being a professional seller with a global audience gives you many benefits.

![online shop with multi language support](/blog/online-shop-multi-language.png)

**Many online shops have great translations**, and they are perfectly faking that they are local stores. The client will
notice that it's not the local store, only then when he will get the package. Numerous online shops and retail stores
offer from 4 to 20 languages for visitors.

## 3. SEO systems

If you are providing SEO service, you know the best that application which is available for your customers in native
language converts much better than the others. Many professional tools have at least 5 languages to choose from because
SEO tools are the kind of services that are used globally to increase the audience. Not every SEO expert or SEO novice
knows English perfectly to understand how your search engine optimization app will work for him. He/she will be familiar
with the basic words, but to explain them more you will need translation management.

![multi language SEO optimization](/blog/multi-language-seo-optimization.jpg)

I'm sure you heard about [ahrefs](https://ahrefs.com) we are also using this tool. Currently, the app supports 13
languages!
Wow! Maybe this is the reason the page is so popular among SEO experts!

## 4. Business products

The most important apps need to be translated and have high-quality translations. **Mobile and web systems must be
translated by humans** to achieve the best possible explanation. Specialized vocabulary which occurs in such systems
should be consistent with the other business apps. If the potential client won't find words which he is familiar in your
system or landing page, then he may leave your page. Try to reach native speakers to get the best possible translation.

Another way is to check your competitor's page and try to match words, so your potential clients will know that they are
on the right page. Most of our clients support more than 18 languages in their apps. A good starting point should be at
least 5 languages which include: English, French, Italian, Spanish, and German. In many cases, you will also want to
support your language. Selling service on your local market is always a little easier than going global right away.

![business apps add more languages](/blog/business-apps-add-more-languages.png)

### Example business apps with translation management systems

A good example of business apps:

- Translation agency [Luisa.ee](https://www.luisa.ee) from Estonia supports 5 languages on their site,
- [VendingMetrics](https://app.vendingmetrics.com) is the vending company that provides mobile, and web app both of them
  provides 5 languages to choose,
- Estonian startup [Getid.ee](https://getid.ee) which provides fast identity verification for global businesses,
- [ReactJS documentation](https://reactjs.org/languages) supports more than 20 languages. Every documentation page has an individual GitHub repository where people are translating content.
- Nederland company [print.com](https://print.com) that lets you order every print product at lightning speed!

## Conclusions

The rule of thumb on deciding if an app needs multi-language support is simple. If your app is targeted to people who
are not very technical, then **you should consider adding multi-language support.**
What if you don't have time or resources to translate the content right away? It's simple! There are libraries
like [FormatJS](/blog/posts/formatjs-reactjs-internationalization/)
provides an option to display default content. Using FormatJS you can determine the translation key which you will use
in the future, and the default language value for now if translation won't be found. You don't have to use any other
external tool to do it.

**An excellent approach is to add i18n support, even if you don't plan to add more languages now.** Such an approach will
help you in the future in adding the next languages effortlessly. Not using specialized tools right away may cause that
your application will suffer from unprofessional and 'partial' translation. Developers often forget to add a special
piece of code to use translated content someplace.







Translation Hosting

SimpleLocalize CLI

REST API

Auto-translation

Alternative translations

Tips