If you're interested in having me reprise any of these presentations for your company, user group, or conference, please see the abstracts page for more details.
I've presented most of these seminars and tutorials several times, updating them each time. These are links to the most recent and up-to-date version of each of these talks.
XML, the Extensible Markup Language, has been adopted in realms as diverse as human resources, object serialization, genealogy, and music. This high-level overview shows you how you might use XML in your own areas of interest. Standards discussed include CSS, XSLT, XSL-FO, DTDs, XLinks, SAX, and DOM. It shows you brief examples of each of these and explains both their intended purpose and their practical uses so you can intelligently decide which ones you need to work with and which ones you can safely ignore. After you've attended this seminar, you'll know what all the different XML technologies and tools are, and be able to decide when they are and are not appropriate for your web sites and applications.
XML is a simple, flexible format that allows you to design markup languages to fit your documents rather than the one-size-fits-all approach of HTML. XML is suitable not only for Web pages, but also for printed documentation, application file formats, and data interchange between applications. This talk discusses what XML can do for your programs and Web sites. In it, you'll learn how to write well-formed XML documents and display them on Web sites using CSS style sheets. This talk assumes basic familiarity with HTML and the Web but no prior knowledge of XML.
XML based syndication is moving from its foundations in weblogs to unexpected arenas: source code control systems, audio narrowcasts, e-mail, bug tracking, stock tickers, and more. News readers like Vienna, NetNewsWire, RSSOwl, and Newsgator are replacing classic web browsers for many uses. This session explores the fundamental technologies underlying this explosion of content: the various versions of RSS, OPML, Atom, and the Atom Publishing Protocol. Learn the tricks and techniques for integrating these XML applications into your products as both clients and servers.
Six years after XML 1.0 was released, the community is finally beginning to understand which practices work and which ones don't. This talk explores patterns (and quite a few anti-patterns) common in XML development, and explains which are which, and why. You'll learn as many specific ways to improve your XML systems as we can cram into 90 minutes.
More and more applications are generating XML documents as their primary or secondary outputs. XML is much easier to parse than traditional formats. At the same time, it has a number of syntactic options that make testing output more difficult than testing traditional, less rich formats. Simple string comparison is often too naive to properly test XML. This talk explores the challenges and pitfalls of testing XML documents. It explains what to look for when testing XML documents and even more importantly what to ignore. We'll consider various tools for testing XML including parsers, schemas, DTDs, canonical XML, and XPath. Finally, we'll discuss automating tests by writing JUnit test cases that use various XML APIs such as DOM to compare the actual output to the expected output.
Despite all the advances made on the Web in the last decade+, forms have changed little since Mosaic 1.0. We now have JavaScript to give them a little intelligence, and browsers can sometimes autofill a few fields, but otherwise they present the same basic interface they did ten years ago. The wait for better user interfaces is over. XForms are a radically more powerful forms technology for the Web that enables separation of presentation and content, data type aware input fields, enhanced accessibility for users, far richer user interface widgets, and much, much more. Learn how you can take advantage of XForms to build the next generation of killer web apps.
Do DTDs bore you? Does the W3C XML Schema Language drive you to tears? Rejoice, because an alternative is here. RELAX NG is a new international standard schema language that's based on powerful mathematics but simple enough for math-phobics to use. It provides the 80% of features developers actually need from schemas at about 20% of the complexity. And it can do a few things the W3C XML Schema Language can't. In 90 minutes you can learn to do with RELAX NG what would take a full day of training in the W3C XML Schema Language.
XQuery is a new fourth generation language being designed at the W3C to extract information from collections of XML documents, including those stored in native XML databases. It is based on XPath 2.0, but features a more familiar, procedural syntax than XSLT. This talk explores XQuery 1.0, shows you when it's appropriate and where you can use it. You'll learn both the syntax and semantics of this powerful new language.
It is generally recognized that the standard APIs for processing XML have their drawbacks. SAX, though efficient, is hard to use, and DOM can be just plain ugly. XOM is a new XML object model developed by Elliotte Rusty Harold. It is an open source (LGPL), tree-based, streaming API for processing XML that strives for correctness and simplicity while still being able to process documents of arbitrary size and complexity. XOM implementations are available for Java and Python. In this 90 minute presentation, Elliotte will explain the philosophy behind XOM and give some demonstrations of how it boosts productivity and leads to cleaner, more understandable code for XML processing.
StAX, the Streaming API for XML, is a new pull parsing API for processing XML with Java. Unlike traditional, SAX based push parsers, pull parsers put your application in charge of the program. You drive the processing rather than being driven by it. Nonetheless, you get all the speed and size advantages of a streaming API. This class explores the design patterns common in pull parsing. Learn how you can integrate pull-parsing into your application chains, and more importantly whether you should.
XML based markup languages are described with Document Type Definitions (DTDs). This seminar shows you how to document your own XML applications using DTDs. You'll learn how to declare elements, attributes, and entities; how to validate documents against DTDs; and how to organize your DTDs in a clear, maintainable, and reusable fashion.
One of the most common complaints about DTDs is that they don't allow authors
to specify constraints on the element and attribute content. For instance,
they do not let you say that a MONTH element contains an integer
between 1 and 12. Schemas fill this gap in the XML family. They also fill many other
holes left by DTDs; among them inheritance, data typing, and namespace-aware validation.
This talk introduces you to the W3C's new XML schema language, and shows you how to use it
to make validation far more powerful.
Without links, HTML would be just another document format. Without links it could never have created the Web. And yet until quite recently XML has been lacking any similar facility. The wait, however, is over. This talk introduces XLinks and XPointers, the two main proposals for making XML not just text but hypertext. You'll learn how to use XLinks and XPointers to build hypertext systems far more sophisticated than anything that's possible with HTML.
Namespaces are one of the most fundamental yet widely misunderstood factors in the XML equation. They do both more and less than many people expect of them. This talk shows you how to use namespaces in both new and existing XML applications, including how to integrate them with DTDs and schemas.
The Extensible Stylesheet Language (XSL) includes a very powerful declarative language for transforming XML documents into new XML documents called XSLT. XSLT has many applications including electronic commerce and Web page display. In this talk you'll write XSL stylesheets that can change XML to HTML, sort data, extract subsets of the data, and otherwise manipulate and massage data for display to the end user.
XMLPULL is a new, extremely fast streaming API for reading XML documents that can handle arbitrarily large documents without many of the complexities of SAX. This pull-based API has the potential to be as easy to use as tree-based APIs like DOM and JDOM while being as fast and memory efficient as push-based APIs like SAX. Although its API is very different than either SAX or DOM, XMLPULL is fully conformant with all relevant XML standards. It supports well-formedness checking, validation, namespaces, and even schemas. Learn how you can integrate pull-parsing into your applications and systems.
DOM Level 3 is the next generation of the
popular Document Object Model language and parser independent
API for reading and writing XML and HTML documents.
DOM3 adds standard means of locating a parser, creating a new document,
and accessing DTDs and schemas. It also fill a number of holes in
existing DOM interfaces such as Element and Node.
Attendees should already be familiar with the DOM2 Core API.
XInclude is a radical new way of building large XML documents out of smaller component parts. Unlike competing technologies such as general entity references and XLinks, all the parts are fully usable by themselves as well as when merged with the master document. Indeed one part can be used in many different documents. XInclude encourages modular and reusable development of web sites, book, and information systems. This talk completely covers XInclude syntax. Several different implementations are presented using a variety of APIs, and the strengths and weaknesses of each are elaborated.
The Extensible Stylesheet Language (XSL) includes a very powerful declarative language for transforming XML documents into new XML documents called XSLT. XSLT has many applications including electronic commerce and Web page display. In this talk you'll learn how to write XSL stylesheets that can change XML to HTML, sort data, extract subsets of the data, and otherwise manipulate and massage data for display to the end user.
XML is the most hyped technology since Java. It's been touted as an almost universal technology that will replace HTML, JavaBeans, UML, EDI, relational databases, petroleum products, and sliced bread. Clearly that's an exaggeration; but how much of the hype is really accurate and how much is just vapor? In this talk you'll find out just what XML really is and what it can (and can't) do.
More and more software development work requires handling XML. Everything from Ant build files to WSDL documents describing network services are implemented as XML. Test cases and output can often be most conveniently stored as XML. The default install of Eclipse includes a rudimentary XML editor. Third party plug-ins add much more sophisticated editing abilities, as well as other tools such as XSL transformers, schema validators, schema editors, and more. This session will demonstrate the latest plug-ins for working with XML in Eclipse.
XML is a flexible meta-language that allows you to design markup languages to fit your documents rather than the one-size-fits-all approach of HTML. XML is suitable not only for Web pages, but also for application file formats, object serialization, and data interchange between applications. This tutorial will show you how to use Java to process XML documents and show you why you might want to do that.
The session begins with a quick review of XML syntax. However we'll look at it from the perspective of a programmer using XML as an output format. XML files are text files so you'll explore how Java outputs text using Writers and how to use these classes to write XML. Then you'll see some demonstrations of the conversion of existing data formats to XML.
Of course writing data is only half of the I/O equation so next you'll learn how to read XML documents from Java. Input is considerably more complicated than output. Fortunately 90% of the work can be done for you by free parsers like the Apache Project's Xerces. You'll see how to use the standard, event based Simple API for XML (SAX) to drive your own programs through callbacks.
Most parsers also support a more object oriented view of an XML document by implementing the W3C's Document Object Model (DOM). You'll investigate the DOM in depth, see how it compares to SAX, and learn which API is appropriate for which tasks.
This one day tutorial is not for the faint of heart. We're going to run right up to the bleeding edge of today's XML technology, and then we're going to keep on going. This tutorial is for developers who have already mastered the basics of XML, DTDs, and namespaces and are looking for the next level. We'll be exploring the latest W3C and third party extensions to XML definitely including:
We'll also take some time to explore some technologies a little further out on and even past the bleeding edge, possibly including:
However, we're going to leave the exact list of topics open right up until the day of the show so we can give you the freshest, most up-to-date coverage we can, very likely including a few things that haven't even been invented yet. This tutorial shows you not only where XML is and what you can do with it today, but also where it's going and what you'll be able to do with it tomorrow. If you want to get a leg up on your competitors by understanding tomorrow's technology today, this is the talk for you.
This seminar is not for the faint of heart. We're going to run right up to the bleeding edge of today's XML technology, and then we're going to jump off. This tutorial is for programmers who have already mastered SAX and DOM and are looking for the next level. We'll be exploring the latest W3C and third party APIs and standards for processing XML including: the XML Infoset, Canonical XML, XML Digital Signatures, DOM Level 3, XBase, XInclude, and XPointers.
This tutorial will showsyou how to use Java to process XML documents and show you why you might want to do that. XML files are text files so you'll explore how Java outputs text using Writers and how to use these classes to write XML. Then you'll see some demonstrations of the conversion of existing data formats to XML.
Of course writing data is only half of the I/O equation so next you'll learn how to read XML documents from Java. Input is considerably more complicated than output. Fortunately 90% of the work can be done for you by free parsers like the Apache Project's Xerces. You'll see how to use the standard, event based Simple API for XML (SAX) to drive your own programs through callbacks.
Most parsers also support a more object oriented view of an XML document by implementing the W3C's Document Object Model (DOM). You'll investigate the DOM in depth, see how it compares to SAX, and learn which API is appropriate for which tasks.
JDOM is an open source, tree-based, Java API for processing XML documents that's been designed with simplicity and convenience as its foremost purposes. JDOM programs can use any commonly available SAX or DOM parser. At a high level, it's similar to the DOM, but since JDOM was designed specifically for Java rather than for multiple languages, it feels much more natural and "right" to Java programmers. This talk teaches you how to use the JDOM to read and write XML documents from your Java programs while automatically maintaining well-formedness and checking validity. It also compares and contrasts JDOM with the existing SAX and DOM APIs to help you choose which API to use for which projects.
Without links, HTML would have been just another document format. Without links it could never have created the World Wide Web. And yet until quite recently XML has been lacking any similar facility. The wait, however, is over. This talk introduces XLinks, XPointers, XInclude, and XML Base, the technologies that enable you to make XML not just text but hypertext. You'll learn how to put these all together to build hypertext systems far more sophisticated than anything that's possible with HTML.
XSLT 1.0 has been one of the biggest success stories in the XML family.
It's solved a lot of problems developers didn't even know they had
until they saw what XSLT could do. This talk explores the future
of querying and transforming XML documents
including new XSLT elements such as xsl:document,
extension functions written in XSLT,
a new version of XPath that can query remote documents
and use functions in location paths, and a whole new language
called XQuery, a fourth-generation language
for extracting data from XML documents and using that
data to produce new XML documents.
If you attended a particular presentation, and want the notes from a specific talk on a specific day, you'll find them here.