1

I work in a game development company with around 100 employees. Every one of them can add text for translating. There is a lot of text to translate, so keeping track of all the text is problematic. Before we send text to translators someone needs to find all text that was added or changed, and this is a huge waste of time.

In what ways can we simplify this process? How can we track changes in files that contain text?

3

Start with Source Control

Recommending specific tools is off-topic here, but from a software project management standpoint (and even from an engineering point of view) the correct answer is likely to be using effective source control.

A source code management (SCM) system like Subversion or Git is built to do exactly what you're trying to do: track changes to text files within a project. Good SCMs even make it easy to list recent changes, compare files, or compare versions of the same file.

Implement Internationalization and Localization

Process

Once you have source control in place, you will probably want to develop processes and engineering practices for internationalization and localization. Your project management process should include the following sub-processes:

  1. Internationalization
  2. Localization
  3. Quality Assurance

Engineering

Your engineering practices should include a consistent way to manage globalized messages. According to Wikipedia:

The current prevailing [engineering] practice is for applications to place text in resource strings which are loaded during program execution as needed.

Specific engineering methods are outside the scope of a site focused on project management. However, this should give you a solid foundation for exploring your project's needs and developing your own engineering practices.

0

Keep all bits of text together in a single file (or rather, one file per language). When you need to use that text, pull it from the file.

This way, with all text being kept together, it is much easier to visualize all of it. It also becomes much easier to see changes to that file, especially if you are using source control - just compare the newest version of that file to the version of it X days ago, and you see all the changes anyone has made to that language's text.

This also makes it much easier to switch between languages - you just swap which file is being used.

  • This is, more or less, how we handle it right now. We have also separate files per purpose, every language have few files (like with dialogues or options). With something around 5 languages and few thousand records per language it really isn't easy to track. – Derag Jan 17 '17 at 20:03
  • @Derag That is the problem. You should have ONE file per language. Not a few files per language. If everything is all in a single file, it becomes much easier to track changes. – Sarov Jan 17 '17 at 20:16
0

I see this as a tool-based solution rather than a management based solution. You are already using resource files, and

We have also separate files per purpose, every language have few files (like with dialogues or options). With something around 5 languages and few thousand records per language it really isn't easy to track.

So your problem (as I see it) is to determine when resource texts are changed, and what work must be done to fix up all the resources for the other languages.

My first thought was to create a program to extract all resource texts to a flat file with fields like

Source-File
Resource-Name
Resource-Language
Resource-Text

...and then sort it, and difference the current flat file with a previous version. Now you can see the changed resources and manually fix them up.

Of course, new inputs from your translators will show up in the diff's and will need to be ignored.

But your situation (100 employees) strikes me as an opportunity to create a much better tool that would enhance software development in your next projects. Here is a more complex tool concept:

Create a program to extract all resource texts to a database table with fields like

Source-File
Resource-Name
Resource-Language
Resource-Text
Last-Change-Date
From-Resource-File-Flag
Translator-Name

The program would add to this table with changed resources - IE, if the language and Text is the same, the row would not be updated. If the language/text is different than the current row, add that resource as a new row.

Thus the table would hold all versions of the resource by date. The From-Resource-File-Flag would indicate that the source of this row is from a developer change to a resource file.

Because the table is in SQL, you would be able to execute queries. You would be able to identify changes by developers that would need to be translated. You would also be able to locate resources that are not translated - for example, there is an English and French version but no Spanish version.

But the best part is that a separate tool (or website) would now be possible so that you can apportion out translation changes without too much human oversight. A translator would sign on and see a list of texts that need to be translated; the translation would be added to the database and then propagated back to the resource file with another program.

As I said, more of a tool based solution. A management based solution might fail if people are not diligent. There would be more testing to ensure that all resources were translated (since if a resource is not translated, the resource text would be output in the wrong language).

  • Idea with SQL sound great but it is too much work for our needs. Keeping history of changes that is interesting idea. – Derag Jan 24 '17 at 9:25
0

If it's not possible to reduce the number of people who can change text, then finding a tool to automatically detect changes and create a translation order queue for you might be the way to go.

I don't have any personal experience with enterprise translation management systems (e.g., Transifex), but I've used startup-friendly ones like WebTranslateIt and OneSky. Both of these have developer tools and APIs that can be baked into your workflow in such a way that it synchronizes the latest state of your text resource files into their portals.

Tools like that can be accessed by translators and host the entire translation process. If a change is synchronized more recently than the latest state of a translation in a particular language, it's marked on a message by message, language by language basis. These can easily be filtered on by translators, and dashboards help managers keep track of progress.

There's quite a wide field of services like this lately. It depends on whether you manage linguists yourself, have a relationship with a provider who you send kits to as needed, crowd-source translations, or whatever your current day-to-day may be.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.