HTML allows to mark up (or describe) the structure of a human-readable web document or web user interface, while XML allows to mark up the structure of all kinds of documents, data files and messages, whether they are human-readable or not. XML can also be used as the basis for defining a version of HTML that is called XHTML.
XML provides a syntax for expressing structured information in the form of an XML document with nested elements and their attributes. The specific elements and attributes used in an XML document can come from any vocabulary, such as public standards or (private) user-defined XML formats. XML is used for specifying
document formats, such as XHTML5, the Scalable Vector Graphics (SVG) format or the DocBook format,
data interchange file formats, such as the Mathematical Markup Language (MathML) or the Universal Business Language (UBL),
message formats, such as the web service message format SOAP
XML is based on Unicode, which is a platform-independent character set that includes almost all characters from most of the world's script languages
including Hindi, Burmese and Gaelic. Each character is assigned a unique integer code in the range between 0 and 1,114,111. For example, the Greek
letter π has the code 960, so it can be inserted in an XML document as
π using the XML
Unicode includes legacy character sets like ASCII and ISO-8859-1 (Latin-1) as subsets.
Almost all Unicode characters are legal in a well-formed XML document. Illegal characters are the control characters with code 0 through 31, except for the carriage return, line feed and tab. It is therefore dangerous to copy text from another (non-XML) text to an XML document (often, the form feed character creates a problem).
Generally, namespaces help to avoid name conflicts. They allow to reuse the same (local) name in different namespace contexts. Many computational languages have some form of namespace concept, for instance, Java and PHP.
XML namespaces are identified with the help of a namespace URI, such as the SVG namespace URI
"http://www.w3.org/2000/svg", which is associated with a namespace prefix, such as
svg. Such a
namespace represents a collection of names, both for elements and attributes, and allows namespace-qualified names of the form prefix:name, such as
svg:circle as a namespace-qualified name for SVG circle elements.
This example shows the start tag of the HTML root element, in which the XHTML namespace is declared as the default namespace.
The following example shows an SVG namespace declaration for an
svg element embedded in an HTML document:
<html xmlns="http://www.w3.org/1999/xhtml"> <head> ... </head> <body> <figure> <figcaption>Figure 1: A blue circle</figcaption> <svg:svg xmlns:svg="http://www.w3.org/2000/svg"> <svg:circle cx="100" cy="100" r="50" fill="blue"/> </svg:svg> </figure> </body> </html>
XML defines two syntactic correctness criteria. An XML document must be well-formed, and if it is based on a grammar (or schema), then it must also be valid with respect to that grammar, or, in other words, satisfy all rules of the grammar.
There must be exactly one root element.
Each element has a start tag and an end tag; however, empty elements can be closed as
<phone/> instead of
Tags don't overlap. For instance, we cannot have
Attribute names are unique within the scope of an element. For instance, the following code is not correct:
<attachment file="lecture2.html" file="lecture3.html"/>
it is well-formed,
and it respects the grammar.
The World-Wide Web Committee (W3C) has developed the following important versions of HTML:
2000: XHTML 1 as an XML-based clean-up of HTML 4,
2014: (X)HTML 5 in cooperation (and competition) with the WHAT working group supported by browser vendors.
HTML was originally designed as a structure description language, and not as a presentation description language. But HTML4 has a lot of purely presentational elements such as
has been taking HTML back to its roots, dropping presentational elements and defining a simple and clear syntax, in support of the goals of
We adopt the symbolic equation
HTML = HTML5 = XHTML5
stating that when we say "HTML" or "HTML5", we actually mean XHTML5
because we prefer the clear syntax of XML documents over the liberal and confusing HTML4-style syntax that is also allowed by HTML5.
The following simple example shows the basic code template to be used for any HTML document:
<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> <head> <meta charset="UTF-8" /> <title>XHTML5 Template Example</title> <meta name="viewport" content="width=device-width, initial-scale=1"/> </head> <body> <h1>XHTML5 Template Example</h1> <section><h2>First Section Title</h2> ... </section> </body> </html>
Notice that in line 1, the HTML5 document type is declared, such that browsers are instructed to use the HTML5 document object model (DOM).
html start tag in line 2, using the default namespace declaration attribute
xmlns, the XHTML namespace URI
http://www.w3.org/1999/xhtml is declared as the default namespace for making sure that browsers, and other tools, understand that all
non-qualified element names like
body, etc. are from the XHTML namespace.
Also in the
html start tag, we set the (default) language for the text content of all elements (here to "en" standing for
English) using both the
xml:lang attribute and the HTML
lang attribute. This attribute duplication is a small price to
pay for having a hybrid document that can be processed both by HTML and by XML tools.
Finally, in line 4, using an (empty)
meta element with a
charset attribute, we set the HTML document's character
encoding to UTF-8, which is also the default for XML documents.
For user-interactive web applications, the web browser needs to render a user interface (UI). The traditional metaphor for a software
application's UI is that of a form. The special elements for data input, data output and
user actions are called form controls or UI widgets. In HTML, a
form element is a section of a web page consisting of block elements that
contain form controls and labels on those controls.
Users complete a form by entering text into input fields and by selecting items from choice controls, including dropdown selection lists, radio button groups and
checkbox groups. A completed form is submitted with the help of a submit button. When a
user submits a form, it is normally sent to a web server either with the HTTP GET method or with the HTTP POST method. The standard encoding for
the submission is called URL-encoded. It is represented by the Internet media type
application/x-www-form-urlencoded. In this encoding, spaces
become plus signs, and any other reserved characters become encoded as a percent sign and hexadecimal digits, as defined in RFC 1738.
Each form control has both an initial value and a current value, both of which are strings. The initial value is specified with the control
value attribute, except for the initial value of a
textarea element, which is given by its initial contents.
The control's current value is first set to the initial value. Thereafter, the control's current value may be modified through user interaction or
scripts. When a form is submitted for processing, some controls have their name paired with their current value and these pairs are submitted with
Labels are associated with a control by including the control as a child element within a
(implicit labels), or by giving the control an
id value and referencing this ID in the
attribute of the
label element (explicit labels).
In the simple user interfaces of our "Getting Started" applications, we only need four types of form controls:
single line input fields created with an
<input name="..." /> element,
single line output fields created with an
<output name="..." /> element,
push buttons created with a
<button type="button">...</button> element,
dropdown selection lists created with a
select element of the following
<select name="..."> <option value="value1"> option1 </option> <option value="value2"> option2 </option> ... </select>
<form id="Book"> <p><label>ISBN: <output name="isbn" /></label></p> <p><label>Title: <input name="title" /></label></p> <p><label>Year: <input name="year" /></label></p> <p><button type="button">Save</button></p> </form>
In an HTML-form-based data management user interface, we have a correspondence between the different kinds of properties defined in the model classes of an app and the form controls used for the input and output of their values. We have to distinguish between various kinds of model class attributes, which are mapped to various kinds of form fields. This mapping is also called data binding.
In general, an attribute of a model class can always be represented in the user interface by a plain
input control (with the
type="text"), no matter which datatype has been defined as the range of the attribute in the model class. However, in
special cases, other types of
input controls (for instance,
type="date"), or other widgets, may be used. For instance,
if the attribute's range is an enumeration, a
select control or, if the number of possible choices is small enough (say, less than
8), a radio button group can be used.