"Reactive Streams is an engineering collaboration between heavy hitters in the area of streaming data on the JVM. With the Reactive Streams Special Interest Group, we set out to standardize a common ground for achieving statically-typed, high-performance, low latency, asynchronous streams of data with built-in non-blocking back pressure-with the goal of creating a vibrant ecosystem of interoperating implementations, and with a vision of one day making it into a future version of Java."
"We present a novel streaming algorithm for evaluating XPath expressions that use backward axes
(parent and ancestor) and forward axes in a single document-order traversal of an XML document.
Other streaming XPath processors, such as YFilter, XTrie, and TurboXPath handle only forward axes.
We show through experiments that our algorithm significantly outperforms (by more than a factor of
two) a traditional non-streaming XPath engine. Furthermore, since our algorithm only retains relevant
portions of the input document in memory, it scales better than traditional XPath engines. It can process
large documents; we have successfully tested documents over 1GB in size. On the other hand, the
traditional XPath engine degrades considerably in performance for documents over 100 MB in size and
fails to complete for documents of size over 200 MB."
"In this paper we propose the TurboXPath path processor, which accepts a language equivalent to a subset of the
for-let-where constructs of XQuery over a single document.
TurboXPath can be extended to provide full XQuery support
or used to augment federated database engines for efficient
handling of queries over XML data streams produced by external sources. Internally, TurboXPath uses a tree-shaped path
expression with multiple outputs to drive the execution. The
result of a query execution is a sequence of tuples of XML
fragments matching the output nodes. Based on a streamed
execution model, TurboXPath scales up to large documents
and has limited memory consumption for increased concurrency"
"The pipe Go package offers an easy way for Go programs to make use of other applications available in the system via a Unix-like pipeline mechanism. The input and output streams in such pipelines do work as streams, so large content can go across the pipeline without being loaded entirely in memory."
"Our project (titled xstream)
concentrated on evaluation of XPath over XML streams.
This research area contains multiple challenges resulting
from both the richness of the language and the
requirement of having only a single pass over the data.
We modified and extended one of the known algorithms,
TurboXPath [4], a tree-based IBM algorithm. We also
provide extensive comparative analysis between
TurboXPath and XSQ [5], currently the most advanced of
finite automata (FA)-based algorithms."
"Rapture I/O is a fledgling library for Scala which provides a consistent, intuitive and extensible API for handling common I/O operations, such as sending HTTP requests and streaming data between files, URLs and sockets.
Rapture I/O offers the functionality of java.io, but unifies its features into simpler, more coherent and higher-level concepts, allowing tasks which once took several lines of code to be often accomplished in just one, taking full advantage of Scala's rich syntax."
"JSON Processing project is the open source reference implementation of JSR 353 - Java API for JSON Processing. The JSR provides portable APIs to parse, generate, transform, and query JSON using the streaming API or the object model API."
Group items tagged 
Cached
