XML: History, Uses, and Web Services Explained
This paper traces the origins of Extensible Markup Language (XML) from the browser wars of the mid-1990s through its development as a lightweight alternative to SGML. It examines XML's principal uses, including data structure description, document transformation, server-side configuration, and object serialization. The paper also explores key parsing strategies (DOM and SAX), the role of XML in open-source tooling such as Apache and Jakarta Ant, and the emerging battleground of Web Services — particularly SOAP messaging, UDDI registries, and the JAXR wrapper service. The paper concludes that XML has not replaced HTML but has instead become an indispensable companion technology across virtually every modern software development context.
- Introduction and Origins of XML: XML's emergence from SGML and browser wars
- XML for Data Description and Validation: Using XML and DTDs to describe data
- Transformations, Parsers, and Object Serialization: XSL transforms, DOM/SAX parsers, serialization
- XML in Configuration Files and Open Source: XML in EJB, Apache, and Ant configs
- Web Services, SOAP, and XML Registries: SOAP messaging, UDDI, and JAXR services
- Conclusion: XML as HTML companion in modern development
✍️ How to write this paper — guide, tools & examples ▾
What makes this paper effective
- It grounds abstract concepts in concrete code examples — the employee record, DTD snippet, and SOAP envelope give readers tangible illustrations of each XML use case.
- It follows a logical progression from XML's historical roots outward to progressively more complex applications, making the argument easy to follow even for readers new to the topic.
- It acknowledges trade-offs honestly, noting the learning-curve drawback of XML configuration files alongside the benefits, which adds analytical credibility.
Key academic technique demonstrated
The paper uses the technique of contextual framing: each new XML application (transformation, parsing, configuration, Web Services) is introduced by first explaining the problem it solves, then showing how XML addresses that problem. This cause-and-effect structure makes technical exposition accessible and rhetorically persuasive without requiring prior reader expertise.
Structure breakdown
The paper opens with a historical overview of XML's emergence from SGML and the browser wars. It then moves through increasingly specialized use cases — data description and DTD validation, XSL transformations and parser types (DOM vs. SAX), object serialization and reflection, server-side configuration files, and finally Web Services via SOAP and JAXR. A brief conclusion synthesizes the trajectory, arguing that XML has found a complementary rather than competitive role alongside HTML.
Introduction and Origins of XML
Extensible Markup Language (XML) was born at the height of the browser wars in the mid-1990s. As Microsoft, Netscape, and the W3C produced new and better versions of HTML, Jon Bosak of Sun Microsystems started the W3C SGML working group. Before long, the group was renamed to XML, and this lighter cousin of SGML was born. Since that time, XML has become a major server-side resource for web site presentation.
The Standard Generalized Markup Language (SGML) is a very complex and rigid markup language used mostly in the publishing industry. Predating HTML, SGML has been around for slightly over a decade. It is a language for describing markup languages, particularly those used in electronic document exchange, document management, and document publishing. HTML is itself an example of a language defined in SGML. In order to bring order to the chaos the browser wars created, HTML also became a rigid and standardized markup language for web presentation. This left XML to fill the flexibility void that had formed. XML was designed from its inception to be flexible enough to describe any kind of markup schema the industry could devise.
This flexibility allowed for the development of many uses that were not envisioned when XML was first formalized. XML diverged into the general categories of describing data structures, moving data between systems, transforming data from one format to another, and — most recently — enabling Web Services. Web Services became possible because XML's design is programming-language-neutral, making it an effective language-neutral communication channel.
When XML was first designed, many people believed it would be quickly adopted as a replacement for HTML. At first, XML was used to describe scientific terms and domains such as chemistry and music notation, but this never caught on beyond the small groups who championed those markup schemes. Instead, XML became more of a server-side tool than a presentation tool. However, HTML 4 has since been extended into XHTML. Even though XHTML is a new standard, compatibility with existing HTML user agents is achievable by following a small set of guidelines. This means the original vision of XML as a presentation layer might yet be realized as more tools are developed that produce content in this format.
XML for Data Description and Validation
The most basic use for XML is to describe the data structure of the content it contains. The following example of an employee record illustrates how this might be formatted:
<?xml version="1.0"?>
<!DOCTYPE employee SYSTEM "employee.dtd">
<employee>
<name>Mr. XML Schema</name>
<position>facilitator</position>
<contact>
<mail-stop>B8</mail-stop>
<phone-ext>[redacted]</phone-ext>
<email/>
</contact>
</employee>
The first line defines which XML version is being used; this information is consumed by parsers. The <employee> tag follows. Everything between that opening tag and its closing </employee> tag is considered to constitute an Employee record. This employee contains attributes for name and position, as well as a nested object attribute for contact. This self-documenting quality helps both developers and parsers understand what the data contained between the tags represents.
While this is a major breakthrough in data description, it does not by itself define what is allowed as content. That validation function is handled by the Document Type Definition (DTD), which uses XML markup declarations. A DTD for the example above might look similar to the following:
<!ELEMENT employee (name, position, contact)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT position (#PCDATA)>
<!ELEMENT contact (mail-stop, phone-ext, email)>
<!ELEMENT mail-stop (#PCDATA)>
<!ELEMENT phone-ext (#PCDATA)>
<!ELEMENT email (#PCDATA)>
The process of getting an employee record into a web page for presentation requires a transformation from XML to HTML. This is accomplished using the XML file, an XSL transformation file, and a parser — precisely how XML was used immediately after it was invented. Over the years, this workflow has grown in complexity so that PDF files, scalable vector graphics, and other advanced output formats can also be produced.
Another use for these transformations has emerged in the database world, where they are used to transfer data from one table schema to another. Along the same lines, data can be reformatted for consumption by new systems. These kinds of processes have greatly enhanced the data warehouse industry. Without a transformation, a web browser will either show raw XML or use its default XML parser to display the data — an outcome that is rarely suitable for general web viewing.
Transformations, Parsers, and Object Serialization
Parsers come in two flavors: validating and non-validating against the DTD. Additionally, there are two distinct parsing styles: DOM and SAX. The XML developer must choose which parsing style to use and whether validation should be performed.
DOM (Document Object Model) parsers read the entire XML document into memory as a document tree. The developer then traverses this model by reading the value of each node. Because the entire document resides in memory, this parsing process can be very slow for large documents. That limitation led to the development of the second parsing style.
SAX parsers read XML documents one element at a time and are considered event-based. This approach lowers memory requirements considerably but provides only a narrow view of the document's contents at any given moment. SAX is the preferred parsing mode in modern programming languages. Each element in the XML file triggers an event, and based on the content of that event the developer can determine what action to take. This approach is particularly useful for object creation using reflection.
Java, and other languages, provide a language feature called reflection. Using reflection, data objects can be serialized into XML, transferred to other languages, and then deserialized again in the target language. One common approach is to maintain matching object definitions in both languages. A frequent motivation for this pattern is to provide a web front-end to a legacy system.
XML is so popular that many new web sites are migrating their data into XML format and converting their object-oriented objects into XML for business-logic processing. Java can provide this kind of functionality using the Domify library from SourceForge.net. Domify is a Java library that adapts an arbitrary graph of Java objects to a W3C DOM interface, with DOM nodes lazy-loaded to minimize processing overhead. This feature ties easily into the Model-View-Controller (MVC) architecture for web presentation, as demonstrated in the Maveric MVC framework.
Conclusion
XML has had a slow acceptance rate, but within the last few years it has exploded into the mainstream of almost every new software development project. Every major vendor now includes XML in their product offerings in one form or another. XML has not replaced HTML; instead, it has found a complementary role in providing the data that HTML presents to end users.
References
Harold, Elliotte Rusty. 1998. XML Extensible Markup Language. IDG Books Worldwide.
Tidwell, Doug. 2001. "Transforming XML into SVG." IBM DeveloperWorks. Available at Accessed December 2, 2002.
Walsh, Kathy, and Sang Shin. "Discover and Publish Web Services with JAXR." Java World. Available at http://www.javaworld.com/javaworld/j2-06-2002/jw-0614-jaxr_p.html. Accessed December 2, 2002.
XHTML 1.0: The Extensible HyperText Markup Language (second edition). W3C. Available at Accessed December 2, 2002.
Always verify citation format against your institution’s current style guide requirements.