Advanced Memsource Usage // Useful File Handling Tools

Manual project creation

For the vast majority of projects, we do not need to create projects manually in Memsource as the integration with the EasyTranslate platform does most of the heavy lifting. Creating a project manually, while removes all integration with the Platform, is still useful in certain circumstances. Such as analysing files for clients that have not created a formal PO yet, having a secluded environment to test different project setups, without potentially polluting pre-existing jobs, consolidating large project with multiple languages into 1 easier to manage setup, etc.

The benefits of translation memory, term bases, machine translation, user management are not lost even if we set out to create a project manually - we only have to add this functions manually.

To create a new project from scratch we simply click on the “+” icon on the navigation menu in Memsource.

 

 

 

 

This will bring us to a creation menu not too dissimilar from creating a user, term base, or translation memory bank. To have the bare minimum setup to create a new project, we need to give it an easily identifiable name and denote the source and target languages. This can also be updated after the fact, by pressing “Edit” in the top right of the project, once it’s been generated.

And a blank project is created!

We would still need to add translation memory banks, files, analyse said files and whichever extra conditions we would want to provide.

 

 

 

Multiple languages in one project

As mentioned earlier, one of the main reasons we would create a manual Memsource project is to consolidate projects from multiple languages into one easier to manage overview. This is achieved by adding all the relevant target languages in the initial project creation. Once all target languages have been selected and we try to create a new job within the project - it will display for us the possibility of creating the same job for multiple languages within the same project. We can opt out certain languages, by unchecking the languages. By default it will always select all languages. If the linguist is already known and sourced, we can pre-emptively add them as well to save click-work in the future.

Memsource template creation

For certain returning clients, that have a specific file structure or a pre-assigned team of linguists, we may want to create a template so we can avoid repetitive tasks (assigning the same linguists, creating an extra proofreading step each time, specific file setups, switching to a very specific translation memory base, etc).

To create a template, we need to first have a Memsource project that fulfils the criteria we want to have in the template. Whilst it does not have to contain everything we want in the template, it’s a faster process if we build upon it, instead of doing everything from scratch.

In the top right of any Memsource project we will have the option to take the settings from the project and Save as a template.

This will bring us to a project template creation page, not too dissimilar from creating a project itself.

Here we will list out all possible permutations a client’s request may have: languages we service for the client, adding extra workflow steps (besides the default translation step), pre-assigning pre-determined linguists, etc.

We can also set up specific file import settings to automate file preparation procedures if the client consistently comes with the exact same types of files. (i.e. always provides multi-lingual Excel files with source columns always in columns A, C, E - and target columns in B, D, F).

Important: if we set up file import settings in the template, it will not upload the file based on these settings when we analyse files on the platform using the template. It will only pre-populate the settings when we re-add the file in the Memsource after the template analysis.

Once the project template has been saved, we will immediately find it on the platform if we go into the dropdown menu of analysis templates. The list is organised based on dates of template creations - oldest templates at the top; newest templates at the bottom.

 

 

 

 

 

Translation Memory uploading and management

Creating a Translation Memory

Thanks to our Platform’s integration with Memsource, whenever we analyse a new project’s files the system will check to see if that client has done any prior translation and will attach their old TM to the new project in Memsource. If it’s a first time the client is ordering or the the source language is new, it will then automatically create a new TM going forward. Whilst this process is automised, there will be occasions where we need to create a new translation memory base.

There are two ways of doing this:

1. One is to simply press “Create new” under Translation Memory within a pre-existing Memsource project.

There we it will pre-fill all relevant languages from that project and select the appropriate source language. We need only to add a name for the TM as well as adding an extra languages that we want to be part of that TM.

Once it’s created it will be there and will remain always readily available. One thing to note is, that despite us creating a new TM under a project that was automatically generated, it will not automatically link the new TM to the client going forward. To have this new TM be attached to future projects it would require us to create a template that includes it and use that template consistanty.

The process afterwards is identical to the aforementioned one, difference being it will not pre-populate the source and target languages. The subsequent usage via generation of a template is also needed, if we do not want to manually re-attach a translation memory each time a new project is created.

Editing and managing Translation Memory

Whilst uploading a TMX file’s translation data into a TM is simple as it only requires importing a file with no extra settings. Partial removal or updating TM entries is far more complicated and involves meticulous editing of export files to achieve.

Uploading translation memory via a .tmx/.xliff/.sdlxliff file.

This part is quite straightforward. When we access the needed translation memory in Memsource we merely need to scroll down to the bottom of the page and press “Import” under the Import/Export section.

In the new pop-up we would select the .tmx/.xliff/.sdlxliff file needed to upload and proceed.

A couple of noteworthy things about .tmx/.sdlxliff files:

• A .tmx/.sdlxliff file does not necessarily come from Memsource. It might have originated from a different CAT tool with different segmentation properties. Because of this, segmentation of the TM in the .tmx/.sdlxliff might not be exactly 1:1 as it would be if it was being translated in Memsource. So a 100% conversion to Memsource might not be possible.

• Even if the respective translations are correct, if the languages defined in the .tmx/.sdlxliff are not accurate - Memsource will not import the TM.

Uploading translation memory via a .xlsx file.

Whilst the process is the same as uploading a .tmx/.xliff/.sdlxliff - what changes is how the .xlsx file is prepared. Typically translations are not exported in .xlsx files via CAT tools. Typically translation memory exported this way is done manually with careful compiling of external resources. These could have been assembled by a client by meticulously copying and pasting content from finished work. The file would resemble a multilingual excel file with an iso code denoting the language in the first row of a language column and subsequent translation underneath.

A few things to note:

• To import a specific language into the Memsource TM, all the languages need to be denoted within Memsource before we upload the .xlsx.

• The ISO codes within the .xlsx file need to be exactly the same as they are in Memsource (if the language code in Memsource is “fr”, but in the file it is “fr_fr”, it will not upload)

• The segmentation will be based on a “cell = cell” context. It will not do any extra segmentation or processing before uploading translation memory. (for example: A1 has multiple sentences within one cell and the corresponding cell in a following language has also multiple sentences within one cell - the resulting TM entry will not break it down per sentence. This TM match will most likely not re-used then as it will be too broad).

Editing a TM

There will be cases where at times we need to remove or change multiple TM entries that we have on Memsource. If it’s one or few fringe segments then we can do this easily within the search function inside the Translation Memory page of any given TM on Memsource, but once we have to do mass editing - the process becomes far more complicated.

To begin the editing process we first need an export of the current state of the TM. To do this, we simply navigate to the same section we used to “Import” TM data, but instead opt for “Export”. We will then be greeted by a pop-up allowing us to select the permutations under which we’ll export the TM.

The first row in the pop-up denotes of whether we want to export it in .TMX or .XLSX format. The .tmx format requires special tools to edit, which we do not typically use, so we will be proceeding with .xlsx.

The next section allows us to select which languages' translations we want to export. Despite it being selectable, the export will still create all columns that are set within the TM, it will merely not populate the translations themselves.

The next and most important part would be the various extra details we want to include about the TM entries.

The settings we select here are purely dependent on what we are trying to achieve. Here’s a few ideas:

• A translator we employed turned out to be unskilled and entered several bad translations into the Translation memory and we want to remove all their work to ensure that translations in the future don’t get populated with bad 100% matches. Here we might opt to include “Last modified by” to be able to filter all translations by a particular user.

• A specific job was done poorly and we want to remove all relevant TM data from it. Here we might want to have “Project” enabled so we can pinpoint all segments from a specific PO.

• A client no longer has access to a previous translation, but doesn’t remember the PO number of the job that it was under, but they know exactly what was the name of the file that was translated. Here using “File” and “Project” option will list out what file was translated to create the TM entry and list under what project it was done, helping us quickly find a vague, forgettable job.

Whilst we can select all options when we’re creating an export and have a massive super-file, this will be an extremely taxing file to open and edit as it will require a lot of computer processing power, which our equipment might not be able to handle. As such, it’s important to only select the settings that we absolutely need to do our work. Memsource often times already drains your sanity enough, don’t let system crashes and freezes take even more of it.

Once we have a good export we can finally move on to making the actual changes we need.

In the above mock example we’re going to perform 2 changes:

1. We will delete the entire segment and all translations under Row 2.

2. We will update the translation in cell E3.

To delete any translation we cannot simply delete a row and re-upload the file, this will not tell Memsource how to deal with the change. To either delete or update we need also declare to Memsource whether or not anything needs to be done.

If we want to delete an entire segment and all corresponding translations for that segment we would have to declare that the ID of the segment is up for deletion. If we wanted only to delete 1 language’s translation of that segment, then we would delete and leave blank the relevant cell and then tell Memsource to that ID of the segment has a need for updating.

To give Memsource the command to treat the ID the way it has to, we have to add the text line “|delete” or “|update” at the end of the ID. In the example above, since we want to delete the entire segment the end ID would look like…

_001WvYCB7YrkoUw0UE4Qy4axe|delete

This kind of editing would be needed for each row that requires action. If no action is needed and can be left as is, no suffix is needed.

The process would be similar for Row 3 where we need to update the translation. Once we’ve made the right amendments, we simply would add the suffix of “|update” to the ID and it would then process it accordingly during re-import. And it would look like….

_005kkl9l0I0G0kg2UW8MTUKVe|update

After all the necessary changes have been made, we simply save the file and import it the same way we did in the previous examples of importation.

Term Base uploading and management

Term bases provide invaluable brand identity to translations that we do. Certain clients might prefer a specific way of phrasing certain expressions or even singular words over other synonyms. Creating and managing a term base helps maintain that consistency without depending on suppliers to remember them. Having a term base uploaded into Memsource will directly show the terms and how to approach them in the CAT tool and within an issue list if we run a QA analysis.

We have various options when uploading a term into the term base including setting it as forbidden, case sensitive, providing context, specifying gender, etc.

Creating a Term Base

To create a term base, we first need to map out which languages will go into the term base along with which client the term base will belong to. This is done by pressing the + icon next to Term Base on the left-side navigation bar.

It is key to create a term base name that is easily identifiable, especially if there are multiple term bases used for the same client, but different types of text. Here we set all of the required languages that will be part of the term base. Whether it’s the source language or target language is irrelevant - we add them all.

(note: be wary of multiple variations of the same language, i.e. English UK/US, Chinese traditional/simplified, etc. If the correct variation is not chosen, Memsource will not recognise it as the correct language the term applies to)

Once the term base is created we then need to populate it with the relevant terms. This can be done by importing a .tbx or .xlsx file with a batch of multiple terms,

 

or can be added individually within the term base.

Normally for the initial term base upload we would want to opt for uploading an Excel (.xlsx) file as it is much faster method when we need to add and define multiple terms. Memsource detects what term belongs to which language by having them in each respective column with the language’s ISO code being the top-most cell in the column as seen below:

 

If we set up the terms in this manner, we will add them, but they will have no nuance or definitions apart from just being there. We can, as a follow up, define them individually by clicking on each term and adding the relevant details, but depending on the volume of terms to update and define - this would be very manual and time consuming process.

 

The best way to setup a complex term base is to “create” a term base template via Memsource and add the definitions at the same time as the terms. This can be done by exporting a term base (even if it’s empty)

and selecting the appropriate definitions to be included.

We do not need to define all of these settings, only the ones that are relevant for what we want to achieve. In this example we will only define terms as forbidden, case sensitive and add a note.

(The resulting export will look something like this. If term base is empty, it will only have the column definitions.)

Since we only want to define the terms as forbidden, case sensitive and leave notes, we delete all irrelevant columns - each instance of CID; TID columns.

Here if we uploaded this excel sheet as a term base in Memsource - it will create 3 terms:

• An approved translation for “Prüfung” in German, that’s not case sensitive.

• An approved translation for “Test” in English, that’s not case sensitive.

• A forbidden translation for “Testas” in Lithuanian with a note of “not local enough”, that’s not case sensitive.

If the terms are already in the terms base it will create a duplicate term. If the duplicated term has conflicting definitions, this would result in unsolvable QA issues. It’s important that when building up a term base to make sure that terms are not duplicated.

Once the term base have been set up, we only need to make sure that it gets attached to the relevant client’s projects. This will not retroactively update all past project with the term base, only new ones we generate.

File batch editing

Unlike certain other CAT tools, Memsource does not have an option to content search through multiple projects and files to find and replace segments. To achieve the same result within Memsource we have to either update the TM with the changes we want and pre-translate already finished translations, or individually edit the changes into each job in Memsource. Neither is ideal.

In cases where we need to mass edit files we can employ an editor that is capable of doing this.

The current MacOS editor of choice would be Sublime Text (https://www.sublimetext.com/) as it is a shareware cross-platform editor with a very powerful toolset that supports many different files types we can face when dealing with translation.

In Sublime we’re able to take an entire folder of files and mass edit them instantaneously. This is done using the “Find in File” function (SHIFT+CMD+F).

 

 

 

At the bottom of the window we’ll have 3 fields we need to quantify:

• What to “Find”.

• “Where” to find the files containing the segment we’re searching for.

• What to “Replace”.

We can select “Find” to get an overview of the extent of changes that would be made and “Replace” to implement. It will then open all updated files within Sublime, at this point we still need to confirm the changes by saving all of the newly updated files.

If needed we can save files individually or opt to simply “Save all” - overwriting all files that had changes made.

It’s important to acknowledge that this is not much more complicated than finding and replacing text in Excel, Word, etc. There is no function to narrow down the search area of the files or look for specific criteria before making the changes. As such, it’s important to keep aware that if we’re not careful, we may mass edit text that’s beyond the scope of our intention.

Memsource mass user creation

Memsource has the option to create multiple users at once if needed, but it is also a faster method to create a single user as well.

 

From the “Users” tab in Memsource we have 2 options when creating a new Memsource user - “New” and “Import”. Using “New” we will be able to create a single new user after waiting an eternity for the page to load. Meanwhile we can use the “Import” function to create multiple users at once, bypassing the long load time to get to the user creation page.

Pressing the “Import” button will bring a pop-up that will allow us to download Memsource’s mass user import template. This will also be the place where we import the finished template.

The template itself is rudimentary and only asks for the most basic identifying information.

• First Name

• Last Name

• Email

• Username

• Role

• Active

• Receive newsletter

We simply fill in the linguist's full name and email in their respective fields and create a username for them that we think of ourselves. Columns E, F, G are case sensitive so it’s important to fill those cells in all-caps as illustrated in the example.

Each row of the excel represents a single user so if we need to create multiple users, each line must be filled in individually.

Once completed, we save the file and go back to the Import feature and insert the file there.

(note: the file name does not matter and can be renamed or not, depending on your needs)

If the sheet was filled in correctly and the new user is not a duplicate, we will get a positive notification at the top of the page.

If the user’s username or already exist in the database, we will instead be greeted with an error message describing the issue.

(there is currently an issue Memsource denying creation of a user under the premise of “user already exists” even though there is clearly no user of that nature in the database. The cause is currently unidentified, but can be bypassed by slightly changing the username such as “anders.anderson1”)

Then we proceed to send the login credentials to the linguist via the “Email Login” and once they finished setting up their password, they’re ready to go!

---

Manual Memsource seat cleanup

If there ever is a case of having no available Memsource seats and the automatic cleanup script is not running. We can manually clear out idle users that are presently not working on tasks, by using filters and mass editing.

To identify if there is a “seating problem” we need to hover over the “New” button in the “Users” page and it will bring up a breakdown of users of each permission type.

If it turns out we need to urgently assign a translator, but no seats are available. The simplest way to do so would be as such:

1. Enabling the filtering option.

2. Checking the “Active” box to show only users actively taking up Memsource seats;
   Sorting the account type for “Linguist”

3. Select users within this filter that have “0 Jobs”.

We then to proceed to “Edit” the multiple selected users. This will bring us to a much more condensed version of the user account editing page.

As it only populates the page with the “Active? Yes/no” option, the page loads much faster than it would be normally when editing a single user. Hence, for efficiency sake, it’s best to avoid deactivating single users and instead opt for multiple deactivations at once.

 

 

---

File splitting in Memsource

Memsource has a built in functionality to split source files into multiple parts. This can be useful for splitting the workload among several linguists to meet tight deadlines on large translation requests, but can also be valuable in assisting singular linguists in organising their workload into more manageable chunks. As Memsource can drastically slow down if it needs to load thousands of segments at once, reducing the load time will save time (and sanity) for the linguist.

Under the “Tools” dropdown menu within a translation project we have the option to split files in various ways, depending on your needs.

Memsource will then generate multiple jobs within the same project that we can use. Once the translation is done and we need to download the completed file, it will automatically recompile the split files back into 1 seamless file.

---

Client review

In some cases, the client might want to have a more active role in reviewing and approving the translations we write. To avoid the processes of having to send offline copies of files, back and forth - we can create an extra revision step in Memsource called “Client review”.

By having the client directly access the translation within Memsource, they can make adjustments to their liking and immediately update the translation memory in doing so, ensuring that future translation are the best they can be.

To allow the client to perform a “Client review” we need to set them up with a “Guest” permission type user and set them with the correct client ID on their profile.

The first step is to identify what is the correct client ID on the project we’re planning to assign the client to. This can be found at the top of the Memsource project page.

We then need to assign this client ID to the client’s user, also within Memsource. We access the user setting by pressing “Edit” while having the client’s account selected.

In this page all we need to do is enter the correct ID we checked before. There can be several similar looking client ID generated, so it’s imperative to select the correct one.

(note: the list is populated by every single client that had at least one analysis done for them, making the list extremely massive, cumbersome and difficult to navigate. This may or may not be the most frustrating experience of your life)

After denoting the user as a client, we will gain access to a new dropdown menu called “User Rights”. Here we can specify the exact level of privileges the client can have: editing ability, viewing of projects, editions to the term base/translation memory, etc.

After providing the client’s account with the right credentials and assigning them to the right Memsource project - we’re ready to roll!

---

Workflow Changes in Memsource

To get a better overview of the extent a proofreader has edited a file after translation, we can create a workflow changes table via Memsource. This is extremely useful for file formats that may not be easily readable (such as InDesign files).

Within the “Tools” option in a Memsource project we select the “Export Workflow Changes” option which will then create a new tab with a table of the different states of translation.

Once the table has been generated, it will highlight text in red of changes made in the revision step. This provides a visually identifiable way to find and identify the extent of changes done. Unfortunately, Memsource does not currently have the option to create an offline export of this table. Using other tools in our disposal we can still create a reasonable clear export of it.

By pressing “CMD + A” we will highlight the entire text in the table and copy it. We can then create a blank Word document and paste everything in there. While visually not exact, it will still highlight all of the changes made as comments for easier identification.