<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
<!DOCTYPE rss PUBLIC "-//Netscape Communications//DTD RSS 0.91//EN" "http://my.netscape.com/publish/formats/rss-0.91.dtd">

<rss version="0.91">
	<channel>
		<title>TrooBloo - SAX</title>
		<description>Articles and tutorials regarding SAX</description>
		<link>http://www.troobloo.com/tech/sax.shtml</link>
		<language>en-us</language>

		<item>
			<title>The Collected Works of SAX</title>
			<link>http://www.xml.com/pub/a/2001/07/18/collectedsax.html</link>
			<description>by Leigh Dodds July 18, 2001 Now more than three years old, SAX (Simple API for XML) is the oldest and most stable XML API in widespread use today. Yet despite its obvious utility it can be quite daunting to programmers making their first foray into manipulating XML documents. It's no surprise, then, than many appear to prefer using the DOM API in their early coding efforts, despite its many quirks and additional overhead. A likely reason is that most tutorials introduce XML as a...</description>
		</item>

		<item>
			<title>Introducing XML::SAX::Machines, Part Two</title>
			<link>http://www.xml.com/pub/a/2002/03/20/machines.html</link>
			<description>by Kip Hampton March 20, 2002 Introduction In last month's column we began our introduction to XML::SAX::Machines , a group of modules which greatly simplifies the creation of complex SAX application with multiple filters. This month we pick up where we left off by further illustrating how XML::SAX::Machines can be used to remove most of the drudgery of building SAX-based XML processing applications. If you have not read last month's offering, please do so now. Example One -...</description>
		</item>

		<item>
			<title>Dynamic XML Conversion Using the SAX Parser</title>
			<link>http://www.phpbuilder.com/columns/scheffler20030325.php3</link>
			<description>This article describes an alternative way of converting XML to HTML using the SAX parser. For each tag you want to convert, you write a conversion function. This function is called with two arguments: contents and attributes. The return value of the function will replace the tag and its contents in the finished document. Introduction We all know it: XML is great. (If you don't, look at some of the great articles at this site.) But why is it so complicated to use? You have to learn about...</description>
		</item>

		<item>
			<title>High-Performance XML Parsing With SAX</title>
			<link>http://www.xml.com/pub/a/2001/02/14/perlsax.html</link>
			<description>by Kip Hampton February 14, 2001 The problem: The XML documents you have to parse are getting too large to load the entire document tree into memory; performance is suffering. The solution: use SAX. Understanding Event-Driven XML Processing SAX (Simple API for XML) is an event-driven model for processing XML. Most XML processing models (for example: DOM and XPath) build an internal, tree-shaped representation of the XML document. The developer then uses that model's API (...</description>
		</item>

		<item>
			<title>Handling SAX Errors</title>
			<link>http://www.fawcette.com/javapro/2002_11/magazine/columns/javatecture/</link>
			<description>November 2002 Issue Y ou're charging away using some great piece of code you wrote (or someone else wrote) that is making your life easier, when suddenly plotz! boom! The whole thing collapses in some useless Java error you don't understand and don't want to track down. Why do people write code like that? Because handling errors is a lot of trouble and it is much easier to leave them &quot;as an exercise for the reader.&quot; In his book about extreme programming, Kent Beck emphasizes that you...</description>
		</item>

		<item>
			<title>Simple XML Parsing with SAX and DOM</title>
			<link>http://www.oreillynet.com/pub/a/onjava/2002/06/26/xml.html</link>
			<description>by Philipp K. Janert, Ph.D. 06/26/2002 XML has arrived. Configuration files, application file formats, even database access layers make use of XML-based documents. Fortunately, several high-quality implementations of the standard APIs for handling XML are available. Unfortunately, these APIs are large and therefore provide a formidable hurdle for the beginner. In this article, I would like to offer an accessible introduction to the two most widely used APIs: SAX and DOM. For each API, I...</description>
		</item>

		<item>
			<title>Practicing Safer SAX</title>
			<link>http://www.fawcette.com/javapro/2002_10/magazine/columns/javatecture</link>
			<description>October 2002 Issue I t's amazing what you can find in the back of your cupboard. Just last weekend, I found a half-bottle of an inexpensive 1991 Merlot that had gotten mixed in with the salad oil and vinegar bottles. How appropriate: Now I have some new red wine vinegar I didn't know I had! Well, we sometimes find old code lying around in the same way, and although it doesn't really spoil, it can get out of date. For example, consider XML parsers. All of the common methods for parsing...</description>
		</item>

		<item>
			<title>Transforming Flat Files To XML With SAX and XSLT</title>
			<link>http://www.developer.com/xml/article.php/2108031</link>
			<description>By Jeff Ryan Go to page: 1 2 Next Introduction When we need to transform XML into other formats, XSLT (eXtensible Stylesheet Language for Transformations) does a wonderful job. However, sometimes we have a flat file or non-XML data structure that we need to transform into XML or other markup languages. Wouldn't it be nice if we could use the power of XSLT to transform these data structures as well? Well, the answer is we can use XSLT to transform non-XML data sources using SAX (Simple...</description>
		</item>

		<item>
			<title>Mapping XML to Java, Part 1</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/xml/mapping/</link>
			<description>Employ the SAX API to Map XML Documents To Java Objects By Robert Hustead ; Reprinted from JavaWorld September 2000 ML is hot. Because XML is a form of self-describing data, it can be used to encode rich data models. It's easy to see XML's utility as a data exchange medium between very dissimilar systems. Data can be easily exposed or published as XML from all kinds of systems: legacy COBOL programs, databases, C++ programs, and so on. However, using XML to build systems poses two...</description>
		</item>

		<item>
			<title>Rapid Resolution</title>
			<link>http://www.xml.com/pub/a/2001/06/20/catalogs.html</link>
			<description>by Leigh Dodds June 20, 2001 SAX users will be interested in a little exchange (actually a disagreement) that took place on XML-DEV this week about how SAX might best be altered to support entity catalogs. Regular readers will remember that the issue of using catalogs -- a means to map SYSTEM and PUBLIC identifiers into physical locations -- was covered in an XML-Deviant article last year (&quot; Filling in the Gaps &quot;, and see also &quot; What's In a Name? &quot; for additional discussion of entity...</description>
		</item>

		<item>
			<title>Floating-Point in .NET Part I: Concepts and Formats</title>
			<link>http://www.c-sharpcorner.com/Code/2005/April/ExtremeFloatingPoint.asp</link>
			<description>Author Date Of Submission User Level Jeffrey Sax 04/18/2005 Intermediate Source Code: Extreme.FloatingPoint1.zip 8Kb Introduction Here's a quick quiz. What is printed when the following piece of code runs? We calculate one divided by 103 in both single and double precision. We then multiply by 103 again, and compare the result to the value we started out with: Console.WriteLine(&quot;((double)(1/103.0))*103 &lt; 1 is &quot;, ((double)(1/103.0))*103 &lt; 1); Console.WriteLine(&quot;((float)(1/103.0F))*103 &gt;...</description>
		</item>

		<item>
			<title>A Better XML API for Java</title>
			<link>http://www.fawcette.com/xmlmag/2002_03/magazine/columns/collaboration/kjones/</link>
			<description>T wo APIs are widely used when parsing, creating, and managing XML in Java: SAX and DOM. Because it is fast and lightweight, SAX is great for consuming XML and performing tasks based on that XML. However, SAX does not allow for the in-memory manipulation of XML. DOM, on the other hand, allows programmers to create and manipulate XML in memory, storing the XML as a tree of information. DOM, however, is memory hungry and considered by many to be over-engineered. To address the problems of...</description>
		</item>

		<item>
			<title>Pull Parsing in C# and Java</title>
			<link>http://www.xml.com/pub/a/2002/05/22/parsing.html</link>
			<description>by Niel Bornstein May 22, 2002 In my first article in this series, I wrote about porting a SAX application called RSSReader to the new Microsoft .NET Framework XmlReader . After publication, I received a message from Chris Lovett of Microsoft suggesting I revisit the subject. As he said, while the code I presented works, my approach was not optimal for the .NET framework; I was still thinking in terms of SAX event driven state machinery. A much easier way to approach this problem is to...</description>
		</item>

		<item>
			<title>Does StAX Stack Up?</title>
			<link>http://www.developer.com/java/ent/article.php/3351701</link>
			<description>Where does StAX fit in with its sister API for processing XML documents? Despite its name, SAX isn't all that simple. In fact, it's kind of awkward at first. The developer writes a handler class that receives event callbacks. It is a &quot;push&quot; type of API that requires reading the entire XML document. SAX is strictly an API for reading XML documents. You must learn another API to write XML documents. DOM is a very powerful API that can be used to create, query, and manipulate XML...</description>
		</item>

		<item>
			<title>Java and XML Basics, Part 3</title>
			<link>http://www.devarticles.com/c/a/XML/Java-and-XML-Basics-3/</link>
			<description>( Page 1 of 9 ) So far, during this series of articles ( part 1 , part 2 ) we've looked at DOM and SAX, and I suppose most of you are thinking which one of the two approaches is preferable? Well, there is no general rule of thumb, but this article might help you make the right decision when you ll have to. NOTE Before you get started, you'll probably want to download the support file (70KB) which contains sample codes for all articles in this series up to this point.) Performance...</description>
		</item>

		<item>
			<title>An Introduction to StAX</title>
			<link>http://www.xml.com/pub/a/2003/09/17/stax.html</link>
			<description>by Elliotte Rusty Harold September 17, 2003 Most current XML APIs fall into one of two broad classes: event-based APIs like SAX and XNI or tree-based APIs like DOM and JDOM. Most programmers find the tree-based APIs to be easier to use; but such APIs are less efficient, especially with respect to memory usage. An in-memory tree tends to be several times larger than the document it models. Thus tree APIs are normally not practical for documents larger than a few megabytes in size or in...</description>
		</item>

		<item>
			<title>Transforming XML with XSL using Sablotron</title>
			<link>http://www.phpbuilder.com/columns/justin20001025.php3</link>
			<description>Justin Grant In my last article I covered the use of the expat functions available to PHP for parsing XML documents using the SAX method. The sample code was a class that read the XML document and generated the HTML to present the data in a nice table. This example was far from perfect due to the fact that the presentation of the data was not separate from the class code that had to parse the XML document. This meant that a slight modification to the HTML generated by the class could...</description>
		</item>

		<item>
			<title>Java and XML Basics, Part 2</title>
			<link>http://www.devarticles.com/c/a/XML/Java-and-XML-Basics-2/</link>
			<description>( Page 1 of 6 ) Last time, we learned about JAXP, Xerces, DOM and the javax.xml.parsers Java Package. How about getting a little taste of the SAX interfaces? We look at available classes and interfaces, and learn how to use SAX for XML Processing. Given SAX's power, perhaps we can look forward to the day when we'll be translating not just XML, but maybe even Klingon! Maybe not. Before you get started, you'll want to download the support files for this tutorial. SAX Parsing While, in the...</description>
		</item>

		<item>
			<title>Top Ten SAX2 Tips</title>
			<link>http://www.xml.com/pub/a/2001/12/05/sax2.html</link>
			<description>by David Brownell December 05, 2001 If you write XML processing code in Java, or indeed most popular programming languages, you will be familiar with SAX, the Simple API for XML. SAX is the best API available for streaming XML processing, for processing documents as they're being read. SAX is the most flexible API in terms of data structures: since it doesn't force you to use a particular in-memory representation, you can choose the one you like best. SAX has great support for the XML...</description>
		</item>

		<item>
			<title>XML Basics for Java Developers, Part 2</title>
			<link>http://www.oreillynet.com/pub/a/onjava/excerpt/learnjava_23/index2.html</link>
			<description>by Jonathan Knudsen , Pat Niemeyer In this second part in a several part series on XML for Java developers from Learning Java, 2nd Edition , learn about SAX and the SAX API. SAX Related Reading Learning Java, 2nd Edition By Pat Niemeyer , Jonathan Knudsen Table of Contents Index Sample Chapter SAX is a low-level, event-style mechanism for parsing XML documents. SAX originated in Java but has been implemented in many languages. The SAX API To use SAX, we'll be using classes from the...</description>
		</item>

		<item>
			<title>The XMLPULL API</title>
			<link>http://www.xml.com/pub/a/2002/08/14/xmlpull.html</link>
			<description>by Elliotte Rusty Harold August 14, 2002 Elliotte Rusty Harold is coauthor of XML in a Nutshell, 2nd Edition . Most XML APIs are either event-based like SAX and XNI or tree-based APIs like DOM, JDOM, and dom4j. Most programmers find tree-based APIs to be easier to use, but they are less efficient, especially when it comes to memory usage. A typical in-memory tree is several times larger than the document it models. These APIs are normally not practical for documents larger than a few...</description>
		</item>

		<item>
			<title>Using XML::Twig</title>
			<link>http://www.xml.com/pub/a/2001/03/21/xmltwig.html</link>
			<description>by Kip Hampton March 21, 2001 If your problem is finding a fast, memory-efficient way to handle large XML documents, but the needs of your application make using the SAX interface overly complex, the solution is to use XML::Twig. Why XML::Twig? If you've been working with XML for a while it's often tempting frame solutions to new problems in the context of the tools you've used successfully in the past. In other words, if you are most familiar with the DOM interface, you're likely to...</description>
		</item>

		<item>
			<title>Getting Started with XOM</title>
			<link>http://www.xml.com/pub/a/2002/11/27/xom.html</link>
			<description>by Michael Fitzgerald November 27, 2002 Elliotte Rusty Harold's new XML Object Model ( XOM ) is a simple, tree-based API for XML, written in Java. XOM attempts to build on good ideas from other Java XML APIs -- SAX , DOM , and JDOM -- and to leave behind some of their frustrations. The result is a high-level open-source API that is easy to learn and use, assuming that you are already familiar with Java and XML. Unlike SAX, XOM is written with classes instead of interfaces, making it...</description>
		</item>

		<item>
			<title>An Introduction to Streaming Transformations for XML</title>
			<link>http://www.xml.com/pub/a/2003/02/26/stx.html</link>
			<description>by Oliver Becker , Paul Brown , Petr Cimprich February 26, 2003 Overview This article introduces Streaming Transformations for XML ( STX ), a template-based XML transformation language that operates on streams of SAX events. STX resembles XSLT 1.0 , the tree-driven transformation language for XML, but STX offers unique features and advantages for some applications. XSLT's popularity has grown over the past three years, both aiding and riding on the adoption of XML . In comparison to...</description>
		</item>

		<item>
			<title>DOM XML: An Alternative to Expat</title>
			<link>http://www.phpbuilder.com/columns/matt20001228.php3</link>
			<description>Matt Dunford Overview: An alternative to expat. There are many xml tutorials for php on the web, but few show how to parse xml using DOM. I would like to take this opportunity to show there is an alternative to the widespread SAX implementation for php programmers. DOM (Document Object Model) and SAX (Simple API for XML) have different philosophies on how to parse xml. The SAX engine is extremely event-driven. When it comes across a tag, it calls an appropriate function to handle it....</description>
		</item>

		<item>
			<title>Ten Lessons Learned From An XML Developer</title>
			<link>http://www.developer.com/xml/article.php/2194491</link>
			<description>By Jeff Ryan Go to page: 1 2 Next Introduction XML (eXtensible Markup Language) is a very simple and elegant language for representing structured data. However, XML programming has a big learning curve. There are several APIs such as SAX (Simple API for XML), DOM (Document Object Model), and TrAX (Transformation API for XML) to understand. There is a family of languages such as XSLT (XML Stylesheet Language Transformations) and XPath to learn. DTDs and XML Schemas must be mastered to...</description>
		</item>

		<item>
			<title>A Survey of APIs and Techniques for Processing XML</title>
			<link>http://www.xml.com/pub/a/2003/07/09/xmlapis.html</link>
			<description>by Dare Obasanjo July 09, 2003 Introduction In recent times the landscape of APIs and techniques for processing XML has been reinvented as developers and designers learn from their experiences and some past mistakes. APIs such as DOM and SAX , which used to be the bread and butter of XML APIs, are giving way to new models of examining and processing XML. Although some of these techniques have become widespread among developers who primarily work with XML, they are still unknown to most...</description>
		</item>

		<item>
			<title>Using Embedded XML Databases to Process Large Documents</title>
			<link>http://www.xml.com/pub/a/2003/10/22/embed.html</link>
			<description>by Mark Wilcox October 22, 2003 XML has been around for several years now and many, if not most, of you reading this article are using it in your job. You're most likely familiar with using one of the standard APIs for XML processing -- DOM and SAX; if you're are a Java programmer, you may be familiar with JDOM. It's a general consensus that DOM programming is easier to program with because it allows you to get at elements and attributes without having to maintain processing state as...</description>
		</item>

		<item>
			<title>From JDOM to XmlDocument</title>
			<link>http://www.xml.com/pub/a/2002/04/03/csharp.html</link>
			<description>by Niel Bornstein April 03, 2002 The Microsoft .NET framework is becoming well known for its integration of XML into nearly all data-manipulation tasks. In the first article in this series, I walked through the process of porting a simple Java application using SAX to one using .NET's XmlReader . I concluded that there are advantages and disadvantages to each language's way of doing things, but pointed out that if you are not a fan of forward-only, event-based XML parsing, neither one...</description>
		</item>

		<item>
			<title>Big Documents, Little Attributes</title>
			<link>http://www.xml.com/pub/a/2001/06/06/xmlqa.html</link>
			<description>by John E. Simpson June 06, 2001 Q: How do I process a big XML document? DOM-based XML parsers load an XML document's tree structure into memory. What if the XML document is too big -- say, 7 million records? This may give an out-of-memory error. On the other hand, SAX-based parsers read character-by-character from an XML document. If I have to search for a record at the end of a document this big, it's going to take a long time to find the matching record. So what sort of parser should...</description>
		</item>

		<item>
			<title>Using XPath with SOAP</title>
			<link>http://www.xml.com/pub/a/ws/2003/09/16/jaxen.html</link>
			<description>by Massimiliano Bigatti September 16, 2003 XPath is a language for addressing parts of an XML document, used most commonly by XSLT. There are various APIs for processing XPath. For the purposes of this article I will use the open source Jaxen API. Jaxen is a Java XPath engine that supports many XML parsing APIs, such as SAX, DOM4J, and DOM. It also supports namespaces, variables, and functions. XPath is useful when you need to extract some information from an XML document, such as a...</description>
		</item>

		<item>
			<title>XML Basics for Java Developers, Part 3</title>
			<link>http://www.oreillynet.com/pub/a/onjava/excerpt/learnjava_23/index3.html</link>
			<description>In part three in this series of book excerpts on XML basics for Java developers from Learning Java, 2nd Edition , learn about the Document Object Model (DOM). DOM Related Reading Learning Java, 2nd Edition By Pat Niemeyer , Jonathan Knudsen Table of Contents Index Sample Chapter Read Online--Safari In the last section , we used SAX to parse an XML document and build a Java object model representing it. In that case, we created specific Java types for each of our complex elements. If we...</description>
		</item>

		<item>
			<title>XML Namespaces Support in Python Tools, Part 1</title>
			<link>http://www.xml.com/pub/a/2003/03/10/python.html</link>
			<description>by Uche Ogbuji March 10, 2004 I have covered a lot of tools for processing XML in Python. In general I have deferred discussion of each tool's handling of XML namespaces in order to stick to the basics in the individual treatments. In this article I start to examine the support for XML namespaces in these packages, with a look at SAX and DOM from the standard Python library. But first, a warning. XML namespaces are largely a matter of shrugging acceptance among most XML users, but they...</description>
		</item>

		<item>
			<title>Getting Started With Cocoon 2</title>
			<link>http://www.xml.com/pub/a/2002/07/10/cocoon2.html</link>
			<description>by Steve Punte July 10, 2002 Introduction Cocoon 2 , part of the Apache XML Project, is a highly flexible web publishing framework built from reusable components. Although reusability is an oft-touted quality of software frameworks, Cocoon stands out because of the simplicity of the interface between the components. Cocoon 2 uses XML documents, via SAX, as its intercomponent API. As long as a component accepts and emits XML, it works. The purpose of this article is to provide an...</description>
		</item>

		<item>
			<title>Manipulate XML Data Easily with Integrated Readers and Writers in the .NET Framework</title>
			<link>http://msdn.microsoft.com/msdnmag/issues/03/05/Real-WorldXML/default.aspx</link>
			<description>Dino Esposito This article assumes you're familiar with XML and the .NET Framework Level of Difficulty 1 2 3 Download the code for this article: Real-WorldXML.exe (120KB) SUMMARY In the .NET Framework, XmlTextReader and XmlTextWriter provide for XML-driven reading and writing operations. In this article, the author discusses the architecture of readers and how they relate to XMLDOM and SAX parsers. He also shows how to use readers to parse and validate XML documents, how to leverage...</description>
		</item>

		<item>
			<title>Does StAX Belong in Your XML Toolbox?</title>
			<link>http://www.developer.com/xml/article.php/3397691</link>
			<description>By Jeff Ryan Go to page: 1 2 Next Introduction Whenever you get a new tool in your toolbox, you are anxious to use it. As you followed along the examples in my previous articles, &quot; Does StAX Stack Up? &quot; and &quot; Delving Deeper Into StAX ,&quot; you may have noticed that StAX (Streaming API for XML) is a very developer-friendly API. You also might be a little confused over when to use StAX versus the other XML processing tools in your toolbox such as SAX (Simple API for XML), DOM (Document...</description>
		</item>

		<item>
			<title>NetBeans: Working with XML, Part 3</title>
			<link>http://www.oreillynet.com/pub/a/onjava/excerpt/netbeans_2/index3.html</link>
			<description>Related Reading NetBeans: The Definitive Guide By Tim Boudreau , Jesse Glick , Simeon Greene , Vaughn Spurlin , Jack J. Woehr Table of Contents Index Sample Chapter In this final installment on working with XML, excerpted from NetBeans: The Definitive Guide , learn how to generate Java classes. Generating Java Classes Here comes the best part (after all, we are Java programmers): generating Java source code to process XML documents. First, we'll create a SAX document handler to read...</description>
		</item>

	</channel>
</rss>
