Xml
•
2 likes•2,007 views
The document provides an overview of XML and related technologies including SOAP and WSDL. It discusses what XML is, its uses, XML schemas and validation, and XML query languages. It also covers SOAP and WSDL for defining web services, and related specifications from the W3C and OASIS. Examples of XML documents and tags are provided to illustrate XML syntax and structure.
![Agenda ,[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
More Related Content
What's hot
What's hot (20)
Viewers also liked
Viewers also liked (18)
Similar to Xml
Similar to Xml (20)
More from Vishwa Mohan
Xml
- 1. An overview of XML & SOAP Ch.Vishwa Mohan Project Manager KREST Embedded Technologies
- 4. Microsoft .NET Experiences & Solutions Tools Software for Connecting Information, People, Systems and Devices XML Web Services across the Entire Microsoft Platform Servers Clients Services
- 8. What is Self Describing? ST*323*712990413 V1*7039610*NEW ZEALAND QUEEN*D*104N*SCAC***L LS*0100 R4*D*D*JAX*JACKSONVILLE FL**** V9*EAD**920819**JACKSONVILLE FL***A26 R4*D*D*ORF*NORFOLK, VA**NORFOLK INTL TERMIN** V9*EAD**920817**NORFOLK, VA***A26 R4*L*K*MEB*MELBOURNE, AUST**** V9*EDD**920712**MELBOURNE, AUST***A40 R4*L*K*SYD*SYDNEY, AUST**** V9*EDD**920715**SYDNEY, AUST***A40 R4*L*K*WLG*WELLINGTON, NEW ZEALAND**** V9*EDD**920721**WELLINGTON, NEW ZEA***A40 LE*0100 SE*25*712990413 This is not self describing data!
- 16. XML Document Example <?xml version="1.0" encoding="utf-8“ ?> <!DOCTYPE employees SYSTEM "C:mployee.dtd"> <employees xmlns="http://www.krestembedded.com/empinfo"> <employee gender=“male"> <name> <first>Vishwa</first> <last> Mohan</last> <nick>C.V</nick> </name> <qualification>M.E </qualification> <designation>Project Manager</designation> </employee > <employee gender=“female"> <name> <first>Subba</first> <last>Laxmi</last> </name> <qualification>B.Tech</qualification> <designation>Project Associate</designation> </employee > </employees>
- 25. XML DTD & Schema
- 29. The “employee” DTD <?xml version="1.0" encoding="UTF-8"?> <!ELEMENT employees ((employee+))> <!ATTLIST employees xmlns CDATA #FIXED "http://www.krestembedded.com/empinfo"> <!ELEMENT employee ((name, qualification, designation))> <!ATTLIST employee gender (male | female) #REQUIRED> <!ELEMENT name ((first, last, nick?))> <!ELEMENT first (#PCDATA)> <!ELEMENT last (#PCDATA)> <!ELEMENT nick (#PCDATA)> <!ELEMENT qualification (#PCDATA)> <!ELEMENT designation (#PCDATA)>
- 36. Schema for Employees <?xml version="1.0" encoding="utf-8"?> <xs:schema targetNamespace="http://www.krestembedded.com/empinfo" xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="employees"> <xs:complexType> <xs:sequence> <xs:element maxOccurs="100" name="employee"> <xs:complexType> <xs:sequence> <xs:element name="name"> <xs:complexType> <xs:sequence> <xs:element name="first" type="xs:string" /> <xs:element name="last" type="xs:string" /> <xs:element minOccurs="0" name="nicK" type="xs:string" />
- 37. Schema for Employees </xs:sequence> </xs:complexType> </xs:element> <xs:element name="qualification" type="xs:string" /> <xs:element name="designation" type="xs:string" /> </xs:sequence> <xs:attribute name="gender" type="xs:string" use="required" /> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>
- 41. XML Elements and Relations
- 42. XML Elements and Relations
- 71. XML Linking Languages (XLink, XPointer)
- 74. XML Style Sheet Specification (CSS, XSLT, XSLT-FO)
- 81. XSLT with Templates <?xml version=“1.0”?> <xsl:transform xmlns:xsl= “http://www.w3.org/1999/ XSL/ Transform” xsl:version=“1.0”> <xsl:template match=“/”> <xsl:text> <html><head><title>Article Summary</title></head> <body><h1>Article Summary by Author</h1></xsl:text> <xsl:apply-templates> <xsl:text></body></html></xsl:text> </xsl:template/> <xsl:template match=“author”> <xsl:text><p><b>Author: </b></xsl:text> <xsl:apply-templates select=”/author/surname”/> <xsl:text>, </xsl:text> <xsl:apply-templates select=:”/author/fname”/></p> </template>
- 82. Web Services & SOAP
- 85. Four Tenets of Service Orientation SERVICE ORIENTATION Compatibility Based On Policy Share Schema & Contract, Not Class Services Are Autonomous Boundaries Are Explicit
- 88. Web Services
- 90. SOAP Message <?xml version="1.0" encoding="UTF-8" ?> < env:Envelope xmlns:env= " http://www.w3.org/2002/12/soap-envelope "> < env:Header > <n:alertcontrol xmlns:n="http://example.org/alert"> <n:priority>1</n:priority> <n:expires>2012-12-12T00:00:00</n:expires> </n:alertcontrol> < /env:Header > < env:Body > <m:alert xmlns:m="http://example.org/alert"> <m:msg>World is going to destroy ! </m:msg> </m:alert> < /env:Body > < /env:Envelope >
- 92. SOAP Envelope
- 95. RSS
- 97. Simple RSS Example <rss version="0.91"> <channel> <title>XML.com</title> <link>http://www.xml.com/</link> <description>XML.com features services for XML community</description> <language>en-us</language> <item> <title>Normalizing XML, Part 2</title> <link>http://www.xml.com/pub/a/2002/12/04/normalizing.html</link> <description> Relation normalization techniques to XML schema data modeling </description> </item> <item> <title>The .NET Schema Object Model</title> <link>http://www.xml.com/pub/a/2002/12/04/som.html</link> <description>Describes in detail the use of the .NET Schema Object Model </description> </item> </channel> </rss>
- 98. Thank You ! You can reach me at : [email_address] 9490995632
Editor's Notes
- XML 1.0 is the specification that defines what &quot;tags&quot; and &quot;attributes&quot; are XLink describes a standard way to add hyperlinks to an XML file. XPointer is a syntax in development for pointing to parts of an XML document. CSS , the style sheet language, is applicable to XML as it is to HTML. XSL is the advanced language for expressing style sheets. Based on XSLT. XSLT is used to transfom XML documents from one form to other.
- Key Messages: .NET is our implementation of xml web services – our strategy to ensure that our products connect better together and better with others. we ’ ve spent the past 3 years making XML web services integral to our entire business software platform .NET provides the comprehensive means for interoperating and driving new value from all of your (your partners and customers) existing systems … regardless of platform they run on or what programming language they were created in … Your decision will be in choosing the best software platform for bringing connectedness and integration to life … and we hope you see that .NET is the best choice We are continuing to push XML Web services and support for it in the toolset – you will see our implementations of WS-Security as we get into the details of our platform and tools Slide Build: 2 [see script] Slide Script: [BUILD 1] Microsoft .NET is software for connecting people, systems, information and devices. For Developers it means the ability to quickly build solutions that interoperate across languages, platforms and devices For IT, it means the ability to integrate new and existing systems across the organization and externally w/ Partners For Businesses, it means having the agility to connect more deeply with customers, integrate with business partners and empower its employees For Consumers it ’ s the ability to access and act upon information anytime, anywhere and on any device [BUILD 2] Microsoft .NET is built on a foundation of XML Web Services enabling both new and existing applications to connect with software and services across platforms, applications and programming languages Slide Transition: Strips Right-Down Additional Information for Presenter: NOTE: If you forego a drilldown on tools, servers, etc, this slide provides a high level overview on the commitment.
- The current version of XML is 1.0. Still XML version 1.1 exists but not used those have special requirements. Any Kind of Data: XML documents contain text, never binary data. So BMP, voice information can’t be store in XML documents. To include binary data you need to encode into different format and you can specify encode format as attribute. But MTOM works on binary format. Unambiguous structure: An XML document not only contains data but also the structure
- XML is designed to improve the functionality of the Web by providing more flexible and adaptable information identification. XML is a powerful tool for data representation, storage, modelling , and interoperation . 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 meta language used to define new markup languages . With XML, you can create a language crafted specifically for your application or domain. (Eg: XAML, ebXML , etc.,) SGML is the Standard Generalized Markup Language defined by ISO 8879. This is also a meta language. SGML has been the standard, vendor-independent way to maintain repositories of structured documentation for more than a decade, but it is not well suited to serving documents over the web. XML was created so that richly structured documents could be used over the web. The only viable alternatives, HTML and SGML, are not practical for this purpose.
- Well formed documents are: Only small set of rules. Semantics not really known. Can be displayed Can be processed Easy to work with. Valid XML documents are: Can be validated against a standard set of rules Large number of DTD's available For instance XHTML is an XML DTD Others: e-business, multimedia, chemical language, mathematics, etc. Advantage: correct interpretation and processing possible Superceeded by XML-schema: start today, use schema not DTD
- explex
- In short HTML is a markup language for presentation, and XML is a language for creating markup language that describe structured data.
- XML has its root in SGML which was created in 1986. SGML was too complex, something bit simpler was needed thus the birth of XML. SGML is the Standard Generalized Markup Language defined by ISO 8879. SGML has been the standard, vendor-independent way to maintain repositories of structured documentation for more than a decade, but it is not well suited to serving documents over the web.
- The XML PI is: Very important for detecting encoding Identifies XML when file and media type information is unavailable or unreliable
- Elements are the most common form of markup. Delimited by angle brackets, most elements identify the nature of the content they surround. <title> Definitive XML Schema </title>
- In order to insert these characters into your document as content, there must be an alternative way to represent them. Character reference is a mechanism for inserting characters that cannot be typed directly on your keyboard.
- The name , called the PI target, identifies the PI to the application. Applications should process only the targets they recognize and ignore all other PIs. Any data that follows the PI target is optional, it is for the application that recognizes the target. The names used in PIs may be declared as notations in order to formally identify them. Any data that follows the PI target is optional, it is for the application that recognizes the target.
- The commas between element names indicate that they must occur in succession. The plus after author indicates that it may be repeated more than once but must occur at least once. The question mark after price indicates that it is optional An XML DTD can be interchanged with the XML instance An XML DTD can provide a schema for a broad class of XML documents
- Target element is the element which the attribute applies. Attr- Name is the attribute name.
- The commas between element names indicate that they must occur in succession. The plus after employee indicates that it may be repeated more than once but must occur at least once. The question mark after nick indicates that it is optional
- Schemas are developed to replace DTD’s
- Schemas are developed to replace DTD’s The Schema consists a set of predefined rules that describes a given class of XML document.
- XML Schema definition language (XSD) has become the mainstream language for describing XML documents.
- The definitions placed within the xsd:schema element are automatically associated with the namespace specified in the targetNamespace attribute.
- Lexical
- The definitions placed within the xsd:schema element are automatically associated with the namespace specified in the targetNamespace attribute.
- The key difference between the above two parsing is that DOM loads the entire document into an in-memory data structure. In case of SAX iterates over the XML document one piece at a time in a forward-only and read-only fashion. Processing instructions provide a mechanism for document authors to communicate with XML-aware applications behind the scenes. SAX is primarily a collection of interfaces in the org.xml.sax package. The interface ContentHandler is the key piece of SAX. Almost every SAX program need to use this interface. ContentHandler is a call back interface.
- DOM allows programs and scripts to dynamically access and update the content structure and style of a document. The HTML DOM defines the objects and properties of all HTML elements, and the methods (interface) to access them.
- Some of the DOM rules: In a node tree, the top node is called the root Every node, except the root, has exactly one parent node A node can have any number of children A leaf is a node with no children Siblings are nodes with the same parent Some of the properties and methods of XML DOM : These are some typical DOM properties: x.nodeName - the name of x x.nodeValue - the value of x x.parentNode - the parent node of x x.childNodes - the child nodes of x x.attributes - the attributes nodes of x Element methods are: x. getElementsByTagName ( name ) - get all elements with a specified tag name x. appendChild ( node ) - insert a child node to x x. removeChild ( node ) - remove a child node from x
- SAX stands for Simple API for XML. Unlike DOM , there is no formal specification for SAX. The Java implementation of SAX is considered to be normative , and implementations in other languages attempt to follow the rules laid down in that implementation, adjusting for the differences in language where necessary. The memory footprint of a SAX parser, by contrast, is based only on the maximum depth of the XML file (the maximum depth of the XML tree) and the maximum data stored in XML attributes on a single XML element.
- XmlReader and XmlWriter are abstract classes.
- Another significant XML-related feature that was introduced in SQL Server 2005 is support for XML indexes . You can create primary and secondary XML indexes for columns of type xml to enhance XML query performance. XML DML is Microsoft enhancement for XQuery.
- The XML data type in SQL Server can also be strongly typed with XML Schemas. With a strongly typed XML Column, it is verified if the data confirms to the schema when XML data is inserted.
- XPath is used by XSL also by XPointer .
- XPath is used by XSL also by XPointer .
- The <xsl:stylesheet> and <xsl:transform> are completely synonymous and either can be used. The match attribute can also be used to define a template for the entire XML document.
- An <xsl:template> element defines a template rule to be triggered when a particular part of the source document is being processed. The attribute match=&quot;/&quot; indicates that this particular rule is triggered right at the start of processing the source document. Here «/» is an Xpath expression which identifies the root node of the document:
- XQuery is based on existing XPath query language. With support added for better iteration, better sorting results, and the ability to construct the necessary XML. Whereas XML Schema only defined the types, XQuery has defined the operations that are allowed on those types. XQuery results are either typed or untyped. The type information is based on schema language. XQuery is a strongly typed programming language . Like Java and C#, for example, it's a mix of static typing (type consistency checked at compile-time) and dynamic typing (run-time type tests).
- Types in XQuery: Numbers, including integers and floating-point numbers. The boolean values true and false. Strings of characters, for example: &quot;Hello world!&quot;. These are immutable - i.e. you cannot modify a character in a string. Various types to represent dates, times, and durations. A few XML-related types. For example a QName is a pair of a local name (like template) and a URL, which is used to represent a tag name like xsl:template after it has been namespace-resolved.
- Popular template processors , like JSP, ASP, and PHP, allow you to embed expressions in a programming language into HTML content. XQuery gives you that ability, plus the ability to embed XML/HTML forms inside expressions, and to have them be the value of variables and parameters. XQuery node values are immutable. You can’t modify node after it has been created. The sortby() takes an input sequence (in this case $books) and one or more ordering expressions . $books sortby (author/name)
- The document() function returns the root node of a document. The /book expression selects the child elements of the root that are named book, so $book gets set to the single root element.
- An important goal for XQuery is that it should be usable as a query language for XML databases. Compare the corresponding SQL statement,
- So 3+4 is a complete, valid XQuery program which evaluates to the integer 7. The XQuery standard specifies the result value of an expression or program, but it does not specify how it is to be evaluated. An implementation has considerable freedom in how it evaluates an XQuery program, and what optimizations it does.
- The below is second section of the fifth chapter of the doc. /doc/chapter[5]/section[2] XQuery element constructor consists of a start tag and an end tag, enclosing an optional list of expressions that provide the content of the element. A FLWOR expression binds some expressions, applies an optional predicate and ordering, and constructs a new result. FLOWER stands for FOR, LET, WHERE, ORDER and RETURN Clause
- Popular template processors , like JSP, ASP, and PHP, allow you to embed expressions in a programming language into HTML content. XQuery gives you that ability, plus the ability to embed XML/HTML forms inside expressions, and to have them be the value of variables and parameters. XQuery node values are immutable. You can’t modify node after it has been created.
- We've seen atomic values (numbers, strings, etc), and node values (elements, attributes, etc). These are together known as simple values. The for expression first evaluates the expression following the in . Then for each value of the resulting sequence, The variable (in this case $x) is bound to the value, and the return expression evaluated using that variable binding.
- USER & AUTO: Today <A> links in HTML are USER Today <IMG> links in HTML are AUTO <A> links are ACTUATE =USER and SHOW =REPLACE <IMG> links are ACTUATE =AUTO and SHOW =EMBED
- Simple declaration is : H1 { font-weight: bold } Simple Complex declaration is: H2, H3, H4 {font-size: 12pt; font-style: normal; font-weight: bold;} Complex
- My Notes: Today's applications require the ability to communicate with other systems in an efficient and secure manner. Speaker Notes For years, software development has focused on how to best reuse the code that we write. Ultimately, people and businesses want long-term return on their short-term investments in code. How do we do this? We’ve seen 3 waves of advancement in this movement in recent decades: 1980s and Object-Orientation: Object-oriented development promised the idea of building reusable abstractions (called classes) that we could then inherit from in order to reuse the base class functionality. This shift from simple procedural-based code brought with it a lot of benefits including polymorphism (the ability to dynamically bind types at runtime), abstractions that included both state and behavior, and encapsulation (controlling which parts of the code the external world can access). However, Object-Orientation by itself didn’t facilitate the dynamic evolution of software at runtime. Once an application was built, it was static. There wasn’t an easy way to infuse new code into an application. 1990s and Components: Component-based development helped us overcome this challenge. It forced the developer to think about the external facing interface of the application. This enabled us to build systems that dynamically load and bind to new functionality at runtime (an application discovers new components after it has been built) and introduced the notion of an application as a growing/evolving organism. To facilitate dynamic loading, we saw a big emphasis on runtime metadata. In the past, you couldn’t easily discern application capabilities since there was very little/rudimentary metadata information stored as part of the application. Whereas C and C++ programs from 1980s were these relatively opaque collections of code, component-based applications of the 1990s enabled runtime inspection of code to determine what a particular component supported. This introduced the notion of self-describing systems. But while this metaphor worked really well on a single machine (using method invocation on an object reference), we hit scaling problems when we tried to stretch it out and apply it as the substrate for distributed software integration (across machines, etc). 2000s and Service-Orientation – With Service-Orientation, we retain the benefits of self-describing applications, explicit encapsulation, and dynamic loading of functionality. What changes is the metaphor with which we accomplish it. Instead of using method invocation on an object reference, we shift the conversation to that of message passing – a proven metaphor for scalable distributed software integration. In addition, to support dynamic loading of service-based functionality, we use schema to describes the structure of messages, behavioral contract to define acceptable message exchange patterns, and policy to define service semantics. Simplifying service-oriented development is one of the biggest bets we’re making in &quot;WCF&quot;. &quot;WCF&quot; takes the service-oriented concepts of message passing, schema, contract, and policy, and implicitly applies it to all of the services we build. As such, &quot;WCF&quot; provides you with the first true service-oriented programming model. Transition to next slide: We define service oriented applications as those that adhere to “The Four Tenets of Service-Orientation.” Let’s examine these and see how &quot;WCF&quot; implements them… 03/27/11 05:51 © 2004 Microsoft Corporation. All rights reserved. This presentation is for informational purposes only. Microsoft makes no warranties, express or implied, in this summary. Next Generation Business Solutions Platform Strategy Review
- Service management includes many functions including, Security, Deployment, Logging, Dynamic rerouting and Maintenance.
- Speaker Notes Boundaries are Explicit: Services run in a separate process from their clients • Well-defined public interface to your service • Avoid RPC use explicit messages • Public “gateway” to your internal (private) implementation • Don’t expose implementation details. Explicit boundaries mean that a service can be deployed anywhere and be easily and freely accessed by other services, regardless of the environment or development language of the other service. Here messages need to cross the development environment boundaries. Same time it doesn’t care about the message consumer environment also. The thing to keep in mind is that there is a cost associated with crossing boundaries. These costs come in a number of forms, such as communication, performance, and processing overhead costs. Services should be called quickly and efficiently. Tenet 1: Boundaries are Explicit . Based on the underlying concept of encapsulation, this tenet specifies the publishing and consumption of functionality as sets of services that abstract their underlying implementation Services are Autonomous: • Deployed/Versioned independent of system and other services • Contract, once published should not be changed • A service owns its needed business components • A service should be able to perform without external dependencies Services are built and deployed independently of other services. Systems, especially distributed systems, must evolve over time and should be built to handle change easily. This SOA principle states that each service must be managed and versioned differently so as to not affect other services in the process. Ex: In the book publisher example, the Order Process service and Order Fulfillment service are completely independent of each other; each is versioned and managed completely independent of the other. In this way, when one changes it should not affect the other. It has been said that services should be built not to fail. In following this concept, if a service is unavailable for whatever reason or should a service depend on another service that is not available, every precaution should be taken to allow for such services to survive, such as redundancy or failover. Tenet 2: Services are Autonomous . Autonomy means we design the system to support the inevitable evolution of the service’s implementation over time. As we build our services, we need to assume that their internal implementation will evolve (be versioned) over time and that our services as well as the services on which we depend could change location at (almost) any time. Services share schema and contract, not class: • Clients send messages to a service that conform to a contract. • Classes contain data and behavior. • Contract must not change once published. • Contracts/Schemas provide platform-independent interoperability • Contract via WSDL Think “schemas = data” and “contracts = behavior.” The contract contains information regarding the structure of the message. Services do not pass classes and types; they pass schemas and contracts. This allows for a loosely coupled system where the service does not care what type of environment the other service is executing on. The information being passed is 100 percent platform independent.. Tenet 3: Services share schema and contract, not class . For those of you who are familiar with ASMX - this is exactly how ASMX works: The service publishes a contract that clients use to generate their own code to call the service. No types are shared between service and its clients by default. In addition, neither Service requires knowledge of each others’ internal workings in order to exchange data – they only need the published schemas & contracts. Service compatibility is determined based on policy: • Separate “content” from “behavior” • Policy describes non functional constraint such as communication protocols, security and reliability requirements Services look at each others’ policy, looking for similarities so that they can start communicating. If two services can’t satisfy each others’ policy requirements, all bets are off. These policies exist in the form of machine-readable expressions. Policies also allow you to move a service from one environment to another without changing the behavior of the service. Tenet 3: Service compatibility is determined based on policy . The services communicate through dynamically negotiated communications channels that support the necessary semantics (security, reliability, etc). Service policy statements created automatically based on configuration, class attributes, and method signatures. Client channels automatically configured via retrieved service policy. By “name” means that we reference a well known name in Policy that represents a whole specification of behavior that needs to be used when talking to this endpoint.
- UDDI : Universal Description, Discovery and Integration. XML Web Service discovery is the process of locating and interrogating XML Web Service descriptions. Programmatic discovery can be enabled when an XML Web service publishes a .disco file.
- If SOAP uses the HTTP as transport then HTTP security would be adequate for SOAP.
- An Envelope : That defines a framework for describing what is in a message and how to process it. It is always a root element of SOAP message. Optional Header: A set of encoding rules for expressing instances of application-defined data types. When Header present it should be the first child element of the envelope. The Header element is a generic mechanism for adding features to a SOAP message in a decentralized manner. Mandatory Body: A convention for representing remote procedure calls and responses. Play load, response message and Fault elements goes here. The fault element is shown in <soap:Fault> . The fault element must contain a faultcode followed by faultstring .
- The SOAP fault model requires that all SOAP-specific and application-specific faults be reported using a single distinguished element, env:Fault , carried within the env:Body element. The Fault element contains two mandatory sub-elements, Code and Reason , and (optionally) application-specific information in the Detail sub-element Another optional sub-element, Node , identifies via a URI the SOAP node which generated the fault, its absence implying that it was the ultimate recipient of the message which did so. There is yet another optional sub-element, Role , which identifies the role being played by the node which generated the fault. The Code sub-element of Fault is itself made up of a mandatory Value sub-element, whose content is specified in the SOAP specification as well as an optional Subcode sub-element.
- The user subscribes to a feed by entering into the reader the feed's URI or by clicking an RSS icon in a web browser that initiates the subscription process. The RSS reader checks the user's subscribed feeds regularly for new work, downloads any updates that it finds, and provides a user interface to monitor and read the feeds.
- The above RSS feed in version 1.0 format: <rdf:RDF xmlns:rdf=&quot;http://www.w3.org/1999/02/22-rdf-syntax-ns#&quot; xmlns=&quot;http://purl.org/rss/1.0/“ xmlns:dc=&quot;http://purl.org/dc/elements/1.1/“ > <channel rdf:about=&quot;http://www.xml.com/cs/xml/query/q/19&quot;> <title>XML.com</title> <link>http://www.xml.com/</link> <description>XML.com features a rich mix of information and services for the XML community.</description> <language>en-us</language> <items> <rdf:Seq> <rdf:li rdf:resource=&quot;http://www.xml.com/pub/a/2002/12/04/normalizing.html&quot;/> <rdf:li rdf:resource=&quot;http://www.xml.com/pub/a/2002/12/04/som.html&quot;/> <rdf:li rdf:resource=&quot;http://www.xml.com/pub/a/2002/12/04/svg.html&quot;/> </rdf:Seq> </items> </channel> <item rdf:about=&quot;http://www.xml.com/pub/a/2002/12/04/normalizing.html&quot;> <title>Normalizing XML, Part 2</title> <link>http://www.xml.com/pub/a/2002/12/04/normalizing.html</link> <description>In this second and final look at applying relational normalization techniques to W3C XML Schema data modeling, Will Provost discusses when not to normalize, the scope of uniqueness and the fourth and fifth normal forms.</description> <dc:creator>Will Provost</dc:creator> <dc:date>2002-12-04</dc:date> </item> <item rdf:about=&quot;http://www.xml.com/pub/a/2002/12/04/som.html&quot;> <title>The .NET Schema Object Model</title> <link>http://www.xml.com/pub/a/2002/12/04/som.html</link> <description>Priya Lakshminarayanan describes in detail the use of the .NET Schema Object Model for programmatic manipulation of W3C XML Schemas.</description> <dc:creator>Priya Lakshminarayanan</dc:creator> <dc:date>2002-12-04</dc:date> </item> <item rdf:about=&quot;http://www.xml.com/pub/a/2002/12/04/svg.html&quot;> <title>SVG's Past and Promising Future</title> <link>http://www.xml.com/pub/a/2002/12/04/svg.html</link> <description>In this month's SVG column, Antoine Quint looks back at SVG's journey through 2002 and looks forward to 2003.</description> <dc:creator>Antoine Quint</dc:creator> <dc:date>2002-12-04</dc:date> </item> </rdf:RDF>