From the Publisher

Extensible Markup Language (XML) is a rapidly maturing technology with powerful real-world applications, particularly for the management, display, and transport of data. Together with its many related technologies, it has become the standard for data and document on the web.

This book teaches you all you need to know about XML - what it is, how it works, what technologies surround it, and how it can best be used in a variety of situations, from simple data transfer to using XML in your web pages. It builds on the strengths of the first edition, and provides new material to reflect the changes in the XML landscape - notably SOAP and Web Services, and the publication of the XML Schemas Recommendation by the W3C.

Who is this book for?

Beginning XML 2^nd Edition is for any developer who is interested in learning to use XML in web, e-commerce or data storage applications. Some knowledge of mark up, scripting, and/or object oriented programming languages is advantageous, but not essential, as the basis of these techniques is explained as required.

What does this book cover?

• XML syntax and writing well-formed XML
• Using XML Namespaces
• Transforming XML into other formats with XSLT
• Xpath and Xpointer for locating specific XML data
• XML validation using DTDs and XML Schemas
• Manipulating XML documents with the DOM and SAX 2.0
• SOAP and Web Services
• Displaying XML using CSS and XSL
• Incorporating XML into traditional databases and n-tier architectures

Product Details

• Table of Contents
• Read a Sample Chapter

Table of Contents

Read a Sample Chapter

Beginning XML

John Wiley & Sons

Chapter One

Extensible Markup Language (XML) is a buzzword you will see everywhere on the Internet, but it's also a rapidly maturing technology with powerful real-world applications, particularly for the management, display and organization of data. Together with its many related technologies, which will be covered in later chapters, it is an essential technology for anyone using markup languages on the Web or internally. This chapter will introduce you to some of the basics of XML, and begin to show you why it is so important to learn about it.

We will cover:

The two major categories of computer file types - binary files and text files - and the advantages and disadvantages of each

The history behind XML, including other markup languages - SGML and HTML

How XML documents are structured as hierarchies of information

A brief introduction to some of the other technologies surrounding XML, which you will be working with throughout the book

A quick look at some areas where XML is proving to be useful

While there are some short examples of XML in this chapter, you aren't expected to understand what's going on just yet. The idea is simply to introduce the important concepts behind the language, so that throughout the book you can see not only how to use XML, but also why it works the way that it does.

Of Data, Files, and Text

XML is a technology concerned with the description and structuring of data, so before we can really delve into the concepts behind XML, we need to understand how data is stored and accessed by computers. For our purposes, there are two kinds of data files that are understood by computers: text files and binary files.

Binary Files

A binary file, at its simplest, is just a stream of bits (1's and 0's). It's up to the application that created a binary file to understand what all of the bits mean. That's why binary files can only be read and produced by certain computer programs, which have been specifically written to understand them.

For example, when a document is created with a word processor, the program creates a binary file in its own proprietary format. The programmers who wrote the word processor decided to insert certain binary codes into the document to denote bold text, other codes to denote page breaks, and many other codes for all of the information that needs to go into these documents. When you open a document in the word processor it interprets those codes, and displays the properly formatted text on the screen, or prints it to the printer.

The codes inserted into the document are meta data, or information about information. Examples could be "this word should be in bold", "that sentence should be centered", etc. This meta data is really what differentiates one file type from another; the different types of files use different kinds of meta data.

For example, a word processing document will have different meta data from a spreadsheet document, since they are describing different things. Not so obviously, word processing documents from different word processing applications will also have different metadata because the applications were written differently:

As the above diagram shows, a document created with one word processor cannot be assumed to be readable in or used by another, because the companies who write word processors all have their own proprietary formats for their data files. So Word documents open in Microsoft Word, and WordPerfect documents open in WordPerfect.

Luckily for us most word processors come with translators, which can translate documents from other word processors into formats that can be understood natively. Of course, many of us have seen the garbage that sometimes occurs as a result of this translation; sometimes applications are not as good as we'd like them to be at converting the information.

The advantage of binary file formats is that it is easy for computers to understand these binary codes, meaning that they can be processed much faster, and they are very efficient for storing this meta data. There is also a disadvantage, as we've seen, in that binary files are "proprietary". You might not be able to open binary files created by one application in another application, or even in the same application running on another platform.

Text Files

Like binary files, text files are also streams of bits. However, in a text file these bits are grouped together in standardized ways, so that they always form numbers. These numbers are then further mapped to characters. For example, a text file might contain the bits:

1100001

This group of bits could be translated as the number "97", which would then be further translated into the letter "a".

This example makes a number of assumptions. A better description of how numbers are represented in text files is given in the section on "Encoding" in Chapter 2.

Because of these standards, text files can be read by many applications, and can even be read by humans, using a simple text editor. If I create a text document, anyone in the world can read it (as long as they understand English, of course), in any text editor they wish. There are still some issues, like the fact that different operating systems treat line ending characters differently, but it is much easier to share information with others than with binary formats.

The following diagram shows just some of the applications on my machine that are capable of opening text files. Some of these programs will just allow me to view the text, while others will let me edit it as well.

In its beginning, the Internet was almost completely text-based, which allowed people to communicate with relative ease. This contributed to the explosive rate at which the Internet was adopted, and to the ubiquity of applications like e-mail, the World Wide Web, newsgroups, etc.

The disadvantage of text files is that it's more difficult and bulky to add other information - our meta data in other words. For example, most word processors allow you to save documents in text form, but if you do then you can't mark a section of text as bold, or insert a binary picture file. You will simply get the words, with none of the formatting.

A Brief History of Markup

We can see that there are advantages to binary file formats (easy to understand by a computer, compact), as well as advantages to text files (universally interchangeable). Wouldn't it be ideal if there were a format that combined the universality of text files with the efficiency and rich information storage capabilities of binary files?

This idea of a universal data format is not new. In fact, for as long as computers have been around, programmers have been trying to find ways to exchange information between different computer programs. An early attempt to combine a universally interchangeable data format with rich information storage capabilities was SGML (Standard Generalized Markup Language). This is a text-based language that can be used to mark up data - that is, add meta data - in a way which is self-describing. We'll see in a moment what self-describing means.

SGML was designed to be a standard way of marking up data for any purpose, and took off mostly in large document management systems. It turns out that when it comes to huge amounts of complex data there are a lot of considerations to take into account and, as a result, SGML is a very complicated language. With that complexity comes power though.

A very well-known language, based on the SGML work, is the HyperText Markup Language, or HTML. HTML uses many of SGML's concepts to provide a universal markup language for the display of information, and the linking of different pieces of information. The idea was that any HTML document (or web page) would be presentable in any application that was capable of understanding HTML (termed a web browser).

Not only would that browser be able to display the document, but also if the page contained links (termed hyperlinks) to other documents, the browser would be able to seamlessly retrieve them as well.

Furthermore, because HTML is text-based, anyone can create an HTML page using a simple text editor, or any number of web page editors, some of which are shown below:

Even many word processors, such as WordPerfect and Word, allow you to save documents as HTML. Think about the ramifications of these two diagrams: any HTML editor, including a simple text editor, can create an HTML file, and that HTML file can then be viewed in any web browser on the Internet!

So What is XML?

Unfortunately, SGML is such a complicated language that it's not well suited for data interchange over the web. And, although HTML has been incredibly successful, it's also limited in its scope: it is only intended for displaying documents in a browser. The tags it makes available do not provide any information about the content they encompass, only instructions on how to display that content. This means that I could create an HTML document which displays information about a person, but that's about all I could do with the document. I couldn't write a program to figure out from that document which piece of information relates to the person's first name, for example, because HTML doesn't have any facilities to describe this kind of specialized information. In fact, that program wouldn't even know that the document was about a person at all.

Extensible Markup Language (XML) was created to address these issues.

Note that it's spelled "Extensible", not "eXtensible". Mixing these up is a common mistake.

XML is a subset of SGML, with the same goals (mark up of any type of data), but with as much of the complexity eliminated as possible. XML was designed to be fully compatible with SGML, which means that any document which follows XML's syntax rules is by definition also following SGML's syntax rules, and can therefore be read by existing SGML tools. It doesn't go both ways though, so an SGML document is not necessarily an XML document.

It is important to realize, however, that XML is not really a "language" at all, but a standard for creating languages that meet the XML criteria (we'll go into these rules for creating XML documents in Chapter 2). In other words, XML describes a syntax that you use to create your own languages. For example, suppose I have data about a name, and I want to be able to share that information with others and I also want to be able to use that information in a computer program. Instead of just creating a text file like this:

John Doe

or an HTML file like this:

John Doe

I might create an XML file like this:

John Doe

Even from this simple example you can see why markup languages like SGML and XML are called "self-describing". Looking at the data, you can easily tell that this is information about a , and you can see that there is data called and more data called . I could have given the tags any names I liked, however, if you're going to use XML, you might as well use it right, and give things meaningful names.

You can also see that the XML version of this information is much larger than the plain-text version. Using XML to mark up data will add to its size, sometimes enormously, but achieving small file sizes isn't one of the goals of XML; it's only about making it easier to write software that accesses the information, by giving structure to data. However, this larger file size should not deter you from using XML. The advantages of easier-to-write code far outweigh the disadvantages of larger bandwidth issues. Also, if bandwidth is a critical issue for your applications, you can always compress your XML documents before sending them across the network - compressing text files yields very good results.

Try It Out - Opening an XML File in Internet Explorer

If you're running IE 5 or later, our XML from above can be viewed in your browser.

1. Open up Notepad and type in the following XML:

John Doe

2. Save the document to your hard drive as name.xml.

3. You can then open it up in IE 5 (for example by double-clicking on the file in Windows Explorer), where it will look something like this:

How It Works

Although our XML file has no information concerning display, IE 5 formats it nicely for us, with our information in bold, and our markup displayed in different colors. Also, is collapsible, like your file folders in Windows Explorer; try clicking on the - sign next to in the browser window. For large XML documents, where you only need to concentrate on a smaller subset of the data, this can be quite handy.

This is one reason why IE 5 can be so helpful when authoring XML: it has a default stylesheet built in, which applies this default formatting to any XML document.

XML styling is accomplished through another document dedicated to the task, called a stylesheet. In a stylesheet the designer specifies rules that determine the presentation of the data. The same stylesheet can then be used with multiple documents to create a similar appearance among them. There are a variety of languages that can be used to create stylesheets. In Chapter 4 we'll learn about a transformation stylesheet language called Extensible Stylesheet Language Transformations (XSLT) and in Chapter 11 we'll be looking at a stylesheet language called Cascading Style Sheets (CSS).

As we'll see in later chapters, you can also create your own stylesheets for displaying XML documents. This way, the same data that your applications use can also be viewed in a browser. In effect, by combining XML data with stylesheets you can separate your data from your presentation. That makes it easier to use the data for multiple purposes (as opposed to HTML, which doesn't provide any separation of data from presentation - in HTML, everything is presentation).

What Does XML Buy Us?

But why would we go to all of the bother of creating an XML document? Wouldn't it be easier to just make up some rules for a file about names, such as "The first name starts at the beginning of the file, and the last name comes after the first space"? That way, our application could still read the data, but the file size would be much smaller.

How Else Would We Describe Our Data?

As a partial answer, let's suppose that we want to add a middle name to our example:

John Fitzgerald Doe

Okay, no problem.

Continues...

---

Excerpted from Beginning XML by David Hunter Kurt Cagle Chris Dix Roger Kovack Jonathan Pinnock Jeff Rafter Excerpted by permission.
All rights reserved. No part of this excerpt may be reproduced or reprinted without permission in writing from the publisher.
Excerpts are provided by Dial-A-Book Inc. solely for the personal use of visitors to this web site.

---