VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

Top Ways to Translate Correctly | Apple Xcode String Catalogs and Localised Variants

To translate an Apple Xcode string catalog correctly, work with the actual localisable key, its language entries and any plural or device variation that the application uses. A .xcstrings file is more than a bilingual word list: it is a structured catalogue that Xcode can populate from SwiftUI and other localisable source text, then use to deliver the right message for a language, region and interface situation. This guide explains how to localise Xcode string catalogs, review SwiftUI interpolated strings, handle language-specific plurals and device variants, and test translations before release.

The visible difficulty is that a catalog can be substantially translated while the app still sounds inconsistent. An automatically extracted source string might lack the screen context a translator needs; a plural variant may be grammatically wrong for one count; or a desktop instruction can say ‘tap’ when a person should click. Apple documents String Catalog workflows for adding languages, translating entries, varying strings and testing them in the app. The task is therefore not merely to fill empty cells. It is to connect each target phrase to its code usage, selector conditions, interaction and release evidence.

What you need to know first

  • Treat Apple Xcode string catalogs and target-language variants as a language-and-software contract, not a stand-alone word list.
  • Diagnose resource identity, dynamic arguments, grammatical choice and device behaviour separately.
  • Use a staged workflow: inventory, context, translation, structural checks, runtime tests and release audit.
  • Compare concrete examples, failure modes and independently reproducible test results before approval.
  • Preserve application meaning, including negations, timing, permissions, money and user choices.
  • Practise on a small sample first; extend only when the sample passes.

The visible problem: why a fluent translation can still fail

Imagine that a SwiftUI shopping application shows a message with an item count. The English source message is extracted and appears in the catalogue. A reviewer translates only the ordinary displayed string and ignores the plural variants. Another translator translates ‘Tap here’ identically for the macOS version, where the action is a click. Both translations look acceptable when printed outside the app; both fail when used. The remedy is to inspect the entire localized message unit, its variable and selector structure, the particular device where it appears and the status of the translation. The string catalog is the working source of truth for this specific platform lane.

The first diagnostic question is not “does the sentence sound natural?” but “what contract does the application expect this string to satisfy?” A string may identify a code key, interpolate a count, select a grammatical variant, carry a clickable instruction or announce an accessibility event. These roles are different. A correction that improves one role may silently damage another. For Apple Xcode string catalogs and target-language variants, a careful team should be able to point to the source location, the condition that displays the text, the proposed target wording, the protected characters and a repeatable test. Without those observations, approval remains a guess.

The second diagnostic question concerns the reader. Who will see this screen, what do they already know and what action will they take on the strength of its wording? A warning must retain the original danger or restriction. A preference label must identify the available choice. A payment message must distinguish a request from a completed transaction. Translate faithfully before trying to make language shorter, warmer or more promotional. Only then adjust style and screen fit within the original meaning.

First principles: eight distinctions that prevent error

1. A catalog entry is tied to program use

Some keys are derived from source strings or registered by localisable APIs. Changing a label without understanding extraction and usage can create duplicates or leave old entries behind.

Keep the development build and catalogue snapshot together, and ask how each key is invoked before deleting or renaming it.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

2. Variant selection is part of meaning

A message can have forms for different numbers or devices. A single universal target phrase is often inadequate.

Read the selector and variable conditions as part of the message, not optional decoration; review each displayed branch.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

3. Comments carry decision-making context

Xcode can provide or generate comments that describe a screen, variable or intended meaning, but automatic comments still deserve verification.

Use contextual comments to disambiguate short strings; annotate gaps where automatic descriptions are too vague.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

4. The user action should remain exact

Tap, click, press, swipe and select are not interchangeable in every platform context.

Write for the actual device input method and verify that the action described matches the control the user can activate.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

5. Interpolation should remain structurally safe

Counts, names and other dynamic values can be inserted into localisable text. The grammar may need a different arrangement around these values.

Inspect variable types and generated placeholder forms before translating, then test with distinctive sample values.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

6. Localisation state is not language quality

A catalog can mark entries translated, but that state does not prove clarity, appropriateness or on-device correctness.

Treat status as workflow metadata; conduct linguistic and functional QA separately.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

7. Region is not an afterthought

A language may have regional usage differences that affect spelling, units, social norms or user instructions.

Add language and region targets intentionally and test representative regional settings.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

8. Display conditions are part of the contract

A phrase might work on an iPhone at default text size but fail on an Apple Watch or with Dynamic Type.

Validate wording and layout across the actual supported devices, accessibility settings and real value lengths.

This distinction is practical, not merely terminological. Ask the reviewer to demonstrate it on one real screen or test input. If the target sentence seems accurate only when separated from the application, the evidence is incomplete. Record the accepted form, the condition under which it appears and the reason a similar-looking alternative would fail. A well-supported decision can be reused when the same mechanism appears elsewhere; a vague preference such as “sounds better” cannot reliably protect a release.

A repeatable twelve-stage translation method

The following sequence is designed for Apple Xcode string catalogs and target-language variants. It moves deliberately from discovery to evidence. Do not collapse linguistic and engineering acceptance into a single checkbox: people can review naturalness while automated tests inspect keys, formatting and resource loading. The method also prevents premature large-scale translation. First prove a small representative set, especially one count-driven message, one value with special characters and one ambiguous screen label. Then proceed to the remainder of the catalogue.

Stage 1: Extract in a current build

Compile the project so Xcode discovers supported localisable strings.

Compare the catalog inventory with actual screen navigation and note entries that might still be hard-coded.

The deliverable for this stage is a dated source build and a verified string inventory. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 2: Choose catalog boundaries

Decide whether Localizable.xcstrings is sufficient or whether other catalog tables are needed.

Avoid duplicating messages between catalogs simply because multiple teams own screens.

The deliverable for this stage is a table-to-feature map for translators. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 3: Review source usages

Open the editor assistant or jump to source locations for ambiguous entries.

Document screens, variable roles, audience and the consequence of taking a proposed action.

The deliverable for this stage is context-rich key notes instead of blind word lists. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 4: Add languages and regions

Select supported target languages and optional regions in Xcode.

Use a documented language strategy so that default and regional terminology do not conflict.

The deliverable for this stage is an approved supported-locale list. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 5: Resolve extraction drift

Compare catalog entries after source changes and identify strings that are new, renamed or no longer used.

Do not silently preserve translations for obsolete UI text simply to retain a high completion percentage.

The deliverable for this stage is a source-change reconciliation log. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 6: Translate base messages

Write target wording in natural grammar with accurate state and action.

Treat privacy, financial and account messages as high risk and obtain the relevant subject-matter review.

The deliverable for this stage is an approved base translation per relevant locale. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 7: Translate plural branches

Vary count-sensitive strings by plural where the code and catalog support it.

Do not assume English forms cover another language; supply and test the categories Xcode presents.

The deliverable for this stage is a count-to-displayed-message test table. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 8: Translate device branches

Use Xcode’s device variations when the interface action genuinely differs across platforms.

Keep one core intent but adapt terms such as tap and click to the supported device.

The deliverable for this stage is a per-device wording matrix. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 9: Inspect interpolation

Check generated variables and any formatting details before approval.

Verify that translators have not removed variables or turned dynamic data into literal illustrative text.

The deliverable for this stage is a variable parity test with multiple sample values. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 10: Review states and comments

Distinguish catalog status from actual content review and improve misleading context notes.

Ensure no high-risk item is assumed complete merely because the editor displays a green checkmark.

The deliverable for this stage is an independent linguistic sign-off record. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 11: Test localizations

Preview screens and run the app in chosen languages, devices and text settings.

Look for long strings, screen reader issues, incorrect variable placement and regional fallback.

The deliverable for this stage is screenshots and reproducible defects by device and locale. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Stage 12: Release with traceability

Rebuild after translations are merged and verify the shipping target.

Keep project version, catalog snapshot, reviewed locale list and an escalation route for corrections.

The deliverable for this stage is a release packet that supports future updates. Do not accept a screenshot alone when the error concerns a program identifier; do not accept a parser result alone when the error concerns an instruction to a person. Keep a short record of the source, the target locale, the change made and who or what verified it. A later reviewer should be able to reproduce the result without guessing which editor, screen or sample data was used.

If the check fails, identify the earliest step that made the bad outcome possible and repair that step rather than patching only the displayed words. This is a useful transfer habit: one precise fix often prevents the same error in many other messages. If the source itself is ambiguous or the software contract is unclear, return it to the appropriate developer or content owner instead of inventing a condition that the application never promised.

Twenty worked examples: from source text to reliable output

Each case presents an observable input, a tempting but unsafe edit, the correct direction of repair and a way to prove the repair. Examples are deliberately varied: some are grammar problems, some are encoding or syntax problems, some are resource-resolution problems, and others are real interface safety problems. A professional review should be able to classify the case before applying its solution. The examples are teaching scenarios, not a substitute for running the project’s own build and locale tests.

Worked example 1: Extracted source string

Start with this situation: A SwiftUI Text string becomes a catalog entry after a build. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The team manually edits only a spreadsheet and fails to bring the translation into the project. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Translate the catalog entry used by the build and confirm the app draws from it. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Build and run with the target locale. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 2: Plural for visited places

Start with this situation: A view interpolates the count of places visited. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Only the English-looking general string is translated; the one-form is unnatural. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use the catalog’s plural variation and enter the forms appropriate to the target language. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test counts 0, 1, 2 and additional grammatical edge cases. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 3: Russian-style category variation

Start with this situation: A translated count message needs more than one and other grammatical forms. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The translator supplies two forms and assumes the rest can fall back to English. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Complete the locale-specific variants shown in Xcode and check their selection. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Drive several counts through the actual interpolation. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 4: Mac versus iPhone instruction

Start with this situation: One message instructs people to open a detail view. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The iPhone text says ‘tap’ but is reused unchanged on macOS. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use a device variation when the user input method demands different words. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Run the instruction on both supported platforms. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 5: Variable identity

Start with this situation: A text includes a person’s name and a count. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: A translated sentence accidentally gives the count grammatical treatment for a name. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Preserve the mapping between variables and intended semantic roles. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test with a long name and an unusual count. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 6: Ambiguous ‘Archive’

Start with this situation: A source entry ‘Archive’ might name a destination or a command. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Translation is chosen before the reviewer knows whether a noun or verb is intended. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Read source usage and add a disambiguating comment; split messages if necessary. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Verify the word inside its actual control. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 7: Generated comment misfires

Start with this situation: An automatically generated note describes nearby code but not the real user action. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The translator trusts it as authoritative and writes for the wrong screen. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Check auto-generated context against the UI and improve notes when inaccurate. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Read the usage and review a screenshot. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 8: New string after source change

Start with this situation: A code change adds a privacy option. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Reviewers see an older high completion percentage and miss the new untranslated entry. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Run extraction again, review new state and approve the added copy. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Check the exact shipping build. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 9: Stale source meaning

Start with this situation: A button changes from ‘Delete’ to ‘Deactivate’. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Old target-language wording still expresses permanent deletion. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Re-evaluate source changes semantically, even if the design appears similar. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Execute the action in a test environment. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 10: Regional Portuguese

Start with this situation: A target locale is Portuguese for Brazil. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The catalog contains only another regional form with unsuitable terms. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Add and test the appropriate language-region translation where the product supports it. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Change device language and region and inspect selected copy. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 11: Dynamic Type expansion

Start with this situation: A label fits a narrow default font size. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: At larger accessibility text sizes the translated call-to-action clips. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Improve the target phrase and layout without deleting necessary conditions. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test supported Dynamic Type settings. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 12: Voice accessibility

Start with this situation: A control’s visual name is localised but the spoken description is not. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: VoiceOver announces inconsistent languages or ambiguous actions. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Include accessibility descriptions in extraction and review. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Listen through the critical interaction path. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 13: Date formatting

Start with this situation: A translator writes a fixed month/day order inside a message. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The resulting date is confusing in another region. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use appropriate locale-aware date formatting rather than concatenating translated words. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Test several regions with the same underlying date. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 14: Device selector overused

Start with this situation: A team creates separate device strings for a sentence that has identical meaning everywhere. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Variants drift and require needless maintenance. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use device-specific wording only where behaviour or interface space actually changes. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Compare the displayed message across supported platforms. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 15: Long product name

Start with this situation: An interpolated product name exceeds the sample length. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The localised string looks fine with a short placeholder but breaks on real names. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use long representative test values and layout-resilient text. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Inspect wrapping with a realistic long name. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 16: Gendered phrasing

Start with this situation: A message assumes one grammatical treatment for an unknown user’s identity. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Target wording imposes unsupported personal information. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Use neutral wording or a supported variation strategy based on actual known data. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Review use cases with unknown and nonbinary identities. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 17: Error code and prose

Start with this situation: An error message includes a machine error code and a human explanation. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The code is translated or erased. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Protect the code while translating what a person should do next. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Check the diagnostic code matches logs. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 18: Source and target mix

Start with this situation: One screen shows target-language text beside an unlocalised button. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The catalog contains the visible text but the button is generated outside supported localisable APIs. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Find and internationalize the missed source string. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Change app language and inspect the entire screen. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 19: Translation imported after review

Start with this situation: Translated entries are imported from an external vendor. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: The team assumes the import preserved context and variants. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Inspect merged catalog data, especially selector branches and new-state indicators. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Run a post-import diff and smoke test. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Worked example 20: App language without region change

Start with this situation: Users select a different app language but keep their device region. The first task is to identify the human meaning and the software element that carries it. Write those as two separate observations. The visible English words alone cannot tell a reviewer whether the problem lives in grammar, a code token, a selector or the way the application displays the string.

A plausible failure is: Reviewers assume language alone controls all currency and date display. It is easy to approve a change like this if the review is reduced to a bilingual cell comparison. The defect becomes visible only when the reviewer asks what input or state activates the message, what part of it is not freely translatable and which user decision the output might affect.

The better approach is: Test language and regional formatting separately according to platform behaviour. Keep the adjustment as narrow as possible so a linguistic improvement does not invent a new software behaviour. If the design or source copy is inadequate, document the requested developer change and keep it separate from a translation-only approval. A workaround that merely hides the symptom may make a later locale harder to maintain.

Verify with this observable check: Verify price and date with independent locale inputs. Record the target locale, sample data and relevant build or editor version. The result should be judged twice: first for exact technical behaviour, then for clear target-language meaning. If either test fails, the example is not complete. Once it passes, record the rationale as a reusable example for the next translator who meets the same class of problem.

Twelve failure modes and how to diagnose them

A failure-mode catalogue is useful because an apparent spelling mistake can actually come from missing context, encoding, wrong resource resolution or a stale build. Diagnose the mechanism before replacing the words. Each entry below identifies an observable symptom, the most economical correction and an acceptance test. Keep these records attached to the product’s review process: they are more useful than a generic demand to ‘check the translation carefully’.

Failure 1: Empty translated cells

Symptom: Source language appears unexpectedly despite catalog coverage. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Inspect catalog state, language choice and shipped build resources. The proof is: Verify the targeted key in a device run. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 2: Lost plural branches

Symptom: Count messages show incorrect endings. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Provide every required grammatical form for the target locale. The proof is: Test 0, 1, 2, 5, 11 and 21 where relevant. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 3: Wrong device verb

Symptom: Mac users are told to tap or iPhone users to click. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Vary by device only for meaningful action differences. The proof is: Run each platform’s actual user flow. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 4: Unhelpful extraction context

Symptom: A short word is translated as a noun instead of a command. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Add a real screen description and developer comment. The proof is: A screenshot clarifies the part of speech. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 5: Stale code association

Symptom: A renamed string reuses a translation that no longer matches. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Reconcile catalogue changes after every extraction. The proof is: A source-target review catches changed intent. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 6: Placeholder loss

Symptom: An interpolated name or count disappears. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Check typed variables, insertion and target grammar. The proof is: Runtime output shows all expected values. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 7: Overconfident completion status

Symptom: Workflow says translated but the sentence is misleading. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Require separate linguistic and functional approval. The proof is: A reviewer logs acceptance criteria. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 8: Poor regional vocabulary

Symptom: One region reads another region’s terms. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Define requested region targets and test actual fallback. The proof is: Locale-specific QA validates representative screens. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 9: Accessibility gap

Symptom: VoiceOver speaks a different language from the screen. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Translate accessibility text and test spoken flows. The proof is: A language-switch speech test passes. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 10: Screen overflow

Symptom: Control text is clipped when translated. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Use flexible layout and fit-aware wording. The proof is: Large-font and compact-device screenshots pass. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 11: Unnecessary variant multiplication

Symptom: Several variants say the same thing and drift apart. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Consolidate copy where the product permits it. The proof is: Version diff shows one controlled source of meaning. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Failure 12: Unreviewed vendor import

Symptom: Imported strings overwrite approved target text. A reviewer should capture the exact input and display state rather than simply label this as an inaccurate translation. In particular, compare the original and target output, identify any protected token or locale-specific branch and note whether the error appears across all locales or just one. This distinguishes a product defect from a translation decision.

Correction: Use change comparison and human review before merging. The proof is: Sampled imported variants match approved meaning. If the correction cannot be demonstrated, keep the item open. Do not trade a missing string for a misleading one or make a security-related message friendlier at the cost of changing its meaning. The acceptable fix must preserve both the end-user decision and the application’s actual state.

Practice and transfer: ten checks learners can perform

These exercises are designed to transfer beyond the examples. Attempt each without looking at the proposed check, explain the rule you used and show independent evidence. Do not score a task as solved because the text ‘looks correct’ in its source file. The end condition is a reasoned translation and a visible result in the appropriate parser, build or application. A teacher can turn the exercises into paired reviews: one person checks language and another checks the technical contract.

Practice 1: Extract and annotate ten entries

Task: Build the app, locate ten new catalog keys and attach screen-based context to each. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: A reviewer should be able to distinguish a label, alert and action without guessing. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 2: Create a plural matrix

Task: Choose one count-sensitive message and identify all target forms in Xcode. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Evaluate several actual numbers instead of relying on English one/other examples. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 3: Plan device language

Task: Write ‘open details’ instructions for an iPhone and a Mac with appropriate input verbs. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Test user actions, not merely sentence elegance. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 4: Test interpolation

Task: Insert a very long name and a two-digit count into a translated message. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Check identity, grammar and layout together. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 5: Review a source rename

Task: Compare ‘Delete’ and ‘Deactivate’ in an account settings UI. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Write a safe translation for each and record why the old one cannot be reused. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 6: Add a regional target

Task: Select a language with meaningful regional variants and document the chosen region. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Test app language and device region separately. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 7: Check catalog comments

Task: Examine five generated comments and mark any that do not resolve the translator’s ambiguity. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Replace vague comments with concise, verified screen context. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 8: Test accessible text

Task: Read the translated view with VoiceOver using the target language. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Check meaning, action and focus order. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 9: Audit import changes

Task: Diff a catalog before and after translation import. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Identify changed existing strings, new variants and missing entries. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Practice 10: Build a release checklist

Task: List exact devices, languages, counts and accessibility settings tested. Before editing, write a two-column plan: what can change linguistically, and what must remain technically intact. Then produce the smallest reliable test example. Using one carefully chosen example teaches more than translating twenty unrelated fragments without inspecting their behaviour.

Self-check: Keep screenshots and a build identifier as evidence. Explain what failure would look like, what evidence would contradict your answer and which part of the workflow you would revisit. For an advanced exercise, repeat the same task with a long variable, an unsupported locale or an accessibility setting. That second context is where a superficially memorised solution often stops working.

Frequently asked questions

Do I edit .xcstrings as ordinary JSON?

A catalog is structured data; prefer Xcode’s supported workflow unless engineering has validated direct edits, and never remove keys or selector structures casually.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

When do strings appear in the catalog?

Xcode discovers supported localisable strings when the project is built. The exact extraction depends on how the text is written in source code.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

What makes a plural variation different?

It associates distinct target messages with grammatical quantity categories selected at runtime, not merely a prettier singular/plural pair.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Should all strings vary by device?

No. Use a device-specific variant when wording genuinely depends on interaction or platform constraints.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Does a translated state prove quality?

No. It indicates workflow status, not that the user can understand the sentence or safely complete the action.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Can comments be automatically generated?

Xcode supports generating comments, but their accuracy and sufficiency should be checked against actual source usage.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Is it enough to test one iPhone?

No. Test representative screen sizes, supported devices, languages, regions, large text and accessibility flows.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

Do catalog strings cover dates and currencies?

Not alone. Use locale-aware formatting APIs for values, and translate surrounding explanatory text appropriately.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

How do I avoid changing the app’s behaviour?

Protect variables and identifiers, preserve selector meanings and validate actual UI actions and states.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

What should I read next?

The CLDR plural guide explains grammatical categories; the Apple guide here focuses on Xcode catalog and device behaviour.

For Apple Xcode string catalogs and target-language variants, the safest general habit is to distinguish a language decision from a system decision. Ask whether the change affects the audience’s understanding, a resource identifier, dynamic data or the locale that determines the message. Test the relevant layer. If the source material does not reveal enough context to answer, request that missing information rather than substituting a guess.

A practical review sheet for parents, students and working translators

A beginner need not learn every detail of a software framework before doing useful translation work. Begin with ten messages. For each, write the source, intended user meaning, target version, context, protected symbols, a sample dynamic value and the on-screen result. Ask another person to test the message without being told what it is supposed to say. If their interpretation differs from the source action, discuss the mismatch. This is a language lesson as well as an engineering lesson: words are useful only when they convey the right distinction to the reader.

For classroom transfer, select a short instruction that uses a condition, a negative and a number. Translate it into another language, then back into a plain-language paraphrase of the target. Check whether the condition and the negative survived. Next compare two messages that differ in just one state: requested versus completed, open versus closed, allowed versus required. A small change of meaning can be more consequential than a large spelling error. The same habit supports reading comprehension, written precision and responsible communication.

For production, prioritise defects by consequences. A clipped decorative caption may be lower risk than an incorrect cancellation warning. An altered error code can block diagnosis; an incorrect consent phrase can affect what a person believes they have permitted. Rate issues by user impact, not the number of words changed. Agree on a release gate, keep the original source available and make targeted corrections rather than rewriting the entire translation when one mechanism fails.

Authoritative documentation and further learning

Platform documentation is authoritative for software syntax and runtime behaviour, but it is not a substitute for a native-language reviewer, product-state evidence or accessibility testing. For grammatical choices, examine actual target-language usage and distinguish an illustrative translation from an officially approved term. When tools or platform versions change, verify the behaviour against the project that will ship.

Continue with the translation series index; the Vocabulary Learning Hub; the CLDR plural rules guide; the JSON resource bundle guide; the Fluent localisation guide; the XLIFF 2.1 translation guide. For the adjacent English-learning route, follow the ‘How English Works’ pathways linked from the Vocabulary Learning Hub. These routes serve different questions: word meaning, grammatical category, resource-file mechanics and runtime assurance.

Closing decision: is the translation ready?

A translation of Apple Xcode string catalogs and target-language variants is ready only when the target sentence preserves the intended user action and the system displays it under the correct conditions. Require evidence for the high-risk branches, not just a plausible sentence. Start with the visible problem, return to first principles, apply the repeatable method, test edge cases and document where the remaining uncertainty lies. When both language and application behaviour pass, the translation becomes a dependable part of the user experience rather than a fragile layer of text.