Effective XML - 50 Specific Ways to Improve Your XML

Series: Addison-Wesley Effective Software Development Series

Learning the fundamentals of XML might take a student a week. Learning how to use XML effectively might take a lifetime. In keeping with the tradition of Scott Meyer's books on C++, Elliotte Rusty Harold discusses 50 rules that will help students improve their XML programs.

This book is not a tutorial. It is not going to teach your students what a tag is or how to write a DTD (Document Type Definition). Instead it's going to tell them when, why, where, and how to use such XML tools effectively (and equally important when not to use them).

Since XML has become a fundamental underpinning of new software systems, it becomes important to ask new questions, not just what XML is, but how does one use it effectively? Which techniques work and which don't? Perhaps most importantly, which techniques appear to work at first but fail to scale as systems are further developed? This book answers these questions. It is not enough for students to learn to write programs that compile and produce the expected results. It is important for them to write code that is extensible, legible, and maintainable because XML can be used to produce robust, extensible, maintainable systems.

List of contents

Preface.

Acknowledgments.

Introduction.

Element versus Tag.

Attribute versus Attribute Value.

Entity versus Entity Reference.

Entity Reference versus Character Reference.

Children versus Child Elements versus Content.

Text versus Character Data versus Markup.

Namespace versus Namespace Name versus Namespace URI.

XML Document versus XML File.

XML Application versus XML Software.

Well-Formed versus Valid.

DTD versus DOCTYPE.

XML Declaration versus Processing Instruction.

Character Set versus Character Encoding.

URI versus URI Reference versus IRI.

Schemas versus the W3C XML Schema Language.
I. SYNTAX.
Item 1. Include an XML Declaration.

The version Info.

The encoding Declaration.

The standalone Declaration.
Item 2. Mark Up with ASCII if Possible.
Item 3. Stay with XML 1.0.

New Characters in XML Names.

C0 Control Characters.

C1 Control Characters.

NEL Used as a Line Break.

Unicode Normalization.

Undeclaring Namespace Prefixes.
Item 4. Use Standard Entity References.
Item 5. Comment DTDs Liberally.

The Header Comment.

Declarations.
Item 6. Name Elements with Camel Case.
Item 7. Parameterize DTDs.

Parameterizing Attributes.

Parameterizing Namespaces.

Full Parameterization.

Conditional Sections.
Item 8. Modularize DTDs.
Item 9. Distinguish Text from Markup.
Item 10. White Space Matters.

The xml:space Attribute.

Ignorable White Space.

Tags and White Space.

White Space in Attributes.

Schemas.
II. STRUCTURE.
Item 11. Make Structure Explicit through Markup.

Tag Each Unit of Information.

Avoid Implicit Structure.

Where to Stop?
Item 12. Store Metadata in Attributes.
Item 13. Remember Mixed Content.
Item 14. Allow All XML Syntax.
Item 15. Build on Top of Structures, Not Syntax.

Empty-Element Tags.

CDATA Sections.

Character and Entity References.
Item 16. Prefer URLs to Unparsed Entities and Notations.
Item 17. Use Processing Instructions for Process-Specific Content.

Style Location.

Overlapping Markup.

Page Formatting.

Out-of-Line Markup.

Misuse of Processing Instructions.
Item 18. Include All Information in the Instance Document.
Item 19. Encode Binary Data Using Quoted Printable and/or Base64.

Quoted Printable.

Base64.
Item 20. Use Namespaces for Modularity and Extensibility.

Choosing a Namespace URI.

Validation and Namespaces.
Item 21. Rely on Namespace URIs, Not Prefixes.
Item 22. Don't Use Namespace Prefixes in Element Content and Attribute Values.
Item 23. Reuse XHTML for Generic Narrative Content.
Item 24. Choose the Right Schema Language for the Job.

The W3C XML Schema Language.

Document Type Definitions.

RELAX NG.

Schematron.

Java, C#, Python, and Perl.

Layering Schemas.
Item 25. Pretend There's No Such Thing as the PSVI.
Item 26. Version Documents, Schemas, and Stylesheets.
Item 27. Mark Up According to Meaning.
III. SEMANTICS.
Item 28. Use Only What You Need.
Item 29. Always Use a Parser.
Item 30. Layer Functionality.
Item 31. Program to Standard APIs.

SAX.

DOM.

JDOM.
Item 32. Choose SAX for Computer Efficiency.
Item 33. Choose DOM for Standards Support.
Item 34. Read the Complete DTD.
Item 35. Navigate with XPath.
Item 36. Serialize XML with XML.
Item 37. Validate Inside Your Program with Schemas.

Xerces-J.

DOM Level 3 Validation.
IV. IMPLEMENTATION.
Item 38. Write in Unicode.

Choosing an Encoding.

A char Is Not a Character.

Normalization Forms.

Sorting.
Item 39. Parameterize XSLT Stylesheets.
Item 40. Avoid Vendor Lock-In.
Item 41. Hang On to Your Relational Database.
Item 42. Document Namespaces with RDDL.

Natures.

Purposes.
Item 43. Preprocess XSLT on the Server Side.

Servlet-Based Solutions.

Apache.

IIS.
Item 44. Serve XML+CSS to the Client.
Item 45. Pick the Correct MIME Media Type.
Item 46. Tidy Up Your HTML.

MIME Type.

HTML Tidy.

Older Browsers.
Item 47. Catalog Common Resources.

Catalog Syntax.

Using Catalog Files.
Item 48. Verify Documents with XML Digital Signatures.

Digital Signature Syntax.

Digital Signature Tools.
Item 49. Hide Confidential Data with XML Encryption.

Encryption Syntax.

Encryption Tools.
Item 50. Compress if Space Is a Problem.
Recommended Reading.
Index. 0321150406T08272003

About the author

Elliotte Rusty Harold is originally from New Orleans to which he returns periodically in search of a decent bowl of gumbo. However, he currently resides in the Prospect Heights neighborhood of Brooklyn with his wife Beth, dog Shayna, and cat Marjorie (named after his mother-in-law). He's a frequent speaker at industry conferences including Software Development, Dr. Dobb's Architecure & Design World, SD Best Practices, Extreme Markup Languages, and too many user groups to count. His open source projects include the XOM Library for processing XML with Java and the Amateur media player.

Summary

Provides 50 practical rules of thumb based on real-world examples and best practices. This book illustrates how you can save development time while improving your XML code. It also provides essential information on building services such as verification, compression, authentication, caching, and content management.

Product details

• Authors: Elliote Rusty Harold, Elliotte Rusty Harold
• Publisher: Addison-Wesley Longman, Amsterdam
• Languages: English
• Product format: Paperback / Softback
• Released: 01.01.2003
• EAN: 9780321150400
• ISBN: 978-0-321-15040-0
• No. of pages: 336
• Dimensions: 176 mm x 235 mm x 20 mm
• Weight: 640 g
• Series: Effective Software Development Series; Addison-Wesley; Effective Software Development; Addison-Wesley; Effective Software Development Series
• Subject: Natural sciences, medicine, IT, technology > IT, data processing > Programming languages