XML Family of Specifications: A Practical Guide / Edition 1

XML Family of Specifications: A Practical Guide / Edition 1

by Kenneth B. Sall
5.0 1
Pub. Date:

Paperback - Rent for

Select a Purchase Option (BK&CD-ROM)
  • purchase options

Temporarily Out of Stock Online


XML Family of Specifications: A Practical Guide / Edition 1

As XML continues to mature, developers need to understand how this standard and its related technologies are revolutionizing software development. XML Family of Specifications: A Practical Guide , now a two-volume set, provides a complete roadmap for understanding how XML, XSL, XML Schema, and related specifications interlink to create powerful, real-world applications.

Product Details

ISBN-13: 9780201703597
Publisher: Addison-Wesley
Publication date: 06/14/2002
Edition description: BK&CD-ROM
Pages: 1168
Product dimensions: 7.40(w) x 9.10(h) x 2.30(d)

Table of Contents

List of Figures.

List of Tables.




1. History of the Web and XML.

Ancient History (1945 to 1985).

Hypertext and Early User Interfaces.

GML and SGML: Content vs. Presentation.

ARPANET and the Internet: Infrastructure.

Medieval History (1986 to 1994).

Berners-Lee, the Web, and HyperText Markup Language.

Historic Timelines.

Premodern History (1994 to 1998).

Ultramodern History (1998 to 2001).


For Further Exploration.


I. Fundamental XML Concepts, Syntax, and Modeling.

2. Overview of the XML Family of Specifications .

Fixing the Web.

HTML Standards Change Too Slowly.

Browser-Specific Extensions Are Problematic.

No Meaningful Markup of Data.

Presentation Is Often Fixed for Monitors.

Content Changes Cause Problems.

Browser Paradigm Is Too Constraining.

Search Engines Need Better Focusing.

Can't Specify Collections of Related Pages.

One-Way Linking Is Too Limited.

Enter XML and Its Many Benefits.

What Does XML Look Like?

Presentation vs. Structure.

XML Representation with a DTD.

Document-centric vs. Data-centric.

Processing XML with XSLT.

XPath Language.

Benefits and Applications.

Domain-Specific Vocabularies.

XML Can Describe User Interfaces.

XML Complements HTML.

Validated, Self-Describing Data.


Search Engines.

Distributed Applications.

Granular Updates.

User-Selected and User-Specific View of Data.

Device-Dependent Display of Data.

Resolution-Independent Graphics in a Text Format.

Rendering with Formatting Objects.

Unicode and Alternate Character Set Support.

The Big Picture and the Role of the W3C.

W3C Recommendation Process.

W3C Domains, Activities, and Working Groups.

The Big Picture.


For Further Exploration.

3. XML Syntax and Parsing Concepts.

Elements, Tags, Attributes, and Content.

XML Document Structure.

XML Declaration.

Document Type Declaration.

Document Body.

Markup, Character Data, and Parsing.

XML Syntax Rules.


Legal XML Name Characters.

Elements and Attributes Are Case-Sensitive.

Uppercase Keywords.

Case Conventions or Guidelines.

Root Element Contains All Others.

Start and End Tags Must Match.

Empty Elements.

Proper Nesting of Start and End Tags.

Parent, Child, Ancestor, Descendant.

Attribute Values Must Be Quoted.

White Space Is Significant.


Processing Instructions.

Entity References.

CDATA Sections.

Well-Formed vs. Valid Documents.


Well-Formed or Toast?

Validating and Nonvalidating Parsers.

Event-Based vs. Tree-Based Parsing.

Event-Based Parsing.

Tree-Based Parsing.


For Further Exploration.

4. DTD Syntax.

What Is a DTD and When Is It Needed?

Elements and Content Models.

Element Content Model.

Sequencing and Choosing Elements.

Occurrence Indicators.

Mixed Content Model.

EMPTY Content Model.

ANY Content Model.

Expressions: The Good, the Bad, and the Ugly.

Deterministic Content Models.


Attributes, Attribute Types, and Default Values.

Attribute-List Declaration.

Attribute Types.

Attribute Default Values.

Elements vs. Attributes: Guidelines.

Example DTD and XML Instance.

Invoice DTD.

Invoice XML Instance.

External and Internal DTD Subsets.

External Subsets.

Internal Subsets.

External Subset with Internal Subset.

Entities and Notations.

Document Entity.

General Entities.

Parameter Entities.


Generating DTDs and XML Instances.

Generating a DTD from an XML Instance.

Generating XML Instances from a DTD.

Overall DTD Structure.


For Further Exploration.

5. Namespaces, XML Infoset, and Canonical XML.


Why Namespaces Are Needed: Resolving Name Conflicts.

Qualified Names, Prefixes, Local Names, and Other Terminology.

Declaring Namespaces in XML Documents.

Default Namespace.

Handling Namespaces in a DTD or XML Schema.

Validating Documents with Namespaces.

What Does a Namespace Point To?

Namespace Support and Use.

Special Attributes: xmlns, xml:space, xml:lang, and xml:base.

Common Namespaces.

XML Information Set.

What's in the Infoset?

What's Not in the Infoset?

Canonical XML.

Why Is Canonical XML Needed?

Canonical XML Terminology.

Canonical XML Example: Different but Equal.


For Further Exploration.

6. XML Schema: DTDs on Steroids.

The Need for Schemas: Why DTDs Aren't Always Enough.


No Metadata Access.

Limited Datatypes.

Hard-to-Define Ranges or Sets.

No Subclassing.

Order of Children Is Too Rigid.

Limited Way to Express Number of Repetitions.

Lacks Namespace Support.

Enter XML Schema.

Historical Perspective: Forerunners of XML Schema.

XML-Data and XML-Data Reduced.

Document Content Description.

Schema for Object-Oriented XML.

Document Definition Markup Language.

Relevant Specifications.

Basic Example.

Address DTD and Instance.

Address Schema and Instance.

What Have We Gained?

Collection Schema Example.

Collection DTD.

Collection XML Schema.

Collection Schema Instance.

Key Concepts and Terminology.

Schema Components.

Keywords: DTD vs. XML Schema.

Elements, Declarations, and Definitions.

Element Repeatability: minOccurs and maxOccurs.

XML Representation Summary of xsd:element.

Local vs. Global Scope.

Attribute Declarations and Occurrence.

Content Model and Model Groups: Introduction.

Creating and Using Datatypes.

Definition of Datatype.

Object-Oriented Analogy: A Brief Detour.

Simple Types, Complex Types, Simple Content, Complex Content, and Derivation.

Built-in Datatypes.

Derivation by Constraining a Simple Type with Facets.

Regular Expressions for Pattern Facet.

Derivation by List.

Derivation by Union.

More about Complex Types.

Adding and Constraining Attribute Values.

Restricting a User-Defined Type.

Adding Element Children.

Adding Elements to a User-Defined Type.

Extension of Complex Types with Complex Content.

Restriction of Complex Types with Complex Content.

Empty Elements with and without Attributes.

Summary of Type Definition Cases.

Limiting Derivation.

More about Content Models and Model Groups.

Mixed Content Model.

Generic xsd:any Content Model.

Group Element.

Attribute Groups.

Miscellaneous XML Schema Topics.


Namespaces and XML Schema.

Import and Include.

Working with XML Schema.

XML Schema Software.

Converting DTDs to XML Schema.

Converting with TurboXML by TIBCO Extensibility.

Converting with XML Spy IDE by Altova.

Schema Validation.

Validation Using XSV by Henry Thompson.

Validation Using XML Spy.

Schema Repositories and Registries.



Open Applications Group.

More Miscellaneous Topics.

Shortcomings of XML Schema.

When to Use DTDs Instead of XML Schema.

XML Schema Topics Not Covered in Detail.

XML Schema Alternatives.






For Further Exploration.


7. Parsing with SAX.

Overview of Parsing and Processing XML.

Parsing, Validation, APIs, and Consumers.

Different Approaches: SAX and DOM, JDOM, and JAXP.

XML Infoset and Its Relation to Parsing.

Recommended Java Parsers and Non-Java Support.

Development of SAX.

SAX: Event Handler Model.

SAX2 Interfaces and Classes.

Major Interfaces and Classes.

Overall SAX Application Sequence.

ContentHandler and Context Tracking.


ErrorHandler: Well-Formedess and Validation.

Features and Properties.

SAX1 vs. SAX2.

Using SAX with Java.

Determining the Parser Driver Classname.

Compiling and Running a SAX Application.

Minimal SAX Example.

More Robust SAX Example.

Valid Parse Results.

Error Results.

More Representative Input.

SAX Filters.

Writing XML Using SAX.


For Further Exploration.

8. Parsing with the DOM.

Overview of the DOM.

Historical Perspective.

Tree vs. Event Model.

@BHEADS = Generic Interfaces: Good or Bad?

DHTML Comparison.

Relevant Specifications and Key Resources.

DOM Levels.

DOM Level 2 Specifications.

DOM Level 3 Specifications.

Testing for Feature Support.

Collection DTD and Instance Revisited.

DOM Nodes and How the DOM Works.

Node Interface.

NodeList and NamedNodeMap.

Node IDL Definition.

Node Java Binding.

Overview of DOM Interfaces and Their Methods.

Core DOM Level 2 Interfaces and Methods.

Document Interface.

Using the DOM.

Compiling and Running a DOM Application.

Overview of Apache Xerces Packages.

Minimal DOM Application.

Handling Additional DOM Processing Requirements.

Error Handling.

Checking for Feature Availability.

Accessing Node Type-Specific Properties.

DOM2 Output with Valid Input.

Examples of Well-Formedness and Validation Error Handling.

Accessing Attributes.

Filtering Nodes of Interest.

Adding, Changing, and Removing DOM Nodes.

Serializing DOM Trees.

Script Access to the DOM.

Microsoft's DOM.

DOM-Related Markup Languages.

DOM for MathML 2.0.

DOM for SMIL Animation.

DOM for SVG 1.0.

Complete DOM Code Example.


For Further Exploration.

9. Processing with JDOM and JAXP.

Overview of Java XML APIs.

JDOM: A Java-centric Parsing Approach.

How JDOM Differs from the DOM.

JDOM Packages.

Using JDOM.

Reading and Writing with JDOM.

JDOM Output with Valid Input.

Examples of Well-Formedness and Validation Error Handling.

JDOM Summary.

Sun's XML APIs: The Java XML Pack.

JAXP: Sun's Java API for XML Processing.

JAXP 1.1 Components and Packages.

Specifications Supported by JAXP.

Using JAXP 1.1.

Enabling Validation.

Using SAX with JAXP.

Using DOM with JAXP.

Java System Properties for JAXP.

JAXP Code Example.

TrAX Overview and Basic Example.

JAXP Summary.

SAX vs. DOM vs. JDOM vs. JAXP--Who Wins?

For Further Exploration.


10. Styling XML Using CSS2.

What Is CSS?

CSS Basics: Declarations, Selectors, and Use with HTML.

Rules, Declarations, Selectors, Properties, and Values.

Embedded CSS Style Sheet in HTML.

External CSS Style Sheet.

Associating External CSS with HTML.

CSS2 Selectors.

Netscape 6 vs. Internet Explorer 5.5.

Style Sheet or Stylesheet?

Using CSS with XML.

Associating CSS with XML.

Element Names and the Display Property.

Rendering Example of XML with CSS.

Improved CSS Style Sheet for XML.

Robust CSS Style Sheet with Generated Text.

CSS with Internet Explorer 5.5.

Limitations of Using CSS for XML.


For Further Exploration.

11. Transforming XML with XSLT and XPath.

Overview of XSLT and XPath.

What Is XSL? XSLFO? XSLT? XPath?

XSLT Processing Model.

Historical Perspective.

Relevant Specifications.

Using XSLT.

Server-Side Transformations.

XSLT and XSLFO Software Lists.

Functional Capabilities of XSLT.

Advantages of XSL/XSLT Compared to CSS.

@BHEADS = Choosing and Using XSLT Processors.

Running the Xalan XSLT Processor.

Hello XSLT Example.

XSLT Concepts and Examples.

Example XML Document: collection6.xml.

Central Concepts.

Value of a Node or Expression.

Default Built-in Template Rules and Node Tests.

The <xsl:stylesheet> Element.

Namespaces for XSLT, XPath, and XSLFO.

Stylesheet Structure.

Implicit vs. Explicit Stylesheets and Push vs. Pull.

Conditionals and Variables.

More about Setting Variables.

Multiple Decisions.

Generating an HTML Table.

Accessing Attributes.

Attribute Sets for Reuse.

XML to XML: Shallow Copies.

XML to XML: Deep Copies and Creating Elements.

More XML to XML Transformations.

Reader Challenge: Invoice XML to XML Transformation.

Iterating and Sorting.

Primary and Secondary Sort Keys.

Associating XSL with XML: Processing Instruction or Element.

Special Characters: Disabling Output Escaping.

Output Methods Revisited: XML, HTML, Text.

Reuse: Named Templates and Passing Parameters.

Attribute Value Templates.

Reuse: Including and Importing.

XPath Concepts and Examples.

The XPath Model.

Location Paths and Steps.

XPath Axes.

Node Types, Node Values, and Node Tests.

@BHEADS = Data Types.

XPath Expressions vs. XSLT Patterns.

XPath Operators.

XPath Functions.

Node-Set Functions in XPath.

String Functions in XPath.

Boolean Functions in XPath.

Numeric Functions in XPath.

XSLT Elements and Instructions.

Root and Top-Level Elements.

XSLT Instructions.

XSLT Functions.

Examples of XSLT Functions.

Case Study: Generating Link Pages from This Book's “For Further Exploration” Sections.

Problem Statement and Goals.

Examining the Generated XML Structure.

Basic Structure and Pitfalls.

Extracting the Links.

Adding Chapter Information.

Sorting the Links.

Adding Style.

Final Solution.

Additional XSLT Topics.

Microsoft XSL: Old and in the Way.

@BHEADS = Topics Not Covered in Detail.

Beyond XSLT 1.0: XSLT 2.0, XPath 2.0, EXSLT, and XSLTSL.


For Further Exploration.

12. Practical Formatting Using XSLFO.


The Context of XSLFO.

Extensible Markup Language.

The XML Family of Recommendations.


Basic Concepts of XSLFO.

Basic Concepts.

Area and Page Basics.

Page Geometry.

XSLFO Objects Related to Basic Areas and Simple Page Definitions.

Generic Body Constructs.

XSLFO Objects Related to Generic Body Constructs.


XSLFO Objects Related to Tables.

Static Content and Page Geometry Sequencing.

XSLFO Objects Related to Static Content and Page Geometry Sequencing.

Floats and Footnotes.

XSLFO Objects Related to Floats and Footnotes.

Keeps, Breaks, Spacing, and Stacking.

Interactive Objects.

XSLFO Objects Related to Dynamic Properties and Dynamic Rendering Sequencing.

Supplemental Objects.

Lesser Used XSLFO Objects.

For Further Exploration.


13. XLink: XML Linking Language.


Why HTML Linking Isn't Sufficient.

What Is XLink?

Link Types and the xlink:type Attribute.

Terminology and Concepts.

Support for XLink.

Relevant Specifications.

Historical Perspective.

Simple Link: Reinventing the Anchor.

Simple Link Code Example.

Declaring XLinks in DTDs.

Validating Simple XLinks with a Modified DTD.

XLink Attributes.

Attributes by Purpose and Datatype.

Attributes by Link Type.

Link Behavior.

xlink:show Attribute.

xlink:actuate Attribute.

Extended Links: The True Flexibility of XLink.

Basic Extended Link Example.

Locator Link Type.

Resource Link Type.

Arc Link Type.

Title Link Type.

Extended Link Code Example.

Outbound, Inbound, and Third-Party Links.

Third-Party Extended Link Example.


XML Base Support for Relative URIs.

XLink Implementations.


For Further Exploration.

14. XPointer: XML Pointer Language.


Relevant Specifications.

Relationship to XPath.

Relationship to XLink.

Forms of XPointers.

Terminology and Concepts.

Historical Perspective.

Code Example Modification.

Forms of XPointers.

Full XPointers.

Bare Names.

Child Sequences.

XPointer Functions.

start-point() and end-point().

here() and origin().


range() and range-inside().

string-range ().

Node-Points and Character-Points.



Escaping in XPointers.

XPointer Implementations.


For Further Exploration.


15. XHTML: HTML for the Present and the Future.

The XHTML Family.

Why Do We Need XHTML?

Overlap of XHTML Family.

Relevant Specifications: The XHTML Family.

XHTML 1.0.

Strictly Conforming XHTML Documents.

Simple XHTML Example.

Three Flavors of XHTML 1.0 DTDs: Which Should You Use?

Differences between XHTML 1.0 and HTML 4.01.

Sloppy HTML Example.

Validating HTML 4.01 Transitional and Strict.

HTML Tidy: Converting HTML to XHTML.

Validating XHTML 1.0 Transitional and Strict.

Considerations for Displaying XHTML.

Combining XHTML with Another Vocabulary.

Modularization of XHTML.

Abstract Modules and Implementations.

The Modules.

Anatomy of a Module.


Building DTD Modules (Adding Your Own Module).

XHTML Basic.

RDDL: An Extension of XHTML Basic.


RDDL Qualified Names Module.

RDDL 1.0 Document Model Module.

RDDL Resource Module.

RDDL XLink Module.

Sample RDDL Document.

XHTML 1.1--Module-based XHTML.

XHTML 1.1 Modules and Elements.

Conforming XHTML 1.1 Documents and the Driver.

Document Model Module and Customizing XHTML 1.1.

Near Future XHTML.

XForms: Next Generation Web Forms.

XML Events: An Events Syntax for XML.

Modularization of XHTML in XML Schema.

XHTML 2.0.


For Further Exploration.

16. RDF: Resource Description Framework.



History of RDF.

Model, or “Why Couldn't I Just Use XML?”

RDF Specifications.


Core Data Model of RDF.

Vocabulary for Ontological Description Using RDF.

Qualified Values: Special Case of Structured Values.

Classes and Instances.

Properties, Subproperties, and Property Constraints.


Miscellaneous Vocabulary.

XML Serialization Syntax for RDF.

Full Syntax.

Container Syntax.

Abbreviated Syntax.

Parse Types.

Syntactic Conventions for Schemata.

Advanced Topics.

Statements about Statements.

Introducing Additional Constraints.

Model Theory.

For Further Exploration.


A. XML Family of Specifications in a Nutshell.

B. E-Commerce Specifications.

C. HTML 4.01 Character Entities.

D. Setting Up Your XML Environment.


Index. 0201703599T05082002

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews

XML Family of Specifications: A Practical Guide 5 out of 5 based on 0 ratings. 1 reviews.
Guest More than 1 year ago
An excellent and comprehensive description of XML. Very up to date. The author gives a clear summary of the history of XML and where the various portions stand. He is to be commended for having a colour diagram on the inside cover, summarising the many specifications that are part of XML or associated with it, like XPath, XLink, JDOM, JAXP, DOM. Affiliated with this is a large pull out colour chart, that gives the time line and status of the components. The book is near exhaustive in its description of these components. You would do well to constantly refer to these two diagrams. Pin the chart above your computer! This may sound trivial to some. But when you are digging your way through a detailed set of examples in the book, it really helps to have a schematic overview to place things in perspective. All the more so if you happen to be new to many of the topics. Even experienced users can benefit. The book has a CD with full listings of the examples. A great time saver. Also, since the author did not provide problem sets, you can easily make up your own, based on the CD. For example, suppose you are looking at Chapter 8, "Parsing with the DOM". Take an example document and its DTD from the CD. Change the DTD to add more elements and attributes. Make some of these mandatory. Run the parser on the document and the DTD. You should get errors, as expected, because the document is missing some new required items. Understand the error messages. Then correct the document by adding instances of those items. Rerun the parser. Any errors? If not, then try adding more to the DTD and document. This will really help you learn. You can quickly build up documents of some nontrivial complexity. Of course, you can, and should, do analogous things with the other chapters. In terms of the reader's background (I'm talking to you): You can come from either a formal programming environment, or from a publishing/designer background. In both cases, you should already be well familiar with HTML. This is not a formal prerequisite, but a lot of things in the book really do come easier if you know HTML. The programming examples in the book are usually in java, but the author emphasises that XML is not a procedural programming language like java. Rather, it is a declarative language, where you make templates. In this sense, XML is closer to HTML than to java or C. This book is worth your attention.