Introduction to XML for web developers

Introduction to XML for Web Developers is a four-part course designed by Selena Sol.

Like HTML, XML (also known as Extensible Markup Language) is a markup language which relies on the concept of rule-specifying tags and the use of a tag-processing application that knows how to deal with the tags.

However, XML is far more powerful than HTML.

This is because of the "X". XML is "eXtensible". Specifically, rather than providing a set of pre-defined tags, as in the case of HTML, XML specifies the standards with which you can define your own markup languages with their own sets of tags. XML is a meta-markup language which allows you to define an infinite number of markup languages based upon the standards defined by XML.

The design goals for XML are:

• XML shall be straightforwardly usable over the Internet.
• XML shall support a wide variety of applications.
• XML shall be compatible with SGML.
• It shall be easy to write programs which process XML documents.
• The number of optional features in XML is to be kept to the absolute minimum, ideally zero.
• XML documents should be human-legible and reasonably clear.
• The XML design should be prepared quickly.
• The design of XML shall be formal and concise.
• XML documents shall be easy to create.
• Terseness in XML markup is of minimal importance.

Read More/Download

XML and Databases

by Ronald Bourret

This paper gives a high-level overview of how to use XML with databases. It describes how the differences between data-centric and document-centric documents affect their usage with databases, how XML is commonly used with relational databases, and what native XML databases are and when to use them.

NOTE: Although the information discussed in this paper is (mostly) up-to-date, the idea that the world of XML and databases can be seen through the data-centric/document-centric divide is somewhat dated. At the time this paper was originally written (1999), it was a convenient metaphor for introducing native XML databases, which were then not widely understood, even in the database community. However, it was always somewhat unrealistic, as many XML documents are not strictly data-centric or document-centric, but somewhere in between. So while the data-centric/document-centric divide is a convenient starting point, it is better to understand the differences between XML-enabled databases and native XML databases and to choose the appropriate database based on your processing needs. For a more modern look at the difference between XML-enabled and native XML databases, see chapter 1 of XML for DB2 Information Integration.

Is XML a Database?
Before we start talking about XML and databases, we need to answer a question that occurs to many people: "Is XML a database?"

An XML document is a database only in the strictest sense of the term. That is, it is a collection of data. In many ways, this makes it no different from any other file -- after all, all files contain data of some sort. As a "database" format, XML has some advantages. For example, it is self-describing (the markup describes the structure and type names of the data, although not the semantics), it is portable (Unicode), and it can describe data in tree or graph structures. It also has some disadvantages. For example, it is verbose and access to the data is slow due to parsing and text conversion.

A more useful question to ask is whether XML and its surrounding technologies constitute a "database" in the looser sense of the term -- that is, a database management system (DBMS). The answer to this question is, "Sort of." On the plus side, XML provides many of the things found in databases: storage (XML documents), schemas (DTDs, XML Schemas, RELAX NG, and so on), query languages (XQuery, XPath, XQL, XML-QL, QUILT, etc.), programming interfaces (SAX, DOM, JDOM), and so on. On the minus side, it lacks many of the things found in real databases: efficient storage, indexes, security, transactions and data integrity, multi-user access, triggers, queries across multiple documents, and so on.

Thus, while it may be possible to use an XML document or documents as a database in environments with small amounts of data, few users, and modest performance requirements, this will fail in most production environments, which have many users, strict data integrity requirements, and the need for good performance.

A good example of the type of "database" for which an XML document is suitable is an .ini file -- that is, a file that contains application configuration information. It is much easier to invent a small XML language and write a SAX application for interpreting that language than it is to write a parser for comma-delimited files. In addition, XML allows you to have nested entries, something that is harder to do in comma-delimited files. However, this is hardly a database, since it is read and written linearly, and then only when the application is started and ended.

Examples of more sophisticated data sets for which an XML document might be suitable as a database are personal contact lists (names, phone numbers, addresses, etc.), browser bookmarks, and descriptions of the MP3s you've stolen with the help of Napster. However, given the low price and ease of use of databases like dBASE and Access, there seems little reason to use an XML document as a database even in these cases. The only real advantage of XML is that the data is portable, and this is less of an advantage than it seems due to the widespread availability of tools for serializing databases as XML.

Read More/Download

XML Tutorials

XML (Extensible Markup Language) is a set of rules for encoding documents electronically. It is defined in the XML 1.0 Specification produced by the W3C and several other related specifications; all are fee-free open standards.

XML’s design goals emphasize simplicity, generality, and usability over the Internet.It is a textual data format, with strong support via Unicode for the languages of the world. Although XML’s design focuses on documents, it is widely used for the representation of arbitrary data structures, for example in web services.

There are a variety of programming interfaces which software developers may use to access XML data, and several schema systems designed to aid in the definition of XML-based languages.

As of 2009, hundreds of XML-based languages have been developed, including RSS, Atom, SOAP, and XHTML. XML-based formats have become the default for most office-productivity tools, including Microsoft Office (Office Open XML), OpenOffice.org (OpenDocument), and Apple's iWork.

• XML tutorials from Wikipedia
• Introduction XML tutorial from JavaCommerce
• XML Basics - An Introduction to XML from Xmlfiles
  
• XML from w3schools
• XML from tizag
• XML from javascript blogspot 

WML and WMLScript

By Vijay Mukhi, Harish Mehta

The world of technology is not a place for those who fear challenges. Every challenge holds within it the seeds of tremendous opportunity. Economic downturns or the uncertain paths of new technology cannot shadow the promise of Indian software talent.

India entered the new millenium in a blaze of glory with its stunning successes in the software industry. Thanks mainly to this, the Indian economy will never be the same. The export potential of information technology, and software in particular, has changed forever the balance of India’s international trade in India’s favor.

India is now a key source for technology manpower for the world. This has brought far-reaching change even within the country. Corporate structures, capital markets, education and career options, forex reserves, financial and telecom services are passing through a major change.

India is herself absorbing the lessons she is teaching the world. Primary among these is the use of technology to alleviate, if not eradicate, the long-standing economic problems of the nation.

Information Technology is now on the threshold of bringing great new gains for many areas of the economy like agriculture, healthcare, tourism, employment, social services and enterprise support systems.

Global technology trends will have an equal impact on us. Recognizing and riding trends has become imperative. It is the only way to combat the influx of multinational competition that liberalization (which is the other side of the globalization coin) will inevitably bring.

The global technology trend towards distributed computing and thin clients will manifest itself here with virtually no time lag. The technology jump paradox dictates that while technology jump reduces the technology gap, it also brings the responsibility of upgrading to new technology more quickly and more efficiently.

New generation wireless communication technology is exemplary in this respect. In wireless software technology, WML (wireless mark-up language) is playing a key role as the use of the Internet expands beyond the desk-top PC to a wide variety of devices, mainly cell-phones and PDAs to begin with.

WML programming presents an opportunity for Indian programmers to become spokesmen for our excellence in software, and establish the kind of leadership and value perception that the Indian programming community deserves. The need for WML programming services is going to increase dramatically in the near future, both globally and within the country.

This book is both timely and visionary. It will widen employment opportunities and increase income potential. I earnestly hope that it will also inspire and support entrepreneurship around wireless technology.

Wireless technology is one of the fastest growing segments of the New Age Economy. IDC has forecasted that by mid-2001, almost every new cellphone model will be WAP-enabled. The poster child for the wireless industry is NTT DoCoMo, which has revolutionized the wireless segment in Japan with its i-Mode technology. Japan has an estimated 17 million i-Mode subscribers, which include salesmen, housewives and, surprisingly, a huge segment of teenagers.

However, the big news in wireless is m-commerce, or mobile commerce. Strategic Analytics has estimated the size of the m-commerce market to be over US $ 1 billion in 2000, growing to US $ 200 billion by 2006.

What does all this mean for India? We know that we have severe infrastructure problems when it comes to Internet penetration and usage. Our telephone systems need massive investments to cater to growing needs for upgrading and even basic access. This is because India is a geographically large country, and setting up wired telephone lines is both expensive and time-consuming.

Europe had a much higher adoption rate for wireless technologies than the USA, because the physical line connectivity was lower.  Wireless provides a very quick and relatively cost-effective solution for voice and data connectivity.

For the Internet, wireless provides the same ease and low cost of connectivity. The mobile phone industry is showing tremendous growth. In the last five months of 2000, the all-India mobile user base has grown from 2.5 million subscribers to 3.1 million, an increase of 11.6% in five months. Now, with the crashing rate structures of all mobile service providers, that rate of growth is set to explode.

It is a matter of time before this large subscriber base demands not just voice, but even data connectivity. The cell-phone will be recognized as a tool for much more than just personal voice connectivity. There will certainly be a quantum and quality jump in the nature and frequency of the use of mobile devices. For this to happen, a wide and varied range of data services have to be made available on the wireless platform. WML programming skills will drive and feed on this trend.

I am sure that this book will receive the success and the applause that it deserves. I could not have thought of a better person to write it. And it gives me great pleasure to have the privilege of being a part of the beginning of yet one more glorious chapter in India’s software history.

Read More/Download

WML Tutorial

By SoftSteel

This tutorial takes you through the basics of WAP, and provides all the information you need to create your own WAP pages using the Wireless Markup Language (WML). The WMLScript tutorial that we promised has unfortunately had to be postponed, however. We shall return to it when we have time.

WAP - the Wireless Application Protocol - is a suite of network protocols that specify ways of sending data across the airwaves. As with such protocol suites, they are organised hierarchically. At the bottom there are low-level protocols that are concerned with establishing connections, coding alphanumeric characters, etc. At the top there are the high-level protocols such as WML - the Wireless Markup Language - which is concerned with passing page information.

This set of tutorials is concerned with WML. Being web programmers, rather than network engineers, this is what we're interested in. WAP as a whole has been designed to take into account various limitations in handsets and networks. Because the networks are slow, and the handsets unable to carry much memory or power, an effort has been made to make all of the elements as efficient as possible. It is not clear at present whether any of this efficiency has been gained at the cost of functionality - if so, then WAP will be under threat when the fast mobile networks are commonplace and handset technology has improved. But if other things remain equal, then WAP's efficiency will continue to contribute towards its success.

Read More/Download

XQL (XML Query Language)

Edited by Jonathan Robie

As more and more information is either stored in XML, exchanged in XML, or presented as XML through various interfaces, the ability to intelligently query our XML data sources becomes increasingly important. XML documents are structured documents – they blur the distinction between data and documents, allowing documents to be treated as data sources, and traditional data sources to be treated as documents.

XQL is a query language designed specifically for XML. In the same sense that SQL is a query language for relational tables and OQL is a query language for objects stored in an object database, XQL is a query language for XML documents. The basic constructs of XQL correspond directly to the basic structures of XML, and XQL is closely related to XPath, the common locator syntax used by XSL and XPointers. Since queries, transformation patterns, and links are all based on patterns in structures found in possible XML documents, a common model for the pattern language used in these three applications is both possible and desirable, and a common syntax to express the patterns expressed by that model simplifies the task of the user who must master a variety of XML-related technologies. Although XQL originated before XSL Patterns, there were strong similarities between the two languages, and we have adopted XPath syntax for the constructs which differed. Not all constructs found in XPath were needed for queries, and some constructs used in XQL are not found in XPath, but the two languages share a common subset.

The XQL language described in this paper contains several features not found in previously published versions of the language, including joins, links, text containment, and extensible functions. These new features are inspired in large part by discussions stemming from the W3C QL '98 Workshop, and make it possible to combine information from heterogeneous data sources in powerful ways. Great care has been made to maintain the fundamental simplicity of XQL while adding these features.

This paper is intended as input for the upcoming W3C Query Language Activity, and for the further development of XPath.

Read More/Download

A Query Language for XML

By Alin Deutsch, Mary Fernandez, Daniela Florescu, Alon Levy and Dan Suciu

An important application of XML is the interchange of electronic data (EDI) between multiple data sources on the Web. As XML data proliferates on the Web, applications will need to integrate and aggregate data from multiple source and clean and transform data to facilitate exchange. Data extraction, conversion, transformation, and integration are all well-understood database problems, and their solutions rely on a query language. We present a query language for XML, called XML-QL, which we argue is suitable for performing the above tasks. XML-QL is a declarative, ``relational complete'' query language and is simple enough that it can be optimized. XML-QL can extract data from existing XML documents and construct new XML documents.

Keywords: XML, query languages, electronic-data interchange (EDI)

The goal of XML is to provide many of SGML's benefits not available in HTML and to provide them in a language that is easier to learn and use than complete SGML. These benefits include user-defined tags, nested elements, and an optional validation of document structure with respect to a Document Type Descriptor (DTD).

One important application of XML is the interchange of electronic data (EDI) between two or more data sources on the Web. Electronic data is primarily intended for computer, not human, consumption. For example, search robots could integrate automatically information from related sources that publish their data in XML format, e.g., stock quotes from financial sites, sports scores from news sites; businesses could publish data about their products and services, and potential customers could compare and process this information automatically; and business partners could exchange internal operational data between their information systems on secure channels. New opportunities will arise for third parties to add value by integrating, transforming, cleaning, and aggregating XML data. In this paper, we focus on XML's application to EDI. Specifically, we take a database view, as opposed to document view, of XML. We consider an XML document to be a database and a DTD to be a database schema.

EDI applications require tools that support the following tasks:

• extraction of data from large XML documents,
• conversion of data between relational or object-oriented databases and XML data,
• transformation of data from one DTD to a different DTD, and/or
• integration of multiple XML data sources.

Read More/Download

XML Schema Definition [XSD]

By Vijay Mukhi, Shruti Gupta and Sonal Mukhi

In the e-world, we constantly hear of proclamations about the concept of transacting business sans human intervention. This concept is bolstered by the ability to program electronic devices in such a manner, so as to enable them to perform all the requisite tasks by themselves, totally independent of any human involvement.

For instance, if your refrigerator malfunctions, it would be able to register a complaint with the mechanic's computer, specifying the details of the glitch. So, don't be bewildered if a mechanic arrives unannounced at your doorstep and apprises you of the defect in your fridge, which you obviously would be oblivious to.

In such a scenario, when these gadgets and machines need to collaborate with one another, data has to flow to and fro between them. This data has to be in a specific format to facilitate apt and precise interpretation at both ends. To enable this, the data must be validated prior to the occurrence of any such transaction. It is here that the XML Schema plays a vital role by validating the data that flows back and forth.

The XML Schema specifies the properties of a resource, while the XML file stipulates a set of values for these properties. The primary utility of the XML Schema lies in its ability to concede generous amount of autonomy to the programmer to define the rules of data validity; and thereafter, to hand over the responsibility of data validation to the XML validator. This liberates the programmer from the mundane drudgery of the task of data validation.

The reader must be acquainted with the C# programming language since the XML Schema and the XML files are read and written to using program written in this language. Also, it is assumed that the reader is conversant with XML too.

The book gets underway with the chapter on Dataset, which delves upon the concepts that relate to a database. It acquaints you with the nuances of the xsd file and its importance in the scheme of things.

The next chapter handles the concept of validating an XML file using the XML Schema, which is a surrogate for the Document Type Description or DTD. It encompasses all the rules that the XML file must conform to.

Then, in the next few chapters, the focus is veered towards the assimilation of the basic elements of the Schema file, such as attributes, inheritance, namespaces and restrictions. An entire chapter is dedicated to each one of them, wherein they are explored in considerable detail. Then, the intricacies of creating the XML Schema files using a program, are revealed. Finally, the last chapter in the book inquires into the mechanism of how the XML Schema Definition tool can be used to generate the XML Schema and the C# classes.

Thus, a beautiful tapestry of topics has been spread before your eyes, woven together to bridge the chasm of ignorance about the XML Schema. The heady mélange of theory and examples eases the task of comprehending complex concepts.

By its inherent nature, the métier of software programming makes it mandatory for programmers to remain on the cutting edge of technology. Therefore, we entreat you to throw forbearance to the wind and set about the task of updating your knowledge about the XML Schema without any further ado.

We wish you joyful reading and a flight of fascinating discovery!  

Read More/Download

XML Web Services and SOAP

By Vijay Mukhi

This book offers you the most opportune moment to set sail on a voyage of discovery, during which, you shall visit the topics of XML Web Services and the Simple Object Access Protocol, SOAP. It proceeds according to a coherent roadmap, to ensure that each topic builds up incrementally on its predecessor.

You should assimilate what has been presented in a specific chapter, before venturing on to the next one. We have essayed at quelling the general fear of learning a new language by clearly explaining all the complex topics. We have re-visited some topics to ensure that you have a lucid understanding of the intricate concepts, even though we are aware that reiterations could result in ennui. We have included a vast array of examples, which strip the sheen of complexity in which most concepts are generally ensconced.

XML Web services are the fundamental building blocks in the transition towards Distributed Computing on the Internet. XML Web Services are fast becoming the standard for application interaction. An XML Web Service is a standard way of exposing services to a large number of users.

An XML Web service is a function that is exposed, so that other applications on the Web can exploit its inherent capabilities. By using XML Web services, application developers can converge their creative energies on the unique value-added functions that they wish to provide. XML Web services are modular and extensible. However, there are a number of features that have been left to the developer for implementation.

SOAP, Simple Object Access Protocol, is described as a communications protocol. It is a specification that defines the XML format for messages. The SOAP specification defines the structure of an XML document, which can be used to exchange data between two applications. It expounds a way to represent programming language specific datatypes, in XML.

The most compelling feature of SOAP is that, it has been implemented on many different hardware and software platforms. This implies that SOAP can be used to link disparate systems both, within and outside your organization. SOAP is primarily used to facilitate communication between different programs. These programs may have been written in different languages, and could be running on different platforms.

SOAP is extremely popular and has become the de facto industry standard, as it facilitates interoperability between assorted environments, and it uses HTTP as the transport mechanism.

You would acquiesce that our book titled 'XML Web Services and SOAP' is not meant for the technically naïve. The reader must have sufficient knowledge of C# and ASP.Net, before launching forth with this book. The primary assumption is that you have either read our book on C#, ASP.NET, or any one of the other innumerable books on this topic, strewn all over the market.

We have adopted a step-by-step approach wherein, we first acquaint you with the smallest Web Service. Once you are at ease with it and can create a webservice effortlessly, we progress on to examining the packets that are sent across by the client to the server, and vice-versa. We have based our theory on the packets that have been trapped, using the Trace Utility from the Microsoft SOAP Toolkit, 2.0.

The XML Web Services are built on WSDL, SOAP, XML and UDDI specifications. The second chapter introduces us to WSDL. We have even endeavored to explicate the code generated by the wsdl program. While doing so, we realized that we had to devote an entire chapter to the different data types. We also had to analyze the changes that occur, when data is sent across from client to server and vice-versa. This eventually directed us on to the next chapter of DataSet, since a DataSet is a collection of DataTable objects that embody data. Following this, we attempt to perceive how a web service can be called, using Javascript in an html file.

Then, we proceed on a sojourn to the SOAP packets, which are our next area of interest. Here, we begin with the SOAP headers, and learn how to create custom attributes to enhance the capabilities of the Web Service. Once these aspects have been elucidated, we focus on security issues relating to SOAP. Here, we delve upon the processes of encryption and decryption of data, as well as, on compression and decompression of data.

Finally, all miscellaneous attributes relating to Web Services, which were not touched upon earlier, are tackled in the remaining chapters. After discussing the SOAP faults, we move on to an authentication program, where all the knowledge attained by us so far, has been put to use. The topic of Disco has also been attended to, before going into the details of a WSDL file. We have concluded this book with the chapter on Remoting, where our attention rivets around the data and the data types that get generated in the SOAP packets, when functions are called with different types of parameters.

We are sure that if you read this book with earnest, you diligence will definitely pay off. We exhort you to make the most of this wonderful opportunity. Let the pursuit of knowledge be your lodestar.

Read More/Download

XML-RPC HOWTO

By Eric Kidd

Describes how to use XML-RPC to implement clients and servers in a variety of languages. Provides example code in Perl, Python, C, C++, Java, PHP and other languages. Includes sections on Zope and KDE 2.0. Applies to all operating systems with XML-RPC support.

XML-RPC is a simple, portable way to make remote procedure calls over HTTP. It can be used with Perl, Java, Python, C, C++, PHP and many other programming languages. Implementations are available for Unix, Windows and the Macintosh.

XML-RPC was inspired by two earlier protocols. The first is an anonymous RPC protocol designed by Dave Winer and announced in an old DaveNet essay. (This is why XML-RPC servers are often installed under /RPC2.) The other, more important inspiration was an early draft of the SOAP protocol.

XML-RPC is not the only way to make remote procedure calls. Other popular protocols include CORBA, DCOM and SOAP. Each of these protocols has advantages and disadvantages.

SOAP is very similar to XML-RPC. It, too, works by marshaling procedure calls over HTTP as XML documents. Unfortunately, SOAP appears to be suffering from specification creep.

SOAP was originally created as a collaboration between UserLand, DevelopMentor and Microsoft. The initial public release was basically XML-RPC with namespaces and longer element names. Since then, however, SOAP has been turned over a W3C working group.

Unfortunately, the working group has been adding a laundry-list of strange features to SOAP. As of the current writing, SOAP supports XML Schemas, enumerations, strange hybrids of structs and arrays, and custom types. At the same time, several aspects of SOAP are implementation defined.

Basically, if you like XML-RPC, but wish the protocol had more features, check out SOAP. :-)

Read More/Download

A Gentle Introduction to xml

Interactive XML tutorials

These tutorials introduce a variety of XML topics including, SVG, DTD, Schema, XSLT, DOM and SAX. Each topic includes a number of problems that the student must complete. For all of the problems the student has access to online parsers that process the students answers and give immediate feedback.

Contents

• SVG - Scalable Vector Graphics
• SVG is an example of an XML application. Using SVG we can create images made up of lines, shapes and text.
• DTD - Document Type Definition (more DTD)
• A DTD describes an XML application. An XML documents may be validated against a DTD. The DTD specifies the elements that may be included, how they may be nested and what attributes each element may have.
• XSLT Extensible Style Sheet Transformations
• An xsl sheet describes the transformation of an XML document. The xsl transformation involves matching nodes against templates. The xsl transfomation may use XPath expressions.
• DOM at progzoo
• DOM - Document Object Model
• The Document Object Model includes a set of classes that have been implemented in a variety of languages. In these examples we use Java to process XML documents using DOM.
• SAX - Simple API for XML
• The SAX interface allows us to process XML documents in Java. Although this interface is harder to use (than DOM) it is more efficient and allows us to process large documents without the overheads that DOM introduces.
• XML Schema
• A schema may be used to validate an xml document. Schema perform more or less the same function as a DTD - they do it better but are considerably more complex.

All of the tools used are freely available. The web interface is convenient for beginners however more ambitious students should be able to install the tools and run the examples from their own machines.

Read More/Download

XML and Web Services Reference Guide

by Nicholas Chase

A cousin of Hypertext Markup Language (HTML), Extensible Markup Language (XML) provides a human-readable, platform-independent way to represent data, whether it's content destined for a web page or brochure, or data destined for an enterprise database.

Like HTML and their mutual parent, Standard Generalized Markup Language (SGML), XML works on the principle of tags, which delineate elements and content...

Following are the topics covered in this XML guide.

• The Document Object Model
• DOM and Java
• DOM and JavaScript
• DOM and .NET
• DOM and C++
• DOM and Perl
• DOM and PHP
• DOM Level 3
• The Simple API for XML (SAX)
• SAX and Java
• SAX and .NET
• SAX and Perl
• SAX and PHP
• Validation
• Document Type Definitions (DTDs)
• XML Schemas
• RELAX NG
• Schematron
• Validation in Applications
• XSL Transformations (XSLT)
• XSLT in Java
• XSLT and RSS in .NET
• XSL-FO
• XPath
• XML Base
• XHTML
• XHTML 2.0
• Cascading Style Sheets
• XUL
• XML Events
• XML Data Binding
• XML and Databases
• SQL Server and FOR XML
• Service Oriented Architecture
• Web Services
• Apache Axis2
• REST
• SOAP
• SOAP and Java
• WSDL
• UDDI
• XML-RPC
• Ajax
• JSON
• Ruby on Rails
• Web Services Security
• SAML
• XML Digital Signatures
• XML Key Management Services
• Internationalization
• Grid Computing
• Web Services Resource Framework
• WS-Addressing
• WS-Notifications
• New Languages: XML in Use
• Google Web Toolkit
• Google Sitemaps
• Accessibility
• The Semantic Web
• WML
• Google Web Services
• The Yahoo! Web Services Interface
• eBay REST API
• WordML
• DocBook
• XML Query
• XForms
• Resource Description Framework (RDF)
• Topic Maps
• Rich Site Summary (RSS)
• Simple Sharing Extensions (SSE)
• Atom
• Podcasting
• Scalable Vector Graphics (SVG)
• OPML

Read More/Download

An Introduction to XML and Web Technologies

By Anders Moller and Michael Schwartzbach

What is XML?
XML: eXtensible Markup Language is a framework for defining markup languages:

• there is no fixed collection of markup tags - we may define our own tags, tailored for our kind of information
• each XML language is targeted at its own application domain, but the languages will share many features
• there is a common set of generic tools for processing documents

XML is not a replacement for HTML:

• HTML should ideally be just another XML language
• in fact, XHTML is just that
• XHTML is a (very popular) XML language for hypertext markup

XML is designed to:

• separate syntax from semantics to provide a common framework for structuring information (browser rendering semantics is completely defined by stylesheets);
• allow tailor-made markup for any imaginable application domain
• support internationalization (Unicode) and platform independence
• be the future of structured information, including databases 

Following are the few topics covered in this XML tutorial

• HTML and XML - structuring information for the future
  Namespaces, XInclude, and XML Base - common extensions to the XML specification
  DTD, XML Schema, and DSD - defining language syntax with schemas
  XLink, XPointer, and XPath - linking and addressing
  XSL and XSLT - stylesheets and document transformation
  XQuery - document querying
  DOM, SAX, and JDOM - programming for XML
  W3C - some background on the World Wide Web Consortium

Read More/Download

A Technical Introduction to XML

by Norman Walsh

It is somewhat remarkable to think that this article, which appeared initially in the Winter 1997 edition of the World Wide Web Journal was out of date by the time the final XML Recommendation was approved in February. And even as this update brings the article back into line with the final spec, a new series of recommendations are under development. When finished, these will bring namespaces, linking, schemas, stylesheets, and more to the table.

This introduction to XML presents the Extensible Markup Language at a reasonably technical level for anyone interested in learning more about structured documents. In addition to covering the XML 1.0 Specification, this article outlines related XML specifications, which are evolving. The article is organized in four main sections plus an appendix.

What is XML?
XML is a markup language for documents containing structured information. Structured information contains both content (words, pictures, etc.) and some indication of what role that content plays (for example, content in a section heading has a different meaning from content in a footnote, which means something different than content in a figure caption or content in a database table, etc.). Almost all documents have some structure.

A markup language is a mechanism to identify structures in a document. The XML specification defines a standard way to add markup to documents.

Read More/Download

Introduction to XForms, Part 1: The new Web standard for forms

By Chris Herborth

XForms is the next generation of Web-based data processing. It replaces traditional HTML forms with an XML data model and presentation elements. In this three-part series, you'll be introduced to XForms and its capabilities, including the basic XForms model and form, the various types of controls, and basic and advanced form submission. This article covers how XForms actually works, and shows you how to set up XForms with Firefox and Microsoft® Internet Explorer so that you can view your XForms samples.

Introduction
XForms is gaining momentum rapidly, with support available for common browsers using extensions or plugins, and through things like the IBM® Workplace Forms technology (see the Resources section to find out more). Its flexibility and power make it attractive to Web developers, and its small footprint and client-side processing make it attractive to systems administrators. The W3C is currently reviewing XForms 1.1 as a Working Draft document (1.0 is an official Internet Recommendation, which puts it on par with things like XHTML, PNG, and CSS), and IBM is currently spearheading an effort to merge competing XML-based forms' standards with the features and abilities of XForms.

This article explains the evolution of forms from simple text searches to today's interactive masterpieces and explains the next step in Web forms, XForms. It explains what makes XForms different and gets the user ready for Part 2 by setting up his or her environment.

Read on to see how a simple HTML form can be replaced with a simple XForms form, and how you can use XForms' capabilities to save (and reload later) a form's data to a local file.

If you'd like to follow along with the XHTML and XForms documents discussed in this article, grab the archive linked in the Downloads section. It contains the files you're going to look at, which you can use as a starting point for your own XForms experimentation.

You'll also be installing an XForms extension that lets you view XForms documents directly in current versions of Firefox, Internet Explorer, Seamonkey, or Mozilla. If you don't currently have one of these excellent, standards-compliant browsers installed, now's a good time to get one.

Read More/Download

Introduction to XForms

by Mark Birbeck

A key idea of our approach to building internet applications is making good use of standards-based languages, in particular XForms.

XForms is an exciting new language from the W3C that can be used to create anything from simple forms to complex Web 2.0 applications. XForms are dynamic, cross-platform, accessible, script-free...and 100% standard.

This handbook covers everything you need to know to get started with XForms. You'll start with a simple walkthrough to get your development environment up and running, then create two fully functioning applications--one that saves links to del.icio.us, and another that searches Flickr. Both use CSS-driven Ajax animations. Once you've seen what XForms can do, building web applications will never be the same!

What is XForms?

XForms is a relatively recent standard from the W3C, designed to allow us to create sophisticated user interfaces using mark-up. This means that defining a user interface is much the same as using HTML, except that XForms has been designed from the ground up to cope with many of the things that we usually have to dive into script to do.

And XForms doesn't just make it easy to replace script in our applications, it also provides us with the means to manipulate and validate XML; unlike most languages that you might have used, XForms brings XML right into the heart of the language.

Read More/Download

Developer's Guide to Building XML-based Web Services with the Java 2 Platform, Enterprise Edition (J2EE)

By James Kao

Web services using XML standards is a new paradigm in the way B2B collaborations are modeled. It provides a conceptual and architectural foundation which can be implemented using a variety of platforms and products. Today, developers can use the Java 2 Enterprise Edition (J2EE) to build XML-based web services. They can leverage existing J2EE technologies to build a complete and fully interoperable web service that complies with XML standards. Without radical reengineering, and without rebuilding a proven J2EE system, developers can construct complex and powerful web services applications.

A web service is an application that accepts requests from other systems across the Internet or an Intranet, mediated by lightweight, vendor-neutral communications technologies. These communications technologies allow any network-enabled systems to interact. As technologies mature, a web service will encompass additional special functionality geared towards performing multiparty B2B collaboration.

Web services are evolving and beginning to operate in an extremely intelligent and dynamic way. These smart web services will understand the context of each request and produce dynamic results based on each specific situation. The services will adapt their processes based on the user’s identity, preferences, location, and reason for the request. Multiple services will be combined on the fly, collaborating to produce a unique, customized solution. The mechanics of this collaboration will be completely transparent to the consumer, who will experience only the collective benefit delivered by the end result.

The XML standards which a web services system is built upon allows for an implementation-neutral approach to performing business collaborations. There are many possible implementations developers can use, including a variety of products, platforms, and standards. By using a standards-based approach, developers can build a system that provides maximum interoperability for their web services.

This white paper describes the portable Java and XML technology approach for implementing a web services architecture. It explains each of the key web services technologies and how they fit together. You will gain a better understanding of the concepts that underlie a XML web services architecture, and how they fit together with J2EE. We begin with a 30,000-foot birds-eye view of how to build web services using J2EE. This section will give you a high-level understanding of the building blocks of a web services system. We will elaborate on each functional area later in this white paper.

Read More/Download

Essential XML Quick Reference: A Programmer's Reference to XML, XPath, XSLT, XML Schema, SOAP, and More

Addison-Wesley and Developmentor have provided TheServerSide.NET with the entire book of Essential XML Quick Reference for free download. Essential XML Quick Reference is for anyone working with today's mainstream XML technologies. It was specifically designed to serve as a handy but thorough quick reference that answers the most common XML-related technical questions.It goes beyond the traditional pocket reference design by providing complete coverage of each topic along with plenty of meaningful examples. Each chapter provides a brief introduction, which is followed by the detailed reference information. This approach assumes the reader has a basic understanding of the given topic.The detailed outline (at the beginning), index (in the back), bleeding tabs (along the side), and the page headers/footers were designed to help readers quickly find answers to their questions.

This XML book "Essential XML Quick Reference: A Programmer's Reference to XML, XPath, XSLT, XML Schema, SOAP, and More" is written By Aaron Skonnard and Martin Gudgin

Following are the topics covered in this XML book.

• XML 1.0 and Namespaces
• Document Type Definitiosn
• XPath 1.0
• Xpointer, Xinclude, and XML Base
• XSL Transformation 1.0
• SAX 2.0
• DOM Level 2
• XML Schema Datatypes
• XML Schema Structures
• SOAP 1.1

Read More/Download

Developing SGML DTDs

By Eve Maler and Jeanne El Andaloussi

A document type definition (DTD) forms the foundation of an SGML edifice. The goal of Developing SGML Document Type Definitions is to help individuals and organizations develop high-quality, effective DTDs.

We have been involved in a variety of Standard Generalized Markup Language (SGML) projects, including design and development of large DTDs, in computer companies and industry-wide forums. Through these efforts, we've refined a DTD development methodology that can help anyone embarking on SGML projects develop DTDs that meet the goals of those projects. In this book we will describe our methodology and techniques for doing the work of designing, implementing, and documenting DTDs.

Developing SGML Document Type Definitions is intended to serve as a workbook for anyone who is, or might soon be, responsible for developing DTDs. The audience for this book includes people in the following roles:

• Publications and MIS project managers and project leaders responsible for the successful migration to and implementation of SGML-based systems in their environments. If you're a manager in this position, this book will show you how to make the DTD development phase of your SGML project successful through resource and project planning. Part I, “Introduction and Overview” and Part IV, “Documentation, Training, and Support” are meant especially for people in this role.
• Document authors, editors, and other subject matter experts who create, edit, or assemble the targeted information. They are authorities in the required form and content of that information and are typically in the best position to describe many document type requirements. If you're a subject matter expert, this book will show you how to uncover, express, and justify your requirements in clear, usable document analysis reports. Part II, “Document Type Design” is meant especially for people in this role.
• DTD implementors, developers of document-processing applications, and system and database administrators responsible for implementing and maintaining DTDs and the systems and software tools that process the targeted information. If you're a developer, this book will show you how to contribute to the DTD requirements work and how to design and implement DTDs for readability, maintainability, and flexibility. Part III, “DTD Development” and some notes in Chapter 5, Document Type Modeling and Specification are meant especially for people in this role.

If you're embarking on a relatively small SGML project or a pilot for a larger effort, you may find yourself filling all three roles; this is often the case for the “SGML champion” in an organization.

Read More/Download

XML By Example

By Benoit Marchal

XML by Example is intended for people with some basic HTML coding experience. If you can write a simple HTML page and if you know the main tags you know enough HTML to understand this book. You don’t need to be an expert, however. Some advanced techniques introduced in the second half of the book (Chapter 7 and later) require experience with scripting and JavaScript. You need to understand loops, variables, functions, and objects for these chapters. Remember these are advanced techniques, so even if you are not yet a JavaScript wizard, you can pick up many valuable techniques in the book.

This book is for you if one of the following statements is true:

• You are an HTML whiz and want to move to the next level in Internet publishing.
• You publish a large or dynamic document base on the Web, on CDROM, in print, or by using a combination of these media, and you have heard XML can simplify your publishing efforts.
• You are a Web developer, so you know Java, JavaScript, or CGI inside out, and you have heard that XML is simple and enables you to do many cool things. You are active in electronic commerce or in EDI and you want to learn what XML has to offer to your specialty.
• You use software from Microsoft, IBM, Oracle, Corel, Sun, or any of the other hundreds of companies that have added XML to their products, and you need to understand how to make the best of it.

You don’t need to know anything about SGML (a precursor to XML) to understand XML by Example. You don’t need to limit yourself to publishing; XML by Example introduces you to all applications of XML,  including publishing and non publishing applications.

Read More/Download

Perl & XML

by Erik T. Ray and Jason McIntosh

This book marks the intersection of two essential technologies for the Web and information services. XML, the latest and best markup language for self-describing data, is becoming the generic data packaging format of choice. Perl, which web masters have long relied on to stitch up disparate components and generate dynamic content, is a natural choice for processing XML. The shrink-wrap of the Internet meets the duct tape of the Internet.

More powerful than HTML, yet less demanding than SGML, XML is a perfect solution for many developers. It has the flexibility to encode everything from web pages to legal contracts to books, and the precision to format data for services like SOAP and XML-RPC. It supports world-class standards like Unicode while being backwards-compatible with plain old ASCII. Yet for all its power, XML is surprisingly easy to work with, and many developers consider it a breeze to adapt to their programs.

As the Perl programming language was tailor-made for manipulating text, Perl and XML are perfectly suited for one another. The only question is, "What's the best way to pair them?" That's where this book comes in.

This book was written for programmers who are interested in using Perl to process XML documents. We assume that you already know Perl; if not, please pick up O'Reilly's Learning Perl (or its equivalent) before reading this book. It will save you much frustration and head scratching.

We do not assume that you have much experience with XML. However, it helps if you are familiar with markup languages such as HTML. We assume that you have access to the Internet, and specifically to the Comprehensive Perl Archive Network (CPAN), as most of this book depends on your ability to download modules from CPAN. Most of all, we assume that you've rolled up your sleeves and are ready to start programming with Perl and XML. There's a lot of ground to cover in this little book, and we're eager to get started.

Read More/Download

Java and XSLT

by Eric M. Burke

Java and Extensible Stylesheet Language Transformations (XSLT) are very different technologies that complement one another, rather than compete. Java's strengths are portability, its vast collection of standard libraries, and widespread acceptance by most companies. One weakness of Java, however, is in its ability to process text. For instance, Java may not be the best technology for merely converting XML files into another format such as XHTML or Wireless Markup Language (WML). Using Java for such a task requires skilled programmers who understand APIs such as DOM, SAX, or JDOM. For web sites in particular, it is desirable to simplify the page generation process so nonprogrammers can participate.

XSLT is explicitly designed for XML transformations. With XSLT, XML data can be transformed into any other text format, including HTML, XHTML, WML, and even unexpected formats such as Java source code. In terms of complexity and sophistication, XSLT is harder than HTML but easier than Java. This means that page authors can probably learn how to use XSLT successfully but will require assistance from programmers as pages are developed.

XSLT processors are required to interpret and execute the instructions found in XSLT stylesheets. Many of these processors are written in Java, making Java an excellent choice for applications that must interoperate with XML and XSLT. For web sites that utilize XSLT, Java servlets and EJBs are still required to intercept client requests, fetch data from databases, and implement business logic. XSLT may be used to generate each of the XHTML web pages, but this cannot be done without a language like Java acting as the coordinator.

This book explains the most important concepts behind the XSLT markup language but is not a comprehensive reference on that subject. Instead, the focus is on interoperability with Java, with particular emphasis on servlets and web applications. Every concept is backed by working examples, all of which work on widely available, free tools.

Read More/Download

Java & XML

by Brett McLaughlin

When I wrote the preface to the first edition of Java & XML just over a year ago, I had no idea what I was getting into. I made jokes about XML appearing on hats and t-shirts; yet as I sit writing this, I'm wearing a t-shirt with "XML" emblazoned across it, and yes, I have a hat with XML on it also (in fact, I have two!). So, the promise of XML has been recognized, without any doubt. And that's good.

However, it has meant that more development is occurring every day, and the XML landscape is growing at a pace I never anticipated, even in my wildest dreams. While that's great for XML, it has made looking back at the first edition of this book somewhat depressing; why is everything so out of date? I talked about SAX 2.0, and DOM Level 2 as twinklings in eyes. They are now industry standard. I introduced JDOM, and now it's in JSR (Sun's JavaFigure 0 Specification Request process). I hadn't even looked at SOAP, UDDI, WSDL, and XML data binding. They take up three chapters in this edition! Things have changed, to say the least.

If you're even remotely suspicious that you may have to work with XML in the next few months, this book can help. And if you've got the first edition lying somewhere on your desk at work right now, I invite you to browse the new one; I think you'll see that this book is still important to you. I've thrown out all the excessive descriptions of basic concepts, condensed the basic XML material into a single chapter, and rewritten nearly every example; I've also added many new examples and chapters. In other words, I tried to make this an in-depth technical book with lots of grit. It will take you beginners a little longer, as I do less handholding, but you'll find the knowledge to be gained much greater.

Read More/Download

SAX2

 by David Brownell

Think of this book as if it were really called Everything You Wanted to Know About SAX. It provides a quick tutorial, while also serving as a complete reference that explains how to use this popular XML API effectively and efficiently. You'll find motivations for every programming interface and see how to build components for your application (or specialized environment) on top of SAX.

The information in this book is based on the current version of the Java language support for SAX2.

If you are programming with XML in Java, or starting to do that, and you want to learn how to use SAX2 to its fullest, this book is for you. It assumes that you are familiar with Java programming and have a basic understanding of XML, including DTDs. You may have some exposure to DOM, an alternative parser API, but you need more efficient, or more complete, access to XML than you can get with such a generic tree structure API. Although there's a lot of interest in XML from server-side programmers, and this book includes some examples targeted at servlet-based systems, SAX2 is addressed to Java developers working on all scales, from embedded systems to enterprise applications.

Although versions of the SAX API have been provided for developers who use C/C++, Pascal, Perl, and Python, this book is not addressed to such developers except in the broad sense that good SAX programming idioms transcend the particular language used to express them.

This book is for Java programmers working with XML who need an efficient way of reading or generating XML documents. The simple API for XML (SAX)'s event-based approach provides an extremely streamlined set of tools for Java programmers.

Read More/Download

XML Schema

 by Eric van der Vlist

As developers create new XML vocabularies, they often need to describe those vocabularies to share, define, and apply them. This book will guide you through W3C XML Schema, a set of Recommendations from the World Wide Web Consortium (W3C). These specifications define a language that you can use to express formal descriptions of XML documents using a generally object-oriented approach. Schemas can be used for documentation, validation, or processing automation. W3C XML Schema is a key component of Web Services specifications such as SOAP and WSDL, and is widely used to describe XML vocabularies precisely.

With this power comes complexity. The Recommendations are long, complex, and generally difficult to read. The Primer helps, of course, but there are many details and style approaches to consider in building schemas. This book attempts to provide an objective, and sometimes critical, view of the tools W3C XML Schema provides, helping you to discover the possibilities of schemas while avoiding potential minefields.

Read this book if you want to:

• Create W3C XML Schema schemas using a text editor, XML editor, or a W3C XML Schema IDE or editor. 
• Understand and modify existing W3C XML Schema schemas. 

 You should already have a basic understanding of XML document structures and how to work with them.

Read More/Download

XSLT

by Doug Tidwell

The heart of this book is designed to take you through the basics of XSLT and help you solve problems with this exciting new technology. It contains the following chapters:

Chapter 1, "Getting Started", covers the basics of XML and discusses how to install the Xalan stylesheet engine. Chapter 2, "The Obligatory Hello World Example", takes a look at an XML-tagged "Hello World" document, then examines stylesheets that transform it into other things. Chapter 3, "XPath: A Syntax for Describing Needles and Haystacks", covers the basics of XPath, the language used to describe parts of an XML document. Chapter 4, "Branching and Control Elements", discusses the logic elements of XSLT ( and ) and how they work. Chapter 5, "Creating Links and Cross-References", Covers the different ways to build links between elements in XML documents. Using XPath to describe relationships between related elements is also covered. Chapter 6, "Sorting and Grouping Elements", Goes over the element and discusses various ways to sort elements in an XML document. It also talks about how to do grouping with various XSLT elements and functions. Chapter 7, "Combining XML Documents", discusses the document() function, which allows you to combine several XML documents, then write a stylesheet that works against the collection of documents. Chapter 8, "Extending XSLT", > explains how you can write extension elements and extension functions. Although XSLT and XPath are extremely powerful and flexible, there are still times when you need to do something that isn't provided by the language itself. Chapter 9, "Case Study: The Toot-O-Matic", > goes through a complicated case study that puts XSLT through its paces. The chapter reviews the Toot-O-Matic, an XSLT tool that generates a wide range of output documents from a single file.

The last section of the book contains reference information:
Appendix A, "XSLT Reference", an alphabetical listing of all the elements defined by XSLT, with a discussion of all attributes of those elements and how they were designed to be used. Appendix B, "XPath Reference", a listing of various aspects of XPath, including datatypes, axes, node types, and operators. Appendix C, "XSLT and XPath Function Reference", > an alphabetical listing of all the functions defined by XPath and XSLT. Appendix D, "XSLT Guide", a series of "How do I...?" questions, with brief examples and/or references to sections of the book that explain how to do common tasks. 

Read  More/Download

XML in a Nutshell

by Elliotte Rusty Harold and W. Scott Means

XML is one of the most important developments in document syntax in the history of computing. In the last few years it has been adopted in fields as diverse as law, aeronautics, finance, insurance, robotics, multimedia, hospitality, travel, art, construction, telecommunications, software, agriculture, physics, journalism, theology, retail, and comics. XML has become the syntax of choice for newly designed document formats across almost all computer applications. It's used on Linux, Windows, Macintosh, and many other computer platforms. Mainframes on Wall Street trade stocks with one another by exchanging XML documents. Children playing games on their home PCs save their documents in XML. Sports fans receive real-time game scores on their cell phones in XML. XML is simply the most robust, reliable, and flexible document syntax ever invented.

XML in a Nutshell is a comprehensive guide to the rapidly growing world of XML. It covers all aspects of XML, from the most basic syntax rules, to the details of DTD and schema creation, to the APIs you can use to read and write XML documents in a variety of programming languages.

There are hundreds of formally established XML applications from the W3C and other standards bodies, such as OASIS and the Object Management Group. There are even more informal, unstandardized applications from individuals and corporations, such as Microsoft's Channel Definition Format and John Guajardo's Mind Reading Markup Language. This book cannot cover them all, any more than a book on Java could discuss every program that has ever been or might ever be written in Java. This book focuses primarily on XML itself. It covers the fundamental rules that all XML documents and authors must adhere to, whether a web designer uses SMIL to add animations to web pages or a C++ programmer uses SOAP to exchange serialized objects with a remote database.

Read More/Download

Processing XML with Java

By Elliotte Rusty Harold

This book is written for experienced Java programmers who want to integrate XML into their systems. Java is the ideal language for processing XML documents. Its strong Unicode support in particular made it the preferred language for many early implementers. Consequently, more XML tools have been written in Java than in any other language. More open source XML tools are written in Java than in any other language. More programmers process XML in Java than in any other language.

Processing XML with Java will teach you how to:

• Save XML documents from applications written in Java
• Read XML documents produced by other programs
• Search, query, and update XML documents
• Convert legacy flat data into hierarchical XML
• Communicate with network servers that send and receive XML data
• Validate documents against DTDs, schemas, and business rules
• Combine functional XSLT transforms with traditional imperative Java code

This book is meant for Java programmers who need to do anything with XML. It teaches the fundamentals and advanced topics, leaving nothing out. It is a comprehensive course in processing XML with Java that takes developers from little knowledge of XML to designing sophisticated XML applications and parsing complicated documents. The examples cover a wide range of possible uses including file formats, data exchange, document transformation, database integration, and more.

 XML is deliberately architecture, platform, operating system, GUI, and language agnostic (in fact, more so than Java). It works equally well on Mac OS, Windows, Linux, OS/2, various flavors of Unix, and more. It can be processed with Python, C++, Haskell, ECMAScript, C#, Perl, Visual Basic, Ruby, and of course Java. No byte order issues need concern you if you switch between PowerPC, X86, or other architectures. Almost everything in this book should work equally well on any platform that’s capable of running Java.

Most of the material in this book is relatively independent of the specific Java version. Java 1.4 bundles SAX, DOM, and a few other useful classes into the core JDK. However, these are easily installed in earlier JVMs as open source libraries from the Apache XML Project and other vendors. For the most part, I used Java 1.3 and 1.4 when testing the examples; and it’s possible that a few classes and methods have been used that are not available in earlier versions. In most cases, it should be fairly obvious how to backport them. All of the basic XML APIs except TrAX should work in Java 1.1 and later. TrAX requires Java 1.2 or later.

Read More/Download

XForms Essentials

The book in your hands introduces you to XForms, a combination of two of the most successful experiments ever performed with the Web: XML and forms.

2003 marks the 10-year anniversary of forms on the Web. During that time, the Web grew from a loose collection of technical research sites to the livelihood of millions, browser empires have risen and fallen, and the tech economy went through an inflationary period of cosmic proportions only to collapse back in upon itself. The addition of forms to the otherwise static HTML language in 1993 was a revolutionary step forward, making possible Yahoo!, Google, Amazon, Hotmail, and countless other interactive sites.

During the mid-nineties, the World Wide Web Consortium (W3C) began work on XML, a uniform way to represent structured text and data, in an attempt to simplify an earlier language called SGML. XML became a W3C Recommendation in 1998, and has since gained momentum, becoming the foundation for XHTML, SVG, the Universal Business Language (UBL), syndication formats such as RSS, and DocBook (which was used to write this book). Nearly every data format that consists primarily of human-readable data has been influenced by XML.

You should read this book if you want to:

• Create XForms files in a text or XML editor
• Convert existing forms (electronic or paper) to XForms
• Collect XML data from users in a user-friendly way
• Reduce the amount of JavaScript needed within browser interfaces
• Increase the security and reliability of your current information system by combining client-side and server-side checks into a common code base
• Understand how to create interactive web sites using the latest standard technology 

Read More/Download

Sams Teach Yourself XML in 21 Days

By Steven Holzner

Sams Teach Yourself XML in 21 Days, written by expert author Steve Holzner, offers hundreds of real-world examples demonstrating the uses of XML and the newest tools developers need to make the most of it. In Week One, he starts from basic syntax, and discusses XML document structure, document types, and the benefits of XML Schema. Week Two covers formatting using either CSS or the Extensible Sytlesheet Language, and working with XHTML and other tools for presenting XML data on the Web, or in multimedia applications. The final chapter of week two discusses XForms, the newest way to process forms in XML applications. Week Three applies XML to programming with Java, .NET or JavaScript, and building XML into database or Web Service applications with SOAP. Along the way, Steve shows readers the results of every lesson and provides both the "how" and "why" of the inner working of XML technologies.

Introduction

Welcome to Extensible Markup Language (XML), the most influential innovation the Internet has seen in years. XML is a powerful, very dynamic topic, spanning dozens of fields, from the simple to the very complex. This book opens up that world, going after XML with dozens of topics—and hundreds of examples.

Unlike other XML books, this book makes it a point to show how XML actually works, making sure that you see everything demonstrated with examples. The biggest problem with most XML books is that they discuss XML and its allied specifications in the abstract, which makes it very hard to understand what's going on. This book, however, illustrates every XML discussion with examples. It shows all that's in the other books and more besides, emphasizing seeing things at work to make it all clear.

Instead of abstract discussions, this book provides concrete working examples because that's the only way to really learn XML. You're going to see where to get a lot of free software on the Internet to run the examples you create—everything from XML browsers to XPath visualizers to XQuery processors to XForms handlers, which you don't find in other books. You'll create XML-based documents that display multimedia shows you can play in RealPlayer, use browser plug-ins to handle XML-based graphics in the popular Hypertext Markup Language (HTML) browsers, enable Web pages to load and handle XML, and much more. XML can get complicated, and seeing it at work is the best way to understand it.

Read More/Download

DocBook XSL: The Complete Guide

This book is for people who want to publish DocBook XML files using the DocBook XSL stylesheets. It is a "how to" guide that gets you up and running quickly, and then provides the details you need to gain access to the full power of DocBook. The book covers:

Obtaining and setting up XSL tools and the DocBook XSL stylesheets.

• Using the built-in options to control the XSL stylesheets.
• Customizing the XSL stylesheets to match your design needs.

(This book does not cover the SGML version of DocBook, nor the DocBook DSSSL stylesheets.)

You do not need to be an XML expert to use DocBook XSL. You will need to know about XML elements and attributes, since you will be working with DocBook XML files. And you will need to know how to execute commands by typing them on a command line rather than through a point-and-click interface. If you know nothing about XSL, you can still use the stylesheets to generate high-quality output. You can also customize to a degree using the built-in stylesheet parameters. Learning some XSL will enable you to more fully customize the output. This book can teach you basic XSL, and provides dozens of examples that you can use and learn from.

Read More/Download

DocBook: The Definitive Guide

by Norman Walsh and Leonard Muellner

DocBook provides a system for writing structured documents using SGML or XML. It is particularly well-suited to books and papers about computer hardware and software, though it is by no means limited to them. DocBook is a document type definition (DTD). Because it is a large and robust DTD, and because its main structures correspond to the general notion of what constitutes a book, DocBook has been adopted by a large and growing community of authors. DocBook is supported “out of the box” by a number of commercial tools, and support for it is rapidly growing in a number of free software environments. In short, DocBook is an easy-to-understand and widely used DTD. Dozens of organizations use DocBook for millions of pages of documentation, in various print and online formats, worldwide.

This book is designed to be the clear, concise, normative reference to the DocBook DTD. This book is the official documentation for the DocBook DTD. We hope to answer, definitively, all the questions you might have about all the elements and entities in DocBook. In particular, we cover the following subjects:

• The general nature of DocBook. With over 300 elements, DocBook can be a bit overwhelming at first. We quickly get you up to speed on how the pieces fit together.
• How to write DocBook documents. Where should you start and what should you do?
• Parsing and validation. After you've written a document, how can you tell if it really conforms to the DocBook DTD?
• How to publish DocBook documents. After you've written one, what do you do with it? We provide a guide to using some popular free tools to publish DocBook documents both in print and on the Web.
• Customizing the DTD. Many individuals and corporations have standardized on the DocBook DTD. Whether your subject matter is computer software documentation or not, we explain how you can write a “customization layer” to tailor DocBook explicitly for your information.
• Understanding all of the elements. Each element is extensively documented, including the intended semantics and the purpose of all its attributes. An example of proper usage is given for every element. The parameter entities and character entities are also described.
• Stylesheets. Several standard stylesheet languages are briefly described.
• XML compatability. We outline all of the points that you'll need to consider as you or your organization contemplate XML for authoring, publishing, or both.
• Additional resources and a CD-ROM. Finally, we direct you to other places you can go for all the latest info, and offer a complete set of online documentation on the CD-ROM.

Read More/Download

OASIS OpenDocument Essentials Using OASIS OpenDocument XML

OASIS OpenDocument Essentials introduces you to the XML that serves as an internal format for office applications. OpenDocument is the native format for OpenOffice.org, an open source, cross-platform office suite, and KOffice, an office suite for KDE (the K desktop environment).

You should read this book if you want to extract data from OpenDocument files, convert your data to OpenDocument format, or simply find out how the format works.

The examples in this book are written using a variety of tools and languages. I prefer to use open-source tools which work cross-platform, so most of the programming examples will be in Perl or Java. I use the Xalan XSLT processor, which you may find at http://xml.apache.org. All the examples in this book have been tested with OpenOffice.org version 1.9.100, Perl 5.8.0, and Xalan-J 2.6.0 on a Linux system using the SuSE 9.2 distribution. This is not to slight any other applications that use OpenDocument (such as KOffice) nor any other operating systems (MacOS X or Windows); it’s just that I used the tools at hand.

Chapter 1, The Open Document Format
This chapter tells you how a document in OpenDocument format is stored and what its major components are.

Chapter 2, The meta.xml, styles.xml, settings.xml, and content.xml Files
This chapter explains the XML elements that describe meta-information (information about the document), style information, and various settings associated with a document in OpenDocument format. It also describes the general structure of the file that contains a document’s content.

Chapter 3, Text Document Basics
This chapter tells you how text documents handle character, paragraph, and section formatting. It also describes bulleted and numbered lists, and outline numbering.

Chapter 4, Text Documents—Advanced
This chapter covers frames, images, fields, footnotes, tracking changes, and tables in text documents.

Chapter 5, Spreadsheets
Spreadsheets have a great deal in common with tables; this chapter points out the similarities and differences. It also covers topics such as formulas and content validation.

Chapter 6, Drawings
This chapter explains the OpenDocument elements for basic shapes such as lines, rectangles, circles, etc.; stroke and fill properties; 3-D elements and text animation.

Chapter 7, Presentation
Text and drawings are at the heart of a presentation; this chapter covers the elements used to add backgrounds, transitions, and sound.

Chapter 8, Charts
The OpenDocument format has elements that allow you to represent charts based on data in your spreadsheets. This chapter describes the elements for chart titles, legends, axes and tickmarks.

Chapter 9, Filters in OpenOffice.org
You don’t have to create a stand-alone application to transform XML files to OpenDocument format. In this chapter, you’ll find out how to make an import filter that integrates your transformations into the OpenOffice.org application.

Read More/Download

Open XML : The markup explained

By Wouter van Vugt

Amongst the many new technologies implemented in the Microsoft Office 2007 platform there is one that you cannot miss. The new Open XML markup languages for documents, spreadsheets and presentations are here to alleviate difficulties experienced with document development and retention using older binary techniques. Open XML provides an open and standardized environment which builds on many existing standards such as XML, ZIP and Xml-Schema. Since the use of these techniques has found its way to almost every platform in use nowadays, the document is no longer a black-box containing formatted data. Instead, the document has become the data! It is easy to integrate in your business processes. Open XML provides several new technologies to allow the business data inside the document to be represented outside of the main document body, enabling easy access to the important areas of a document and allowing great document reuse. The purpose of this book is to provide you with the building blocks required to build your own document-centric solution. In this book you will discover the basics of WordprocessingML, SpreadsheetML and PresentationML as well as the DrawingML supporting language. Learn about the use of custom markup to enable custom solutions using WordprocessingML, the formulas of SpreadsheetML or the great visual effects that can be applied using DrawingML.

Who is this book for?
In this book you will be provided a detailed overview of the three major markup languages in Open XML. This book is written for those who have a basic understanding of XML or HTML. If you are a software architect or developer who needs to build document-centric solutions you can learn about how to build your value-added solutions based on the Open XML platform. Those new to document markup languages as well as those more experienced in document markup but new to Open XML will benefit from this book.

Read More/Download