(4) 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 [XML Transformations (XSLT) – Part I] is an example for an XML programming language
  • XSD [XSD – Part I] and XPath [XML Path Language (XPath)] become an integral part of Java in XJ [http://www.research.ibm.com/xj/]

(5) 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 [Simple API for XML (SAX) (1)] as an event-based API for accessing XML documents
  • DOM [Document Object Model (DOM) (1)] 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 [XML Data Binding (1)] framework for the mapping
  • using hand-crafted code that can be better tailored to the schemas

(6) Typical XML & Programming Problem

• Asynchronous JavaScript and XML (Ajax) [../web-fall10/ajax] is based on HTTP & XML
  • JavaScript code can communicate with the server using XMLHttpRequest [http://www.w3.org/TR/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, then 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

(8) 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

(9) SAX Parser

(11) XML Trees Everywhere

• DOM is a tree-based API for accessing XML documents
  • the specification using a language-independent Interface Definition Language (IDL) [http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html]
  • language bindings map IDL to specific languages such as Java [http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/java-binding.html] or JavaScript [http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ecma-script-binding.html]
• DOM is based on a in-memory representation of an XML document
  • random document access using the tree's node structure [http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-1950641247]
  • more specific tasks such as getting an element's attribute by name [http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-217A91B8]
• 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

(12) DOM Parser

(13) 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 [http://www-128.ibm.com/developerworks/java/library/j-jdom/#h2]
  • 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

(15) 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 XSD anyway
• Several XML data binding frameworks are in widespread use
  • Java Architecture for XML Binding (JAXB) [https://jaxb.dev.java.net/]
  • Castor, another Java-based data binding framework

(17) An XML Programming Language

• XSLT is not practical as a general-purpose programming language
  • input and output are 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 [http://dret.net/lectures/xml-fall08/xdm])
  • simple values use XSD [XSD – Part I]'s Simple Types [XSD – Part I; Simple Types (1)]
  • 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

(19) 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