Introduction,
Converting,
Limitations,
Future,
Closing
The emergence of the Internet and other distributed networks
puts increasing importance on the ability to create global
software--that is, software that can be developed independently
of the countries or languages of intended users--and then
translated for multiple countries or regions. Java 1.1 takes a
major step forward in creating global applications and applets.
It provides frameworks based on the UnicodeTM 2.0 character
set--the standard for international text--and it provides an architecture for
developing global applications, which can present messages,
numbers, dates, and currency in any country's conventional
formats.
However, when all is said and done, it may not be clear just
how to go about making your program ready for localization with
Java 1.1. This article outlines how to do that, what the
strengths and limitations are of the current 1.1 support, and
what to expect in the future. The discussion also applies to new
programs; it is generally much easier to build a global program
from the ground, than to go back later and retrofit it!
In the first section, we discuss how to convert your
application into a global application. We then move on to look at
what the current limitations in the JDK 1.1 are, and what the
future may hold in store for us.
Background
The bulk of the international support in Java 1.1 was licensed
from Taligent, with data supplied by IBM's Native Language
Technical Center (NLTC) in Toronto. Taligent had developed an
integrated set of object-oriented frameworks to support the
creation of international software, providing a standard API to
make handling the requirements of different countries and
languages transparent to developers. Using experience gained in
building C++ frameworks, Taligent redesigned its frameworks in
Java, which allows for a much simpler API and implementation.
This was a cooperative effort with JavaSoft, which participated
in reviewing and adapting the APIs we supplied.
Before diving into the text, we will clarify some notation
that we will be using. In the examples, changed text will be
in italic, and comments will be in blue. We will also use
the following terms:
- display string
- A string that may be shown to the user. These strings
will need to be translated for different countries.
Non-display strings, such as URLs, are used
programmatically, and are not translated.
- locale
- A name for conventions shared among a large set of users
for language, dates, times, numbers, etc. Typically, a
single country is represented by a single locale (and
loosely speaking, you may use "country" and
"locale" interchangeably). However, some
countries, such as Switzerland, have more than one
official language and therefore multiple locales.
- global application
- An application that can be completely translated for use
in different locales. All text shown to the user is in
the native language, and user expectations are met for
dates, times, and other locale conventions. Also known as localizable
application. To globalize is to convert your
program into a localizable one. (Of course, with Java, you
can also have global applets.
The JDK 1.1 implements the Unicode 2.0 character set with the
Unicode character database version 2.0.14; for brevity, we will
refer to this as Unicode 2.0.14. (Also, our use of the term application
should be understood to include applets, unless otherwise noted.)
Note: On some browsers, the default font sizes are a bit
small for the examples. You can reset the size to make
them more readable. For example, in Netscape, use
Options:General Preferences:Fonts.
Introduction,
Converting,
Limitations,
Future,
Closing