eduKate Singapore

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.

Next useful routeCanonical hubHELP

How People Translate Quickly | ActivityStreams 2.0 Language Maps: Localize Federated Posts Without Changing Who Said What

—

by

eduKate Asia

How do people translate ActivityStreams 2.0 posts quickly while keeping the social record intact? Use the specification’s natural-language value forms—especially nameMap, summaryMap and contentMap—for language-specific text that the publisher is authorized to supply. Keep the object’s id, actor attribution, audience, reply relationship and delivery address out of the translation layer. Then verify what a receiving client actually displays, because valid multilingual JSON is not a guarantee that every federated application will choose the intended language.

ActivityStreams 2.0 is a vocabulary and JSON serialization for describing activities and objects on the social web. That makes it a particularly revealing translation problem: a short post may contain human prose alongside identifiers that say who authored it, who received it, what it replies to, and whether an image or link belongs to the message. A well-intentioned localization script that rewrites every string could accidentally change a profile URL or the relationship between a note and its author. Faithful translation changes the reader-facing expression, not the provenance of the action.

This guide focuses on authorized multilingual representation of a federated object’s natural-language fields, not on auto-translating strangers’ posts or editing existing remote activity records. We use a fictional museum announcing a free public tour in English and Malay. The example identifies exactly where text belongs, why the base object identity must remain stable, what to do when a language is missing, and how to report the limits of client support without overstating interoperability or search visibility.

First define who is entitled to speak in the translated voice

A museum publishing its own bilingual announcement can approve two language versions as part of one editorial act. A third-party aggregator displaying an unofficial translation of somebody else’s message has a different responsibility: it must preserve attribution and signal that the target wording is a translation rather than silently presenting it as the author’s original expression. These two cases may look identical in a user interface, but the trust relationship is different. Before altering serialized content, write down the publisher, translator, target audience and authority under which the translated words will be distributed.

The acceptance statement for our example is precise: a visitor choosing Malay should read the museum’s approved Malay tour announcement; a visitor choosing English should see the English original; both should be looking at the same announcement identifier, attributed to the same museum account, with the same event date and reply context. The reviewer must reject any change that accidentally turns the museum’s note into a new anonymous note or introduces a different invitation time. Translation quality includes preserving the social act that the text performs.

An authorization gate also helps manage edits. If the museum later changes its departure point, translating the original wording again without checking the revised source would publish a stale instruction. The solution is to version the approved message and track when each localized value was reviewed. A high-quality translation is not permanently correct merely because it was correct when first published. Social objects can carry updates, and the translation process must recognize the difference between a new statement and a revised rendering of an old statement.

Read the ActivityStreams object as a graph before reading its prose

An ActivityStreams object normally contains fields with very different jobs. A Note has an id representing its identity and can use attributedTo to indicate the author. An activity can identify its actor and object. A note may have inReplyTo, to, cc, attachments and tags. Each relationship adds context that a reader needs to understand who is speaking and what the message refers to. The visible prose may be only a small part of the record. Translating correctly requires preserving that larger structure.

Imagine two otherwise identical statements: ‘The tour is cancelled,’ published by the museum, and ‘The tour is cancelled,’ posted as a visitor’s rumor. The surface sentence matches exactly; the provenance does not. If a translation tool changes or loses the attributedTo relationship, it can turn a harmless language-service operation into a serious misrepresentation. The same applies to an inReplyTo reference. A translation of a reply to yesterday’s tour question must not become a free-floating announcement that readers interpret as today’s official notice.

Build a protected-fields manifest before translation. Store the object ID, type, attribution, audience and delivery references; relevant URLs; time stamps; replies; and attachment targets. Record what is expected to remain unchanged and why. This is not an instruction to assume all other strings are translatable. Some string-valued fields represent machine addresses, media types or controlled values. The correct distinction comes from property definitions, not from the surface appearance of quotation marks in JSON.

Natural-language values have two serialization forms

The W3C ActivityStreams 2.0 Core specification defines natural-language values that can appear either as a single JSON string or as a language map. The string form uses names such as name, summary and content; the corresponding map forms are nameMap, summaryMap and contentMap. A map associates BCP 47 language tags with strings. This is the structural feature that makes native multilingual descriptions possible without creating a separate object identity for every language in the simplest publishing workflow.

The distinction is not just a naming preference. An implementation expecting a string in content may not treat an arbitrary object placed there as a valid equivalent of contentMap. Likewise, contentMap is not a place to put an array of translations lacking language keys. A review needs both JSON syntax and model semantics. If the source system produces a form unsupported by its own delivery client, a perfectly translated string may never reach the reader. Test the producer and consumer as a pair rather than trusting the editor’s preview.

The specification requires the keys of a natural-language map to be well-formed BCP 47 language tags and the values to be strings. It also recognizes und for an undetermined language. These are semantic commitments: a label tagged ms should genuinely be Malay; an English draft should not be relabeled ms merely to satisfy a locale toggle. A tag is a promise to downstream software about how to select and present the value. The words and their metadata have to agree.

A small bilingual museum note makes the boundaries visible

Our fictional museum plans a guided courtyard tour at 10:00 local time. The source editor prepares the English title and message; a Malay editor reviews the equivalent wording. The digital team creates one note with a stable identifier, a stable museum attribution and language-mapped display fields. The JSON below illustrates the narrow data pattern; its example addresses are placeholders, not live federated endpoints, and no claim is made that the fixture was delivered to any production server.

{
  "@context": "https://www.w3.org/ns/activitystreams",
  "type": "Note",
  "id": "https://example.org/notes/courtyard-tour-27",
  "attributedTo": "https://example.org/actors/museum",
  "nameMap": {
    "en": "Courtyard Tour",
    "ms": "Lawatan Halaman Dalam"
  },
  "contentMap": {
    "en": "The free guided tour begins at 10:00. Meet at the east gate.",
    "ms": "Lawatan berpandu percuma bermula pada pukul 10:00. Berkumpul di pintu timur."
  },
  "to": ["https://www.w3.org/ns/activitystreams#Public"]
}

The example’s identity and attribution are independent of language selection. Translating the content does not alter the public audience marker or turn a bilingual note into two separate activities. The reader still needs contextual details that the data does not include: the date and applicable time zone, for example, would be essential in a real event announcement. An editor should add those facts to the source content or linked event record before translation, not guess them separately in each locale. Natural-language maps solve a display problem, not incomplete event planning.

A useful bilingual QA test opens the same note in both language settings and checks the title, content, account identity and audience. If one client shows English in both cases, record that behavior as a client-selection limitation or fallback choice; do not manufacture a second note merely to make the screenshot look bilingual without considering delivery and reply consequences. Where distinct-language editions are required for a product reason, treat them as an explicit publication design with clear linkage and provenance, rather than a secret workaround for missing map support.

Distinguish name, summary and content editorially

A name is often a short title or label; a summary may supply a concise representation or explanatory preview; content is the primary message. Their relationship matters in notifications and accessibility surfaces where only part of an object is displayed. A translation that makes the name sound appealing but omits a cancellation condition from the content can cause inconsistent communication. Equally, a translated summary that adds a promise absent from the content creates a new claim. Editorial review should compare each field against its own function and then check consistency between them.

Not every object has all three fields. Some notes use content without a name; a summary may be generated automatically by a publisher or client. If your local system creates summaries, determine whether it generates them from the selected language version or from a default source. A Malay-speaking reader could otherwise receive a Malay content panel with an English notification preview, or worse, a preview that truncates a safety-critical condition. The right fix may be a product-level localized-summary strategy, not adding unsupported custom properties to the ActivityStreams object.

When content includes markup, the translator must understand what is meaningful prose and what is structural HTML. Links, mention targets and formatting should survive without accidentally inserting unsafe markup. The language map still contains a string, even when that string encodes HTML content. Treat it as untrusted input at the consuming interface, apply the application’s normal sanitization rules, and test how the display behaves. Translation permission does not grant permission to bypass security validation or rewrite a link target to an unrelated destination.

Keep actor, object and audience separate from language

ActivityStreams gives each activity its own context: who performed it, what object was involved, and which audiences may receive or view it. A localizer should not change actor, object, attributedTo, to, cc, bto or bcc to produce a more localized reading experience. These fields govern identity and routing rather than grammar. They may be strings or arrays of IRIs, which makes them particularly vulnerable to careless string-replacement tools that assume all text-like values are language.

The consequence of changing an audience is not merely cosmetic. A public message can become privately routed, or private context can be exposed to the wrong recipients, depending on the producer’s behavior. If a translation pipeline copies an inbound activity, removes recipients and republishes the copy, it may have created an entirely new communication with different privacy conditions. A safe pipeline starts with a fixed protected-field diff and rejects transformations that alter audience or delivery values unless a separate authorized publishing workflow explicitly calls for that change.

Attribution deserves similar care. The museum’s actor URL is an identity reference, not a localized profile caption. The visible display name of an actor may itself have localized values, but changing the actor ID is a different operation. If a receiving client only displays a default account name, that limitation should not be solved by fabricating a new actor for every language. Identity stability lets readers follow, verify and respond to the same institution across language boundaries. Linguistic variety should not fracture the social graph.

Translate event facts as protected packets

Our example includes 10:00 and ‘east gate’. The time is a factual anchor; the gate is a venue instruction. A fluent Malay sentence is inadequate if it moves the meeting point to the west gate or confuses morning with evening. Make a fact sheet listing dates, times, locations, accessibility conditions, prices, restrictions and booking requirements before drafting localized content. Some may require official local terminology, but all must describe the same event. A separate fact review catches errors that a language-only proofread can miss.

Relative terms create additional risk in activity feeds. A post saying ‘tomorrow’ has meaning relative to its publication date and location, while a federated copy can reach readers later or outside the original zone. A translator should not silently replace tomorrow with a guessed calendar date, but the publisher should consider whether the message needs an explicit date. The distinction matters because the translation process should preserve source meaning, whereas the editorial process may need to improve the underlying message for all locales before release.

Currency and measurement expressions require the same discipline. If a note offers a free tour, the translation should not introduce a ticket fee; if it gives a distance, a unit conversion must preserve the quantity rather than merely replace the unit label. Natural-language maps do not validate equivalence between values. The QA team must compare protected facts directly and, in a higher-stakes context, use a second reviewer or structured evidence. Strong fidelity checks sit outside the format and make its multilingual affordances trustworthy.

Fallback language is a product decision, not a guess

A reader might prefer ms-SG, while the publisher supplies ms and en. A consumer may choose a broader language, its default language or another display based on its implementation. The ActivityStreams data alone does not guarantee a specific locale-negotiation algorithm for every receiving application. Product teams should define the expected fallback policy and test it in the clients they actually support. A requirement like ‘display Malay whenever the preference starts with ms’ needs an implementation-level test, not a claim that the standard automatically enforces it everywhere.

A missing translation is not the same as an empty translation. Inserting an empty Malay string may tell a client that the field has a Malay value, possibly producing a blank panel instead of a useful English fallback. Better to omit an unapproved target value and use the receiver’s documented fallback, with a visible indication where appropriate. This also protects readers from machine-generated drafts being misrepresented as editorially approved just because their locale keys exist.

The und tag can express genuinely undetermined language, but it should not become a universal bucket for text whose language is simply inconvenient to classify. If the museum knows the language, tag it accurately. If a historical quotation combines languages or lacks enough evidence for classification, record uncertainty honestly and decide whether a separate explanation is needed. A careful language map is a representation of knowledge, not merely a menu from which users select flags.

Handle mixed scripts and directionality in the renderer

A multilingual social note may combine Arabic or Hebrew with Latin URLs, hashtags, dates or product names. The W3C specification discusses text direction and the Unicode bidirectional algorithm because string storage and screen order are not the same problem. A map with a correct language tag can still render confusing punctuation if the client neglects directionality. Test actual right-to-left display in notification cards, full posts, reply composers and copied excerpts, not only the JSON value as printed in a terminal.

Invisible bidirectional controls sometimes help isolate a mixed-direction span, but they also complicate copying, searching and auditing if inserted indiscriminately. Prefer the receiving client’s correct direction-aware rendering model, and use explicit markup where the supported content format permits it. Never place hidden controls into actor IDs, object IDs or mention URLs as a translation workaround. A reader should be able to copy a link and reach the same target regardless of the surrounding language’s writing direction.

Language QA must include mobile screens and assistive technology where relevant. A short notification title might be truncated before its most important qualifying phrase; a screen reader may mispronounce a passage when the language isn’t communicated at the interface layer. These are delivery issues adjacent to, but not solved entirely by, ActivityStreams maps. Report them separately so the team knows whether to revise text length, add UI language metadata or fix the application. A valid payload can coexist with an inaccessible user experience.

Tags and mentions can connect a note to other people or topics. A human-facing hashtag text may look like something to translate, yet the tag could also serve as a stable discovery token used by a community. Replacing a known tag with a guessed translated tag may split a conversation into separate discovery streams. If translated tag displays are desired, handle the policy explicitly: preserve target links and identities, and distinguish a translated explanatory label from a new tag chosen by the publisher for a different audience.

Mention display text can also differ from the identity it points to. A translated paragraph may need different punctuation around a mention, but it must not silently retarget the account URL or attribute a statement to somebody else. Use placeholders or structured token handling while drafting, then reinsert the exact authorized targets. A good QA view highlights mentions and links independently from prose so the reviewer can check grammar and identity without toggling between unrelated technical screens.

Links to a museum’s bilingual landing pages are a special case. Selecting a localized destination may be appropriate, but only if the alternate page has the same official purpose and its URL is verified. That is a deliberate link-management decision rather than a translation of arbitrary URL characters. Record source and target destinations, expected language and fallback behavior. If there is no suitable alternate, keep the original link and add a clear explanation rather than inventing a plausible URL that could lead nowhere or elsewhere.

Receiving applications may support only part of the ideal experience

Some social clients will read a natural-language map and choose an appropriate value. Others may favor a default text field, provide incomplete language selection or show a fallback inconsistently between previews and full posts. A project should not interpret the standard’s representational capability as a promise about every deployed consumer. Read-only protocol documentation and a local parse can establish that a payload is structured coherently; only delivery testing establishes what the intended readers see.

Design a small interoperability matrix with rows for producer, receiving server, browser client, mobile client and preferred language settings. Test new posts, updates, quoted or forwarded contexts and reply threads where supported. Record whether the same object ID appears, whether the localized value was selected, and whether links, mentions and audiences survived. If a client fails, identify whether it ignored the map, had no supported fallback, sanitized markup differently or received a transformed object. Each diagnosis points to a different repair.

Avoid using federated distribution as a convenient mass test environment. Publicly transmitting many trial messages can inconvenience followers and leave durable records. Use authorized staging, test actors and controlled recipient lists whenever possible, and clearly label experimental content. This is especially important when a subject involves public safety, school announcements or a person’s reputation. A purely offline JSON fixture can validate structure without imposing messages on a real community; broader behavior claims should wait for ethically conducted interoperability tests.

Versioned approvals prevent stale parallel language tracks

Consider the museum updating its announcement from 10:00 to 10:30. If the English source is edited immediately but the Malay map still says 10:00, both versions can appear in the same ActivityStreams object while asserting contradictory facts. This is a multilingual consistency defect, not a JSON defect. A sensible editorial workflow locks publication until every required locale has reviewed the changed fact or applies a transparent fallback policy indicating which translations are still pending.

Store a content version, source hash or editorial change identifier alongside your localization workflow even if these controls live outside the serialized object. The translation memory should connect each approved value to the source text it translated. When the source changes, automatically flag dependent languages for re-review instead of assuming old translations remain valid. This procedure is more useful than simply counting translated strings because it measures whether approved meanings are synchronized with the current publisher intent.

For an authorized correction, follow the producer’s update semantics rather than inventing a new activity with the same ID and incompatible fields. The exact protocol behavior depends on the application and related federation stack; ActivityStreams data definitions alone do not dictate a universal workflow for account authentication, signatures or update delivery. Coordinate with the implementer, log the new approved language values and compare the resulting object relationships. An offline translator should not claim a federation update succeeded without evidence from the actual participating systems.

Diagnose malformed maps and misleading locale labels

A common failure is to write content as an object containing language keys rather than using contentMap for the object form. Another is to insert a contentMap array where the specification expects a map from language tags to strings. A third is to use informal keys such as Chinese or Malay-Singapore instead of well-formed language tags. These failures can be caught by a targeted validator that knows the relevant ActivityStreams field conventions and a language-tag checker. A generic JSON parser alone will accept many of these semantically wrong structures.

The opposite failure is a structurally perfect map whose values are mislabeled. A Chinese translation can be stored under ms, a machine-translation draft can be described as approved, or a summary can omit a caution present in the source. Automated validation may detect language mismatch heuristically, but it cannot certify editorial truth. Keep source-target review independent from syntactic checks, and inspect the important factual anchors by hand or through a documented comparison procedure. Multilingual data can be machine-readable while still communicating misinformation.

Unexpected HTML is another diagnostic branch. If escaped entities appear literally, determine whether the value was encoded twice. If tags disappear, inspect the client’s sanitization behavior and the publisher’s content expectations. Do not compensate by disabling sanitization or moving unsafe markup into another field. The repair must preserve the data model and the application’s security boundary. For most museum notices, simple prose with verified links will be more portable than elaborate translated markup across heterogeneous clients.

A controlled QA script can check invariants

For the fictional note, a lightweight validator can parse both the source and candidate JSON documents, compare protected keys and check the language-map shape. This is a screening test, not a substitute for a full ActivityStreams vocabulary validator, editorial approval or recipient-side rendering. Its value lies in making the most dangerous accidental changes obvious before the document leaves the local environment. The invariant list should be adapted to the actual object’s types, extensions and governance rules.

import json
source = json.load(open("note-source.json", encoding="utf-8"))
target = json.load(open("note-localized.json", encoding="utf-8"))
for key in ("id", "type", "attributedTo", "to", "cc", "inReplyTo"):
    assert source.get(key) == target.get(key), key
for field in ("nameMap", "summaryMap", "contentMap"):
    if field in target:
        assert isinstance(target[field], dict)
        assert all(isinstance(v, str) for v in target[field].values())

This code demonstrates a comparison strategy, but it does not validate whether each language tag conforms to BCP 47 or whether the translated prose is accurate. It also cannot tell whether changing a field from absent to present is authorized in every publishing workflow. The production QA should validate the full supported profile, the exact required permissions and the receiving software behavior. Code that exits without error has proved only what its assertions actually check, which is why the reviewer should read the assertions before trusting their reassuring green result.

Changed-context transfer exercise: a bilingual student society announcement

A student society runs a federated account and announces a meeting in English. It wants a Japanese version for exchange students. The post links to a registration form, mentions an external speaker and replies to a previous campus discussion. Its team proposes translating every JSON string and publishing the result as a separate note because its favorite client does not display maps. Describe the safer workflow, including the authority check, fields that cannot be rewritten, locale handling and tests that demonstrate real benefit to readers. Assume the registration form itself has not been localized.

Worked answer

First confirm that the society owns or is authorized to translate the announcement and have an editor approve the Japanese facts. Put the approved human content in the appropriate natural-language representation, using a correctly tagged Japanese value and preserving the original English value where the producer supports that approach. Keep id, attributedTo, reply relationships, mentions and audience intact. Verify the form URL and do not invent a Japanese form destination. Test the two actual client experiences, record fallback behavior, and if separate editions are genuinely required, design a transparent publishing and linking policy rather than treating duplicate posts as a harmless serialization repair.

The important changed context is that the translation includes social relationships and an unlocalized downstream form. Copying the museum’s two-field JSON example is not enough. The right answer explicitly preserves the speaker mention and the reply thread, avoids implying that the registration page is Japanese when it is not, and acknowledges that receiving clients vary. It also notices the student’s reputational responsibility: a machine-generated translation of an external speaker’s name or quote should not be attributed to that speaker as if they authored it. Meaning preservation includes authorship boundaries.

A review checklist for the full federated reader job

Before approving, confirm the publishing authority and source version; verify the intended language tags; compare title, summary and content for factual equivalence; preserve object IDs, actor identities, audiences, mentions, reply relationships and link targets; check markup safety; test fallback; verify the same note appears in each supported locale; and record client versions and limits. A reviewer should be able to reproduce the most important result from the fixture and a controlled receiving environment. Every missing translation should have an explicit state, not a blank string masquerading as completion.

The checklist should also inspect context-specific harm. School closures, medical notices, emergencies and election communications warrant much stronger approval and distribution controls than casual museum updates. The presence of language maps does not make an automatic translation safe to distribute under somebody else’s identity. Escalate high-stakes ambiguous wording to the responsible publisher; do not infer policy from a generic machine-translated sentence. A translation workflow is trustworthy when it knows which decisions are editorial and which are technical.

Keep a final evidence bundle containing the source and localized JSON fixtures, a structural diff, editorial approvals, language-tag review, observed screenshots or client logs, and a clear statement of what was not tested. Later an implementation may upgrade its handling of natural-language maps. With that evidence, the team can rerun the same tests and measure actual improvement. Without it, a previous ‘passed’ claim cannot distinguish a standards-compliant payload from a browser that happened to display the default English text.

Limits, responsible publication and summary

ActivityStreams 2.0 can represent natural-language alternatives but does not guarantee translation accuracy, permission to speak for another author, standardized visual fallbacks in every consumer, or successful delivery through a particular federation implementation. Those concerns remain with the publisher and deployed software. This article does not teach how to bypass delivery permissions, impersonate accounts or mutate someone else’s remote records. A correct language-map edit should remain within an authorized content-production boundary, with provenance and audience preserved.

The shortest dependable workflow is to define the reader job, protect social relationships, translate only eligible prose, attach accurate language tags, run syntactic and factual checks, and test real client behavior. The result is a more inclusive federated message without a rewritten social graph. If there is no native multilingual support in the target client, a transparently labeled companion translation can still help readers, but its status and relationship to the source must be explicit. Respect for identity is the reason this is more than ordinary text substitution.

For wider context, the eduKateSG metadata-crosswalk article explains why strings that look similar can carry different structural meanings, while the guide to preserving names, dates and units helps reviewers protect factual anchors. Neither substitutes for the present article’s focused job: using ActivityStreams language maps while preserving who said what, to whom, and in reply to what. That boundary lets readers find the right repair instead of receiving a broad checklist that never reaches the actual failure point.

Keep editorial translations distinguishable from quoted speech

Federated posts frequently contain quotations from other people, such as a speaker’s statement inside a museum announcement. The museum can approve a translation of its own introduction, but that authority does not automatically extend to rewriting another person’s quotation as though the speaker originally said those target-language words. Preserve the quote’s attribution, determine whether an official authorized translation exists, and make it clear when a quotation has been translated editorially. If the exact wording matters, consider retaining the original quotation alongside an explanatory translation. The point is not to forbid translation; it is to prevent a change in evidentiary status from hiding inside a content map.

The problem becomes sharper when a post is subsequently quoted, forwarded or archived by another account. A receiver may copy only one language value without copying the publisher’s surrounding explanation. For a translated quotation with legal or reputational consequences, that can turn a carefully qualified statement into an apparently verbatim assertion. Check how quote attachments and previews are represented by the chosen application, and whether the target text remains marked as interpreted language where necessary. If the receiving client loses that distinction, consider a simpler source link and clearly labeled translated commentary rather than a fragile display trick.

A language map should not silently repair disagreement between two authorized texts either. If the English museum announcement gives one date while an approved Malay translation gives another, there is no single correct version to select until the publisher resolves the discrepancy. Record the conflict, identify the current source version and request an editorial decision. Republishing a translation that merely sounds plausible can create parallel social realities for audiences using different languages. Provenance checks and factual consistency tests belong in the release gate precisely because each audience may never see the other language.

Measure success by the recipient’s experience, not locale-count statistics

A translation dashboard may proudly report two languages because two keys exist under contentMap. That metric says nothing about whether the receiver displayed the intended value, whether a screen reader used the right language, or whether users understood the meeting instruction. Build an acceptance test around actual reader tasks: find the meeting time, follow the correct museum account, open the official registration page and reply to the original note. Run the tasks in each supported locale with a real client version, noting what is consistent and what fails.

Suppose the full post displays Malay correctly, but the notification card uses an unlocalized summary generated from an English source. A string-coverage report would say the content is complete, while the recipient would reasonably think the service still lacks Malay support. The repair lies in the product’s notification rendering and summary strategy. Similarly, if clicking a translated hashtag reveals an unrelated conversation, the defect concerns identity and discovery rather than spelling. Organizing test results by reader job keeps the team from declaring success based on internal file shape alone.

Collect only the data needed for testing. Screenshots and logs of real social accounts can expose private audience information, handles or personal content. Prefer fictional test accounts and controlled messages, and anonymize captured identifiers where the audit does not need them. Store the structural before-and-after comparison securely, with authorized access and a deletion policy for any sensitive test evidence. Responsible interoperability QA should make translated messages clearer without creating a new privacy leak through the verification process itself.

Frequently asked questions

Which ActivityStreams fields support multilingual natural-language maps?

The core specification identifies natural-language values for name, summary and content, with their object forms nameMap, summaryMap and contentMap. Do not assume other arbitrary fields accept the same shape.

Can a language map replace the object’s ID?

No. The map provides language-specific display strings; the object identifier is a separate identity reference. Translating an ID can break references and provenance.

Can I use a country name as a language-map key?

Use a well-formed BCP 47 language tag rather than an informal English name. The tag needs to describe the actual language of the value.

What does the und language tag mean?

It identifies an undetermined language in contexts where that is genuinely appropriate. It is not a shortcut for unreviewed content or unknown translation quality.

Will every federated client automatically display my preferred language?

No. The format can represent alternatives, but applications differ in selection, fallback and rendering. Test the producer and supported receiving clients.

Is translating somebody else’s published post the same as editing the publisher’s bilingual post?

No. An unauthorized third-party translation should be identified as a translation rather than silently attributed as original author wording. Respect publisher and platform policies.

Can I translate mentions and actor URLs?

Translate surrounding prose, not the identity-bearing target URLs. Keep link destinations and mention identities intact unless a separate authorized link-management decision applies.

Why can a structurally correct map still be dangerous?

Values may contain wrong times, altered conditions or a misleading attribution. JSON validation checks structure, not factual equivalence or authority to publish.

What should happen when a translation is still awaiting approval?

Do not pass an unreviewed draft off as a finished locale value. Use a documented fallback or a clearly labeled pending state appropriate to the product.

How do I prove the same announcement reached both language audiences?

Compare stable identity and relationships, review language-selected content, and collect evidence from actual supported clients. A local JSON parse alone is not delivery proof.

Authoritative sources