[Book Cover]

XML and SGML Cookbook, The: Recipes for Structured Information, 1/e

Rick Jelliffe, New South Wales, Australia

Published May, 1998 by Prentice Hall PTR (ECS Professional)

Copyright 1998, 656 pp.
Paper
ISBN 0-13-614223-0


Sign up for future
mailings
on this subject.


Summary



Features


ULLET =
ULLET =
ULLET =


Table of Contents
I. SYSTEMS OF DOCUMENTS.

    1. Documents & Publications

      Explicit and Implicit Document Type.

        Love, Bloat and Prudence.

          A Six-View Model of Publications.

            Viewing Page Layout.

              Viewing Page Objects.

                Viewing Glyphs.

                  Viewing Characters.

                    Viewing Editorial Structure.

                      Viewing Topic Structure.

                        The Flow of Dependence.

                          Fads, Trends, Polemics.

                            Conflicts of Interest: HTML and SMDL.

                              What about Non-Text?

                                Documents versus APIs.

                              2. The Nature of Markup.

                                What is Good Markup?

                                  Generic and Specific Tagging.

                                    Which is Better: Generic Markup or Specific Markup?

                                      Underlying Forms.

                                        Embedding Other Kinds of Data.

                                          The Worst DTD in the World?

                                        3. Software Engineering.

                                          DTDs and Patterns.

                                            Reusable Components.

                                              Architectures.

                                                Information Units.

                                                  Cohesion and Coupling.

                                                    Waterfalls and Spirals.

                                                      Diagrams.

                                                        Maler and el Andoloussi's Methodology.

                                                          Exploration and Prototypes.

                                                            Prototyping.

                                                              Exploratory DTD Design.

                                                                The Human Side.

                                                                  Viewpoint Analysis.

                                                                    Scenario Analysis.

                                                                      User Interfaces are Documents.

                                                                        Involvement.

                                                                          Useful Skills.

                                                                        4. Implementation Choices.

                                                                          DTD Style Checklist.

                                                                            Do You Need Full SGML?

                                                                              Almost SGML.

                                                                                Non-Standard Generalized Markup.

                                                                                  HTML.

                                                                                    XML.

                                                                                      Your Own Simplified SGML.

                                                                                        SGML with User Extensions.

                                                                                          Thumbs Rule, OK!

                                                                                            Language Analogy.

                                                                                              Object Relationships.

                                                                                                Occurrence.

                                                                                                  Sequence.

                                                                                                5. The Document in Use.

                                                                                                  Declarations are Not Enough!

                                                                                                    Processing SGML.

                                                                                                      SGML Tools.

                                                                                                        Text Tools.

                                                                                                          Storage Management Tools.

                                                                                                            Hybrid Tools.

                                                                                                              Groovy Steps with SGML.

                                                                                                                The Scrub.

                                                                                                                  The Massage.

                                                                                                                    The Tweak.

                                                                                                                      Growth of DTDs.

                                                                                                                        Top 10 Reasons Why DTDs Fail.

                                                                                                                          Design Principles.

                                                                                                                      II. DOCUMENT PATTERNS.
                                                                                                                        6. Common Attributes.

                                                                                                                          SGML.

                                                                                                                            HTML & XML.

                                                                                                                              XLL.

                                                                                                                                TEI.

                                                                                                                                  SGML Extended Facilities.

                                                                                                                                    Default Value Lists.

                                                                                                                                      Data Attributes for Elements.

                                                                                                                                        Limiting the Target Element Types of IDREFs.

                                                                                                                                          Common Data Attributes.

                                                                                                                                            The Unspecified Attribute.

                                                                                                                                              Paragraphs.

                                                                                                                                                Architectural Forms.

                                                                                                                                              7. The Document Shell.

                                                                                                                                                HTML.

                                                                                                                                                  Information Units.

                                                                                                                                                    The Advantages of a Simple Head.

                                                                                                                                                  8. Paragraphs.

                                                                                                                                                    Paragraphs versus Text Blocks.

                                                                                                                                                      Paragraphs versus Paragraph Groups.

                                                                                                                                                        Paragraph Contents.

                                                                                                                                                          Paragraphs Nested Inside Paragraphs.

                                                                                                                                                            Subparagraphs.

                                                                                                                                                              ID Attributes.

                                                                                                                                                                Development of the Paragraph.

                                                                                                                                                                  Paragraph Breaks.

                                                                                                                                                                    Paragraph Groups Revisited.

                                                                                                                                                                  9. Sequences.

                                                                                                                                                                    Examples of Sequences.

                                                                                                                                                                      Bad Mixed Content.

                                                                                                                                                                        Simplifying the Linear Form.

                                                                                                                                                                      10. Named Data.

                                                                                                                                                                        Fielded Text.

                                                                                                                                                                          Sequences of Fielded Text.

                                                                                                                                                                            Element References.

                                                                                                                                                                              Description Tables.

                                                                                                                                                                                Importing ASCII Dumps.

                                                                                                                                                                                  Schema and Type Extension using Parameter Entities.

                                                                                                                                                                                11. Tables.

                                                                                                                                                                                  Direct Markup versus Element Reference.

                                                                                                                                                                                    Simple HTML-Style Tables.

                                                                                                                                                                                      ICADD Tables.

                                                                                                                                                                                        CALS Tables.

                                                                                                                                                                                          HTML 4 Tables.

                                                                                                                                                                                        12. Interactive Systems.

                                                                                                                                                                                          Entity.

                                                                                                                                                                                            Element.

                                                                                                                                                                                              Processing Instruction.

                                                                                                                                                                                            13. Formal Public Identifiers.

                                                                                                                                                                                              OASIS (SGML Open) Entity Catalogs.

                                                                                                                                                                                                SGML and MIME.

                                                                                                                                                                                              14. Data Content Notations.

                                                                                                                                                                                                Some FPIs for Notations.

                                                                                                                                                                                                  ISO Standard.

                                                                                                                                                                                                    Time and Space.

                                                                                                                                                                                                      Non-Standard.

                                                                                                                                                                                                    15. Formal System Identifiers.

                                                                                                                                                                                                      Formal System Identifiers.

                                                                                                                                                                                                        Becoming an FSI User.

                                                                                                                                                                                                      16. Embedded Notations.

                                                                                                                                                                                                        Naming.

                                                                                                                                                                                                          Stylesheets and Scripts.

                                                                                                                                                                                                            Defining Data Types.

                                                                                                                                                                                                              Lexical Typing using Standard Notation Names.

                                                                                                                                                                                                                Lexical Typing using Lexical Models.

                                                                                                                                                                                                                  HyLex and POSIX Regular Expression Delimiters.

                                                                                                                                                                                                                    An Attribute for Dates using HyLex.

                                                                                                                                                                                                                      Date using POSIX Regular Expressions.

                                                                                                                                                                                                                        Embedding Other Notations.

                                                                                                                                                                                                                          Fragment Interchange.

                                                                                                                                                                                                                        17. Organizing & Documenting DTDs.

                                                                                                                                                                                                                          Core Element Type Sets.

                                                                                                                                                                                                                            Base and Derived DTDs.

                                                                                                                                                                                                                              Architectural Forms.

                                                                                                                                                                                                                                DTD Versions.

                                                                                                                                                                                                                                  Multiple Pass DTDs.

                                                                                                                                                                                                                                    Unaccounted-for Elements.

                                                                                                                                                                                                                                      Simple.

                                                                                                                                                                                                                                        Richer.

                                                                                                                                                                                                                                          Documenting Your DTD.

                                                                                                                                                                                                                                            External Documents.

                                                                                                                                                                                                                                              Comments.

                                                                                                                                                                                                                                                Additional Requirements.

                                                                                                                                                                                                                                                  Descriptions in the Document Instance.
                                                                                                                                                                                                                                              III. CHARACTERS AND GLYPHS.
                                                                                                                                                                                                                                                18. About Characters and Glyphs.

                                                                                                                                                                                                                                                  The ISO Character/Glyph Model.

                                                                                                                                                                                                                                                    Millefiori: 1000 Flowers.

                                                                                                                                                                                                                                                      Modern Printed Scripts.

                                                                                                                                                                                                                                                        Character Repertoire.

                                                                                                                                                                                                                                                          Using Entities.

                                                                                                                                                                                                                                                            Using Elements.

                                                                                                                                                                                                                                                              Characters.

                                                                                                                                                                                                                                                                Collation.

                                                                                                                                                                                                                                                                  Simple Collation for English.

                                                                                                                                                                                                                                                                    Collation for Western European Languages.

                                                                                                                                                                                                                                                                      Fuzzy Transforms.

                                                                                                                                                                                                                                                                        Explicit Markup.

                                                                                                                                                                                                                                                                      19. Typeface, Script, & Language.

                                                                                                                                                                                                                                                                        Typeface.

                                                                                                                                                                                                                                                                          Western.

                                                                                                                                                                                                                                                                            Eastern.

                                                                                                                                                                                                                                                                              Specifying Exact Font.

                                                                                                                                                                                                                                                                                Design Group.

                                                                                                                                                                                                                                                                                  Script Codes.

                                                                                                                                                                                                                                                                                    Language Codes.

                                                                                                                                                                                                                                                                                      Country Codes.

                                                                                                                                                                                                                                                                                        Multilingual Documents.

                                                                                                                                                                                                                                                                                          Inline Localizable.

                                                                                                                                                                                                                                                                                            Interlaced Multilingual.

                                                                                                                                                                                                                                                                                              Multilingual Hyperdocument.

                                                                                                                                                                                                                                                                                                Multilingual World Wide Web.

                                                                                                                                                                                                                                                                                                  TEI Writing System Declaration.

                                                                                                                                                                                                                                                                                                20. The Flowering of Coded Character Sets.

                                                                                                                                                                                                                                                                                                  The Joy of Sets.

                                                                                                                                                                                                                                                                                                    Telegraph Codes: Five-Bit Sets.

                                                                                                                                                                                                                                                                                                      ASCII, EBCDIC, and ISO 646: Seven-Bit Sets.

                                                                                                                                                                                                                                                                                                        ISO 8859, ISCII, JIS X 201: Eight-Bit Sets.

                                                                                                                                                                                                                                                                                                          Extended Eight-Bit Sets.

                                                                                                                                                                                                                                                                                                            Sixteen-Bit Sets.

                                                                                                                                                                                                                                                                                                              Extended Sixteen-Bit Sets.

                                                                                                                                                                                                                                                                                                                Universal Sets.

                                                                                                                                                                                                                                                                                                                  Literals.

                                                                                                                                                                                                                                                                                                                    Character Set and Encodings.

                                                                                                                                                                                                                                                                                                                      WG4 Character Encoding Model.

                                                                                                                                                                                                                                                                                                                        How To Specify Character Encoding.

                                                                                                                                                                                                                                                                                                                      21. Them's the Breaks.

                                                                                                                                                                                                                                                                                                                        Spaces, Words, Hyphens and Lines.

                                                                                                                                                                                                                                                                                                                          Word Segmentation.

                                                                                                                                                                                                                                                                                                                            Joining.

                                                                                                                                                                                                                                                                                                                              Splitting Words and Hyphenation.

                                                                                                                                                                                                                                                                                                                                Finding.

                                                                                                                                                                                                                                                                                                                                  White-space.

                                                                                                                                                                                                                                                                                                                                    Word Segmentation in Chinese.

                                                                                                                                                                                                                                                                                                                                  22. Special Characters & SDATA.

                                                                                                                                                                                                                                                                                                                                    Using SDATA Entities.

                                                                                                                                                                                                                                                                                                                                      SDATA Entity Text.

                                                                                                                                                                                                                                                                                                                                        Quality Assurance on Characters.

                                                                                                                                                                                                                                                                                                                                          Accents.

                                                                                                                                                                                                                                                                                                                                            HTML Entities.

                                                                                                                                                                                                                                                                                                                                              Mathematical Scripts and Symbols.

                                                                                                                                                                                                                                                                                                                                                XML.

                                                                                                                                                                                                                                                                                                                                              23. From Characters To Glyphs.

                                                                                                                                                                                                                                                                                                                                                Glyph Mapping.

                                                                                                                                                                                                                                                                                                                                                  Glyph Selection.

                                                                                                                                                                                                                                                                                                                                                    Glyph Selection with Entities.

                                                                                                                                                                                                                                                                                                                                                      Size.

                                                                                                                                                                                                                                                                                                                                                        Superscripts and Subscripts.

                                                                                                                                                                                                                                                                                                                                                          Color Codes.

                                                                                                                                                                                                                                                                                                                                                            Black, Grays and White.

                                                                                                                                                                                                                                                                                                                                                              Colors.

                                                                                                                                                                                                                                                                                                                                                                Typographical Embellishments.

                                                                                                                                                                                                                                                                                                                                                              24. East Asian Issues.

                                                                                                                                                                                                                                                                                                                                                                Custom Symbols.

                                                                                                                                                                                                                                                                                                                                                                  Extra Characters.

                                                                                                                                                                                                                                                                                                                                                                    Gaiji & User-Defined Characters.

                                                                                                                                                                                                                                                                                                                                                                      Custom Fonts.

                                                                                                                                                                                                                                                                                                                                                                        Marking Up Handwritten Text.

                                                                                                                                                                                                                                                                                                                                                                          Ruby Annotations.

                                                                                                                                                                                                                                                                                                                                                                            Native-Language Markup.

                                                                                                                                                                                                                                                                                                                                                                          Appendixes.
                                                                                                                                                                                                                                                                                                                                                                          Appendix A: ISO Special Characters.

                                                                                                                                                                                                                                                                                                                                                                            Languages

                                                                                                                                                                                                                                                                                                                                                                              Added Latin 1.

                                                                                                                                                                                                                                                                                                                                                                                Added Latin 2.

                                                                                                                                                                                                                                                                                                                                                                                  Greek Letters.

                                                                                                                                                                                                                                                                                                                                                                                    Monotoniko Greek.

                                                                                                                                                                                                                                                                                                                                                                                      Russian Cyrillic Characters.

                                                                                                                                                                                                                                                                                                                                                                                        Non-Russian Cyrillic Characters.

                                                                                                                                                                                                                                                                                                                                                                                          Symbols.

                                                                                                                                                                                                                                                                                                                                                                                            Numeric and Special Graphic.

                                                                                                                                                                                                                                                                                                                                                                                              Publishing.

                                                                                                                                                                                                                                                                                                                                                                                                Diacritical Marks.

                                                                                                                                                                                                                                                                                                                                                                                                  General Technical.

                                                                                                                                                                                                                                                                                                                                                                                                    Chemistry.

                                                                                                                                                                                                                                                                                                                                                                                                      Added Math Symbols: Arrow Relations.

                                                                                                                                                                                                                                                                                                                                                                                                        Added Math Symbols: Binary Operators.

                                                                                                                                                                                                                                                                                                                                                                                                          Added Math Symbols: Opening and Closing.

                                                                                                                                                                                                                                                                                                                                                                                                            Delimiters.

                                                                                                                                                                                                                                                                                                                                                                                                              Added Math Symbols: Negated Relations.

                                                                                                                                                                                                                                                                                                                                                                                                                Added Math Symbols: Ordinary.

                                                                                                                                                                                                                                                                                                                                                                                                                  Added Math Symbols: Relations.

                                                                                                                                                                                                                                                                                                                                                                                                                    Greek Symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                      Alternative Greek Symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                    Appendix B: HTML Special Characters.

                                                                                                                                                                                                                                                                                                                                                                                                                      HTMLspecial.

                                                                                                                                                                                                                                                                                                                                                                                                                        HTMLlat1.

                                                                                                                                                                                                                                                                                                                                                                                                                          HTMLsym.

                                                                                                                                                                                                                                                                                                                                                                                                                            HTMLicon.

                                                                                                                                                                                                                                                                                                                                                                                                                          Appendix C: TEI Special Characters.

                                                                                                                                                                                                                                                                                                                                                                                                                            Basic Arabic Letters.

                                                                                                                                                                                                                                                                                                                                                                                                                              Coptic Letters.

                                                                                                                                                                                                                                                                                                                                                                                                                                Extra Classical Greek Letters.

                                                                                                                                                                                                                                                                                                                                                                                                                                  International Phonetics Alphabet.

                                                                                                                                                                                                                                                                                                                                                                                                                                Appendix D: Index of XML Special Characters. Copyright (C) 1998 Rick Jelliffe


                                                                                                                                                                                                                                                                                                                                                                                                                              [Help]

                                                                                                                                                                                                                                                                                                                                                                                                                              © Prentice-Hall, Inc. A Simon & Schuster Company
                                                                                                                                                                                                                                                                                                                                                                                                                              Comments To webmaster@prenhall.com