Abstract

XML is a format for structured data, but it does not prescribe any way of processing these structures. In practice, XML data has to processed by using XML-specific support in some programming environment. In this lecture, the most popular ways of processing XML data are discussed; the Document Object Model (DOM) as a tree-based data model, the Simple API for XML (SAX) as an event-based programming model, and XSL Transformations (XSLT) as a dedicated programming language for transforming XML.

XML and Programming

• XML is a format for structured data
  • trees do not map very well to most programming languages
  • for working with XML, some mapping into the language is required
• There are two basic approaches for programming with XML:
  1. use special functions to work on XML documents as external data objects
  2. map XML documents to native data structures of the programming language
• A third approach is to have an XML programming language
  • XSLT is an example for an XML programming language
  • XSDL and XPath become an integral part of Java in XJ

XML and Programming Languages

• Most programming languages do not support XML natively
  • a certain impedance mismatch between both models in unavoidable
• Function libraries (or their equivalent) can provide XML processing facilities
  • SAX as an event-based API for accessing XML documents
  • DOM as a tree-based API for accessing XML documents
• Mapping between XML and the programming language can take two forms
  • using hand-crafted code (based on XML functions) that performs the mapping
  • generating code using an XML schema and/or target data structures in the language
• Generating mapping code can be done in two ways
  • using a generic XML Data Binding framework for the mapping
  • using hand-crafted code that can be better tailored to the schemas

Typical XML & Programming Problem

• Asynchronous JavaScript and XML (Ajax) is based on HTTP & XML
  • JavaScript code can communicate with the server using XMLHttpRequest
  • in theory, the server sends XML data which is processed by the script
• XML parsing and processing is inconvenient in JavaScript
  • there is a impedance mismatch between JavaScript and XML
  • if the client is slow and the XML is big, parsing can be time-consuming
  • if all clients are JavaScript sending XML is not really necessary
• JavaScript Object Notation (JSON) is a JavaScript-centric data model
  • JavaScript code can directly instantiate JSON structures as runtime objects
  • any non-JavaScript client (if there are any) will have to use JSON as well

Lightweight XML Processing

• SAX is an event-based API for accessing XML documents
• SAX allows users to use event handlers for parsing-related events
  • the parser reads a document and recognizes markup structures
  • for each recognized structure, a user-supplied function can be called
• SAX parsing requires little memory and can handle very large documents
  • the breadth of the XML document tree is irrelevant to SAX parsing
  • the depth of the tree is relevant for checking for well-formed documents
• SAX parsing does not allow random access or backward movement
  • saving context and history is something the application has to manage
  • at a certain complexity, SAX parsing requires a lot of additional code

SAX Parser

XML Trees Everywhere

• DOM is a tree-based API for accessing XML documents
  • the specification using a language-independent Interface Definition Language (IDL)
  • language bindings map IDL to specific languages such as Java or JavaScript
• DOM is based on a in-memory representation of an XML document
  • random document access using the tree's node structure
  • more specific tasks such as getting an element's attribute by name
• DOM parsers have an additional layer for building the tree
  • an underlying SAX parser reports structures for tree building
  • the memory representation is heavily interlinked (requiring substantial memory)
  • DOM calls query or modify the memory representation of the tree
• DOM processing is not appropriate for all tasks
  • very large documents may not fit into memory (risk of thrashing)
  • for isolated tasks, the parsing overhead is prohibitive

DOM Parser

JDOM

• DOM is not optimized for a specific programming language
  • DOM knowledge can be easily transferred between programming languages
  • programming with DOM in a given language often is not very convenient
• JDOM is a Java-specific version of a tree-based XML API
  • represents the same concepts as DOM (XML structures)
  • represents XML concepts in a more Java-friendly way
  • JDOM has no relationship with the W3C's DOM API
• JDOM can be built on top of almost any parser
  • SAX is a pretty common choice for a foundation for JDOM
  • SAX events are then used to build the JDOM tree

Mapping XML into Languages

• XML data binding connects XML with language-specific structures
  • for OO languages this often means mapping schemas and classes
  • code for serialization and deserialization can then be generated
• Typical problems of data binding are schema changes
  • if the schema is updated, can the code be migrated easily?
  • can instances of different versions be handled by the same code?
  • most data binding frameworks do not fully support XSDL anyway
• Several XML data binding frameworks are in widespread use
  • Java Architecture for XML Binding (JAXB)
  • Castor, another Java-based data binding framework

An XML Programming Language

• XSLT is not practical as a general-purpose programming language
  • input and output and limited to handling documents (XML and plain text)
  • system programming is not part of the language model
• XSLT is a very natural choice for XML-centric tasks
  • XML is the data model of XSLT (technically, it now is XDM)
  • simple values use XSDL's Simple Types
  • structured values are XML trees
• XSLT and XML data binding not always work well together
  • XML data binding often is regarded as just a serialization of language structures
  • in these cases, the XML is hard to use outside of the language where it originated
  • these scenarios are a telling sign for poor use of XML

Document Engineering

• Documents are more important than programs
• Programs must be able to easily work with documents
• XML APIs make XML structures available for programs
• XML data binding maps XML to language structures
• XSLT uses XML as its native data model

Assignment 2

• Implement Assignment 1 using simple XML structures
• Assignment 2 asks for a number of sample entries
• Conceptual models can be represented in XML in many different ways