Translate Like a Pro | 9990 — NATS CLI Localization: nats pub, sub, Request-Reply, JetStream Consumers and Unicode QA

NATS CLI localization is the discipline of translating nats pub, nats sub, request-reply and JetStream consumer instructions without changing subjects, server contexts, shell quoting, delivery semantics or machine-readable payloads. Readers searching for NATS command-line translation, multilingual pub-sub examples, JetStream CLI QA and Unicode troubleshooting need a guide that protects exact message behavior as carefully as natural language.

This world-facing tutorial helps developers, technical translators, educators and documentation teams make reliable NATS terminal lessons. It starts with two terminals and a Core NATS publish-subscribe demonstration, then moves through wildcards, queue groups, request and reply, streams, consumer pulls, acknowledgement, credentials, display encoding and multilingual release tests. All hands-on examples belong in a disposable local environment with fictional subjects.

The most important starting distinction is simple: Core NATS publishes to active interest and does not automatically retain missed events for a later subscriber, while JetStream provides configurable storage and consumer state. A translation that calls nats sub a command for replaying all historical messages changes the promise of the lesson. Keep program tokens and subject names literal, and explain the chosen delivery mode before asking someone to copy a command.

Quick answer: how to translate NATS CLI instructions safely

• Preserve nats subcommands, subject names, wildcards, stream names, consumer names and connection context.
• Distinguish live Core NATS interest from retained JetStream data.
• Describe request timeouts as missing timely responses, not proof of no side effect.
• Translate selected sample text while preserving JSON keys, shell syntax and byte semantics.
• Verify Unicode output, credentials redaction and the exact CLI result in a safe sandbox.

From a first message to a reliable localized terminal guide

1. Learn what the nats executable does

The NATS command-line interface is a client that can publish, subscribe, inspect streams and perform other operations against a running NATS deployment. It is not the same process as nats-server.

A translated page that tells readers to “start the NATS server” when it really invokes nats sub changes the intended action and the troubleshooting path.

Separate the local terminal, remote server and named subject before presenting any copyable command. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

2. Preserve the actual command tokens

Commands such as nats pub, nats sub, nats request and nats reply are interpreted literally. Their human explanations can be localized without altering the tokens.

Changing pub to a target-language verb makes a command invalid even if the sentence around it is elegant and grammatically correct.

Print protected code in its own block, and put a natural-language description in an adjacent paragraph. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

3. Explain the subject as an address

In NATS, a subject is the string to which messages are published and on which subscribers register interest. The value orders.created is an identifier, not a translated title.

Changing the subject to a different phrase in just one of two terminal examples prevents the subscriber from receiving what the publisher sends.

Use a synthetic subject name and ask learners to trace it unchanged through both terminal windows. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

4. Distinguish Core NATS from JetStream

Core NATS routes messages to interested subscribers without the persistence guarantees of JetStream. JetStream adds streams and consumer state under explicit configuration.

Calling every nats pub message “saved for later replay” is incorrect for the basic core publish-subscribe demonstration.

Label each exercise as Core NATS or JetStream before describing whether messages are retained. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

5. What publish actually confirms

A simple nats pub command hands a message to the server under the core publish-subscribe model. It does not wait for proof that a downstream application completed its work.

A translated success caption that says “order shipped successfully” could imply a business effect not established by the command.

State which side produced a message and make the absence of application-level confirmation explicit. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

6. Why an active subscriber matters

In Core NATS, a subscriber must have an active interest at the time of publishing to receive a message. A publication with no matching listeners is not stored for future core subscribers.

A tutorial that tells learners to publish first and start the subscriber later will yield confusing empty output if it promises replay.

Teach the correct temporal order: start the subscriber, then publish a disposable message, then inspect what appeared. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

7. One subject can reach multiple listeners

Ordinary core subscribers with matching interests each receive a copy of a publication, subject to actual connectivity and delivery conditions.

A translator who describes subscription as removing a message from a single shared queue invents a model unlike normal fan-out.

Open two authorized local subscribers and compare their displays after one synthetic publication. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

8. A queue group changes distribution

Queue subscribers sharing a group name on the same subject distribute matching deliveries among group members rather than giving every member every message.

A screenshot showing three workers may mislead readers into expecting each worker to see each message despite queue-group load balancing.

Distinguish independent subscribers from grouped subscribers in both diagram and translated wording. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

9. Keep –queue and group names exact

The documented nats sub command supports a queue-group choice. The chosen group identifier is a literal configuration value, not prose to translate casually.

Translating packers on one machine but not the other accidentally splits what was meant to be one work-sharing group.

Draw the subscriber membership, then confirm all intended members use the same exact group value. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

10. Explain at-most-once narrowly

Core NATS offers at-most-once delivery, which means missed core messages are not replayed automatically from storage. It is not a statement that an external business action happens at most once.

A translated brochure that promises complete recovery from a disconnected receiver obscures this limitation.

Describe a subscriber that goes offline before one publish; ask what evidence the later reconnection could provide. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

11. Teach a two-terminal quickstart

The official getting-started material uses one terminal running nats sub and another running nats pub. That separation demonstrates interest and delivery without needing production services.

A single screenshot combining command and result may hide which process was listening first and which produced data.

Label Terminal A and Terminal B, and annotate the exact sequence in prose rather than relying on screenshot order. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

12. Do not translate wildcard syntax

NATS subjects use dot-delimited tokens and matching patterns such as * and > for subscribers. These are parser syntax, not decorative punctuation.

Removing a period or changing a wildcard while making a translated heading more readable changes the matched set of subjects.

Write sample subject patterns alongside literal examples of names they match, and test the intended range. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

13. Know what * matches

The single-token wildcard matches one token of a subject hierarchy in an appropriate subscription pattern. It does not simply stand for an arbitrary number of dot-delimited levels.

A translation that calls it “all following subjects” creates an inaccurate routing model.

Compare orders.*.created with hypothetical orders.us.created and orders.us.west.created; ask which example fits. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

14. Know what > matches

The terminal wildcard can match multiple trailing subject tokens within the documented subject grammar. In many shells, > also has meaning as output redirection.

Pasting an unquoted wildcard example can therefore change the shell’s treatment before NATS even receives the pattern.

Preserve the precise matching pattern and quote it where the tested shell requires. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

15. Subject hierarchy is not geography by default

A name such as orders.eu.created may encode a chosen geographic segment, but NATS itself treats the subject as a string according to routing semantics.

A translator may change eu to the reader’s country because the surrounding article is localized, unintentionally selecting a different event stream.

Keep operational prefixes stable and explain any regional naming convention as a project decision. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

16. Understand message bodies

The string passed to nats pub is a payload, not a command option. It can be a human-readable greeting or structured JSON, and not every payload is intended for natural-language translation.

A simple greeting can be localized in a controlled lab, whereas an application-specific JSON contract may require strict preservation of keys and types.

Mark source payload fields as localizable text, machine keys or opaque bytes before any editing. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

17. Preserve JSON structure

When publishing a sample JSON value, braces, quotes, property names and value types may be required by receivers. Changing a numeric field into a localized formatted number can alter the schema.

A translator may insert thousands separators or translate order_id, making the sample invalid or incompatible with application parsing.

Use a validator on synthetic JSON and compare the exact property names before and after localization. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

18. Demonstrate Unicode payloads

The NATS CLI examples can carry UTF-8 human-facing sample strings through a correctly configured environment. Unicode text is not equivalent to all possible binary payloads.

A correctly translated greeting may render as replacement characters because a terminal or copied source file uses a different encoding.

Run multilingual test strings containing accents, CJK, Arabic and emoji, then compare source bytes with received display. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

19. Use shell quoting deliberately

Quoted payloads pass through the user’s shell before reaching the CLI. Bash, PowerShell and CMD can differ in escaping and variable expansion.

A translated screenshot with curly quote marks may look typographically refined but fail when copied to a terminal.

State the shell and verify a copy-paste test with the actual command block used for publication. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

20. Differentiate terminal output from a record

NATS CLI output may add sequence information, subject names or formatting around received content. Not every printed character belongs to the underlying message body.

Translating terminal decoration as though it were the transmitted payload makes it harder to verify message identity.

Place command, output and explanatory annotation in separate blocks and label each one. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

21. Understand nats request

The request command uses the NATS request-reply pattern, where a client publishes with a reply mechanism and waits for a response under a timeout.

A fluent rendering of request as “publish” drops the expectation of a reply and can make an empty reply look like a lost broadcast.

Draw requester, responder and reply path using fictional messages, and explain the difference from one-way publishing. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

22. Understand nats reply

The reply utility can act as a respondent in a demonstration. It is a client process waiting to handle requests, not a permanent guarantee that an application is available.

A tutorial should not imply that opening one demo replier makes a production service reliable across outages.

Start and stop a disposable responder and explain the observed behavior at each stage. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

23. Explain timeouts correctly

A request timeout bounds how long a caller waits for a reply; it does not by itself prove that the server never received the request or that no side effect happened.

A translation saying “no work was performed” after a timeout is an unjustified and potentially dangerous promise.

Use a hypothetical slow responder and distinguish no timely reply from proof of no processing. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

24. No responders is a distinct condition

Some NATS request paths can report that no responder is available, depending on protocol support and client behavior. That differs from a reply that arrived too late.

A troubleshooting page that treats every request failure as an authentication error sends readers down the wrong path.

Separate missing interest, network failure, timeout and authorization into different branches of a fictional diagnostic table. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

25. What a subject subscription is not

A Core NATS subscription is not automatically a persistent archive, database query or queued historical reader. A new terminal cannot simply retrieve yesterday’s missed core messages.

Calling nats sub “open history” is a common overstatement when readers are familiar with database commands.

Explain current interest first, then introduce JetStream as a separate retention mechanism where appropriate. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

26. Know the role of JetStream streams

A JetStream stream stores messages matching configured subjects under retention and resource policies. A stream name and its subject filters are separate concepts.

Translating a stream name as if it were the payload’s language may reference a different stream or cause a mismatch.

Illustrate a fictional stream named TRAINING capturing a subject such as lessons.>, then keep both identifiers stable. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

27. Explain stream creation prerequisites

A CLI stream-management command may change persistent server configuration. Unlike a read-only nats sub example, it is not safe to run indiscriminately against an organization account.

A localized quickstart that says “create any stream to test” may incur cost or affect production resource limits.

Require a disposable lab and administrator approval for stream lifecycle operations; use help and inspection otherwise. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

28. Preserve retention vocabulary

Stream retention policies determine which stored messages remain under conditions chosen by administrators. “Saved” does not mean permanent, complete or immune to quotas.

A translation promising infinite historical recovery can mislead an incident investigation.

Describe the configured retention scope, and state what the example does not establish about older records. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

29. Know a durable consumer’s job

A JetStream consumer tracks how messages are delivered and acknowledged within configured rules. It is not identical to a transient Core NATS subject listener.

A training page that calls both simply “the same subscriber” hides why replay and acknowledgement differ.

Draw the stream plus consumer as separate objects and identify which state persists beyond one CLI session. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

30. Explain pull consumers concretely

A pull consumer supplies work when a client requests messages, in contrast with continuous delivery patterns. NATS documents CLI operations to request next messages from a consumer.

If pull is translated as “download the entire stream”, readers may assume all records arrive in one operation.

Show a fictional worker requesting one or several messages and explain why this is bounded, repeatable work. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

31. Respect nats consumer next semantics

NATS documentation notes that nats consumer next with a count issues successive single-message pulls rather than one atomic batch fetch. This distinction matters in tutorials about timeouts.

A translator may rewrite the example as “request one batch atomically” simply because a count parameter is visible.

Describe the series of pulls and test whether fewer available messages and a timeout are explained accurately. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

32. A count is not proof of completion

A count option can bound the number of CLI displays or pulls. It does not prove the business system has finished handling that number of records.

A caption announcing “five orders completed” after seeing five messages is unsupported.

Ask learners to separate delivery count from application acknowledgements and external side effects. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

33. Acknowledgements need a separate explanation

In JetStream, acknowledgement behavior affects consumer progress and possible redelivery. Acknowledging a message is not the same as a payment, email or warehouse task completing.

A translator who merges acknowledgement with business success can create dangerous exactly-once claims.

Use a fictional failure between receiving a message and writing a database row, then identify what each observable step proves. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

34. Explain redelivery without duplicate events

A logical stored message can be delivered again when acknowledgement conditions are not met. Repeated display is not necessarily a new publication by the sender.

A mistranslated label “new message” on redelivery can inflate incident counts or confuse trainees.

Track a synthetic message identity across attempts and distinguish publication from delivery attempt. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

35. Avoid exactly-once marketing shorthand

JetStream has explicit delivery and deduplication mechanisms, but broad exactly-once guarantees require understanding client behavior and side effects. The CLI alone cannot certify a business transaction.

A translated overview may remove important conditions from “at least once” or “deduplicated publication”, turning useful technical guidance into a false promise.

State the guarantee’s scope and link to official stream/consumer documentation for detailed constraints. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

36. Do not confuse queue groups and consumers

A Core NATS queue group distributes live messages among interested members. A JetStream consumer has server-managed state and delivery rules.

Using the same generic translation for both mechanisms can cause readers to expect replay in a plain queue-group demo.

Compare a live queue subscriber with a durable stream consumer in two columns and identify persistence differences. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

37. Treat stream names as exact identifiers

Names such as ORDERS or TRAINING identify configured JetStream resources. They often resemble English nouns but are not open invitations to rename live objects.

A translation that changes the stream name in only one terminal command will make a later lookup fail.

Keep the identifier unchanged, while translating its purpose in explanatory sentences. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

38. Treat consumer names as exact identifiers

A durable consumer name or configuration identifier participates in client and server state lookup. A translated copy may inadvertently refer to a new consumer.

An instructor may see a seemingly fresh cursor because the learner addressed a new consumer, not because translation corrected the system.

Record intended stream and consumer names together and test both through read-only inspection. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

39. Understand the CLI context

NATS CLI supports named connection contexts in documented workflows. The selected context can determine server targets, authentication and security configuration.

A translated handout that omits the active context may send an otherwise correct command to a completely different environment.

Ask learners to identify the chosen context before running an operation, without exposing credentials. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

40. Do not put secrets in public commands

Authentication may use credentials, tokens or TLS materials. Public tutorials should contain fictitious placeholders, not actual context files or embedded passwords.

A screenshot copied into a translation system can leak access long after the original onboarding exercise has finished.

Redact secrets and private endpoints and prohibit real credentials in samples, logs or comments. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

41. Distinguish server URL from subject name

A NATS server URL identifies the connection endpoint, while a subject identifies the message route inside that connected system.

A reader may change the subject while believing it selects the destination server, or change the server while thinking it translates a subject.

Draw two separate fields in every exercise: where the CLI connects and which subject it addresses. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

42. Explain TLS without workarounds

Production TLS settings and authentication requirements protect the connection. A successful local unencrypted demonstration should not be generalized into advice to disable security.

A translated troubleshooting paragraph that tells everyone to turn off certificate checks is an unsafe change to the tutorial.

Keep sandbox assumptions obvious and direct production readers to approved configuration. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

43. Know Core NATS delivery limitations

Core publish-subscribe uses ephemeral interest routing. A slow or disconnected subscriber can miss messages, and the CLI cannot resurrect them merely by reopening a subscription.

A translated phrase such as “subscribe to all previous events” violates the model even if it reads naturally.

Use a timeline where one publish occurs before the receiver connects and ask what the reader should expect. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

44. Explain slow-consumer behavior

If a subscriber cannot keep up, server and client flow-control behavior matters; documented NATS learning material describes slow-consumer disconnection conditions.

A large displayed backlog should not automatically be described as a permanent durable queue in a Core NATS example.

Teach the difference between transient client buffering and configured stream persistence. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

45. Watch default payload limits

NATS server configurations impose a maximum payload size. A novice may paste a large translated document into a command intended for short test messages.

A message-size error is not evidence that Unicode translation is forbidden or that all non-English text is unsupported.

Use a short synthetic payload and identify the limit as a byte-size constraint, not a word-count or language rule. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

46. Decode binary data with care

NATS messages may carry arbitrary data, and printing them as text can mislead or garble content. A translation guide must not assume every subscriber output is plain prose.

Changing opaque bytes to a target-language sentence changes the actual transmitted content rather than localizing a label.

Separate examples of human text, structured JSON and uninterpreted binary payloads. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

47. Handle locale-sensitive number formatting

A JSON number or timestamp is not automatically localizable merely because the target language uses different separators or date formats in prose.

A localized decimal comma inside a machine JSON numeric field makes a previously valid record invalid.

Keep wire-format numbers and dates machine-safe; put culturally formatted explanations beside the sample. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

48. Handle right-to-left terminal displays

Arabic and Hebrew can change the visual placement of punctuation around subject names, JSON braces and server URLs. The apparent display order may not match copied bytes.

An attractive localized paragraph can cause readers to omit part of a dot-delimited subject when selecting text.

Isolate commands, test copy-paste and compare actual bytes from source to rendered page. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

49. Use stable synthetic identifiers

Examples should not contain real customer IDs, personal names, production account names or live subject paths. Invented values improve privacy and repeatability.

A local-language replacement of a real identifier can still reveal the underlying system’s naming scheme.

Use a deliberately fictional training namespace and keep it the same across all language editions. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

50. Build a language-aware troubleshooting tree

Missing messages may reflect no active subscriber, wrong subject, another server, permissions or a stream/consumer position. They are not always “translation failures”.

A single canned advice line to reinstall the CLI is a poor response to these distinct causes.

Ask learners to inspect target, subject, connectivity and delivery mode before changing any configuration. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

51. Read output evidence narrowly

A nats sub window displaying a message proves one client saw that payload at that moment. It does not prove other applications, warehouses or dashboards completed their work.

A translated example can quietly change “message received” into “user notified” and become materially misleading.

Specify which process produced the observed line and what further evidence a broader claim would require. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

52. Make errors searchable

Exact command errors, flags and program identifiers are useful for finding official troubleshooting information. A translator may add an explanation, but should not overwrite the original diagnostic.

A support search fails if the only printed error string was freely translated and no original can be recovered.

Retain quoted diagnostics with secrets redacted and add a nearby interpretation in the target language. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

53. Prevent copy-paste typography changes

Smart quotes, nonbreaking spaces and localized punctuation can break CLI syntax. This is especially important where wildcards and JSON quoting mix.

A publisher command that looks identical in a styled article can pass different characters to the shell.

Validate literal code blocks independently of prose proofreading in each target language. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

54. Teach a safe two-terminal experiment

A disposable NATS server, one subscriber and one synthetic publisher are sufficient to demonstrate Core NATS interest routing without touching production systems.

A learner running an example against a shared corporate context may publish to real operational subjects without intending to.

Require explicit lab confirmation and have students predict the output before submitting the sample. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

55. Use a deliberately negative test

After a successful synthetic publication, stop the subscriber, publish once more and reconnect. In a Core NATS lab, the missed message should not suddenly appear as retained history.

This simple contrast explains the persistence boundary better than vague marketing language.

Test in a sandbox and state that JetStream, if configured, follows a different storage model. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

56. Separate training from operational authority

Stream creation, consumer management and credential changes are configuration tasks. Readers should not infer they have permission just because a tutorial contains a command.

A localization that softens “administrator only” to “optional” removes an essential safety boundary.

Show read-only inspection and fictional output for unprivileged learners and require operator approval for mutations. Treat the command as an executable contract. A second reviewer should be able to point to the protected token, explain the expected effect and identify at least one assumption.

57. Plan a bilingual review

A native speaker can confirm that “request”, “reply”, “subscription”, “queue group” and “stream consumer” remain distinct concepts. An engineer verifies syntax and actual delivery behavior.

A sentence can be fluent but erase the difference between ephemeral and durable messaging.

Require independent language and technical signoff, with a written note for each important delivery claim. An example becomes trustworthy when its wording survives a controlled counterexample. Compare a working route to a deliberately different subject or client state in the sandbox.

58. Make accessible terminal lessons

Readers using screen readers should understand which terminal runs first, which subject carries the message and where the output appears without relying on colored arrows.

Alt text such as “blue box sends to green box” is insufficient for a messaging lesson.

Describe publisher, subject and subscriber by role, and label code versus output with words. Good localization avoids promising outcomes beyond what the terminal can prove. Give the reader a short sentence explaining the observation’s boundary, not just a success label.

59. Use official references to maintain accuracy

The NATS documentation covers Core pub-sub, request-reply, queue groups and JetStream consumers separately. These are authoritative scope boundaries for a maintained tutorial.

An older example may still execute while its surrounding guarantee has been updated or clarified in new documentation.

Review the exact official section for each capability and avoid using one page to prove unrelated delivery semantics. Make the explanation usable without insider knowledge: name the exact delivery mode, the process that acts and the state that may persist or disappear.

60. Keep the established conceptual owner

The broader NATS JetStream article already owns general stream, retention, acknowledgement and redelivery concepts. This page should instead teach how readers translate CLI instructions and output.

Duplicating the entire conceptual guide risks competing for generic search queries and leaving CLI learners without precise command guidance.

Link the broader article for architecture and keep the primary promise of this page about copyable terminal workflows. Review the target-language sentence independently, then compare the copied command character by character. Fluent prose cannot compensate for a changed subject or shell symbol.

61. End with a prediction exercise

A reader should be able to identify server context, subject, Core versus JetStream mode, active subscriber conditions and what a displayed response actually establishes.

A student who can recite flags but cannot explain why a late subscriber saw nothing has not mastered the tutorial.

Give a fictional sequence of commands and ask students to predict which message appears, where and why. Localizers can verify the meaning by asking a learner to predict the next observable step before running the example. The prediction should mention the relevant client, subject and message state.

Worked case: a bilingual NATS event-notification workshop

An international software program offers a short NATS lab in Singapore, France, Mexico and Japan. The instructor chooses fictional subject training.arrived and a disposable local NATS service. Terminal A starts nats sub training.arrived; Terminal B then runs nats pub training.arrived "Learner arrived". Students first translate the human-facing message and explanation, leaving the program and subject untouched. The transcript is annotated to show that the subscriber must already be listening for the simple Core NATS example.

In the first translated handout, the French editor calls the subscriber a historical message archive. The Japanese edition translates the subject on the publishing side but not the receiving side, making the terminals silently disagree. The Spanish version contains typographic quotation marks inside a copyable code block. The class repairs all three by explaining the expected client behavior and testing the actual command, rather than merely proofreading the surrounding sentences.

The instructor next asks what changes when another terminal also subscribes. Students see ordinary fan-out, then compare it with a queue-group example using --queue. They distinguish giving every independent listener a copy from sharing work among members of a named group. The goal is not to teach all internals of messaging architecture but to show why translating “queue”, “subscriber” and “consumer” as interchangeable words makes a terminal tutorial inaccurate.

Finally the group visits JetStream concepts as a separate workflow. They read about streams, durable consumer state and the official note that the CLI’s repeated nats consumer next --count requests are not one atomic batch fetch. A review table records connection context, subject, delivery mode, payload, observed output, possible retry or timeout and limits of the claim. The finished editions include Unicode text samples, readable diagrams, safe credential placeholders, source links and instructions to test everything in an approved sandbox. Learners leave knowing what NATS actually did, not simply how to say it in another language.

Release review checklist

1. Verify the CLI version, target server and selected named context.
2. Protect exact subject spelling, tokens, wildcards and shell quotes.
3. Specify Core NATS or JetStream for each example.
4. Describe subscriber timing, queue groups, request timeouts and persistence accurately.
5. Use only fictional subject names and synthetic payloads.
6. Validate structured JSON without changing machine keys or data types.
7. Check bidirectional text, UTF-8, copy-paste and terminal output formatting.
8. Do not expose tokens, certificates or real credentials.
9. Require bilingual, technical and accessibility reviews before publication.

Frequently asked questions

Can I translate the subject name?

Not in a runnable command unless the subject was deliberately changed in all relevant systems. Explain the subject in the target language while preserving the literal route.

Will nats sub show messages published before it started?

Not in a basic Core NATS demonstration. Core pub-sub relies on active interest. JetStream is a different, configurable storage and consumption workflow.

Does nats pub prove a service acted on the message?

No. Publication and application processing are separate observations. Use an explicit request-reply or application-level test when that extra claim matters.

Does a request timeout prove the operation never happened?

No. A timeout means a timely reply was not obtained under the chosen conditions; it does not establish that nothing was processed.

Does a queue group make messages persistent?

No. Queue groups share live work among members. Do not confuse that with JetStream retention and durable consumer state.

Why is my non-English message garbled?

Encoding or rendering may disagree across the editor, shell, client and terminal. Inspect the bytes and the environment rather than rewriting a correct translation blindly.

What does nats consumer next with –count do?

According to NATS’s pull consumer guidance, the CLI uses successive single-message pulls for the count; it is not one atomic fetch operation.

Where should I read the deeper delivery model?

Consult the existing NATS JetStream guide and official NATS documentation. This page deliberately concentrates on how to translate executable CLI learning materials.

Official documentation and next reading

• NATS getting started, including the CLI
• NATS Core publish-subscribe step by step
• NATS queue groups
• NATS JetStream pull consumers and CLI count behavior
• Related conceptual guide: NATS JetStream streams and consumers
• Related CLI guide: RabbitMQ administration

Precise CLI translation preserves the event path, the user’s choice of subject and the real limits of message delivery. It lets readers in different languages run the same safe experiment and reach the same defensible conclusions.