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 

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

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

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

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 & 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

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