Go survey v2 terminal localization helps developers make interactive terminal questions understandable in multiple languages without changing the values that software stores. If you are searching for how to translate survey/v2 prompts, choice labels, validation errors, keyboard help and cancellation messages, start with a simple rule: words presented to the reader may change by locale, but collection identifier, access policy and deposit review status must retain its documented identity. A multilingual terminal application is reliable only when a person understands the choice and the program records the intended result.
This guide uses a multilingual research archive submission CLI as its running example. A public research archivist needs to choose a deposit collection, describe the data license and request archival review, perhaps while working across languages, operating systems and terminal sizes. survey/v2 makes questions practical, but it does not make a misleading success message true. In this workflow, a locally translated access label cannot grant publication or override an embargo. When the user finishes entering answers, the safest message is “Deposit request recorded; access conditions remain under review”, not an invented assertion such as “Your dataset is now publicly available”. That distinction will guide every technical decision.
The following survey/v2 localization tutorial covers prompt types, stable option values, input checks, help text, autocomplete or filtering where supported, Unicode and keyboard behavior, error recovery, terminal QA and multilingual release practices. You will see a concrete implementation sketch, detailed engineering decisions, hands-on failure investigations, an operational checklist, answers to common questions and a four-week improvement route. The goal is a readable system that an international user can trust, without assuming that translating strings alone produces a localized application.
Quick answer: make the visible language flexible and the actual decision stable
- Start with the real task: choose a deposit collection, describe the data license and request archival review.
- Identify the data contract: collection identifier, access policy and deposit review status.
- Translate messages, help, feedback, and option labels, but not immutable identifiers.
- Keep authorization, validation and confirmation independent of how words are rendered.
- Test a complete successful task, a rejected task, an interrupted task and a retry.
- Review Unicode, narrow terminals, no-color displays and native-language comprehension.
- Distinguish request collection from confirmed server state: Deposit request recorded; access conditions remain under review.
- Maintain one official documentation and regression-test trail for releases.
Begin with the user’s decision, not a bag of words
Imagine a public research archivist opening a multilingual research archive submission CLI after a long day. The goal is not to admire translated text; it is to choose a deposit collection, describe the data license and request archival review without creating a mistaken record or taking an unauthorized step. A professional localization should reduce uncertainty at the exact points where a reader must decide. What is being requested? Which options are alternatives, and which can be combined? Does pressing Enter save a draft, submit a request, or commit a completed transaction? These questions cannot be answered by dictionaries alone. They depend on the program’s real behavior and on the reader’s expectations. Even a small terminal assistant deserves the same care as a public service form because its words lead directly to actions.
The pivotal invariant is collection identifier, access policy and deposit review status. These are not decorative nouns. They are pieces of state used by other software, reviewers and audit processes. A translated label can make the state legible to the person, but it cannot redefine that state. In particular, a locally translated access label cannot grant publication or override an embargo. If a localizer receives only a screenshot, they may never discover that the word ‘complete’ means a local questionnaire ended rather than the actual operation succeeded. The safer design gives each state a distinct identifier, a truthful human-readable message and a test that observes the authoritative service result.
A bilingual workflow also needs recovery. People change their mind, close a terminal, lose connectivity or discover an error during the final summary. An interface that says nothing about partial work invites either duplicate submissions or abandonment. The first practical exercise is to write down four state descriptions: untouched, collecting, submitted for review and completed by the responsible service. Place Deposit request recorded; access conditions remain under review beside the state it truthfully describes. Reserve the sentence “Your dataset is now publicly available” for a state that would actually justify it, which may never occur during the interactive prompt itself. The difference between these sentences is a domain contract, not a stylistic preference.
What the library does, and where translation responsibility begins
survey/v2 serves a specific part of the interface: interactive questions and terminal feedback in Go. It is not, by itself, a multilingual content-management platform, a permission engine or a guarantee that strings are correctly understood. Localizing it usually requires application-level message catalogs, stable return values and intentional handling of status. Read the documented API for the exact library version in the project rather than assuming that a different terminal package offers the same helpers. A translated program should remain a valid program: code identifiers, public API field names, configuration keys and protocol values are not ordinary prose, even if readers can see them.
The most useful distinction is between presentation and meaning. Presentation includes the label, hint, help explanation, validation reason and the notice shown when a workflow ends. Meaning includes the selected machine value, business restriction, stored record, authorization result and actual downstream action. The two sides must correspond, but they should not be stored in one variable merely because the first language makes that convenient. A professional implementation can print one phrase in several languages while forwarding a single constant code to the domain service. It can also change a confusing translation without migrating historical records or breaking integrations.
Keep a small decision ledger for each screen. Write the screen’s purpose, who sees it, the available choices, what the answer means, the expected side effect and how a failed action will be communicated. Then list the messages that need translation. This sequence prevents a common inversion: translating an English interface first and discovering later that it described the underlying workflow inaccurately. If a product has no canonical meaning for a status such as ‘accepted’, stop and define the status before soliciting translations. A vocabulary defect is often evidence of a product-state defect.
A compact implementation pattern
Here is a deliberately small illustrative example using survey/v2. It demonstrates the boundary between a localized display and stable application state. It is not a complete production application: real deployments need documented localization loaders, authorization, error reporting and persistence controls. Check the installed package version and adapt module packaging, runtime checks and project style to your environment before use.
package main
import (
"fmt"
survey "github.com/AlecAivazis/survey/v2"
)
func main() {
collection := ""
prompt := &survey.Select{
Message: "Select the archive collection:",
Options: []string{"Oral histories", "Survey datasets"},
Help: "Selection creates a draft; it does not publish the deposit.",
}
err := survey.AskOne(prompt, &collection)
if err != nil {
fmt.Println("Deposit setup cancelled:", err)
return
}
ids := map[string]string{
"Oral histories": "ORAL_HISTORY",
"Survey datasets": "SURVEY_DATA",
}
fmt.Printf("Collection code: %s; state: REVIEW_PENDING\n", ids[collection])
}The most important feature of this example is not the syntax of the translated word; it is what remains unchanged after the user chooses it. The program uses a stable code in the result. It also describes an intermediate state honestly rather than making an unverified promise. If a reviewer translates a word differently tomorrow, the stored code should not change. If the underlying service changes its actual rules, the interface and tests must change together. This division of responsibility is how localization becomes maintainable rather than a collection of exceptions.
Designing a catalog that people can translate responsibly
Use descriptive keys rather than English sentences as hidden identifiers. A key such as ‘archive.review.pending’ tells a translator more than a generic ‘done’; in other environments, the equivalent names should describe actual functions and outcomes. Include screenshots or carefully worded notes for ambiguous English. Specify whether a message is a question, a command, a warning, a past-tense fact or a prediction. Record placeholders and their types, and provide one valid full example. A language reviewer needs to know whether a noun refers to a display label, a durable record or a physical object before selecting terminology.
The catalog should also distinguish fallback from silence. If a translated key is missing, it is better to show a correct fallback sentence and log a missing-translation event than to reuse a nearby but false message. There are legitimate cases for leaving technical tokens in their documented source spelling; a command-line flag, a data-format code and an exact file path are examples. Gloss these naturally in the reader’s language rather than rewriting them into a command that no longer works. Protect the catalog with placeholder checks, duplicate-key checks, and review of messages touching destructive, financial, legal or safety-relevant choices.
Pluralization and grammar need more than substitution. A sentence with a number, date, path or user-entered name may require reordered words, grammatical agreement or directionality controls. Avoid building sentences by concatenating independent fragments. Instead translate complete messages with named variables, give translators context, and use an appropriate message-formatting layer for the languages you actually support. Even if the library is not equipped with internationalization utilities, the surrounding application can own this responsibility. This practice also improves the first language because it forces the author to express a complete thought.
Technical decisions that deserve deliberate tests
1. Ask versus AskOne
Understand the exact application boundary before changing the sentence. survey/v2 offers Ask for a set of questions and AskOne for a single prompt answer In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A developer treats the translated question text as a persistent field identity A sensible implementation is to separate struct or answer field names from human-readable Message strings. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: switch language and compare the populated Go values field by field. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. A translation reviewer can judge tone, but an integration test must establish that the underlying behavior remains valid.
2. Input prompt
First consider what a reader expects after pressing Enter. The Input prompt has a Message and can provide Help text for an explanation In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
Localized help may be omitted when the only test is entering an ordinary short response A sensible implementation is to translate Message and Help together, preserving whether the requested value is required. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: use the help key and confirm the response meaning before entering data. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. That evidence matters more than a perfectly aligned screenshot, because the interface leads to a durable decision.
3. Select options
Treat this as an interface contract, not merely a styling choice. A Select prompt receives a list of option strings and can return a selection to a provided target In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
Using translated option strings directly as permanent collection identifiers causes data divergence A sensible implementation is to build an explicit mapping from presented labels to immutable collection codes. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: select the equivalent collection from differently ordered locale lists. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. Keep the requirement in the acceptance criteria so a later refactor cannot silently bring back the original defect.
4. MultiSelect choices
The most expensive bug is often not a crash but a plausible incorrect action. MultiSelect records several selected items and includes selection controls In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
An operator can mistakenly interpret a checkbox list as one exclusive access class A sensible implementation is to explain how many items may be chosen and enforce policy constraints separately. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: try selecting two subject tags and review the resulting stable codes. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. Test the boundary with deliberately awkward inputs, not just an ordinary English example.
5. Help and help-input rune
Localizing responsibly requires a visible result and a separate truth source. The library can provide help text and customize the rune used to request help In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A literal question mark can be part of a legitimate response or unclear in another keyboard layout A sensible implementation is to choose a documented help key and explain it in localized interaction text. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: enter a response containing a question mark without unexpectedly opening help. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. A credible release record should include both what appeared on screen and what the system actually recorded.
6. WithIcons options
Understand the exact application boundary before changing the sentence. Icons for error, help, question and selection can be customized through option configuration In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A colored question icon may be mistaken for a status code or a confirmation of acceptance A sensible implementation is to use text for every consequential state and treat icons as optional decoration. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: disable color and confirm every prompt remains unambiguous. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. A translation reviewer can judge tone, but an integration test must establish that the underlying behavior remains valid.
7. Select descriptions
First consider what a reader expects after pressing Enter. A Select can supply supplementary descriptions for its available options In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
An archive collection with nearly identical names may be impossible to distinguish by label alone A sensible implementation is to add concise descriptions explaining scope, not invented permissions. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: have a user select the correct collection based on descriptions. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. That evidence matters more than a perfectly aligned screenshot, because the interface leads to a durable decision.
8. Filtering behavior
Treat this as an interface contract, not merely a styling choice. Select and MultiSelect can filter options by typed text, with customizable behavior In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A local-language search term does not match source-language option strings A sensible implementation is to provide locale-appropriate labels and carefully scoped filter behavior. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: search by local spelling and confirm the same collection result. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. Keep the requirement in the acceptance criteria so a later refactor cannot silently bring back the original defect.
9. KeepFilter
The most expensive bug is often not a crash but a plausible incorrect action. Filtering can be retained while selecting several options when configured In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A user may believe filtered options are the only available choices A sensible implementation is to explain whether the filtered set is a view or a limit on permitted selections. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: filter, select one, clear filter and inspect the complete final selection. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. Test the boundary with deliberately awkward inputs, not just an ordinary English example.
10. Required validator
Localizing responsibly requires a visible result and a separate truth source. Survey includes Required and other built-in validation helpers In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A translated explanation might say optional while validation rejects an empty response A sensible implementation is to keep requiredness aligned with policy and repeat it consistently in the label and error. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: submit an empty value in all supported languages. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. A credible release record should include both what appeared on screen and what the system actually recorded.
11. Min and Max validators
Understand the exact application boundary before changing the sentence. Length and item-count validators can enforce bounds on particular answers In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A localized message may confuse character count, byte count and selected item count A sensible implementation is to specify the actual measured unit and test against Unicode text. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: enter long combining sequences and count what is rejected. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. A translation reviewer can judge tone, but an integration test must establish that the underlying behavior remains valid.
12. Custom validation
First consider what a reader expects after pressing Enter. A Question can have Validate or validators supplied through options In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A translation of a restriction cannot replace the actual logic used to accept a value A sensible implementation is to keep domain checks in Go code and only localize the resulting error message. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: test invalid access terms and compare behavior across locales. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. That evidence matters more than a perfectly aligned screenshot, because the interface leads to a durable decision.
13. Editor prompt
Treat this as an interface contract, not merely a styling choice. Editor can launch the user’s chosen editor for longer content in supported environments In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
The terminal may return a large multilingual description with an unexpected encoding A sensible implementation is to treat the returned file content as text, validate its scope and do not truncate silently. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: open and save a mixed-script abstract and compare its bytes. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. Keep the requirement in the acceptance criteria so a later refactor cannot silently bring back the original defect.
14. PageSize display
The most expensive bug is often not a crash but a plausible incorrect action. Select and MultiSelect paginate option lists, and the page size can be adjusted In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
Long localized choices can hide meaning when only a few lines remain visible A sensible implementation is to use concise labels and meaningful descriptions while preserving navigation affordances. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: test low terminal heights and verify every collection remains reachable. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. Test the boundary with deliberately awkward inputs, not just an ordinary English example.
15. Cross-platform terminal behavior
Localizing responsibly requires a visible result and a separate truth source. The library targets interactive Windows and POSIX-style terminal experiences In a multilingual research archive submission CLI, this capability helps the public research archivist proceed from an understandable question to an answer whose meaning the system can check. It should not be assumed that the library itself manages translation catalogs, approval policies or business records. Those responsibilities belong in explicit application code and documented review rules.
A control sequence that works on one terminal can fail or corrupt other output A sensible implementation is to test supported Windows, macOS and Linux shells and include no-color fallback behavior. The distinction matters even when a translation reads fluently: the user needs enough information to act correctly, while the program needs stable values and a recoverable result. Do not accept a local-only screenshot as proof, because screenshots cannot show what was stored or what a service authorized.
The practical acceptance test is precise: perform the same end-to-end deposit task on each target environment. Record the selected locale, the terminal environment, the visible text, the returned value and the resulting state. If the discrepancy affects a consequential decision, block the release until the mismatch is corrected. A credible release record should include both what appeared on screen and what the system actually recorded.
Failure investigations: problems a translation review must catch
A good localization test does not stop at asking whether each sentence sounds natural. It deliberately provokes the conditions under which readers might misunderstand a step, lose work or receive a false confirmation. The investigations below are designed around a multilingual research archive submission CLI. They are independent practice cases: each begins with an observable symptom, then asks the reader to identify the defect, make a controlled repair and check the outcome. Keep test accounts and sample data separate from production. Where a case mentions unauthorized access or sensitive information, simulate the failure with permitted test resources rather than touching real records.
Investigation 1: Translated selection stored
Consider the scene: The archive receives a collection name in Spanish instead of a canonical collection ID. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: A returned option label is used as the database foreign key. This is a meaning problem because the observed words lead to the wrong conclusion about the state. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to map selected localized text back to an immutable identifier before storage. The verification step is to compare collected record IDs across locales. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 2: Select All surprise
Consider the scene: The user presses the right arrow and unintentionally selects all optional tags. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The built-in selection shortcut is not explained or is inappropriate for the task. The defect also reveals a missing ownership boundary between interface copy and application logic. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to use configuration that removes bulk select where necessary and explain available controls. The verification step is to press each documented key and inspect the selected set. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 3: Hidden Help field
Consider the scene: The legal access policy explanation appears only in one language’s help screen. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: Localization coverage focused exclusively on Message. The important question is not whether the initial screen looked convincing, but what the operator could actually do next. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to include Help in the catalog and put decisive restrictions in visible copy. The verification step is to open help in all locales and compare the rule being communicated. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 4: Question mark as data
Consider the scene: A legitimate research title includes a question mark but triggers help. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The default help-input key conflicts with the intended input workflow. The safest response separates source data, visible explanation and the final service response. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to configure an appropriate help rune where needed and document it. The verification step is to enter question-mark titles without losing the response. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 5: Wrong page explanation
Consider the scene: A list spans several pages but one locale says there are three choices. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The translated instructions assume the English collection count. An effective test reproduces the human misunderstanding and also checks the machine outcome. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to use generic navigation text and test lists of changing length. The verification step is to browse the final page in every locale. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 6: Filter losing selected items
Consider the scene: After selecting a tag the filter clears and the user thinks the selection vanished. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The behavior of list filtering was not explained. This is a meaning problem because the observed words lead to the wrong conclusion about the state. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to show a clear selected-items summary and configure KeepFilter deliberately. The verification step is to select three items across different filtered views and inspect results. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 7: Editor text truncated
Consider the scene: A multilingual abstract returns from the editor with missing characters. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: A buffer or encoding conversion is applied after editor exit. The defect also reveals a missing ownership boundary between interface copy and application logic. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to preserve Unicode text and verify round-trip handling for full abstracts. The verification step is to save a test description with emoji, accents and CJK text. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 8: Required check wrong
Consider the scene: The French message calls a note optional but a validator rejects empty input. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: Catalog and validation policy were maintained separately. The important question is not whether the initial screen looked convincing, but what the operator could actually do next. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to store requiredness as one authoritative rule and derive copy from it. The verification step is to submit empty input and have readers compare prompt and outcome. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 9: Maximum items unclear
Consider the scene: The operator chooses four subject tags when only three are allowed. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The prompt shows no translated count limit until rejection. The safest response separates source data, visible explanation and the final service response. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to state the maximum beforehand and enforce it with the appropriate validator. The verification step is to choose exactly three and then four items. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 10: Icon-only status
Consider the scene: A cross icon indicates an error with no readable reason. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: A theme uses icon color as the sole feedback channel. An effective test reproduces the human misunderstanding and also checks the machine outcome. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to render a localized error sentence and a recovery instruction. The verification step is to capture no-color output and read it without visual cues. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 11: Help key untranslated
Consider the scene: The legend describes a keyboard key that differs from the configured help rune. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The documentation text was copied from the default setup. This is a meaning problem because the observed words lead to the wrong conclusion about the state. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to keep a single source for the effective key binding and its localized legend. The verification step is to change the help key and repeat the navigation test. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 12: Index shifts by sorting
Consider the scene: Two languages sort collection names into different orders. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The selected list index is stored as a collection identity. The defect also reveals a missing ownership boundary between interface copy and application logic. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to use codes with an explicit mapping independent of screen order. The verification step is to select the same collection in all languages and inspect the saved ID. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 13: Approval claim premature
Consider the scene: The wizard says the dataset is published when the user finishes typing. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: Answer collection is confused with actual archive approval. The important question is not whether the initial screen looked convincing, but what the operator could actually do next. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to display pending review until the backend confirms public access. The verification step is to simulate an embargo rejection and inspect final copy. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 14: Credential disclosure
Consider the scene: A diagnostic printout includes an access token from an Input prompt. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: All survey responses are treated as safe debugging information. The safest response separates source data, visible explanation and the final service response. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to redact credentials and private identifiers from logs and terminal snapshots. The verification step is to run a test token through every error path and search output. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 15: Missing TTY
Consider the scene: A batch ingestion service invokes the question flow in a headless environment. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The program attempts interactive key reads when there is no terminal. An effective test reproduces the human misunderstanding and also checks the machine outcome. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to provide a noninteractive command path or fail before creating records. The verification step is to redirect standard input and inspect exit and persistence. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 16: Unicode cell drift
Consider the scene: CJK labels and emoji cause pointer icons to misalign with options. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: Code point count is mistaken for terminal display width. This is a meaning problem because the observed words lead to the wrong conclusion about the state. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to use a tested rendering configuration and shorten nonessential ornament. The verification step is to compare visible pointer placement in target terminals. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 17: Unclear access class
Consider the scene: A localized phrase for restricted access sounds equivalent to public access. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The translator lacked domain context and related policy definitions. The defect also reveals a missing ownership boundary between interface copy and application logic. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to explain concrete access consequences in each option description. The verification step is to ask native reviewers who may download a deposit after selection. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Investigation 18: Failure after editor exit
Consider the scene: The editor closes but the archive upload fails; the CLI says Done. For the public research archivist, this may look like a small wording or layout annoyance, but the real consequence can be much larger. A user may choose differently, repeat a step or believe that collection identifier, access policy and deposit review status changed when it did not. Begin by writing down what a first-time reader is likely to infer from the displayed sentence. Then inspect the actual response value and any downstream operation without assuming that the interface’s wording describes reality.
The likely cause is specific: The application equates completed text entry with completed submission. The important question is not whether the initial screen looked convincing, but what the operator could actually do next. Diagnose it by comparing source copy, translated copy, application data and the official API behavior for the version being shipped. Avoid treating a translator’s preference as a substitute for the original product requirement. If the intended behavior was never defined clearly, obtain a policy decision and make it a testable specification before correcting the sentence.
A focused repair is to show the response from archival submission separately from editor success. The verification step is to force an upload failure and verify a recoverable error message. A complete regression also checks the corresponding workflow in a second language and in a narrow terminal. Capture enough evidence that another maintainer can reproduce both the earlier failure and the new passing result. The correct result is not simply fewer complaints; it is the reader reaching the intended decision with the same valid data contract.
Operational quality assurance: test the complete journey
Build a small matrix rather than trying to test every combination on every change. Every release should include the source language, at least one longer translation, one script with different typographic or input characteristics when supported, and a deliberate missing-key fallback. Combine these with normal and narrow terminal widths, color and no-color output, successful completion, invalid input, interruption and service rejection. The matrix should name the actual supported terminals and runtime versions; a claim such as ‘works with Unicode’ is too broad to test. Use real readers for comprehension questions that automated screenshots cannot answer.
Inspect each prompt in context. A tooltip may contain the only explanation of a restriction; a help message may refer to a key that was customized; a translated choice may omit the phrase that separates two similar outcomes. Follow the response into the domain layer and read the persisted value. For a multilingual research archive submission CLI, examine collection identifier, access policy and deposit review status after each selection. Then simulate a retry: many translation defects appear only after the program resumes a partially completed workflow. Keep sensitive values out of test screenshots, and prefer synthetic accounts or fixtures to actual customer records.
A second quality pass checks the things a screen cannot prove: serialized identifiers, policy enforcement, audit events, authorization decisions, errors returned from services and cleanup behavior. Validate that the localized success sentence is grounded in a real successful action, not just that all prompts returned an answer. Test that closing the terminal before submission cannot create an accidental second record on retry. If an action is destructive or difficult to undo, confirm that the question names the affected object and the consequence in natural language. A translated interface should never become more permissive than its source workflow.
Unicode, accessibility and honest terminal behavior
Unicode text should survive from catalog through rendering, input, validation and storage. Yet Unicode correctness is not equivalent to visual correctness: code points, grapheme clusters and display cells can differ. Accents may be composed or decomposed; emoji can join into one visible sequence; East Asian characters may occupy wider cells in many terminals; and bidirectional scripts can reorder punctuation around embedded commands. Do not calculate display width by taking an arbitrary string length, and do not assume every terminal has identical shaping or emoji support. Test the target devices and provide a plain-text fallback when the layout becomes unreadable.
Accessibility is similarly practical. A color-coded error needs explanatory words. A menu that expects arrow keys should tell the reader how to move and choose when that knowledge is not obvious. Hints should use actual keyboard names rather than metaphorical language. Screen readers, redirected input and remote terminals may handle complex controls differently; where interactive prompting is unavailable, a documented noninteractive route should exist or the program should fail predictably before changing data. The correct trade-off sometimes means fewer visual effects and more explicit instructions. That is not a loss of sophistication; it is engineering for real working conditions.
Human proofreading belongs inside these tests. Give a reviewer a realistic task rather than asking, ‘Does this sound good?’ Ask what will happen if they press Enter, whether the choice is reversible, who can see the resulting record and what they would do after a failure. Their answers reveal pragmatic mistakes that grammar checks cannot find. If two readers disagree, investigate whether the original interface was ambiguous before requiring them to agree on a translation. Precise translation often begins by improving the explanation in the source language.
Four-week implementation and learning plan
Week 1 — Identify the decision contract
Trace a complete a multilingual research archive submission CLI transaction from launch to the authoritative record. Inventory every visible message, help string, default, choice label, error and completion line. Record collection identifier, access policy and deposit review status separately from the human text. Install the documented version of survey/v2 in a throwaway test project, inspect real API behavior and choose one non-English locale for a pilot. Document the three most expensive misunderstandings that a real reader could make. Write tests for the default locale before changing any string, because a working comparison is essential.
Week 2 — Build catalogs and stable answers
Extract visible wording into message catalogs with comments, placeholder definitions and one full example for each consequential status. Implement stable choice mappings and domain validation in the underlying application. Use the documented survey/v2 controls for a small end-to-end flow rather than inventing a parallel prompt framework. Review the pilot translations in context and ask readers to explain the effect of each choice. Ensure cancellation returns without claiming that an operation committed. Add missing-key detection and test one intentionally absent translation.
Week 3 — Exercise adverse conditions
Simulate invalid inputs, network errors, authorization rejection, interrupted prompts and retries. Add narrow terminal screenshots, no-color capture, Unicode stress strings and at least one operating system not used by the original developer if the product supports it. Inspect actual saved collection identifier, access policy and deposit review status and verify that a localized selection never changes a stable identifier. Ask native readers to complete the task uncoached and record where they hesitate. Repair false success claims before polishing decorative language.
Week 4 — Review, document and release
Conduct a second reviewer pass on high-consequence copy, freeze the message-key inventory for the release and run automated and manual regression tests. Attach official survey/v2 references and note the tested package version. Keep screenshots as illustrations, not sole evidence. Ship with a rollback path for catalog errors, a way to report misleading translations and a clear owner for every repair. After release, track whether readers complete the intended task without unauthorized side effects; revisit confusing terms rather than assuming a one-time translation finishes the work.
Frequently asked questions
Does survey/v2 translate every message automatically?
No. A terminal-prompt library primarily handles interaction. It may provide customizable visible strings or utility controls, but application-level catalogs, domain vocabulary and outcome messages still need deliberate implementation. Audit every state that a user may see, including validation failures and cancellation, rather than translating only the most common question.
Should we translate values that the application stores?
Usually not. Translate visible labels and explanatory prose, but maintain stable machine-readable values for collection identifier, access policy and deposit review status. If a business code must change, treat it as a documented data migration with compatibility checks, not as a translator’s editorial edit.
Can a translated choice list be sorted alphabetically?
Yes, if doing so does not break the mapping between the displayed item and its stable identity. Some controls return an index or string that needs careful conversion. Test both selection and default behavior after sorting, because a visually harmless reordering can select a different stored value.
What counts as a serious translation bug?
Anything that changes the reader’s understanding of an action, requirement, deadline, authorization, amount, stored identity or completion state deserves priority. A false success message is often more damaging than an awkward adjective. Use severity based on the action a reasonable user would take, not on how conspicuous the typo looks.
How should cancellation be described?
Describe what actually happened. Exiting an unfinished questionnaire is not the same as cancelling an already approved transaction. If partial drafts or temporary files remain, say so; if they are removed, verify cleanup before claiming it. Test keyboard interruption at every consequential step.
How do we test languages that use longer or different scripts?
Use real translated messages, narrow terminal windows, representative grapheme clusters and actual target terminals. Include accented strings, CJK characters and bidirectional layouts as appropriate for supported locales. Check both visual interpretation and round-trip preservation of saved data.
Do we need native-language reviewers if tests pass?
Yes, for consequential explanations and natural-language decisions. Automated tests can prove values, branches and service responses; they cannot establish that every human reader understood the intended consequence. Ask reviewers to perform tasks and paraphrase what a choice will do.
What should a small team ship first?
Begin with one high-value workflow, a source-language catalog, one additional language and a reliable cancellation path. Protect stable identifiers and validation before tackling decorative layout. Add a regression test for every defect found, then expand locale coverage only after the core workflow is dependable.
Is a successful prompt session proof that the operation succeeded?
No. It only proves that the interactive component obtained answers or reached a local endpoint. Query the actual service, permission system or durable record. In this example, the appropriate unverified-completion notice is ‘Deposit request recorded; access conditions remain under review’, not ‘Your dataset is now publicly available’.
Can this guide replace framework documentation?
No. Consult the cited official API for the library release you deploy. Some helpers and options are version-specific, and terminal behavior depends on runtime and operating system. This guide explains the engineering decisions that should surround those documented APIs.
Official documentation and continuing study
- Go survey v2 official package documentation
- Go survey source and README
- Go unicode/utf8 reference
- Go text packages
- Unicode grapheme segmentation
To study fidelity, judgment and the movement of meaning between languages, read Master Art of Translation — the Complete System for Moving Meaning Between Languages. Find related applied chapters in the Translate Like a Pro series index. The earlier Enquirer Node.js localization chapter examines a different interactive-prompt API. Its examples are not interchangeable with the specific survey/v2 methods discussed here; consult each library’s own documentation when implementing.
Conclusion: make the user’s action match the program’s actual state
Good survey/v2 localization is not measured only by grammatical fluency or by the number of strings changed. It is measured by whether a public research archivist can choose a deposit collection, describe the data license and request archival review with a clear understanding of each step and a trustworthy account of the result. Keep collection identifier, access policy and deposit review status stable, make validation and cancellation explicit, verify statements against real service state and test complete tasks in the languages and terminals that people use. Translation then becomes an instrument of reliable action rather than a decorative layer over an uncertain workflow.