Importance of branching and repository integrations in localization

One of the important aspects of localization is the technical side, as this is a significant factor in localization speed and cost. Developers work with resource files, implement new translations, and are responsible for the correct work of localized software versions. But what will happen if developers, instead of the technical part, upload and download resource files and spend time and effort on manual tasks? The technical team will be frustrated by the constant back and forth of the files, distracting them from important tasks and slowing down the processes. However, we know how to prevent this situation and ensure everything is done correctly. Let's start with the basis and overview of Git and its ability to be used in development. Then, till the end of this article, you will get the best practice of organizing the technical side of localization.

Git in a nutshell

Git is a utility for tracking and maintaining a history of file changes. The system enables developers to track modifications and work on the same project simultaneously with colleagues. The primary function of Git is to provide developers with version control and tracking changes; thus, engineers can roll back changes, compare and analyze versions, or merge changes into a repository. Here, we combine the list of factors that condition the popularity of Git:

• Free and open-source;
• Small and fast - all operations are local;
• Data safety: Git is efficient at storing backups.
• Simple branching: Git makes branch management much easier and more efficient.
• Version control: Simplified code rollback to a working state and avoided spending hours looking for errors.

For comfortable collaboration with the code, teams often use web Git hosting services, which fit the requirements for teamwork and provide a list of abilities for CI/CD. Take a look at an example of such solutions:

• GitHub
• Bitbucket
• GitLab
• AWS
• CodeCommit
• Azure
• JetBrains Spaces
• etc.

Let's overview Git's collaboration with the web hosting services on the Git+GitHub example.

Git + GitHub: how does this work?

As mentioned above, Git is a tool for implementing a distributed version control system. GitHub is an online Git-hosting service with all the distributed version control and source control functionality — everything Git supports and more. In addition to GitHub, other services such as Bitbucket and GitLab also use Git.

Let's take a look at GitHub's additional capabilities.

• convenient UI,
• boosted access control,
• issues tracking,
• task management,
• analytics,
• wiki for each project,
• CI/CD pipelines (actions),
• and more

Let's examine Continuous Integration/Continuous Delivery more closely. This approach speeds up development, automates the process of building, testing, and deploying software, avoids early-stage mistakes, and minimizes risks.

GitHub actions allow the creation of any automated workflow with the code. For example, developers can provide tests across multiple operating systems and versions, validate code, compile and log all changes (CI process), and automatic assembly deployment in production, test, or development environments (CD process). After committing to GitHub, the changes will be automatically built, tested, and placed in the needed environment. Different events can trigger GitHub actions, e.g., after pushing a commit in the branch, pull request, or by schedule (once per day/week at the same time.)

Regarding localization, CI/CD pipelines allow easy handling of software versions in different languages. Developers can configure a separate pipeline for each localized version, ensuring the localization changes are appropriately integrated, tested, and deployed. To create such a smooth and automated localization process, teams require a translation or localization management system (TMS/LMS) that allows file transfer between the editing environment and the repositories.

Why does the TMS system need repository integrations?

The market for translation management systems is vast and offers various solutions. One essential thing to consider when choosing a solution for your team is the support of repository integration. Localization implies communication between at least two teams — translators and developers, so the smoother this process is, the more time and cost-saving localization you have.

We designed Lingohub with customers' needs in mind, so our solution supports GitHub, GitLab, Bitbucket, Azure, etc., integrations which, in combination with CAT tools, will allow translators and developers to do their work without worrying about manual file transferring. The file import or export can be done in a few clicks, and you will know that all placeholders and technical nuances are correct as they are controlled by the quality checks tool.

In the context of this topic, an additional Lingohub feature that requires a deep overview is branching support. This magic wand allows your team to take advantage of all the advantages of Git and repository integrations we provide.

What is branching?

Branches are a tool that allows developers to work separately on different features/processes and keep the main code clean. For example, you can have a branch "main" with the clean project code, a separate branch for a new feature "feature_1", or release, "release_1", etc, and work with each independently. At the same time, you can create unlimited branches, and in each branch, you can commit changes. Also, the additional branches can be merged with the main one if/when needed. So, this is a safety and collaborative feature that ensures code correctness and isolates the development of the specific part of the project.

In turn, we at Lingohub provide a branching feature that allows our users to localize branches’ files and work with them directly. With Lingohub, you can connect as many branches as you need and filter them to keep only the required ones. Thus, the localization process does not violate the logic of project development; your team can work with individual parts of the project and easily implement the localization into the CI/CD process, which ensures continuous localization. Let's take a quick look at how Lingohub branches work.

How to work with Git branches with Lingohub?

To overview this topic, we first need to describe the Lingohub plugins briefly. In Lingohub exist two plugin types:

• Workspace-based plugins, which are responsible for settings across the entire workspace.
• Project-based plugins, which are defined by the project type and configure the connection for a specific project(s.)

So, the Lingohub user should connect the repository (for example, GitHub) to the workspace via a plugin, create a project, and set up the Git plugin inside the project (see image below).

How can the branches be used?

After successfully setting up the connection between your repository and Lingohub, you can use the following advantages of the branching feature:

• Focus only on important things with the branch filters. Lingohub supports regular expressions that simplify the filtering process; for example, in the feature* expression, the asterisk matches zero or more characters. Read details about the branching in the help center article.

• Push directly or create pull requests for the defined branch. The second option (pull requests) is preferable because it is more secure, protects your project from code issues, and allows code review. It is the most common flow in the most significant part of a complete project. Use the push directly option only if you are 100% confident with the changes.

• Control the progress per branch. You can have different numbers of languages for each branch and monitor the progress separately within one project.

• Work with separate branches in Editor. The ready filters allow translators to select the needed branch in a few clicks.

Bottom line

Repository integration to TMS is required for all who want to build a smooth and continuous localization process. Lingohub offers integrations with repositories such as GitHub, GitLab, Bitbucket, and Azure, which, in combination with the branching feature, allow organically included localization in the CI/CD process and assist the comfortable work with the translations and resource files. Our team will gladly demonstrate how this option can work with your repository at the short demo call, so don't hesitate to book a suitable time for you right now.