dtd « WordPress.com Tag Feed

DTD Tutorial

sadi02 — Sun, 06 Jul 2008 11:34:00 +0000

The purpose of a DTD is to define the legal building blocks of an XML document. It defines the document structure with a list of legal elements. A DTD can be declared inline in your XML document, or as an external reference.

Why use a DTD?

XML provides an application independent way of sharing data. With a DTD, independent groups of people can agree to use a common DTD for interchanging data. Your application can use a standard DTD to verify that data that you receive from the outside world is valid. You can also use a DTD to verify your own data.

There are two type of DTD

Intenal DTD
External DTD

Internal DTD

This is an XML document with a Document Type Definition:

<?xml version="1.0"?>

<!DOCTYPE note [

  <!ELEMENT note    (to,from,heading,body)>

  <!ELEMENT to      (#PCDATA)>

  <!ELEMENT from    (#PCDATA)>

  <!ELEMENT heading (#PCDATA)>

  <!ELEMENT body    (#PCDATA)>

]>

<note>

<to>Tove</to>

<from>Jani</from>

<heading>Reminder</heading>

<body>Don't forget me this weekend!</body>

</note>

The DTD is interpreted like this:
!ELEMENT note (in line 2) defines the element "note" as having four elements: "to,from,heading,body".
!ELEMENT to (in line 3) defines the "to" element to be of the type "CDATA".
!ELEMENT from (in line 4) defines the "from" element to be of the type "CDATA"
and so on.....

External DTD

This is the same XML document with an external DTD:

<?xml version="1.0"?>

<!DOCTYPE note SYSTEM "note.dtd">

<note>

<to>Tove</to>

<from>Jani</from>

<heading>Reminder</heading>

<body>Don't forget me this weekend!</body>

</note>

This is a copy of the file "note.dtd" containing the Document Type Definition:

<?xml version="1.0"?>

<!ELEMENT note (to,from,heading,body)>

<!ELEMENT to (#PCDATA)>

<!ELEMENT from (#PCDATA)>

<!ELEMENT heading (#PCDATA)>

<!ELEMENT body (#PCDATA)>

Declaring Attributes

In the DTD, XML element attributes are declared with an ATTLIST declaration. An attribute declaration has the following syntax:

<!ATTLIST element-name attribute-name attribute-type default-value>

As you can see from the syntax above, the ATTLIST declaration defines the element which can have the attribute, the name of the attribute, the type of the attribute, and the default attribute value.

The attribute-type can have the following values:

Value	Explanation
CDATA	The value is character data
(eval\|eval\|..)	The value must be an enumerated value
ID	The value is an unique id
IDREF	The value is the id of another element
IDREFS	The value is a list of other ids
NMTOKEN	The value is a valid XML name
NMTOKENS	The value is a list of valid XML names
ENTITY	The value is an entity
ENTITIES	The value is a list of entities
NOTATION	The value is a name of a notation
xml:	The value is predefined

The attribute-default-value can have the following values:

Value	Explanation
#DEFAULT value	The attribute has a default value
#REQUIRED	The attribute value must be included in the element
#IMPLIED	The attribute does not have to be included
#FIXED value	The attribute value is fixed

Declaring an Element

In the DTD, XML elements are declared with an element declaration. An element declaration has the following syntax:

<!ELEMENT element-name (element-content)>

Empty elements

Empty elements are declared with the keyword EMPTY inside the parentheses:

<!ELEMENT element-name (EMPTY)>
 
example:
<!ELEMENT img (EMPTY)>

Elements with data

Elements with data are declared with the data type inside parentheses:

<!ELEMENT element-name (#CDATA)>
or
<!ELEMENT element-name (#PCDATA)>
or
<!ELEMENT element-name (ANY)>
example:
<!ELEMENT note (#PCDATA)>

#CDATA means the element contains character data that is not supposed to be parsed by a parser.
#PCDATA means that the element contains data that IS going to be parsed by a parser.
The keyword ANY declares an element with any content.

If a #PCDATA section contains elements, these elements must also be declared.

Elements with children (sequences)

Elements with one or more children are defined with the name of the children elements inside the parentheses:

<!ELEMENT element-name (child-element-name)>
or
<!ELEMENT element-name (child-element-name,child-element-name,.....)>
example:
<!ELEMENT note (to,from,heading,body)>

When children are declared in a sequence separated by commas, the children must appear in the same sequence in the document. In a full declaration, the children must also be declared, and the children can also have children. The full declaration of the note document will be:

<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to      (#CDATA)>
<!ELEMENT from    (#CDATA)>
<!ELEMENT heading (#CDATA)>
<!ELEMENT body    (#CDATA)>

Wrapping

If the DTD is to be included in your XML source file, it should be wrapped in a DOCTYPE definition with the following syntax:

<!DOCTYPE root-element [element-declarations]>
example: 
<?xml version="1.0"?>
<!DOCTYPE note [
  <!ELEMENT note (to,from,heading,body)>
  <!ELEMENT to      (#CDATA)>
  <!ELEMENT from    (#CDATA)>
  <!ELEMENT heading (#CDATA)>
  <!ELEMENT body    (#CDATA)>
]>
<note>
  <to>Tove</to>
  <from>Jani</from>
  <heading>Reminder</heading>
  <body>Don't forget me this weekend</body>
</note>

Declaring only one occurrence of the same element

<!ELEMENT element-name (child-name)>
example
<!ELEMENT note (message)>

The example declaration above declares that the child element message can only occur one time inside the note element.

Declaring minimum one occurrence of the same element

<!ELEMENT element-name (child-name+)>
example
<!ELEMENT note (message+)>

The + sign in the example above declares that the child element message must occur one or more times inside the note element.

Declaring zero or more occurrences of the same element

<!ELEMENT element-name (child-name*)>
example
<!ELEMENT note (message*)>

The * sign in the example above declares that the child element message can occur zero or more times inside the note element.

Declaring zero or one occurrences of the same element

<!ELEMENT element-name (child-name?)>
example
<!ELEMENT note (message?)>

The ? sign in the example above declares that the child element message can occur zero or one times inside the note element.

Declaring mixed content

example
<!ELEMENT note (to+,from,header,message*,#PCDATA)>

The example above declares that the element note must contain at least one to child element, exactly one from child element, exactly one header, zero or more message, and some other parsed character data as well. Puh!

Attribute declaration example

DTD example:
<!ELEMENT square EMPTY>
  <!ATTLIST square width CDATA "0">
 
XML example:
<square width="100"></square>

In the above example the element square is defined to be an empty element with the attributes width of type CDATA. The width attribute has a default value of 0.

Default attribute value

Syntax:
<!ATTLIST element-name attribute-name CDATA "default-value">
 
DTD example:
<!ATTLIST payment type CDATA "check">
 
XML example:
<payment type="check">

Specifying a default value for an attribute, assures that the attribute will get a value even if the author of the XML document didn't include it.

Implied attribute

Syntax:
<!ATTLIST element-name attribute-name attribute-type #IMPLIED>
DTD example:
<!ATTLIST contact fax CDATA #IMPLIED>
 
XML example:
<contact fax="555-667788">

Use an implied attribute if you don't want to force the author to include an attribute and you don't have an option for a default value either.

Required attribute

Syntax:
<!ATTLIST element-name attribute_name attribute-type #REQUIRED>
DTD example:
<!ATTLIST person number CDATA #REQUIRED>
 
XML example:
<person number="5677">

Use a required attribute if you don't have an option for a default value, but still want to force the attribute to be present.

Fixed attribute value

Syntax:
<!ATTLIST element-name attribute-name attribute-type #FIXED "value">
DTD example:
<!ATTLIST sender company CDATA #FIXED "Microsoft">
 
 
XML example:
<sender company="Microsoft">

Use a fixed attribute value when you want an attribute to have a fixed value without allowing the author to change it. If an author includes another value, the XML parser will return an error.

Enumerated attribute values

Syntax:
<!ATTLIST element-name attribute-name (eval|eval|..) default-value>
DTD example:
<!ATTLIST payment type (check|cash) "cash">
 
XML example:
<payment type="check">
or
<payment type="cash">

Use enumerated attribute values when you want the attribute values to be one of a fixed set of legal values.

Validating with the XML Parser

If you try to open an XML document, the XML Parser might generate an error. By accessing the parseError object, the exact error code, the error text, and even the line that caused the error can be retrieved:

var xmlDoc = new ActiveXObject("Microsoft.XMLDOM")
xmlDoc.async="false"
xmlDoc.validateOnParse="true"
xmlDoc.load("note_dtd_error.xml")
 
document.write("<br>Error Code: ")
document.write(xmlDoc.parseError.errorCode)
document.write("<br>Error Reason: ")
document.write(xmlDoc.parseError.reason)
document.write("<br>Error Line: ")
document.write(xmlDoc.parseError.line)

Try it Yourself or or just look at the XML file

Turning Validation off

Validation can be turned off by setting the XML parser's validateOnParse="false".

var xmlDoc = new ActiveXObject("Microsoft.XMLDOM")
xmlDoc.async="false"
xmlDoc.validateOnParse="false"
xmlDoc.load("note_dtd_error.xml")
 
document.write("<br>Error Code: ")
document.write(xmlDoc.parseError.errorCode)
document.write("<br>Error Reason: ")
document.write(xmlDoc.parseError.reason)
document.write("<br>Error Line: ")
document.write(xmlDoc.parseError.line)

DTD manipulation

Maurizio Storani — Thu, 26 Jun 2008 18:28:52 +0000

Document Type Definition (DTD) is one of several SGML and XML schema languages, and is also the term used to describe a document or portion thereof that is authored in the DTD language. A DTD is primarily used for the expression of a schema via a set of declarations that conform to a particular markup syntax and that describe a class, or type, of document, in terms of constraints on the structure of that document. A DTD may also declare constructs that are not always required to establish document structure, but that may affect the interpretation of some documents. XML documents are described using a subset of DTD which imposes a number of restrictions on the document's structure, as required per the XML standard (XML is in itself an application of SGML optimized for automated parsing).

DTD is native to the SGML and XML specifications, and since its introduction other specification languages such as XML Schema and RELAX NG have been released with additional functionality.

As an expression of a schema, a DTD specifies, in effect, the syntax of an "application" of SGML or XML, such as the derivative language HTML or XHTML. This syntax is usually a less general form of the syntax of SGML or XML.

In a DTD, the structure of a class of documents is described via element and attribute-list declarations. Element declarations name the allowable set of elements within the document, and specify whether and how declared elements and runs of character data may be contained within each element. Attribute-list declarations name the allowable set of attributes for each declared element, including the type of each attribute value, if not an explicit set of valid value(s).

Converts a DTD to an XML Schema with dtd2xs

Dtd2Xs allows to convert complex, modularized XML DTDs and DTDs with
namespaces to XML Schemas. As an example of Dtd2Xs conversion check
out DocBook XML Schema generated from XML DocBook DTD V4.2, and XSL-FO
Schema generated from XSL-FO DTD.

Platforms:
Win32, Linux

License:
Free for non-profit activities

dtd2xs example

Using `dtd2xs` to Convert DTD's with Namespaces

To correctly handle namespaces, dtd2xs must be provided with namespace mapping and target namespace prefix information from command-line (it is not possible to deduce it from DTD itself). Default behavior of dtd2xs is to ignore elements with unmapped prefixes.

In the following examples we will use XSL Formatting Objects (XSL-FO) DTD as an example. The DTD file, fo.dtd, contains definition of a standard XSL-FO plus extensions for RenderX XSL-FO renderer. Standard elements and attributes are defined with fo prefix; RenderX extensions use different namespace and have rx prefix.

To make 'pure' XSL-FO Schema, use:

dtd2xs -t fo -m fo:http://www.w3.org/1999/XSL/Format fo.dtd

Note that -t option is used to specify target namespace prefix (fo), and -m option is used to map this prefix into namespace URI.

To make 'full' Schema, which defines both standard XSL-FO constructs and RenderX extensions, use:

dtd2xs -t fo -m fo:http://www.w3.org/1999/XSL/Format -m rx:http://www.renderx.com/XSL/Extensions -i rx:rx.xsd fo.dtd fo+rx.xsd dtd2xs -t rx -m rx:http://www.renderx.com/XSL/Extensions fo.dtd rx.xsd

We actually need two commands here. First one defines mappings for two namespace prefixes (fo and rx). fo is used as a target namespace prefix and additional option -i rx:rx.xsd means "import components with rx prefix from schemaLocation rx.xsd). In the second command, we extract RenderX extensions into the separate schema file rx.xsd, which will be used (imported) by first Schema file fo+rx.xsd. It may look cumbersome, but W3C XML Schema standard does not allow definition of elements for different namespaces in the single Schema file.

Another caveat is handling attributes for which element namespace is different from attribute namespace. Since a validator must be able to reference definitions of such attributes from an imported schema, dtd2xs generates definitions of such attributes at the top level of the schema.

Note

You must specify target prefix and prefix mappings if your DTD contains namespaces. Without this, dtd2xs will probably generate incorrect Schema.

Converts a DTD to an POJO objects with PlainXML

PlainXML represents a pure Java library which includes various lightweight XML processing tools.

Major features are:

Generation of POJO by DTD;
Using typed POJO for manipulation for XML documents in Java;
XML-POJO mapping using either Java5 annotations or DTD with processing instructions;
Ability to access and modify XML document using POJO instead of SAX or DOM;
Custom preprocessing of XML documents using expression language;
Support of “binary” XML format;
RMI friendly XML marshalling;
Export JavaBeans tree to JSON;

PlainXML Examples follow this

Others DTD Tools:

Visual DTD Editor

Design DTDs easily and intuitively with a built-in DTD Editor! The DTD Editor lets you work with text and tree views to review and modify DTD elements, attributes, and properties.

DTD Validator

Validate XML using any DTD processor (MSXML, Microsoft .NET, Xerces, and others)! DTD is easily associated — internally or externally — with any XML document, making DTD validation and syntax-checking a snap.

DTD Generator

Auto-generate DTDs from any XML document using the Stylus Studio DTD generator. DTDs can be automatically inserted using the !DOCTYPE declaration, or you can generate external DTDs for validating multiple XML documents.

Convert DTD to Schema

Convert your legacy DTD data models to the official W3C XML Schema format using built-in DTD to XSD conversion tools. Converting DTD to XML Schema provides support for both built-in and custom data types.

DTD to XML

Use a DTD to create XML documents! A simple DTD-to-XML document wizard gives you a leg-up on even the most complex XML.

DTD Parsers

DTD parsers supported in Stylus Studio include both DOM and SAX-based XML DTD Parsing components. An internal DTD parser helps you quickly validate XML documents, or select from one of several supported DTD validation parsers for XML like MSXML, .NET, and Xerces.

Using DTD in Java

Use the DTDs that you develop in Stylus Studio inside your Java applications. Using Xerces-J, you can easily parse DTDs as part of your XML validation.

Using DTD in Microsoft .NET

The DTDs that you develop in Stylus Studio can be used inside both traditional Microsoft COM-based applications, as well as newer Microsoft .NET applications. DTD parsing can be implemented in .NET, C#, and visual basic.

References:

[http://www.lumrix.net/]

[http://www.soft-amis.com]

[wikipedia.org]

[http://www.stylusstudio.com/]

Mashuper's reality

Keren Dagan — Fri, 30 May 2008 17:28:41 +0000

In his post "Could Someone Explain Technorati" Chris Brogan wonders about the consistency, accuracy and reliability of Technorati service. I can't explain the behavior of the system over there but I can share some of my experience dealing with different challenges using online APIs (web services) and data. The objective here is to help other mashupers to better prepare for future integrations effort across multiple web services. Since it appears that the mashupers community is growing faster than the web service provider I'm sure that more fellow API consumers can share some stories of their own. I will be happy to hear about.

I see three participants perspectives in this "love triangle": the web site visitor, the mashuper (the API consumer) and the service provider.

My visitor experience:

Chris Brogan talks about his experience from the user perspective in his post. I have nothing to add here but I would say that as a service provider, this should be my top concern satisfying my loyal community. Maybe the way to deal with this in the case from Chris's post is by monitoring for exceptions (drastic rise or fall in the rank/authority).

My mashup experience:

As I mentioned in some of my earlier posts (here, here and here) I'm working on a small project for finding productive bloggers by monitoring for consistent improvements in their Technorati rank. So on a frequent basis I monitor the rank for over 800 bloggers now. I plot some of the result to a designated Twitter account: blogmon.
The first set of challenge is dealing with volatile data:

Some times I see no authority in the results (inboundblogs).
Some times there is no valid last update date in the results: <lastupdate>1970-01-01 00:00:00 GMT</lastupdate>
Most time there is no author (the user did not add it)
Some time there are no tags (the user did not add it)
Some time as Chris mentioned the rank is off for a short period of time

For example see Seth Godin's Blog rank history:

last update    rank    authority
2/12/2008    19    8599
2/25/2008    18    8697
3/17/2008    19    8658
3/22/2008    16    8827
4/10/2008    15    8946
4/19/2008    16    8882
4/23/2008     17    8819
5/1/2008    243
5/12/2008     17    8828
5/14/2008     16    8863
5/20/2008    15    8890

These are the details that a consumer of online volatile data must plan and look for ways to compensate for.

Some suggestions:

Check the validity of the date
Don't just count on the last result i.e. search for the last valid result and monitor over time.
Be prepare to plot partial results (e.g. no top tags or author).
Most important: guard your data i.e. protect what that you take from the service and store in your records.

The next set of challenge has to do with the web service behavior:

I get the fowling error once or twice: Unable to read data from the transport connection: An existing connection was forcibly closed by the remote host.
Some API requests come back with:

<HTML>
     <HEAD>
          <META HTTP-EQUIV="REFRESH" CONTENT="2; URL=http://api.technorati.com/bloginfo?url=****&key=****&version=0.9&start=1&limit=30&claim=0&highlight=0">
      <TITLE>****</TITLE>
      </HEAD>
      <BODY>
           <CENTER>
               <IMG SRC="***">
               <BR>
           </CENTER>
     </BODY>
</HTML>

**I intentionally masked the URL, title, image and my developer Key with ****

This result can crash your system if not handled.

Finally: and I get this one a lot:)

<?xml ... "http://api.technorati.com/dtd/tapi-002.xml">
<tapi version="1.0">
    <document>
        <result>
            <error>You have used up your daily allotment of Technorati API queries.</error>
        </result>
    </document>
</tapi>

Some suggestions:

I can't picture my dev world without Exception Handling - this is the ultimate protection against web service unexpected behavior in this specific case. So guard any call, loading XML result and data parsing by wrapping them with a try and catch block.
Logging - log expected and unexpected behavior for later analysis and recovery.
Build the system so exceptions are caught, logged but the execution can move on to the next task.
This is something that I learned from a smart Army office: "If there is a doubt there is no doubt" basically saying that it is better to not report at all than to report inaccurate data.
Find ways to minimize the API calls - e.g. I ask for tags only when I find a blog worth reporting on
A thought: I'm not an expert in XML and DTD but could it be that using DTD slows down the web service. If you know more about it please share with me/us. Is this really necessary on a read only calls?

About the service:

I can't talk much about what that a web service provider feels or experience (I'm sure that Ian Kallen from Technorati has a lot to share about this subject) but I want to say few things:

Please don't get this post wrong I'm a fan of Technorati - I use it and deeply appreciate their service and thankful for having the option using the APIs . As I said earlier the intention is to share from experience and to allow you to better prepare for such effort.
I guess that it is hard to estimate the load on the system with such growth in the number of mashupers out there. So my heart is with them.
There are two more threats that the web service provider needs to protect itself from and I'm sure that those consume some energy: protecting the hard gather data and its environments from abuse and malicious attacks.

One last comment: ironically I had none problems with Twitter so far:) but I'm aware of the pain that some of the Twitter API user suffer occasionally.

Mashuper's reality

Keren Dagan — Fri, 30 May 2008 17:28:41 +0000

I see three participants perspectives in this "love triangle": the web site visitor, the mashuper (the API consumer) and the service provider.

My visitor experience:

My mashup experience:

Some times I see no authority in the results (inboundblogs).
Some times there is no valid last update date in the results: <lastupdate>1970-01-01 00:00:00 GMT</lastupdate>
Most time there is no author (the user did not add it)
Some time there are no tags (the user did not add it)
Some time as Chris mentioned the rank is off for a short period of time

For example see Seth Godin's Blog rank history:

These are the details that a consumer of online volatile data must plan and look for ways to compensate for.

Some suggestions:

Check the validity of the date
Don't just count on the last result i.e. search for the last valid result and monitor over time.
Be prepare to plot partial results (e.g. no top tags or author).
Most important: guard your data i.e. protect what that you take from the service and store in your records.

The next set of challenge has to do with the web service behavior:

I get the fowling error once or twice: Unable to read data from the transport connection: An existing connection was forcibly closed by the remote host.
Some API requests come back with:

<HTML>
     <HEAD>
          <META HTTP-EQUIV="REFRESH" CONTENT="2; URL=http://api.technorati.com/bloginfo?url=****&key=****&version=0.9&start=1&limit=30&claim=0&highlight=0">
      <TITLE>****</TITLE>
      </HEAD>
      <BODY>
           <CENTER>
               <IMG SRC="***">
               <BR>
           </CENTER>
     </BODY>
</HTML>

**I intentionally masked the URL, title, image and my developer Key with ****

This result can crash your system if not handled.

Finally: and I get this one a lot:)

<?xml ... "http://api.technorati.com/dtd/tapi-002.xml">
<tapi version="1.0">
    <document>
        <result>
            <error>You have used up your daily allotment of Technorati API queries.</error>
        </result>
    </document>
</tapi>

Some suggestions:

I can't picture my dev world without Exception Handling - this is the ultimate protection against web service unexpected behavior in this specific case. So guard any call, loading XML result and data parsing by wrapping them with a try and catch block.
Logging - log expected and unexpected behavior for later analysis and recovery.
Build the system so exceptions are caught, logged but the execution can move on to the next task.
This is something that I learned from a smart Army office: "If there is a doubt there is no doubt" basically saying that it is better to not report at all than to report inaccurate data.
Find ways to minimize the API calls - e.g. I ask for tags only when I find a blog worth reporting on
A thought: I'm not an expert in XML and DTD but could it be that using DTD slows down the web service. If you know more about it please share with me/us. Is this really necessary on a read only calls?

About the service:

I can't talk much about what that a web service provider feels or experience (I'm sure that Ian Kallen from Technorati has a lot to share about this subject) but I want to say few things:

Please don't get this post wrong I'm a fan of Technorati - I use it and deeply appreciate their service and thankful for having the option using the APIs . As I said earlier the intention is to share from experience and to allow you to better prepare for such effort.
I guess that it is hard to estimate the load on the system with such growth in the number of mashupers out there. So my heart is with them.
There are two more threats that the web service provider needs to protect itself from and I'm sure that those consume some energy: protecting the hard gather data and its environments from abuse and malicious attacks.

One last comment: ironically I had none problems with Twitter so far:) but I'm aware of the pain that some of the Twitter API user suffer occasionally.

DTD nedir ?

geyik — Sun, 11 May 2008 11:07:54 +0000

DTD nedir?
DTD bir web sayfasının tipini SGML (Standard Generalized Markup Language) dili ile belirler.
DTD, HTML gibi SGML uygulamaları tarafından kullanılır. Amacı sayfa için geçerli olan markup sitilini belirtmektir. XHTML SGML döküman tipinde tanımlanmıştır. Bir XHTML DTD dökümanı sayfada uyulması gereken kuralları, bilgisayarın anlayabileceği bir dille belirtir.

Yazdığınız XHTML dökümanlarının hangi standartlara uyduğunu DTD belirtir ve sayfada ilk satır olarak yer almalıdır. Sayfalarınızın standarda uygunluğu testlerini W3C’nin doğrulama araçları ile yapabilirsiniz. http://validator.w3.org adresinden bu araçlara ulaşabilirsiniz.

Örütbağı üzerinde bir kaç kaynak adresi de işinize yarayacaktır.
W3C XHTML Anasayfa- http://www.w3c.org/MarkUp/
W3C standart bildirgesi - http://www.w3.org/TR/2000/REC-xhtml-basic-20001219/
W3Schools XHTML sayfaları - http://www.w3schools.com/xhtml
Web tasarımcılarının sanal kütüphanesi (WDVL) XHTML sayfaları - http://www.wdvl.com/Authoring/Languages/XML/XHTML/
Webmonkey XHTML Genel Bakış - http://hotwired.lycos.com/webmonkey/00/50/index2a.html
XHTML tartışmaları - http://www.webreview.com/tag/2000/09_01_00.shtml

SGML, HTML and XML (Video tutorial)

adi11235 — Fri, 09 May 2008 22:27:20 +0000

This old guy does a good job explaining things.

Part 1

Part 2

Validando un XML contra un DTD

Christian López Espínola — Sat, 19 Apr 2008 01:46:27 +0000

Para validar un archivo XML contra un DTD desde un sistema con libxml instalado:

$ xmllint --valid --noout test.xmi --dtdvalid 99-10-05.dtd

Cómo agregar archivos DTD (.ini) en TagEditor

Gabo — Mon, 07 Apr 2008 15:57:14 +0000

Este video explica como agregar los archivos DTD en TagEditor. Se trata de los archivos .ini que suele acompañar a los archivos ttx para traducir en TagEditor.

En caso de no poder abrir un archivo ttx porque el software solicita DTD settings, deben pedir el archivo .ini al Project Manager.

A Look Under the Hood of the Hybrid

mvrankin — Fri, 04 Apr 2008 06:02:06 +0000

Got such a good response with the hybrid InCopy-XML workflow, I felt like it was worth revisiting to go into some details. Let's look at the task of creating a new Schema file with XMLSpy.

In The Grand Schema of Things

The whole reason I start with a Schema and not a DTD is that XMLSpy lets you graphically create Schema. It is a heck of a lot easier for a non-programer to do than writing the code from scratch. But I won’t lie to you. You still need to learn something about XML in general and Schema (with a captial "S") in particular. It’s not quite as easy as just drawing a diagram of your content model.

Well, you can draw pretty much whatever you want, but if you don't know the pitfalls, you’ll get validation errors. And without a valid Schema, you can’t create a that user-friendly authoring template that you need to sell your editors on this whole XML workflow thing.

Help!

Learning XMLSpy can be frustrating for someone who’s used to working with programs like Word and the Creative Suite. The rules for making valid code are strict, the error messages and other jargon might as well be written in another language. Which, actually it is. And the Help won’t teach you anything about XML you didn’t already know. It barely teaches you about XMLSpy. It assumes you know all the rules for coding, and just tells you which buttons perform which functions.

You could buy a printed copy of the manual on E-Bay for $108 (Altova doesn't sell 'em). But instead I would recommend you do the tutorial and then keep something like the O’Reilly book XML in a Nutshell within reach at all times, to serve as a de facto manual. That way you can use that $70 for beer and stand just about the same odds of making a useable Schema.

Namespaces

You need to learn about namespaces right off the bat and make them part of your Schema design so you can use InDesign’s feature of mapping XML attributes to paragraph and character styles. This is necessary since not every paragraph is going to look the same in your layout, but they are still all just paragraphs. I'm not going to get deep into namespaces here since I could devote a few posts to nothing but namespace issues I've had.

OK, now that I made it sound hard, let’s make it look easy.

Diagramming a Content Model

We’ll create a basic Schema for a Major League Baseball team, in honor of the World Series Champeen Red Sox. In XMLSpy, choose File > New and pick W3C XSD from the list of file formats.

Enter the name of your root element in our case, baseball_team, and an optional description of it.

At any time you can choose Text view to see or edit the code. That’s when you’re really glad you don’t need to ever see or edit the code. It's like opening up the washing machine while it's running. You just take a peek, maybe throw a pair of socks in there, and close the lid.

Then click the little blue tree icon to show the Schema diagram. This is where the fun begins.

You now have a wide open field in which to draw out all the children of the root element.

Everything is connected automatically, so you won’t have any loose floating pieces. Now you apply all that stuff you learned in your planning meetings, the elements, the attributes, restrictions and relationships they have. You drag out a connector from the baseball_team element, and choose what kind of child it has.

In this case, it’s a sequence (indicated by the line of dots) of two elements, players and coaching_staff.

players is a sequence of position_players and pitchers. position_players is a sequence of infielders, outfielders, and bench, all with an attribute describing the postion they play. You keep going in this manner till you've finished diagramming your content model.

Regarding attributes, if you want to give your editors a pop-up list of values to choose from, enter the legal attribute names in the facets > enumerations tab.

You can also assign minimum and maximum occurrence values to restrict how many of a certain element you’ll allow. In our example, you have to have at least 3 outfielders on your roster to field a team (and pass a validation test). If no number is shown under an element the schema calls for exactly one of that element. Or you can make an element optional by setting the minimum occurrence to zero, like I did with the assistant_manager and the box outline becomes dashed.

Once you are done, you can convert the Schema to a DTD for importing into InDesign, or showing your friends in the bleacher seats.

On second thought, don't show your DTD in the bleacher seats. That conversation probably won't end well.

Of course the devil's in the details, and there are plenty more details, but let's leave it there for now. That wasn't too painful, was it? We made the engine of the hybrid InCopy-XML workflow, a real live W3C XML Schema, without hand coding it.

Test Drive A Hybrid Workflow

mvrankin — Wed, 02 Apr 2008 06:25:55 +0000

You never know where inspiration will come from. Yesterday it came to me in the form of a traffic jam slowing my ride to work. Sitting on the commuter bus, mired in “bumpa-ta-bumpa”, I stared out the window. Life on pause. I imagined the lake of gasoline that was fueling all these cars, puffing out their tailpipes, melting Greenland. Then a shiny red Toyta Prius rolled by. It had a good vibe, like a forward-thinking, best alternative in an otherwise unworkable situation. A hybrid.

This was definitely a sign from the cosmos that it was time to talk about the hybrid XML-InCopy workflow I’d been playing with since last year. I had planned to finish off the cookbook project tonight, but this idea overtook it in my brain. I offer it up now in case any of you out there is stuck in a traffic jam of a publishing workflow, with a line of products and file formats in each other’s way, slowly crawling ahead while the clock ticks ticks ticks.

The point of a hybrid workflow is to combine the virtues of XML and InCopy to give you speed and efficiency that is otherwise impossible. Single-source authoring means multiple print and/or Web products derive and arrive simultaneously from the same set of keystrokes. You author and edit in XML, transform when necessary, and use InCopy to preview your print layouts, where space is finite and styling matters, as you go.

I know there are people out there who have written amazing scripts, or developed plug-ins or workflow systems that can accomplish what I’m going to show you better, faster, with more goodies. But as always, I write about what can you do with the off-the-shelf tools and garden variety skills. Or if you don’t currently possess those skills, you can come by them without completely re-wiring your brain. Perhaps someday Adobe will release the equivalent of an electric car, XML authoring as part of the Creative Suite, and we’ll all be merrily speeding down the Cross-Media Expressway. What follows is my idea of how to do today. And it works. So hop in the hybrid and take it for a spin.

The Pitch

With a W3C XML Schema as the foundation of your workflow, you can develop multiple print and online products simultaneously, and achieve efficiency and savings through content re-use with off-the-shelf tools.

The Tools

To do this you’re going to need InDesign CS3, InCopy CS3, and the Altova MissionKit For XML Developers. The MissionKit is an XML Developer’s equivalent of the Adobe Creative Suite. It’s three applications that work in concert to for the creation and transformation of XML files: XMLSpy, StyleVision, and MapForce. This is a Windows-only package. There is no Mac version, so if you kneel at the altar of Jobs like I do, you need emulation software like Parallels. Syncrosoft’s oXygen is an alternative that runs on the Mac, but only if you don’t need a lot of help writing XSLT. I do. MapForce gives you graphical creation of XSLT, or as I call it, XSLTW (XSL with Training Wheels). I’m not trying to do a commercial for Altova, but their stuff is the only stuff that I know works for everything we’re trying to do.

Step 1: Planning

This is the big one. Map out all your content. Depending on the complexity of your content, this can be a tough job, so you only want to do it once. Spend enough time to get it right, since everything flows downhill from here. Every screw-up or oversight at this stage will echo throughout the workflow in some combination of time, aggravation, or cost. And everyone needs to know that once this is done, there’s no changing the structure, at least not for anyone who wishes to remain with the company.

Your map should show every piece and where it fits into the overall scheme of your project. Map every recombination, and every dependency. Leave no stone unturned. This part can be a real eye opener. If you survive with your sanity intact, you will understand your content better than ever before and maybe discover new ways of using it.

Reverse engineer your own content. Cut up books and move the pieces around as they would move in the digital realm. Follow the life of a lowly paragraph as it appears throughout your product line. Once you grasp the details, you can answer the first key question. What kind of schema best suits your needs: a custom built-from-scratch schema or a generic format? Do you have the time and money to make the former? Do you have the flexibility for the latter? A bad fit might cost you more in the long run. Investigate DocBook and DITA. If you go generic, skip to step 3.

Step 2: Build the Schema File

With the understanding that you gained by mapping your content, you can now build an XML Schema that will guide your authoring, transformation, and output. Why a Schema? Why not a DTD? I have nothing against DTDs. In fact, they are more appropriate for describing book-like things. Schema excel at describing data more than documents. In fact, I love DTDs so much, the other day on the highway I was passed by someone with the license plate 736 DTD, and I thought “hey, that’s cool.” Then I felt the urge to slap myself for being such a geek.

I say use Schema purely because the Altova tools support Schema in ways that they don’t support DTDs. Namely, you can graphically create a Schema in XMLSpy. I feel a little hypocritical because this is the same tool-based thinking I dissed in a previous post. But facts is facts, and until I find another tool that can do this workflow end-to-end with a DTD, I’m sticking to my story. Actually, if you must have a DTD, there is a workaround: build a Schema, then use XMLSpy to convert the Schema to a DTD.

Step 3: Create Authoring Templates

Using StyleVision you take your Schema and apply styling to it to make a user-friendly authoring template. This is something the oXygen can do too. You choose from CSS properties to apply fonts, spacing, and position to your elements. You can make pop-up menus for standardizing choices, and clickable links to insert required elements.

Step 4: Develop Layout Templates

Import sample XML files into InDesign, structure and style it. Set up styles to tags mapping. Make use of the Story Editor to be sure your tagging remains intact and whitespace characters are where they belong.

Step 5: Distribute Authoring Template

Let the writers have at it.

Step 6: Import XML Files into InDesign

And when you do, be sure to maintain the live link, so the XML file appears in the Links panel.

Step 7: Export to InCopy

BUT tell everyone that the InCopy files are untouchable! Hide them. Instead, InCopy users drop the InDesign file onto InCopy to open it directly.

Step 8: Editors Do the InCopy Two Step

Check out the appropriate stories from the InDesign layout. Show the Links panel to see the XML file. Edit in the XML file, save it. Go back to the Links panel and update the link to the XML file. Magic! You have your cake (XML) and eat (publish) it too.

The fact that this works at all is a complete accident--the unintended consequence of 3 InCopy capabilities: access to the links palette (intended for the management of placed images), the ability to use an InDesign layout for preview (so one story can be simultaneously linked to both an XML file and a .incx file), and the ability to maintain a live link to to text files (meant for Word and spreadsheets). Sometimes things just fall into place.

Editors can do some work, like styling, and working with boilerplate (untagged) content in the layout file. But they must understand the fundamental truth that anything they do between the tags in the layout will be wiped out the next time the XML file is saved. Stuff outside the tags, in whitespace elements, remains.

At the end of the day, when all is said and done, you still have intact XML files, with the most up-to-date content, ready to be flowed into whatever template or media you need.

Bonus Points

At any point in this workflow you can use MapForce to create XSLT to transform your content, making it fit another purpose. You don’t need automated workflow systems or scripts to make that transformation happen now that InDesign supports XSLT. Examples of what you can do with XSLT: Making HTML for Web presentation, making PDF, making alternative print products by gathering or sorting content according to attributes, making NIMAS files.

Math Doesn’t Add Up

All this is great, but it will not work for you if you need MathML. The only ways to get MathML in and out of InDesign involve scripted solutions, or customized versions of 3rd party plug-ins like MathMagic. I hope that some day InMath, which has always been my favorite equation editor for InDesign, will add MathML support. Design Science’s MathType speaks fluent MathML, and you can place those equations (in EPS format) into an InDesign layout. PowerMath also exists for InDesign but I haven’t tried it out. Note to self: I should do a future post comparing all the different ways to do math in InDesign.

Next Steps

My next project (if ever stop spending all my free time blogging) is to experiment with Office Open XML. Since the new version of Office has XML underlying every file format, why not exploit that, and author in Word, transform OOML to your Schema, then import in InDesign, Web, etc. It should work like a charm, and it’ll probably have authors and editors breathing a sigh of joyful relief that the XML authoring tool they have to use is Word. It may not be the electric car, but it’s pretty close to one of those that runs on old french fry oil. Mmmm, I could go for some fries right now.

I'm addicted to: Desktop Tower Defense

Lau — Mon, 24 Mar 2008 18:09:13 +0000

This one came to me from a co-worker. We were talking about video games and he mentioned he played Desktop Tower Defense (DTD) and asked if we ever played it.

Well, I hadn't, so I checked it out. It is awesome!!

I've been playing for a few weeks and have to admit that I spend too much of my regular work time on it.

So go check it out and have fun!!

On why HTML and XML have succeeded, and the lessons therein

Max — Thu, 20 Mar 2008 05:21:01 +0000

Why have HTML and XML succeeded? I believe it is a combination of four things:

Accessibility

There is almost no barrier to entry. Notepad and IE and you're in business.

Resiliance

Tolerance for error. Most mistakes you can make in HTML won't prevent your page from displaying. Unlike most programming languages, HTML will let you be and remain imperfect and continue to make progress. XML is tolerant in a different way. The syntax is more rigorous, but also very, very simple and regular, so XML is tolerant of conceptual errors, which, again, don't prevent you from making progress.

Broad tiers of utility at different skill levels

You can do a lot of HTML and know nothing of cascading style sheets. But once you know them, there is a rich set of new things you can do. You can learn a small set of things, and get a lot of mileage from the knowledge. With each tier, each quantum of skill, there is a broad new plateau that opens.

You can go deep

This is a corollary of the previous point. From HTML there are cascading style sheets, and Javascript, and you can move to the server and find Linux Apache MySQL and PHP, and there is almost no end to how deep. From basic XML there Data Type Definitions and then Schemas, there are XSLTs and XPath and again, a long path with almost no end. And again, for each step, there is a broad range of new function that is available.

So what is the lesson? Keys to success for a new development technology:

Give users a low barrier to entry using tools with which they are already skilled.
Give them a broad range of utility with the first step in skill.
Give them visible success depite their errors.
Give them a new plateau of function with each stepwise gain in skill.
Give them a path to go deep.

Na? Was ist Pi?

kenny1987 — Mon, 17 Mar 2008 07:54:09 +0000

Nicht 3.14... , nicht 3 und auch nicht 42. Sondern 12 :

zumindest in den SGML-Klassen von Java6. Dort meint PI allerdings etwas anderes als die Zahl, nämlich eine Document Processing Instruction. Trotzdem lustig :)

Happy Birthday Desktop Tower Defense!

Paul — Tue, 11 Mar 2008 20:11:20 +0000

DTD is one year old this week! In this post I talk about how the game came to be, how it grew, how many plays it has and how much money it has earned...

DTD was 'launched' by uploading the link to StumbleUpon.com on the 5th March 07. I was at a LAN party at the time and looking back at it now I really should have noticed that perhaps DTD was a little bit special because a lot of the gamers were playing it rather than blowing holes in each other at Counterstrike. Unfortunately they were still shouting and cursing but this time at the audacity of the flying creeps avoiding their mazes. :o)

At the time I was working for a small software company as a Visual Basic developer. I had watched my good friend Dave Scott code Flash Element TD during December and the massive popularity of it's launch in January spurred me on to create my own TD. I spent February learning Flash 8 and, with a little help from Dave, coding DTD 1.0. The original name for game was actually going to be Paper TD. I had quickly decided on a hand drawn look for the towers and situating the game on paper or a notepad seemed a logical choice.

But I felt the game seemed quite flat so I decided to try a view that gave more depth:

Yuck. But fortunately serendipity stepped in and the next attempt produced not only the new background but also a new name, Desktop Tower Defense!

To complete the launch I created a simple website to provide instructions and scoreboards. It was later expanded to include a forum and group scoreboards. I launched DTD in the same way that Dave had which was to simply post the link up to StumbleUpon.com. That produced some small steady traffic over the first few hours but then a Scandinavian website linked to it (very quick to catch new games those guys) and by the end of the first day it had received 30,000 hits. At the time, it was an amazing thing and I remember spending most of the day (and then the week) F5'ing my stat pages! After a few days the site was dugg on Digg.com (killed the server) and was up to 40,000 hits per day. All the activity made it difficult to not improve the game so I started rolling out updates.

Version 1.02 was launched two weeks later which incorporated some new modes and started to fix holes that were being used for hacked/exploited scores. It was dugg again, and pushed above 60K per day.

Version 1.2 was launched two weeks after that and things went crazy for a while. I had upgraded my server from a celeron to a Pentium 4 HT (ooooh) but the 3rd digg killed it yet again, (Probably my poor database code) and the site peaked at over 200,000 pages per day. If you are interested in the stats for the year here they are:

At this point I started to get more serious about earning some money! I already had MochiAds running on the game so I added AdSense ads and a donation box. I tried an affliate program from a t-shirt website but it didn't work out. Over the next couple of months I put out some more bug fixes and added the group & challenge scoreboards to the site. DTD remained at version 1.2. I expected the popularity of DTD to drop off but, after a pause, it carried on going up. It was mentioned on a few popular blogs/sites such as TechCrunch and GigaOm. I did an interview on how much the game was making (which was quoted wildly inaccurately by most other sites) and my work place found out about it. Oops. To cut a short story even shorter I looked at how much DTD was earning, thought 'yeah I can mostly live on that' and decided to quit.

All the activity around DTD spurred me on again to create a new version. Which, as I was depending on the earnings from the game and a games developer (chortle) full time, I thought I should make it look more professional. Version 1.5 was released at the end of June and was much faster, prettier and better all round. Unfortunately the keen DTD'ers hated it! For a month I received hundreds of mails and forum posts complaining about how I had ruined the game. They hated the new design, the new creeps, the new towers and the new modes. Even TechCrunch didn't like it. Bah. In the end I made both the old and the new versions available to keep everybody happy. Most players are now playing 1.5 (and agree its the better version :o).

I had also agreed a sponsorship deal with Kongregate.com for 1.5 which brought in some welcome extra money. The revenue I received from DTD varied quite dramatically through out the year and has proven to be the most frustrating part of the whole experience. This is a graph showing how much was earned per load during the course of the year:

Aah yes half a cent per load, those were the good ol' days. Those of you who run websites will probably have worked out that the current earnings of 0.2 cents per load is equivalent to a CPM of $2. Which I don't think is bad for a single flash game. Imagine if I had two!

My total earnings from DTD for the year from MochiAds, on-site advertising, sponsorship and donations has amounted to just over $100K from 40M loads. Which is nice.

In part 2 I will talk about my dealings with game publishers, licensing headaches, going to the GDC and what is in store for 2008.

I am going acronym crazy, Implementing Adage ATF files using XML

mellerbeck — Tue, 12 Feb 2008 22:09:47 +0000

So our ERP can accept XML files. So I am trying to figure out how to get the X12 doc into the proper XML form. Luckily I have altova mapforce, and I recently just downloaded the trial of Altova XML Spy... I'll probably end buying it as well, I wonder if they will let me take advantage of their package pricing even though I already bought a single version of Mapforce by itself? Anyways since the ERP provided a DTD (Document Type Definition) I found out that you can use XMLSpy to convert a DTD into an XSD which MapForce can use as an XML structure definition. And right now while typing I just realized that MapForce can also accept DTD file so I will just skip that step.

So now I just need to drag my EDI over to the DTD and tada the import will be complete!

Altova Mapforce is the best!

"W3C Gets Excessive DTD Traffic"...

jp — Sat, 09 Feb 2008 12:02:46 +0000

Sul solito Slashdot è apparso un post a tratti esilarante...

Intitolato "W3C Gets Excessive DTD Traffic", rimanda ad una pagina "ufficiale" sul sito del W3C in cui si parla di un certo "problemino"...

A quanto pare il W3C viene letteralmente sommerso di verifiche di DTD.

Cerchiamo di capirci...

Chi "mastica" codice-con-i-tag tutti i giorni ben saprà che, ad esempio, ogni file XHTML che ben si rispetti inizia con qualcosa tipo:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

In parole povere, quel file XHTML verrà controllato, verificando se rispetta uno schema apposito (DTD) che si trova a quell'indirizzo del W3C.

Leggendo sempre sul sito W3C, appare questa frase, che francamente mi ha fatto veramente ridere:

Note that these are not hyperlinks; these URIs are used for identification. This is a machine-readable way to say "this is HTML".

Trascuriamo la sottigliezza per cui un URL (usato guarda caso per gli hyperlink) sia una sottocategoria di URI... Sorvoliamo anche sul fatto che poi uno "non ci debba sempre e per forza cliccare sopra" (sto semplificando, ovviamente) ogni volta che lo vede...

Cioè, fammi capire, ... imponi che chi scrive un file XHTML standard "citi" il tuo indirizzo di casa e poi ti lamenti se tanta (troppa) gente viene da te a controllare se rispetta o meno quello che tu hai imposto?

Ringrazia piuttosto la maggior parte dei browser, che mantiene in cache quel DTD e ti risparmia già moltissime (inutili) richieste!

Ce n'è di gente che sta male... :P

PS: leggere l'articolo sul sito del W3C mi ha fatto davvero ridere, tuttavia ne consiglio un'attenta lettura a tutti i Webmaster. Contiene diversi suggerimenti interessanti. Buona lettura! :P

Instalación y Configuración de Apache Tomcat 6.0 en Windows XP

jcalderon — Fri, 04 Jan 2008 09:20:35 +0000

En este post tratare algunos aspectos importantes en la instalaciòn y configuración Apache Tomcat versión6.0:

Es un servidor web (http) y funciona como un contenedor de servlets. Es la implementación de referencia de las especificaciones de servlets 2.5 y de Java Serves Pages (JSP) 2.1, especificaciones para Java Community Process, usado como servidor web autónomo en entornos con alto nivel de tráfico y alta disponibilidad.

Dado que Apache Tomcat fue escrito en Java, funciona en cualquier sistema operativo que disponga de la máquina virtual Java.

Download:
Java Platform, Standard Edition 6 Development Kit (JDK 6). Debe instalarse previo a la instalación de apache-tomcat.
Apache-tomcat-6.0.14. No descargar la versión que lo instala como un servicio de Windows si se va a usar para desarrollar. Recomiendo Descargar la versión que se instala manualmente descomprimiendo un zip (Windows) o un tar.gz (Linux).

Descomprimir el archivo apache-tomcat. Ejemplo:

Acceder al directorio donde se a descomprimido. Ejemplo:

$CATALINA_HOME = Representa la raiz donde se ha instalado apache-tpmcat.
Cada uno de los directorios de la imagen 4 tienen su respectivo significado:

/bin - arranque, cierre, y otros scripts y ejecutables
/temp – archivos temporales
/conf – archivos XML y los correspondientes DTD para la configuración de apache-tomcat el mas importante es server.xml.
/logs – archivos de registro (log) de apache-tomcat.
/webapps - directorio que contiene las aplicaciones web
/work - almacenamiento temporal de ficheros y directorios

El siguiente paso quizás es uno de los mas importantes y es la creación de la variable de entorno JAVA_HOME. Ejemplo:

JAVA_HOME = directorio del JDK.

Para acceder a la creación de la variable de entorno: Windows+Pausa>Opciones Avanzadas>Variables de Entorno>Nueva

Existen dos archivos sumamente importantes los cuales nos permitirán iniciar y parar apache-tomcat se encuentra en el siguiente directorio.

$CATALINA_HOME/bin/startup = para iniciar o arrancar
$CATALINA_HOME/bin/shutdown = para parar o detener

Seguidamente abrimos un navegador web y escribimos en el URL.

http://{host}:{port}/ = donde {host}{port} representa el hostname y el puerto donde corre apache-tomcat, entonces quedaría http://localhost:8080/ y aparecerá la pagina de bienvenida de apache-tomcat.

Nota: Recuerda iniciar apache-tomcat o de lo contrario se producirá un ERROR.

Para poder acceder a las aplicaciones de gestión y administración de apache-tomcat es necesario crear un usuario accediendo al siguiente directorio.

$CATALINA_HOME/conf/tomcat-users.xml = este archive permite crear un username, password and roles

Entre la etiqueta tenemos que agregar la linea que permitirá crear un usuario. Ejemplo:

Procedemos a parar e iniciar apache-tomcat > http://localhost:8080/ en el navegador > clic en Tomcat Manager > debemos ingresar el username and password anteriormente creado en el archivo tomcat-users.xml.

Quedaría algo así. Ejemplo:

Finalmente pongo la Referencia en donde me he basado para este post

{http://tomcat.apache.org/}

Xml validation with Schematron without a hassle

Danil Glinenko — Thu, 06 Dec 2007 08:29:10 +0000

Recently I've been looking for XML validation solution. Yes, there are many out of there. But I've been looking for the best one.This is what's drawn my attention:

Document Type Definition (DTD) - XML's built-in schema language
- Pros and cons:
  - Not easy for interpreting by humans;
  - Doesn't provide data validation, provides only structure validation;
  - Non-XML syntax;
  - Doesn't have good support of namespaces.
W3C XML Schema (WXS) - an obect-oriented XML schema language. WXS also provides a type system for constraining the character data of an XML document. WXS is maintained by the World Wide Web Consortium (W3C) and is a W3C Recommendation (that is, a ratified W3C standard specification)
- Pros and cons:
  - Xml based syntax;
  - Has data validation;
  - Too restrictive, precise, verbose;
  - Provides very weak support for unordered content;
  - Too long learning curve;
  - It's not easy to write.
RELAX NG (RNG) - a pattern-based, user-friendly XML schema language. RNG schemas may also use types to constrain XML character data. RNG is maintained by the Organization for the Advancement of Structured Information Standards (OASIS) and is both an OASIS and an ISO (International Organization for Standardization) standard.
- Pros and cons:
  - Still grammar based;
  - Uses XML syntax to represent schemas;
  - Supports data-typing;
  - Integrates attributes into content models;
  - Supports XML namespaces;
  - Supports unordered content;
  - Supports context-sensitive content models;
  - Simple syntax and relatively easy for reading by humans;
  - Data types are not part of RELAX NG, but can be specified in a modular fashion.
Schematron - a rules-based XML schema language. Whereas DTD, WXS, and RNG are designed to express the structure of a content model, Schematron is designed to enforce individual rules that are difficult or impossible to express with other schema languages. Schematron is intended to supplement a schema written in structural schema language such as the aforementioned. Schematron is in the process of becoming an ISO standard.
- Pros and cons:
  - Allows directly expressing rules w/o creating a whole grammar;
  - Very flexible;
  - More expressive even than RELAX NG;
  - Relies almost entirely on XPath query patterns for defining rules and checks;
  - Assertion based;
  - Short learning curve;
  - Trivial to implement on top of XSLT.

Considering all pros and cons I really was between RELAX NG and Schematron. WXS is too restrictive and verbose for my needs and I wasn't going to map XML structures to any data objects. DTD isn't worth at all. I needed something simple and flexible with short learning curve and easy to use. The more I'm looking at Schematron the more I like it. It's not grammar-based like RELAX or WXS. It based on XPATH, assertion and rules.Writing Schematron schema to me is like writing unit-tests. You make assumptions about the structure of your XML and check them with assertion. It's very flexible approach you can check only those thing you actually care about. It requires a little different view on XML validation process and you'll need to get used to it. But hey! it's cool. So, try it.This is example from an tutorial on Developer works.

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.ascc.net/xml/schematron">
  <title>Technical document schema</title>
    <pattern id="rightdoc" name="Document root">
      <!-- Validates that ROOT element named as "doc" -->
      <rule context="/">
        <assert test="doc">Root element must be "doc".</assert>
      </rule>
    </pattern>
    <pattern id="extradoc" name="Extraneous docs">
      <rule context="doc">
      <!-- Validates that "doc" element is only allowed at the ROOT -->
        <assert test="not(ancestor::*)">
        The "doc" element is only allowed at the document root.
        </assert>
      </rule>
    </pattern>
    <pattern id="majelements" name="Major elements">
      <rule context="doc">
        <assert test="prologue">
        <name/> must have a "prologue" child.
        </assert>
        <assert test="section">
        <name/> must have at least one "section" child.
        </assert>
      </rule>
    </pattern>
    <!-- Validating for a certain number of elements -->
    <pattern name="Minimum keywords">
      <rule context="prologue">
        <assert test="count(keyword) > 2">
          At least three keywords are required.
        </assert>
      </rule>
    </pattern>
	<!-- Validating a sequence of elements. following-sibling::*[1], selects the element immediately following the context (title).
The next step, self::subtitle, ensures that this element is a subtitle.-->
    <pattern name="Title with subtitle">
      <rule context="title">
        <assert test="following-sibling::*[1]/self::subtitle">
          A "title" must be immediately followed by a "subtitle".
        </assert>
      </rule>
    </pattern>
</schema>

Isn't this cool?

Estructura del html y primeros pasos del css

donestandares — Wed, 05 Dec 2007 19:29:46 +0000

Hi!, Ahora vamos a comenzar con todo el cuento de la creación de paginas web con css, lo primero es lo primero. crear un documento en dreamweaver... ó si usas archivos de texto pues creas un index.html

Ahora, como sabes... todo tiene un orden, las etquetas html también, todo html inicia con algo llamado DOCTYPE, son algunas indicaciones como el documento y unos estandares que se manejan para el html, generalmente... para todo html se maneja la siguiente etiqueta:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transición//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

La anterior etiqueta SIEMPRE va al comienzo de todo documento html, Ahora hay un dato importante. Recuerdas el xml, del que tanto hablan, pues para los que noconosen el xml es un estandar y este maneja etiquetas a la hora de escribirse, por ejemplo los RSS estan basados en xml, entonces digamos en un documento xml tenemos que insertar NOMBRE, APELLIDOS, según las especificaciones el xml debería ir así, con etiquetas según la info que vamos a escribir: <nombre>Andrés</nombre><apellido>Lara</apellido>, si analizamos la etiqueta cuando quiero terminar el contenido la cierro con una etiqueta similar, pero precedida con un / , esto nos indica que la etiqueta termino, ejemplo: <comentario>"Hola pedrito como vas?"</comentario>, ahí el comentario termina con </comentario>, así se puede entender donde comienza las cosas y donde terminan, entonces estos genios... del html comenzaron a trabajar en el html y descubrieron que el html podía ser un xml... ósea si yo comienso una etiqueta la cierro con un </, y todo se dio para que crearan algo llamado xhtml, que quiere decir... un html muy parecido al xml.

Volviendo al tema :P la siguiente etiqueta es la html, que es la que me dice si el documento html que estoy haciendo es HTML ó es XHTML, como nosotros vamos a la delantera, y queremos descrestar a todos, vamos a usar el xhtml que es le mas estandar, el que todos usan, así que si en la calle te dicen "OYE TRABAJAS CON HTML, no! eso es del pasado yo trabajo con xhtml!", entonces seguimos, la etiqueta html va con esta estructura:

Recuerda que esta etiqueta HTML esta abierta hasta el final, solo se cierra en el ultimo punto, a continuación vemos una etiqueta llamada HEAD y esta etiqueta maneja como su nombre lo dice en español CABEZA en español, esta etiqueta hasta donde se cierra maneja todo lo relacionado con titulos... iconos y otras vainas que a continuación vamos a ver, la estructura del head es simple solo abrimos la etiqueta:

<head>

Ahora vamos con las etiquetas META, son etiquetas que sirve para dar algunos detalles del documento XHTML por ejemplo con la etiqueta META podemos manejar las palabras claves... el autor... y la descripción del sitio, por que no me puedo demorar mucho en la explicación les dejo dos enlaces relacionados con HEAD y con META

Etiqueta head

Etiquetas meta

Y la estructura de las etiquetas meta viene siendo así:

Ahora si vamos con una etiqueta importante, la etiqueta TITLE , etiqueta fundamental si queremos hablar del titulo del documento XHTML , ¿Si han visto en las paginas web que aparece el titulo del sitio en la ventana del navegador?, esto lo podemos hacer mediante la eqitueta TITLE , su estructura es la siguiente:

<title>La empresa de mi papa.com</title>

Ahora seguimos con algo que es muy importante entender... por eso es necesario que antes de continuar, creemos una nueva carpeta en donde estamos alojando el index.html, la carpeta deve llamarse "css", sin comillas, en esta carpeta vamos a guardar los archivos css necesarios a lo largo de toooooodo el blog.

dentro de la carpeta css, crea un archivo llamado: "principal.css", sin comillas, y a continuación dentro del archivo inserta el siguiente código:

@charset "utf-8";
/* CSS Document */

Esa porción de código SIEMPRE deve ir SIEMPRE, ahora que creamos el archivo .css continuamos en index.html, ahora para llamar al archivo css que acabamos de crear, utilizamos una instrucción muy simple:

Con esta instrucción, estamosagregando el archivo css, con esto permitimos que el archivo css quede en el caché, como algunas imagenes.

Ahora el paso ultimo seria cerrar la etiqueta </head>, para indicar que hasta ahí va todo.

A continuación abrimos una etiqueta llamada BODY, y el código seria así:

<body>

Repasemos hasta ahora como tenemos el código aproximadamente:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es-ES" lang="es-ES">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="author"
CONTENT="WebMaster de Los Alpes">
<meta name="keywords" CONTENT="viajes, ofertas, Los Alpes, Orlando, Nueva Zelanda">
<meta name="description" CONTENT="La agencia de viajes Los Alpes tiene un gran prestigio en el mundo de las empresas y combina una gran calidad con unos excelentes precios.">
<link rel="shortcut icon" href="img/favicon.ico" mce_href="img/favicon.ico" type="image/x-icon" />
<title>La empresa de mi papa</title>

Ahora dentro del body va el contenido del xhtml, desde tablas hasta imagenes, todo lo que vayamos a trabajar, lo anteriormente colocado es esencial para poder laborar con estos documentos ya que se hace gura que aya compatibilidad entre navegadores y entre dispositivos anteriormente comentados.

Para cerrar solo quedaría colocar las etiquetas finales que seria finalizar la etiqueta BODY y HTML:

</body>
</html>

y pues el código quedaría algo así:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es-ES" lang="es-ES">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<meta name="author"
CONTENT="WebMaster de Los Alpes">
<meta name="keywords" CONTENT="viajes, ofertas, Los Alpes, Orlando, Nueva Zelanda">
<meta name="description" CONTENT="La agencia de viajes Los Alpes tiene un gran prestigio en el mundo de las empresas y combina una gran calidad con unos excelentes precios.">
<title>La empresa de mi papa</title>
<style type="text/css" media="screen">

</style>
</head>
<body>

</body>
</html>

Espero que les aya servido para comenzar, APENAS ES LO BASICO, mas adelante iremos con mas, mañana comenzamos ya completamente con las clases :P chau!.

Qu'est-ce que XML Schema ?

Sarah Haïm-Lubczanski — Wed, 28 Nov 2007 16:54:07 +0000

Il s'agit en fait d'une initiative du W3C, visant à décrire l'ordonnance des balises possibles dans un fichier XML, directement en XML. En fait, il s'agit d'une DTD en XML.

dtd « WordPress.com Tag Feed

DTD Tutorial

Why use a DTD?

Internal DTD

External DTD

Declaring Attributes

Declaring an Element

Empty elements

Elements with data

Elements with children (sequences)

Wrapping

Declaring only one occurrence of the same element

Declaring minimum one occurrence of the same element

Declaring zero or more occurrences of the same element

Declaring zero or one occurrences of the same element

Declaring mixed content

Attribute declaration example

Default attribute value

Implied attribute

Required attribute

Fixed attribute value

Enumerated attribute values

Validating with the XML Parser

Turning Validation off

DTD manipulation

Converts a DTD to an XML Schema with dtd2xs

dtd2xs example

Using dtd2xs to Convert DTD's with Namespaces

Note

Converts a DTD to an POJO objects with PlainXML

PlainXML Examples follow this

Others DTD Tools:

References:

[http://www.lumrix.net/]

[http://www.soft-amis.com]

[wikipedia.org]

[http://www.stylusstudio.com/]

Mashuper's reality

My visitor experience:

My mashup experience:

About the service:

Mashuper's reality

My visitor experience:

My mashup experience:

About the service:

DTD nedir ?

SGML, HTML and XML (Video tutorial)

Validando un XML contra un DTD

Cómo agregar archivos DTD (.ini) en TagEditor

A Look Under the Hood of the Hybrid

Test Drive A Hybrid Workflow

I'm addicted to: Desktop Tower Defense

On why HTML and XML have succeeded, and the lessons therein

Na? Was ist Pi?

Happy Birthday Desktop Tower Defense!

I am going acronym crazy, Implementing Adage ATF files using XML

"W3C Gets Excessive DTD Traffic"...

Instalación y Configuración de Apache Tomcat 6.0 en Windows XP

Xml validation with Schematron without a hassle

Estructura del html y primeros pasos del css

Qu'est-ce que XML Schema ?

Using `dtd2xs` to Convert DTD's with Namespaces