Chapter 01·Getting Oriented·~6 min·
Orientation: Standards and Architecture
Internationalized applications separate source code from locale rules. Unicode, CLDR, ICU runtime engines, and BCP 47 locale tags work together to format text across languages.
Overview
Internationalization separates locale-dependent logic from application source code. Four distinct technical standards handle character encoding, locale rules, runtime formatting, and locale tags. Identifying which layer owns a requirement prevents architectural defects.
Core rule
Assign every localization requirement to its governing layer: Unicode for character properties, CLDR for locale data, ICU and Intl for runtime formatting, and BCP 47 for locale identification.
Specification note: The industry numeronyms count internal letters. i18n has 18 letters between i and n, l10n has 10, g11n has 11, and t9n has 9.
Failure mode
Deferring internationalization leaves English rules embedded in application source code. Common defects include concatenated date fields, hardcoded count !== 1 plural checks, physical left-to-right CSS layouts, and prices formatted with toFixed(2). Translators cannot fix these defects in string catalogs because the defects exist in the code.
Project planning also requires precise terminology. Teams that use i18n and l10n interchangeably cannot separate one-time engineering architecture work from per-market translation work.
Internationalization (i18n) is an architectural engineering investment made once. Localization (l10n) is a recurring operational translation investment made per market.
Business stakes & user risk
Confusing architecture with translation causes project delays and wasted spend. When code contains hardcoded strings or formatting rules, sending files to translators cannot fix the bugs. Engineering must refactor the application at twice the initial cost.
Rule of thumb
Engineers internationalize the codebase so translators can localize the content without writing code.
The Novice Trap vs. Production Standard
Contrast the intuitive assumption with the architecture required for global releases.
“Localization is just translating text strings at the end of the project.”
Naive approach: English-centric code
const label = "Order #" + id + " for " + "$" + price.toFixed(2);Defect:Hardcodes the currency symbol, decimal point, and English word order. Translators cannot move the currency or adjust the label grammar.
Localization requires four coordinated layers: Unicode character storage, CLDR regional data tables, ICU runtime formatting engines, and BCP 47 locale identifiers.
Production standard: Separated concerns
const msg = intl.formatMessage({ id: "order.summary" }, { id, price: intl.formatNumber(price, { style: "currency", currency }) });Benefit:Application code supplies data while the runtime formats currency and numbers according to target market standards.
Cross-Functional Review Questions
Questions for product managers, designers, engineers, and testers to ask during sprint reviews.
“Have we separated one-time engineering costs from per-language translation budgets?”
“Are we utilizing standard runtime Intl APIs instead of building custom formatting helpers?”
“Are interface mockups tested with variable-length text before engineering handoff?”
“How do we verify that source strings are externalized before translation starts?”
Mechanism
Core terminology: i18n, l10n, g11n, and t9n
Localization engineering uses standard numeronyms formed from a word's first letter, internal letter count, and final letter. Internationalization is i18n (18 internal letters), localization is l10n (10), globalization is g11n (11), and translation is t9n (9). Each term designates a distinct engineering or operational scope.
Internationalization (i18n) is the software architecture work that decouples source code from language and cultural assumptions. Localization (l10n) adapts an internationalized product for a specific market by supplying translated catalogs, regional formats, and local compliance assets. Translation (t9n) is the linguistic conversion of text within the localization process. Globalization (g11n) encompasses the combined engineering, linguistic, and commercial lifecycle.
Separating i18n from l10n keeps project schedules accurate. Internationalization is a one-time engineering task in the repository, whereas localization repeats for each target locale.
i18n = i + 18 letters + n internationalization (architecture)
l10n = l + 10 letters + n localization (market adaptation)
g11n = g + 11 letters + n globalization (end-to-end program)
t9n = t + 9 letters + n translation (linguistic text conversion)Interactive demo
Guided exercises
- 1Select the ar-EG tab and inspect the formatted order confirmation sentence. The runtime renders Arabic-Indic digits (٣, ٢٠٢٦), the Arabic month name (أغسطس), and right-to-left base direction automatically from the locale tag.
- 2Under “Who did what”, click CLDR. The formatted count, date, and currency values highlight while the surrounding sentence template dims. Translators author the template, while CLDR and Intl generate the formatted tokens.
- 3Under Count, click 3, and then click 11. In “How the count resolved”, ar-EG shifts from the `few` category (عناصر) to the `many` category (عنصرًا). The runtime selects the grammatical noun form from CLDR plural rules.
- 4Switch to the ja-JP tab and click each Count button from 1 through 100. The resolved plural category remains `other` for every value because Japanese uses a single cardinal category.
- 5Click BCP 47 under “Who did what”. The highlight moves to the locale selector tab (`ja-JP`), showing the language subtag `ja` and region subtag `JP` that key the other three layers.
- 6Click Unicode and toggle between the en-US and ar-EG tabs. The directionality note updates between LTR and RTL because Unicode character properties define the intrinsic direction of Latin and Arabic letters.
One sentence, four locales
Same order: a count, a ship date, a price in USD.
طلبك المكوّن من ٣ عناصر يُشحن في ٥ أغسطس ٢٠٢٦ مقابل ٤٢٫٥٠ US$.
Arabic (Egypt) · dir="rtl"
Count
How the count resolved
Intl.PluralRules("ar-EG").select(3) → "few"
ar-EG has 6 cardinal categories (only 0 resolves to zero). The forms are translations; a CLDR rule, applied by the engine, picks which one renders.
Who did what
Select a layer to highlight the parts of the sentence it produced.
Inspect any BCP 47 tag
A tag is a language subtag, then optional script, region, variant, and extension subtags such as -u-. Type a tag to canonicalize it, split it, and expand it with CLDR likely subtags.
Language
zhChinese
Script
HantTraditional
Region
HKHong Kong SAR China
Maximize (add likely subtags)
zh-Hant-HK
Minimize (drop implied subtags)
zh-HK
Maximize adds the most likely script and region from CLDR (en becomes en-Latn-US); minimize removes subtags the rest of the tag implies. Locale matching compares maximized tags, which is how a zh-HK request matches a zh-Hant bundle.
Implementation rules
- Identify the four standards layers. Unicode defines characters and text properties. CLDR provides locale data tables. ICU and
Intlexecute formatting algorithms. BCP 47 tags identify the target locale. - Route defects to the responsible layer. An incorrect month name is a CLDR data issue. A missing formatter option is an
Intlengine issue. Misordered right-to-left punctuation is a Unicode bidirectional issue. Serving the wrong language is a BCP 47 negotiation issue. - Budget i18n and l10n separately. Internationalization is a one-time engineering investment in the codebase. Localization is a recurring cost for each target market.
- Use built-in runtime APIs. Modern browsers and server runtimes include all four layers. Custom date, number, or plural formatters introduce defects that standard APIs already prevent.
Operational context
Roles
Workflow stages
- ·Architecture review for international readiness
- ·Separating engineering and translation budgets
- ·Triaging localization defects by stack layer
Production incident
The W3C Internationalization specification notes that retrofitting a hardcoded single-locale codebase for global markets requires far more engineering effort than designing locale-independent data paths from the start.