A CASE FOR XML
When designing your XML solution, you are usually faced with the task 
of creating a set of XML specifications that define the structure of 
your data. There are many decisions to be made in regard to structuring 
data such as implementing structural relationships and naming schemes. 
In this week's tip, we'll examine some of the options for XML naming 
schemes.

OVERVIEW
There are many approaches to technical naming schemes. Some companies 
standardize on one specific scheme while others provide vague 
recommendations. The truth of the matter is that it really doesn't 
matter which standard you follow as long as you have a standard and 
you follow it.

Several schemes have been used in standardizing XML entity names. Some 
are borrowed from programming languages. There are three major 
characteristics for the naming schemes: the use of upper and lower case 
letters, the delimitation of words or abbreviations, and how (if at 
all) you implement abbreviations.

THE CASE FOR CASING
There are many options for how you use casing within your XML 
specifications. Actually, there are four main casing options:

* ProperCasing

* CamelCasing

* Lowercasing

* UPPERCASING

As you can see, proper casing uses the proper casing of the words or 
word parts to create the element names. Examples of proper casing are:

<CustomerName> 
<LineItem> 
<ShippingAddress> 
<Age>

Camel casing is called such because the "hump," or upper case letters, 
appear in the middle of the word rather than at the beginning. The Java 
programming language uses camel casing. Examples of camel casing 
include:

<firstName> 
<socialSecurityNumber> 
<birthDate> 
<weight>

Upper and lower casing are also used quite commonly. This casing 
removes any question about whether a specific word or abbreviation 
should be capitalized. Some examples of upper and lower casing are:

<ORDERNUMBER> 
<cancelorder> 
<trackingnumber> 
<SHIPMENTID>

TAKE IT TO DELIMIT
Delimiters are a frequent part of naming standards. The reason is that 
too many objects have long names that are difficult to discern between, 
particularly when these objects have names such as CustomerNumber, 
CustomerIDNumber, CustomerAccountNumber, etc. Using a delimiter to 
separate the words or abbreviations in a name helps the user to better 
understand what the value is representing.

There are various options for delimiters in XML entities. The most 
popular is the underscore character. It's used frequently to separate 
words in XML entities such as:

<Customer_Name> 
<Order_Number> 
<ship_date>

Sometimes a delimiter is used in conjunction with a casing standard to 
help clarify not only the data that the entity contains, but also what 
type of data it is. For example:

<CustomerNumber_Integer> 
<address_string> 
<STATE_STRING_2>

A BRIEF ABOUT ABBREVIATION
Many of the words used in XML entities are quite long. Often, there is 
a series of several words that make up a single XML entity. To help 
alleviate the burden of typing long entity names such as

<CustomerPrimaryBillingAddressCity>

many organizations elect to use abbreviations where necessary. You can 
choose to always use them, or only in special cases (such as when the 
length of the entity name exceeds twenty characters). Some common 
abbreviations are:

* Cust for Customer

* Addr for Address

* Num or No for Number

* Id for Identifier

SUMMARY
XML is a very robust language for expressing your organization's data. 
There are many ways to describe that data using XML. By implementing 
some standards that define the naming schemes used for XML entities, 
you can help remove ambiguities. This week's XML tip has shown you some 
ideas and options for implementing XML naming schemes.

-------------------------------------------