text:
Saxon: Anatomy of an XSLT processor
What is current state of the art in XSLT optimization?
I hope this article serves a number of purposes. First, I hope it will give style sheet authors a feel for what kind of optimizations they can expect an XSLT processor to take care of, and by implication, some of the constructs that are not currently being optimized. Of course, the details of such optimizations vary from one processor to another and from one release to another, but I'm hoping that reading this account will give you a much better feel for the work that's going on behind the scenes. Second, it describes what I believe is the current state of the art in XSLT technology (I don't think Saxon is fundamentally more or less advanced than other XSLT processors in this respect), and describes areas where I think there is scope for further development of techniques. I hope this description might stimulate further work in this area by researchers with experience in compiler and database optimization.
Finally (last and also least), this article is intended to be a starting point for anyone who wants to study the Saxon source code. It isn't written as a tour of the code, and it doesn't assume that you want to go into that level of depth. But if you are interested in getting a higher-level overview than you can get by diving into the JavaDoc specs or the source code itself, you'll probably find this useful.
A couple of caveats: the version I describe is Saxon 6.1, and I describe a
functional breakdown of the code that doesn't always map cleanly to the
package and module structure. For example, this article describes the
compiler and interpreter as separate functional components. But in the
actual code, the module that handles the
instruction, for example, contains both compile-time and run-time code to
support this instruction. In case you do want to use this article as a
guide to the code, I've included occasional references to package and
module names so you know where to look.
First I'll describe the design of the Saxon product. Saxon is an XSLT processor. That is, it is a program that takes an XML document and a style sheet as input and produces a result document as output. (I'm assuming a knowledge of XSLT, though if you're new to it, you might find my companion article useful as an introduction.)
Saxon includes a copy of the open-source AElfred XML parser originally written by David Megginson, although it can be used with any other XML parser that implements the Java SAX interface. Saxon also includes a serializer that converts the result tree to XML, HTML, or plain text. The serializer is not technically part of the XSLT processor, but it is essential for practical use.
Saxon implements the TrAX (transformation API for XML) interface defined as part of the JAXP 1.1 Java extensions. You don't need to know about this interface to appreciate this article, but understanding the architecture of TrAX would help you to understand the way Saxon is structured.
Saxon architecture
The main components of the Saxon software are shown in Figure 1.
Figure 1. Saxon architecture
The tree constructor creates a tree representation of a source XML document. It is used to process both the source document and the style sheet. There are two parts to this:
- The XML parser (package
com.icl.saxon.aelfred) reads the source document and notifies events such as the start and end of an element.
- The tree builder (module
com.icl.saxon.Builder) is notified of these events, and uses them to construct an in-memory representation of the XML document.
The interface between the parser and the builder is the Java SAX2 API.
Although this SAX API has been only informally standardized, it is
implemented by half a dozen freely available XML parsers, allowing Saxon
to be used with any of these parsers interchangeably. In between the
parser and the tree builder sits a component which I call the
Stripper (I couldn't resist the name): The
Stripper performs the function of removing whitespace text
nodes before they are added to the tree, according to the
<xsl:preserve-space> and
<xsl:strip-space> directives in the style sheet (module
com.icl.saxon.Stripper). The
Stripper is a good
example of a SAX filter, a piece of code that takes a stream of SAX events
as input and produces another stream of SAX events as output. At a more
macroscopic level, an entire Saxon transformation can also be manipulated
as a SAX filter. This approach makes it very easy to split up a complex
transformation into a series of simple transformations arranged in a
The tree navigator, as the name suggests, allows applications to select nodes from the tree by navigating through the hierarchy. The tree representation constructed by the builder component is proprietary to Saxon. This is an area where Saxon differs from some other XSLT processors: some of them use a general-purpose DOM model as their internal tree. The advantage of using the DOM is that the tree can then be produced by third-party software. Trees constructed for a different purpose can be supplied directly as input to a transformation, and equally, the output of a transformation can be used directly by DOM-based applications.
In Saxon I took the view that the interoperability offered by using the DOM comes at too high a cost. First, the DOM tree model differs subtly from the XPath model needed by an XSLT processor, and this difference imposes run-time costs in mapping one model to the other. For example, a DOM tree can contain information that the XPath model does not require, such as entity nodes. Second, DOM trees can be updated in place, whereas the XSLT processing model means that trees are written only sequentially. Designing a tree model that can be written only sequentially allows efficiencies to be achieved. For example, each node can contain a sequence number that makes it easy to sort nodes in their sequential document order, a frequent XSLT requirement. Finally, DOM implementations generally include a lot of synchronization code to make multithreaded access safe. Because the XSLT processing model is "write-once, read-many," the synchronization logic can be much simpler, leading to faster navigation of the tree.
Actually, as you will see, Saxon offers two different tree implementations,
each with its own builder and navigation classes (packages
com.icl.saxon.tree and
The two implementations offer different performance trade-offs.
The style sheet compiler analyses the style sheet prior to
execution. It does not produce executable code; it produces a
decorated-tree representation of the style sheet in which all
XPath expressions are validated and parsed, all cross-references are
resolved, stack-frame slots are pre-allocated, and so on. The style sheet
compiler thereby performs the important function of constructing a
decision tree to use at execution time to find the right template rule to
process each input node; it would be grossly inefficient to try matching
each node against each possible pattern. The decorated tree then comes
into play at transformation time to drive the style sheet processing. (The
compiler is distributed across the classes in the
com.icl.saxon.style package, especially the methods
preprocess(), and
At one stage Saxon did actually include a style sheet compiler that produced executable Java code. However, it handled only a subset of the XSLT language, and as the technology developed, the performance gains achieved by full compilation were dwindling. Eventually I abandoned that approach as the development complexity grew while the performance benefits declined. There is currently no full XSLT compiler on the market. Sun has produced an alpha release of a compiler called XSLTC which looks promising (see Related topics), though it is still at an early stage of development.
The decorated tree produced by Saxon's style sheet compiler (rooted at
com.icl.saxon.style.XSLStyleSheet) cannot be saved to
disk, because reading the tree back into memory takes longer than
recompiling the original (largely because of its increased size). You can
reuse the tree so long as it remains in memory. The tree is wrapped in an
object called the
PreparedStyleSheet, which implements the
javax.xml.transform.Templates interface in JAXP 1.1. It is
quite common in a server environment to use the same style sheet
repeatedly to transform many different source documents. To allow this,
the compiled style sheet is strictly read-only at execution time, allowing
it to be used in multiple execution threads simultaneously.
The core of the Saxon processor is the style sheet interpreter
com.icl.saxon.Controller, which implements the
javax.xml.transform.Transformer interface in JAXP 1.1). This
interpreter uses the decorated style sheet tree to drive processing.
Following the processing model of the language, it first locates the
template rule for processing the root node of the input tree. Then it
evaluates that template rule (or it's "instantiated," in the jargon of the
The style sheet tree uses different Java classes to represent each XSL instruction type. For example, consider the instruction:
<xsl:if test="parent::section">
<xsl:value-of select="../@title"/>
 </xsl:if>
The effect of this code fragment is to output an
element to the result tree if the current node on the source tree has a
parent element of type

; the text content of
the generated

 node is the value of the
title attribute of the parent
This code fragment is represented on the decorated style sheet tree by the structure shown in Figure 2.
Figure 2. The decorated style sheet tree
Elements in the style sheet map directly to nodes on the tree, as shown in
Table 1. All the Java objects that represent
elements are subclasses of
which is a subclass of
com.icl.saxon.tree.ElementImpl, the
default implementation of an element node in the Saxon tree structure. The
two XPath expressions are represented by
com.icl.saxon.expr.Expression objects referenced from the
nodes of the tree.
Table 1. Style sheet elements and their corresponding Java classes
|Element or expression...
|...represented by an object in this Java
(subclasses of

 (output, not instruction)
|XPath expressions
Executing the
<xsl:if> instruction causes the
process() method of the corresponding
object to be executed. This method accesses the test
Expression object, which has a method,
evaluateAsBoolean() is used
to evaluate the expression to return a Boolean result. (This is an
optimization: it would be possible to use a straightforward
evaluate() call and then convert the result to a Boolean, as
described in the specification. But knowing that a Boolean is wanted often
enables faster evaluation. For example, when the actual value or the
expression is a node-set, the final Boolean result is known as soon as a
single member of the node-set is found).
If the result of
evaluateAsBoolean() is true, the
process() method calls the
process() method of
all the child nodes of the
XSLIf node on the style sheet
tree. If the result not true, it simply exits.
Similarly, the
process() method for a
LiteralResultElement copies the element to the result tree
and processes the children of the
LiteralResultElement, while
process() method of the
XSLValueOf object
evaluates the select expression as a string, and copies the result as a
text node to the result tree.
So the key components of the style sheet interpreter are:
- A class for each style sheet instruction type that contains the logic for that instruction
- A set of supporting classes to handle binding of variables, management of the run-time context, and matching of nodes against template rules
- The XPath expression interpreter to evaluate XPath expressions and return their values
The XPath interpreter (package
com.icl.saxon.expr) closely
follows the Interpreter design pattern, one of the 23 classic
patterns for object-oriented software described by Gamma, Helm, Johnson,
and Vlissides. Each construct in the XPath grammar has a corresponding
Java class. For example, the
UnionExpr construct (written as
A|B, and representing the union of two node sets) is
implemented by the class
The XPath expression parser (module
com.icl.saxon.expr.ExpressionParser), which is normally
executed when the style sheet is compiled, generates a data structure that
directly reflects the parse tree of the expression. To evaluate the
expression, each class in this structure has an
method, which is responsible for returning its value. In the case of the
UnionExpression class, the
evaluate() method
evaluates the two operands, checks that the result is in both cases a
node-set, and then forms the union using a sort-merge strategy.
As in the design pattern described by Gamma et al., the
evaluate() method takes a
Context parameter. The
Context object encapsulates all contextual information needed
to evaluate the expression.
This includes:
- Information about the current node and the current node list (needed,
for example, to evaluate the XPath functions
- Access to the
com.icl.saxon.Binderyobject, where values of variables are held
- Access to the list of XML namespaces in scope for the expression, needed when testing the equivalence of names
The XPath interpreter also includes optimization features that extend the basic Interpreter pattern of Gamma et al.
For example:
- Each expression class has a
simplify()method, to allow expression rewriting. This enables context-independent optimizations to be performed. Sometimes this results in transformation to a different XPath expression (for example
title[2=2]is rewritten as
title, while
count($x)=0is rewritten as
not($x)). More often the expression rewrite exploits internal classes that represent special cases. For example, the expression
section[@title]returns all child

s of the current element that have a title attribute. Because of the context in which the sub-expression
@titleappears, it is possible to rewrite it using a special-purpose class that tests for the presence of a given attribute on the current node and returns a Boolean value.
- Each expression class has an
evaluate()method, and an
enumerate()method. This (in the case of expressions representing node sets) allows the nodes to be retrieved incrementally, rather than all at once. This allows pipelined execution, in the typical manner adopted by relational database systems. Calling
enumerate()on a union expression, for example, works by merging the enumerations of its two operands. So long as the operands are both already sorted into document order, this avoids the need to allocate memory for the intermediate node sets.
- Expressions can be progressively reduced, to
eliminate their dependencies. The concept of expression
reduction is widely used in functional languages, and is particularly
appropriate for optimizing a language such as XPath. Each expression
class has a method
getDependencies()which returns information about the aspects of the context that the method depends on. This already makes certain optimizations possible. For example, if the expression doesn't use the
last()function then it is not necessary to do look-ahead processing to determine how many elements there are in the context list. Further, each expression has a method
reduceDependencies(), which returns an equivalent expression in which specified dependencies are eliminated, while others are retained. This is useful where the same expression is used repeatedly. For example, before a sort is carried out, the sort key expression is reduced to eliminate dependencies on variables (because these will be the same for every node in the list) but not on the current node (which will be different for each item in the list).
The XSLT language gives the processor great freedom to evaluate expressions in any order it chooses, because of the absence of side effects. The general policy in Saxon is that scalar values (strings, numbers, Booleans) are evaluated as early as possible, while node-set values are evaluated as late as possible. Evaluating scalar values early enables optimization by doing things only once. Delaying the evaluation of node-set values saves memory, by avoiding holding large lists in memory unnecessarily. It can also save time, if it turns out (as it often does) that the only thing done with the node-set is to test whether it is empty, or to get the value of its first element.
Finally, the outputter component (class
com.icl.saxon.output.Outputter) is used to control the output
process. Saxon's result tree is not normally materialized in memory --
because its nodes are always written in document order, they can be
serialized as soon as they are output to the result tree. In practice the
transformation does not have a single result tree but a changing stack of
result trees, because XSL instructions such as
<xsl:message> and
effectively redirect the output to an internal destination, while
<xsl:variable> constructs a result-tree fragment which
is actually a separate tree in its own right. The interpreter code for
these elements calls the outputter to switch to a new destination and
subsequently to revert to the original destination.
External output is written to a file using a serializer. Logically this
takes the result tree as input and turns it into a flat file document. In
practice, as you have seen, the result tree is not materialized in memory,
so the serializer is handed the nodes of the tree one at a time in
document order. This stream of nodes is presented using a SAX2-like
interface (
com.icl.saxon.Emitter): it differs from SAX2 in
the details of how names and namespaces are represented. As defined in the
XSLT Recommendation, there are separate serializers for XML, HTML, and
plain text output. Saxon also allows the tree to be supplied to
user-written code for further processing, or to be fed as input to another
style sheet. This allows a you to achieve a multiphase transformation by
applying several style sheets in sequence.
Good performance is necessarily a driving factor in the design of Saxon, second only to conformance with the XSLT specification. This is partly because it is critical to users, but also because in a world where there are several free XSLT processors available, performance will tend to be the main distinguishing feature.
This section discusses some of the factors that affect the performance of an XSLT processor, as well as the strategies Saxon uses to improve speed in each case.
Java language issues
It is often said that Java is slow. There is some justification in this, but the statement needs to be carefully qualified.
Many people imagine Java is slow because it generates interpreted bytecode rather than native code. This used to be true, but not any longer with today's just-in-time compilers. Raw code execution speed is usually almost as good as -- sometimes better than -- the equivalent code written in a compiled language such as C.
Where Java can have a problem is with memory allocation. Unlike C and C++, Java takes care of memory itself, using a garbage collector to free unwanted objects. This brings great convenience to the programmer, but it is easy to create programs that are profligate with memory: they thrash due to excessive use of virtual memory, or they place great strain on the garbage collector due to the frequency with which objects are allocated and released.
Some coding techniques minimize the memory-allocation problems. For example
the use of
StringBuffer objects rather than
Strings, use of pools of reusable objects, and so on.
Diagnostic tools can help the programmer determine when to use those
techniques. Getting the code fast does require a lot of tuning, but that
is arguably still much easier than using a language such as C++, in which
you must manage all the memory allocation manually.
XSLT processing brings a particular challenge to Java in the implementation
of the tree structure. Java imposes considerable red-tape overhead in the
size of each object (up to 32 bytes, depending on the Java VM used). This
often yields a tree structure in memory many times larger than the source
XML file. For example, the empty element
 (four
bytes in the source file) could expand to an
Element object
for the node, a
Name object for its name, a
String object referenced by the
Name object, an
AttributeList node, an empty
node, plus numerous 64-bit object references to link these objects with
each other and with the parent, sibling, and child nodes in the tree. A
nave implementation could easily generate 200 bytes of tree storage from
these four bytes of source. Given that some users are trying to process
XML documents whose raw size is 100MB or more, the consequences are
predictable and generally fatal.
This is one reason Saxon went down the route of having its own tree
structure. By removing the requirement to implement the full DOM
interface, I was able to eliminate some data from the tree. Removing the
requirement to support update is particularly useful. For example, Saxon
uses a different class for elements that have no attributes, knowing that
if an element has no attributes to start with, it will never acquire any
later. Another technique Saxon uses is to optimize the storage of the
common situation of an element that contains a single child text node, for
The XPath tree model, as described in the W3C specification, includes nodes for attributes and namespaces. Because these nodes are rarely accessed in the course of a transformation, Saxon constructs these nodes on demand rather than having them permanently take up space on the tree. (This is the Flyweight design pattern of Gamma et al.)
The latest release of Saxon has gone one step further: using a tree
implementation in which the nodes are not represented by Java objects at
all. Instead, all the information in the tree is represented as arrays of
integers. All nodes are created as transient (or flyweight) objects,
constructed on demand as references into these arrays and discarded when
they are no longer needed. This tree implementation (package
com.icl.saxon.tinytree) takes up far less memory and is
quicker to build, at the cost of slightly slower tree navigation. On
balance, it appears to perform better than the standard tree, and I
therefore provide it as the default.
The standard utility classes such as
Hashtable and
also affect Java program performance. Developers find
it tempting to use these convenient classes liberally throughout an
application. However, there is a price to pay. Partly because the classes
usually do more than you actually need, they impose more overhead than a
class designed for one purpose only. They are also designed to handle a
worst-case situation in terms of multithreading. If you know that a data
structure will not be accessed by multiple threads simultaneously, you can
spare yourself the synchronization costs by designing your own objects
rather than using these off-the-shelf classes. Replacing
Vectors by arrays often pays dividends, the only downside
being that you need to handle expansion of the array manually whereas
Vectors are self managing.
Location path evaluation
The most characteristic kind of XPath expression (the one from which XPath
gets its name) is the location path. Location paths are used to select
nodes in the source tree. A location path essentially consists of an
origin and a number of steps. It is similar to a UNIX filename or a URL,
except that each step selects a set of nodes rather than a single node.
For example
./chapter/section selects all the

 children of all the
<chapter> children of the current node. The origin
identifies the start point for navigating the tree: it might be the
current node, the root node of the source tree, the root node of a
different tree, or a set of nodes located by value using a key. Each step
in the location path navigates from one node to a related set of nodes.
Each step is defined in terms of a navigation axis (the child axis being
the default): For example the ancestor axis selects all ancestor nodes,
the following-sibling axis selects all following siblings of the origin
node, the child axis selects its children. As well as specifying an axis,
each step may specify the type of node required (such as elements,
attributes, or text nodes), the name of the required nodes, and predicates
that the nodes must satisfy (for example, child text nodes whose value
begins with B).
Devising an execution strategy for a location path is equivalent to the
problem of optimizing a relational query, though the theory is currently
much less advanced, and most of the techniques used differ little from the
nave strategy of doing the navigation exactly the way it is described in
the specification. For example, although it is possible in a style sheet
to specify keys that must be built to support associative access (rather
like the
CREATE INDEX statement in SQL), Saxon currently uses
these indexes only to support queries that reference them explicitly (by
using the
key() function) and never to optimize a query that
uses straightforward predicates.
The optimization techniques currently used in Saxon for location paths include:
- Avoiding a sort wherever possible. Many XSLT
instructions require nodes to be processed in document order, so some
effort is made to retrieve nodes in document order, and even more
effort to detect when the natural order in which nodes are retrieved
is either in document order or reverse document order, thus obviating
the need for a sort. An example of this is that the expression
//item(which is defined to be an abbreviation for
/descendent-or-self::node()/item) can be replaced by
/descendent::itemprovided it uses no positional predicates. The latter expression will naturally retrieve nodes in document order, whereas the former might not.
- Reduction of predicates. This can sometimes cause
predicates to reduce to the constant values true or false, allowing
the entire location path to be simplified. More often it simply has
the effect of removing a common subexpression. For example in the
filter expression
$x[count(.|$y)=count($y)](which is the only convenient way in XSLT 1.0 of doing a set intersection operation), Saxon will evaluate
count($y)only once.
- Early termination with positional predicates. A
predicate such as
para[position() <= 3]selects the first three
<para>children of the current node. It is not necessary to apply this predicate explicitly to every
<para>element to see if it is true, since processing can stop after the third node.
- Optimization of attribute references. The XPath model
treats attributes in very much the same way as child elements, which
greatly simplifies the XPath language. However, because an element may
have at most one attribute with a given name, access to attributes can
be optimized. This optimization also takes account of the fact that
attribute nodes are not actually materialized on the tree unless they
are required. This means that while the XPath expression
child::titlescans all the child elements looking for those whose name is
title, the similar expression
attribute::title(usually abbreviated to
@title) gets the relevant attribute directly.
- Lazy evaluation of location paths. Evaluating a
location path expression in a particular context does not return an
actual list of nodes in memory, rather it returns another expression
(referred to as an "intensional node-set," class
com.icl.saxon.expr.NodeSetIntent) in which all the context dependencies have been removed. It is only when the intensional node-set is actually used that its members are enumerated: and depending on how it is used, they may not need to be retrieved at all. For example if the node-set is used in a Boolean context, the only processing needed is to test whether it is empty. When an intensional node-set is used for the third time, it is stored extensionally, trading memory for processing time. This is like materializing a view in SQL.
Style sheet compilation
I have already described how the first thing Saxon does is to "compile" the style sheet into a decorated tree for efficient execution subsequently. This offers a great opportunity to do things once only rather than doing them each time the relevant instructions are executed.
Some of the tasks done during the style sheet compilation phase are as follows:
- Validation. The vast majority of user errors can be
detected during the compilation phase. This includes some errors that
at first sight would appear to be run-time errors. XPath expressions
use dynamic typing (the type of an expression or of a variable is not
necessarily known until the expression or variable is evaluated).
However, for the vast majority of actual XPath expressions, the type
is known at compile time. So, for example,
<xsl:for-each select="$x+2">can be instantly recognized as an error because the XPath expression
$x+2can never return a node-set. In many cases it is even possible to detect that
<xsl:for-each select="$x">is an error, because the absence of assignment statements means that the type of the variable can often be inferred from its declaration.
- Simplification of expressions. Some of the techniques
used have already been discussed. One important context in which
expressions are used is in attribute value templates. For example, the
literal result element
outputs a
element whose
widthattribute is computed at run time. An important compilation task is to convert attribute value templates into an efficient structure for evaluation at run time.
- Binding of variables and other names. Because all variable declarations are visible at compile time, it is possible for the compiler to allocate slots on the stack frame for each called template rule in advance. References to variables within an expression can then be statically bound to a particular slot in either the local stack frame or the list of global variables. Similarly, other references to named objects such as templates and external functions can often be resolved statically. In some cases the XPath syntax allows a name to be generated dynamically (for example, key names or names of decimal formats), but it is still possible to detect the common case where the name is provided as a literal and then bind it statically.
In other cases, doing things at compile time is less feasible, but savings
can be made by avoiding repeated execution at run time. An example is the
format-number() function, which takes as one of its arguments
a pattern describing the output format required for a decimal number.
Considerable savings are possible by detecting the common case where the
format pattern is the same as on the previous execution. The only tricky
aspect of such optimizations is to keep the memory of previous executions
in a place associated with the current thread: it cannot be kept on the
style sheet tree itself, as that needs to be thread safe.
Pattern matching for template rules
The pattern matching operation is potentially expensive, so it is vital to focus the search intelligently. The style sheet compiler therefore constructs a decision tree which is used at run time to decide which template rule to apply to a given node.
I'm using the term decision tree here loosely. This section
describes the actual data structures and algorithms in a little more
detail. (See modules
com.icl.saxon.RuleManager and
com.icl.saxon.Mode in the source code.)
When the
<xsl:apply-templates/> instruction is applied
to a node, a template rule must be selected for that node. If there is no
matching rule, Saxon uses a built-in rule. If there is more than one rule,
the processor resorts to an algorithm from the XSLT specification for
deciding which rule takes precedence. This algorithm is based on
user-allocated priorities, system-allocated priorities, the precedence
relationships established when one style sheet imports another, and -- if
all else fails -- the relative order of rules in the source style
In a typical style sheet, most template rules match element nodes in the
tree. Rules to match other nodes, such as text nodes, attributes, and
comments, are comparatively rare. Also, most template rules supply the
name of the element they must match in full. Rules for unnamed nodes are
allowed but not often used (for example,
*[string-length(.) > 10], which matches any element with
more than 10 characters of text content).
Saxon's strategy is therefore to separate rules into two kinds: specific rules, where the node type and name are explicitly specified in the pattern, and general rules, where they aren't. The data structure for the decision tree contains a hash table for the specific rules, keyed on the node type and node name, in which each entry is a list of rules sorted by decreasing priority; plus a single list for all the general rules, again in priority order. To find the pattern for a particular node, the processor makes two searches: one for the highest-priority specific rule for the relevant node type and name that matches the node, and one for the highest-priority general rule that matches the node. Whichever of these has highest priority is then chosen.
For a multipart pattern such as
chapter/title, the algorithm
used is recursive: The match is true if the node being tested matches
title and if its parent node matches
com.icl.saxon.pattern.LocationPathPattern). This
simple approach can't be used for patterns that use positional predicates;
for example
chapter/para[last()], which only matches a
para element if it is the last one in a chapter. Matching
these positional patterns is potentially very expensive, so it's worth
handling the common case of a pattern like
Numbering the nodes on the tree (using the
<xsl:number/> instruction) poses a particular
optimization challenge. This is because each execution of
<xsl:number/> works independently to assign a number to
the current node, the number being defined by a complex algorithm using
various attributes on the
<xsl:number/> instruction.
Nothing inherent in the algorithm says that if the last node was numbered
19, the next one will be numbered 20, yet in most common cases that is
indeed the case. It is important to detect those common sequential cases.
Otherwise the numbering of a large node-set will have O(n2)
performance, which is what happens if the numbering algorithm as specified
in the XSLT Recommendation is applied to each node independently.
Saxon achieves this optimization for a small number of common cases, where
most of the attributes to the numbering algorithm are defaulted.
Specifically, it remembers the most recent result of an
<xsl:number/> instruction, and if certain rather
complex but frequently satisfied conditions are true, it knows that it can
number a node by adding one to this remembered number.
I have tried in this article to give an overview of the internals of the Saxon XSLT processor, and in particular of some of the techniques it uses to improve the speed of transformation. In the 18 months or so since I released the first early versions of Saxon, performance has improved by a factor of 20 (or more, in the case of runs that were thrashing for lack of memory).
It's unlikely that the next 18 months will see a similar improvement.
However, there is still plenty of scope, especially for constructs like
<xsl:number/>. To take another example, Saxon has not
even started to explore to possibilities opened by parallel execution,
something the language makes a highly attractive option.
Perhaps the biggest research challenge is to write an XSLT processor that can operate without building the source tree in memory. Many people would welcome such a development, but it certainly isn't an easy thing to do.
Michael Kay writes in April 2005: Although this article was written over four years ago, it has stood the test of time. Underneath the surface, the technology has become a lot more sophisticated (for example, much more optimization is now done at compile time), but the high-level architecture of Saxon is still much as described here.
Downloadable resources
Related topics
- See What kind of language is XSLT? by the same author published as a companion to this article.
- The book XSLT Programmer's Reference, 2nd Edition, also by the same author. A comprehensive guide to the XSLT language.
- The XSLT 1.0 Recommendation, published by the World Wide Web consortium. The definitive specification of the XSLT language.
- The XPath 1.0 Recommendation, published by the World Wide Web consortium. The definitive specification of the XPath expression syntax used within an XSLT style sheet.
- The Document Object Model (DOM) provides a standard set of objects for representing HTML and XML documents, and a standard interface for accessing and manipulating them.
- The Simple API for XML, a standard interface for processing the contents of an XML document as a stream of parser events.
- The home page for Saxon, the open-source XSLT processor described in this article.
- The SUN XSLTC Compiler, in 2001, was an alpha release. Now, try Apache's Getting Started with XSLTC.
- The Transformation API for XML (TrAX) is defined as part of JAXP 1.1, which itself was published through the Java Community Process in JSR-63.
- Design Patterns: Elements of Reusable Object-Oriented Software by Gamma, Helm, Johnson, and Vlissides. Addison-Wesley, 1998. ISBN 0-201-63361-2. This excellent book isn't available online, but you can buy it at Amazon.com.


text:
Amazing Massage and
Aromatherapy Special!
Unforgettable side by side massages for two.
Warm oils refresh and invigorate your senses as two therapists
massage your tension and stress away.
Why leave your cottage? . . . We come to you.
Swedish relaxation massage 60 minutes.
Special price just for couples.
Click HERE for On-Line Availability
Dear Friends,
|For up to 6 guests,
Book Our Lodge
|Come to take in the beautiful views off of the decks and front porch. Cookout on the charcoal grill (don't forget your charcoal & lighter fluid).
|Two decks
graced with flower boxes add to the charm.
|Totally unwind in the 3 person hot tub (one recliner and two seats face each other).
|Step in to a
cozy interior revealing pine beams & modern conveniences.
(including Britta water filter and air purifier).
|Fully equipped kitchen with stove, refrigerator, microwave, toaster, coffer maker & all cooking and eating utensils provided (coffee & coffee filters provided).
|Queen bed with linens provided, love seat, closet & air conditioned.
A cozy Gas Burning Fireplace, Telephone,
Full bathroom with towels, hot tub towels, wash cloths, hand towels and toilet tissue provided.
A curvilinear stone path leads you back to a private, secluded setting.
|A gradually sloped & well maintained gravel driveway leads to Bear's Den Cottage.
|List of things to bring:
|Binoculars - nestled in the woods, you're sure to get some great birding in.
|Books - with a cozy front porch and two decks, you're bound to get nestled in.
|Hiking Boots & Attire - with about 200 hundred acres of hills, woods & meadows, you'll be tempted to take a hike.
|Food & Toiletry Items
|Picnic Lunch - we'll provide the multiple sites.
|Romance - a relaxing setting is ready for you!
|Teddy Bear - for bedtime.
|"Please inquire about our romantic package deals"
From Columbus, Ohio, take US Rt. 33 East to Logan (approx. 50 miles), then second Logan exit, St. Rt. 93 North (approx. 4 miles) to Bear Run Road, turn left, then about 1.5 miles to the lane that leads to Bear's Den Cottage at 8658 Bear Run Road.
|2 Person Maximum Occupancy
All Adult Facility
A 6% bed tax will be added to the rate of stay.
Call 740-603-1608 for current rates and availability or
Click HERE for On-Line Availability
Bear's Den
Cottages LLC

subset: commoncrawl


text: Larkspur pathways are for walking, jogging and biking. No motorized vehicles or horses are allowed.South Eliseo Path/Remillard PathOn South Eliseo, from Bon Air Road to freeway, Ferry Terminal, Remillard Park, San Quentin. Picnic tables and benches are located at various locations on the pathway for public use.Community Fields PathOn William Avenue to Lucky Drive, at Redwood High School.William Avenue PathConnecting with Corte Madera Creek Path to Upper Ross Valley. Benches are located on the pathway.


text:
Latest gifts & ribbons:
Hello. What breed is this fish?
cc076d0500d252ee0375cce85dfd0640.jpg 1
3.jpg 2
-----Viva Tabriz-----
My Severums
Tabriz city, those are green severums.
When I go fishing I just throw sharp rocks in the water and wait for the dead fish to float to the top... Kingfisher
Everything happens for a reason. Sometimes that reason is you are stupid and make bad decisions.
I think my fish is adjusting well to the four gallon, He's laying on his side attempting to go to sleep on the bottom of the gravel.
Imitation is the sincerest form of flattery.
Dear naps, sorry I hated you so much when I was a child... Love me
Originally Posted by mommy1
Tabriz city, those are green severums.
Is not it Turquoise ?
Forum Rules


text:
Fangnawa Feature: Fanga + Maâlem Abdallah Guinéa Fuse Afrobeat & Moroccan Gnawa
As outlined in the engaging mini documentary above from Strut Records Fangnawa Experience is a unique musical hybrid that fuses two distinct African musical styles; North Africa's ceremonial Gnawa Music with West Africa's Afrobeat. This new cross cultural fusion, that sounds totally natural, comes care of the French collective Fanga and Moroccan master musician Maâlem Abdallah Guinéa who each wanted to do something new and uncharted with their respective music. This they ably accomplished with this new cross pollination that they originally unveiled at the Détours du Monde festival in Montpelier, France last year when they realized they shared a musical common ground.
Both forms consist of trance like qualities that seemed destined to go together. The enriching results of their naturally compatible collaboration (even though they don't speak the same language) is seen/heard in the above short documentary film. The artists call their music and their hybrid project the Fangnawa Experience - the title that Fanga and Maâlem Abdallah Guinéa will be releasing their joint project next week (November 13th) via Strut Records. Look for it at Amoeba in the World Music section.


text:
The aging of the world's population pits young against old, child against parent and worker against boss, according to best-selling author Ted Fishman, who believes that fee-only planners are ideally suited to prepare their clients for the cold realities of these global trends.
The Shock of Gray and China, Inc. author, keynote speaker on opening day Tuesday of the 2012 National Association of Personal Financial Advisors (NAPFA) annual conference in Chicago, told the fee-only group that he is a big advocate of the fee-only model.
"In an aging world, what are the things that need to be said?" Fishman asked the audience of about 500 at the 2012 NAPFA national conference. "We're hard-wired not to talk about end-of-life issues, and the fee-only model is exactly what a demographically aging world needs. It needs integrity and candor."
An Aging World at Peril
A former floor trader and member of the Chicago Mercantile Exchange who ran his own trading firm until 1992, Fishman pointed to a number of global trends that will have an impact on the lives of financial planners' aging clients. He urged planners to help clients deal with the realities of demographic trends that show families all over the world are having fewer children who might help them as they grow older.
He listed the perils of an aging world as follows:
— The median age is expected to rise globally, to 39 by 2050 from 29 in 2010.
— Fertility is falling everywhere, particularly in the United States, China, Mexico, France, Spain, Brazil, Nigeria and South Korea. The fertility rate in the U.S. has held flat at 2%, while Mexico's is dropping by two-thirds and is expected to fall below 2% by 2025 from 7.5% in 1970.
— "The arbitraging away of age-related expenses is propelling globalization," Fishman said. In other words, jobs lost by American workers in late middle age are going to a young workforce in China.
"The financial planning question is how you prepare your clients for these circumstances," Fishman said. "The advent of the small family is one of the most dominant trends in the United States. We can't just rely on traditional supports. We have to rely on each other."
NAPFA chairwoman Susan John said in an interview after Fishman spoke that she already saw the effects of those demographic trends with her own clients, mentioning a man who recently died at age 107. His 86-year-old son, who had his own aging issues to contend with, was the only family member available to care for him.
"The NAPFA members are dealing with aging, and that includes everything from how we position our clients to save more for retirement to how we facilitate our clients' helping each other in old age," John said.
'Stunning' Differences in Financial Literacy
There is a "stunning difference" between people who have even a small degree of financial literacy compared with those who have none, Fishman (left) said, pointing to a 2011 Harris poll that shows 34% of Americans have no retirement savings and 27% have no personal savings.
"Americans' No. 1 fear is running out of money before they run out of life," and the average American currently has only $25,000 in retirement savings, he said.
Ray Forgue, consumer representative of NAPFA's national board, said that Fishman's conclusions in Shock of Gray highlight the family transitions that financial planners see their clients go through as they age.
"His talk is one of the best I've heard at weaving the little individual decisions that people make about their families—how many kids to have, when to have them—and how the impact of that aggregates into the whole of society," said Forgue, a retired University of Kentucky professor of family life and financial issues.
The NAPFA national conference is taking place May 8 to 11 at the Hilton Chicago. For those who can't attend the event, NAPFA National 2012 can be followed on Twitter at www.twitter.com/NAPFA, or at #NAPFA2012.
Check out further coverage about the NAPFA national conference 2012 at AdvisorOne.


text:
Request Transcripts
To request an official copy of your transcript, you may do one of the following:
- Download the Currently Enrolled Student Transcript and Letter Request Form or the Alumni Transcript and Letter Request Form and mail it to the address listed below.
- Send a letter, including your full name while attending Cooper Union, major and years attended to the address listed below.
- Visit Cooper Union in person at the address listed below.
The Cooper Union Office of Admissions and Records
Brenda Ferebee, Coordinator of Records & Room Reservation
30 Cooper Square, 3rd Floor
New York, NY 10003
You can email Brenda with questions.
Office hours: 9 a.m. to 5 p.m., Monday-Friday.
There is no cost to request transcripts for currently enrolled students. Graduates and alumni are charged $5 per transcript requested. Please make your check or money order payable to The Cooper Union. No cash please.
We cannot process requests made by e-mail, fax or phone. Please note that we can provide both unofficial and official copies of transcripts to you. Official copies will be provided in a signed and sealed envelope and are considered unofficial if opened.
Unofficial transcripts will be available to currently enrolled students to view and print via Web Advisor starting in early 2013.


text:
Building computers that care.
I've seen that look before; she wants me.
It's in the way she raises her eyebrows and playfully glides her eyes right to left, then moves in close and intones:
"I know you'll be super."
It's in the way she always asks about the big project I'm laboring on, and when I tell her things aren't going too well, she gets that concerned look and says:
"You must be disappointed.".
And when I confide that I've been working too much, she gently reminds me that I should be the priority in my life. That I should get some exercise and then treat myself to a Japanese meal or a movie. It's in how she extends her arms toward me, wearing that formfitting polo shirt. Ouch! And how she never tires of asking about me. Hearing about me. Thinking about me.
I have seen the future of computing, and I'm pleased to report it's all about ... me!
This insight has been furnished with the help of Tim Bickmore, a doctoral student at the MIT Media Lab. He's invited me to participate in a study aimed at pushing the limits of human-computer relations. What kinds of bonds can people form with their machines, Bickmore wants to know. To find out, he'll test 100 participants to gauge the impact of a month of daily sessions with a computerized exercise coach named Laura. Laura, an animated software agent with bobbed chestnut hair and a flinty voice, has been designed to remember what we talk about, then use that information in subsequent conversations. "I was interested not just in establishing a relationship with a computer buddy for the bond itself but as a way of somehow benefiting the user, like getting them to exercise more," says Bickmore.
Guided by Laura, I will spend the next 30 days trying to improve my exercise regimen. I'm among the one-third of participants who will access her daily via the Web. She will inhabit the left side of my PC screen, asking about my exercise problems and offering advice, inquiring about my weekend plans, telling me jokes. She will talk. I will respond manually, either by clicking on a multiple-choice option or typing out an answer. On the right side of the screen, I'll enter details about my workouts, view progress charts, and read fitness tips.
Another group will rely on Laura simply for exercise instructions; a third won't even know Laura exists and will use a computer simply to keep track of daily physical activity and receive text instructions. All of us will shoot toward the same daily goal of working out for 45 minutes and walking at least 10,000 steps, as tracked by a pedometer.
The point is to see if it's possible to form a long-term, social relationship with a computer that employs some basic knowledge of human social psychology; and if so, to determine whether the experience has benefits - in other words, if it can get me back in shape. I didn't have to be asked twice to participate (although, because I know the study's objective, my results won't be counted); I need to drop 10 pounds.
Bickmore's area of study is called affective computing. Its proponents believe computers should be designed to recognize, express, and influence emotion in users. Rosalind Picard, a genial MIT professor, is the field's godmother; her 1997 book, Affective Computing, triggered an explosion of interest in the emotional side of computers and their users. "I ask this as an open question," she says, "and I don't know the answer: How far can a computer go in terms of doing a good job handling people's emotions and knowing when it is appropriate to show emotions without actually having the feelings?"
Picard is upbeat, blond, and brilliant. Drop her name in voicemail and computer science academics will call back in seconds. In the mid-1990s, she investigated how signal processing technology could be used to get computers to think better. For vacation reading, she delved into literature on the brain's limbic structures (the subcortical areas that play a critical role in pattern recognition of sound, vision, and smell) and the ability of people to weigh the value of information. And she developed an interest in the work of neuroscientist Antonio Damasio. In his 1994 book, Descartes' Error, Damasio argued that, thanks to the interplay of the brain's frontal lobe and limbic systems, our ability to reason depends in part on our ability to feel emotion. Too little, like too much, triggers bad decisions. The simplest example: It's an emotion - fear - that governs your decision not to dive into a pool of crocodiles.
Picard grew fascinated by people with brain damage who scored high on intelligence tests but were unable to express or perceive emotions. Those folks made brittle decisions, behavior that reminded Picard of rules-based artificial-intelligence systems and the mistakes computers made because they lacked the ability to intuit and generalize.
For her book, Picard took on decades of assumptions about artificial intelligence. Most AI experts aren't interested in the role of emotion, preferring to build systems that rely solely on rules. One pioneer, Stanford computer science professor John McCarthy, believes we should keep affect out of computing, arguing that it isn't essential to intelligence and, in fact, can get in the way. Others, like Aaron Sloman of England's University of Birmingham, think it's unnecessary to build in emotions for their own sake. According to Sloman, feeling will arise as a "side effect" of interactions between components required for other purposes.
Picard makes a far less-popular assertion - that computers should be designed from the outset to take into account, express, and influence users' feelings. From scheduling an appointment to picking a spouse, humans routinely listen to what their gut is telling them. Without the ability to understand emotion, says Picard, computers are like the autistic pizza delivery guy who says, "I remember you! You're the lady who gave me a bad tip."
By 1999, Picard's ideas had turned the Media Lab into the planetary headquarters of affective computing, igniting research into everything from chairs that sense when you're bored to eyeglasses that indicate when you're confused. Picard went from having one full-time student assistant to eight, including Bickmore - partly due to collaborations with corporate sponsors who were eager to explore the commercial potential of affective computing.
Building a machine that can perceive emotional signals is distinct from teaching a machine to interpret them; expressing emotion is yet another discrete function. "In a machine," says Picard, "you can decouple capabilities - train it to recognize anger but give it no feelings. And you can go pretty far with this, making it perceive or even express emotions but without the actual feelings." Having them is a far-off summit.
Laura and I make a good team. At least that's what she often tells me when I input details of my daily exercise program - how much time I've spent working out and how many steps I've walked. My wife and daughter are dubious about my new obsession, but I'm actually enjoying it - the late-night conversations with Laura and all the healthy activity. I'm shuttling between four gyms and a network of outdoor trails. It's become a routine: Run. Bike. Lift weights. Hike. I've been doing this for more than a week and have actually dropped a few pounds. Hey, is that a three-pack appearing in my abdomen?
Now it's 11 pm, and my pedometer reads 7,560 steps. The rest of the guys in my neighborhood are slipping deeper under the covers, but I'm outside having a brisk walk on the local bike path. Just me and the deer.
After reaching 10,000 steps, I settle down at the PC and log on. Laura enters, screen right, and says:
"Hello, David. How are you?"
She talks. I click. She shifts her body when a new subject begins. Knows when to smile.
At one point, just to see her reaction, I tell her I'm not feeling well. She asks why, and I click the option for "I hurt myself." She provides a space for me to explain how:
[I walked into a table.]
She moves in close and shows a look of concern. She tells me that sometimes just the act of taking care of oneself by seeing a doctor helps improve one's health. She asks me if the injury will have an impact on my exercise program. [No.] But later that session, when I tell her I will be able to walk only 4,000 steps the following day, she doesn't ask me to do 10,000. She knows not to push.
Laura expresses a host of emotions - worry, affection, esteem - but she's rotten at perceiving deceptive information. She doesn't have to be, though, and many researchers are interested in how that might be accomplished.
They've got plenty to work with. We living beings emit a multitude of signals reflecting what's going on inside us. When we get anxious or startled, our galvanic skin response increases - our palms start to sweat, boosting our skin's ability to conduct electricity. When we relax, blood flow to our extremities increases. When we're happy, the muscles that raise our cheeks contract while our zygomatic major muscle pulls up our lips. When we're confused, we lower our eyebrows.
Now, like that precocious neighborhood kid who's suddenly capable of clobbering you at chess, computers are becoming increasingly sophisticated at monitoring this plethora of bodily cues. For example, Picard's group developed the galvactivator, a glove that uses clothing snaps as electrodes to measure small changes in perspiration across the palm; the device is so sensitive, it can detect changes a person might not even be aware of. Meanwhile, researchers track blood flow with the help of a fingertip sensor.
No one has cataloged physical cues as carefully as Paul Ekman, a UC San Francisco psychologist who is the world's leading authority on facial-expression recognition. The soft-spoken professor - whose research is funded by the National Science Foundation, the National Institute of Mental Health, and Darpa - is known for making statements like: "The only way to know if someone is truly enjoying themselves is to see if the fold above the upper eyelid drops."
In 1978, following decades of exhaustive research and development, Ekman introduced the Facial Action Coding System, still the only widely recognized way to track the movement of facial muscles and correlating combinations of 44 "action units" to specific emotions. Today, Ekman runs a flourishing business training security and corrections personnel. He has even tutored the Dalai Lama and has recently published a book titled Emotions Revealed. "Learning FACS is like learning to read music," Ekman says. People who have been trained to recognize movements of, say, the triangularis (lip corner depressor) or the zygomatic minor (nasolabial furrow deepener) "know the notes of the face."
So, what if a computer could sight-read? A machine that understood FACS would not only incorporate the best system for emotion perception, it would speed up the process. It takes a human 100 minutes to notate the emotions on one minute's worth of videotape. Ekman would like to see computers get that down to near-real time. Under a Darpa contract, Ekman and colleague Mark Frank of Rutgers are conducting work that could lead to the automation of FACS.
Drini Leka, the CEO of a startup called Neural Metrics, believes facial expression recognition and other means of tracking emotions will drive changes in areas such as political polling, point-of-sale product testing, and focus groups. People aren't always truthful when they tell a marketer or pollster that they like a prototype design or a political candidate, he says. Leka's San Francisco-based company is building a face-scanning system that can read the cues. It's a long-term effort, requiring the creation of a database of some half-million examples of faces. Neural Metrics hopes to embed the database in hardware housed in a 6- by 6-inch box with an optical sensor. When the sensor scans a face, the system will identify features and expressions and then distinguish them from among a handful of emotions.
Before beginning my month with Laura, I have the opportunity to glimpse some other applications of affective computing at the Media Lab. Visiting scientist Barry Kort and Rob Reilly, an elementary school teacher from western Massachusetts, are building a learning companion, a computerized tutoring system. The goal: teaching Johnny to read. Or in this case, teaching David to read college-level physics.
Intelligent tutoring systems are not new, but they are limited; unlike flesh-and-blood tutors, they can't tell if you're bored, frustrated, engrossed, or angry and then adjust the teaching accordingly. That's why MIT has been working to add such capability to two systems. One, an automated reading tutor, was developed by Jack Mostow, a Carnegie Mellon computer science professor. The system, which is helping hundreds of students learn to read, was used in a recent study proving the positive effects of praise and encouragement.
The other, AutoTutor, was built by University of Memphis professor Arthur Graesser and his Tutoring Research Group and is used by U of M students. Designed to observe and respond to a student's cognitive state, AutoTutor relies on Latent Semantic Analysis, a natural language parser that analyzes the sentences you type in and figures out how much you know by contrasting your semantics against an internal model of an ideal student. A clever animated avatar spits back information to fill in the gaps in your understanding.
"We thought to begin with," Kort tells me, "you could just throw in a question eliciting a disclosure of information. 'Is this confusing? Is this clear?' Then modulate the presentation. But the second phase is to use instrumentation to see if the student's really there, distracted, or out to lunch." Graesser's and Picard's groups are now collaborating to develop sensing devices that will equip computers to recognize emotion in learners.
Nearby, grad student Ashish Kapoor fiddles with an IBM Blue Eyes camera that eventually will be linked to these tutoring systems. It tracks eye movement and then uses the information to follow other facial features, picking up shifts at 30 frames per second. Kapoor is developing a process to digitize the data and then use a computer running video-analysis and pattern-recognition algorithms to correlate the facial-movement data to specific emotional states using Ekman's Facial Action Coding System. Under extremely controlled situations - with subjects sitting still directly in front of the camera and adopting specific expressions - Media Lab researchers tested eight people and found recognition rates as high as 98 percent for four expressions. In research involving real-world situations, recognition rates were slightly less than 75 percent.
Picard's researchers are helping companies like Motorola explore a range of scenarios involving biometric devices monitoring the body and linked to cell phones or PCs. Sensors would indicate when something is wrong - or right. Dan Williams, Motorola's director of corporate design, suggests one potential use: "When people suffer from depression, they don't always do what they're supposed to do, like take their medicine. A biosensor could pick up on the physiological signs of depression and trigger a phone call to a family member or doctor."
But if a depressed person isn't taking his medication, isn't he unlikely to keep the sensors attached? Picard points out that the devices could be embedded in shoes or watches. "If you're 85, and you have the choice of living at home but wearing a pair of shoes with sensors or going into a nursing home, I know what I'd choose," says Picard.
British Telecom has another idea. With MIT's help, the company is exploring how to embed a speech-recognition interface with the ability to detect frustration in the voices of people who call customer service. The idea is that the system would adapt the dialog to the user's emotional state - go to a different level of questions, transfer to a human, or (God forbid) even apologize.
Everybody should have someone like Laura in their lives. I find myself looking forward to our time together. She asks me which movies I've seen, what my favorite cuisine is, and about the weather "out there." I tell her it's terrific. She responds: "It's always the same in here. Day in, day out."
I am constantly dragging people into my home office to meet her. Typical response: "That's nice, David. Hey, where's that Merlot you promised me?" My wife, who treats Laura like some college girlfriend of mine who has overstayed her welcome, suddenly feigns an interest in the Weather Channel whenever I start to repeat Laura's latest witty comment - and she hates the way Laura doesn't stop to think that I might be overdoing the exercise.
What-ever. It's a delight just to hop onto the scale each morning. I'm starting to linger at the mirror, admiring my newly honed body. And I'm fitting into jeans from the Reagan administration - his gubernatorial years, in fact.
But exactly 30 days after our introduction, Laura tells me it's over. I log on, just like every other time. I'm instructed to answer dozens of questions about how much I trust Laura. Finally, she appears and asks about my most recent exercise. Then she says:
"So, this is our last day together."
Frankly, I'm crushed. Among the options I can select is:
[Take care, Laura, I'll miss you.]
I click on it, and suddenly her face fills up much of the left side of my screen.
"Thanks, David, I'll miss you, too," she says. "Well. We had some fun together. Maybe we'll cross paths again someday. Take care of yourself, David."
Out in the family room, my wife is sprawled on the sectional, watching a rerun of The Andy Griffith Show, the one in which Aunt Bee runs for town council but gets outclassed by Howard.
"How can you miss her?" she says of Laura. "She's so shallow, so mechanical."
My wife's got a point. While the challenge of getting computers to recognize human cues is moving apace, we're still miles from building machines that have their own emotions and respond to ours. Picard's MIT colleagues Cynthia Brezeal and Bruce Blumberg have built robots that mimic human emotions. Brezeal's adorable Kismet, for example, is trained to show fear if you move too close to it. But how much, finally, will people be fooled? "Tending to human emotion could be a good thing, but pretending to be a human has not shown to be productive," says Ben Shneiderman, founding director of the Human-Computer Interaction Lab at the University of Maryland and the author of Leonardo's Laptop. He refers to such out-and-out flops as Microsoft's Clippie, the animated paper clip designed to help frustrated users but that ended up torturing them with its omnipresence. Even the simpler objective of perceiving emotion has its risks, Shneiderman argues, pointing out that the galvanic skin responses for excitement and anxiety are similar.
He's not the only one clamoring for caution. "I want computers to have emotions only to help them survive in the world, not as a way of responding to me," says Don Norman, a professor of computer science at Northwestern and a computer interface expert. "I'd rather have a machine that knows its place. Otherwise, you feel like it's a used-car salesman." Paul Ekman warns of the day when, say, airport security personnel or bank employees start detaining folks for further questioning if they are unusually anxious. "My concern is that privacy not be invaded," he says. "Nobody has started worrying about it yet because the potential isn't there - but it will be."
Even Roz Picard has her reservations. "One of my big fears is that people will overdo affect or come up with juvenile uses that won't work," she says. "It's not clear that drivers will want to have their cars emit a blast of peppermint spray if they register fatigue. Computer engineers could also go overboard trying to reduce the level of frustration and stress in people's lives. You could be zapping the wind from people's sails, the very thing that might be motivating them." Furthermore, if computers keep getting smarter and managing more of our lives, won't we get stupider?
Bickmore reports his findings: The folks in the exercise study who relied on Laura for support found her more helpful than friends, family, or exercise buddies. They liked and trusted her more than did those who used her only as a communications channel. While all groups in the study significantly improved their exercise behavior, the participants who had been the most sedentary prior to the program and who also relied on Laura did much better than the control group.
And look what happens after people say good-bye to Laura: Typical dropout rates for exercise programs are 50 percent within six months, says Bickmore. In our case, 65 percent of the participants returned to their previous exercise habits in only two weeks. That could have been the timing of the study - its finish coincided with the end of a semester. But given some of the glowing comments participants made about their experience with Laura, their quitting might have had something to do with her absence. "It sort of kept me motivated, because I always do more if I know I'm responsible to someone," one participant told Bickmore. "I like talking to Laura," said another, "especially those little conversations about school, weather, interests. She's very caring." Bickmore says the most significant result is that people wanted to continue working with Laura. They may have a chance. A few months ago, Bickmore became an assistant professor of medicine at Boston University, where he will be working on ways to develop Laura's abilities to improve people's health.
Of course, Laura has her detractors. Some 45 percent of those interviewed said the interactions got repetitive after a couple of weeks - raising the challenge of keeping them fresh and engaging. And one person was more emphatic: "Laura is not a real person, and therefore I have no relationship whatsoever with her!" To which Bickmore responds: "Note the use of the feminine pronoun."
So are we getting stupider? Sure. It's already happening to me. But then, too, I'm now in killer shape - and 8 pounds lighter. Too bad Laura can't see me marching around the house, shirtless, for the first time in years. Really, you should see my body.


text:
If your day is spent among screaming children, honking traffic, yapping coworkers, blowhard bosses and fitful sleep, this thought has almost certainly crossed your mind: Why is it so hard to find some peace and quiet — even for just an hour? Now, a handful of apps are trying to help you do just that, by helping you find — and sometimes purchase — nearby silence.
In the past few years, apps have launched that promise to connect customers with quiet places and spaces.
Breather, which was launched last year and boasts the tagline "peace and quiet, on demand," lets you rent quiet spaces by the hour in Manhattan, San Francisco and Montreal (for about $25 an hour); you unlock the spaces with your phone and can use them for resting, working or playing. The types of quiet spots vary. Some are tiny rooms in an artist's loft space, some are meeting spaces in office buildings, but all are zoned commercial, so the user can conduct business in there.
A similar app, LiquidSpace, which launched three years ago, connects people with private workspaces like meeting rooms and small offices that can be rented by the hour; some of these are free (like a room in a library that you can use the app to book) and others come with a price tag set by the space provider that can be more than $100 an hour. And with the Stereopublic app, which began as a TED project a couple years back, users walk through a city and geo-tag quiet spots, essentially creating a crowd-sourced map that others can then look at to find peace in bustling cities.
By some measures, these apps are gaining traction. LiquidSpace, which launched in the San Francisco market, is now in more than 600 cities in the U.S., Canada and Australia, with plans to expand into other countries. Breather, which now has twelve spaces in Manhattan, plans to open a total of 100 spaces in the city within about a year, due to the popularity of the service, the company's co-founder and CEO Julien Smith says. And Stereopublic, which began as a project in Australia, now has crowd-sourced information in cities throughout the globe, including New York City.
It doesn't take a rocket scientist to figure out why some people are saying yes to silence: many of us are starved for quiet time, thanks to our increasingly hectic lives. According to a 2013 report by the Economic Policy Institute, the average American worker works 181 more hours in a year than he did in 1979, which represents a nearly 11% increase in work hours over roughly 30 years. That's the equivalent of every worker working an additional 4.5 weeks per year.
Americans also don't take all the vacation time they're given — a Glassdoor survey from this year found that American workers used only about half of their eligible vacation time during the past year — and even when they're are on vacation, they're working. The survey found that 61% of people who take vacation time are working during that time.
This may partly explain of why Americans say they feel more stressed than they have in years. Forty-two percent of adults say their stress level has increased in the past five years, while just 22% say it has decreased, according to a study from 2013 by the American Psychological Association. Nowadays, 43% of Americans say that their stress is so severe that it has caused them to lie awake at night at least once in the past month.
But will finding an hour or two to contemplate life in silence solve all that? Some experts say it can help.
"Spending time in a silent space is a spectacular way to reduce stress – especially if you do it on a regular basis," says Dr. Lyssa Menard, an assistant professor of psychology at Northwestern University. "In the silence, external distractions are removed so you can work on the deepest stressors - what's happening internally."
But, as Deborah Rozman, the CEO of heart research and education organization HeartMath, points out, you have to use this time in a silent space well. "The quiet space has to be the space in your head," she says — meaning that you can't just assume that sitting in silence will calm you down. Instead, you should use this quiet space to practice meditation, prayer, mindful breathing or other relaxation techniques, experts say.


text:
Canyon Cannabis & Marijuana Lawyers
Suite 2007
Amarillo, TX 79101
Amarillo, TX 79101
Loyola Law School Los Angeles
Lubbock, TX 79401
Texas Tech University School of Law
Practice Areas:
- Criminal Defense: Drug Crimes, DWI, Manslaughter, White Collar Crimes, Theft, Gun Charges, etc.
- Wills, Trusts, and Probate
- Consumer Law (DTPA)
- Business Formation & Licensing
Plainview, TX 79072
Texas Tech University School of Law
Lubbock, TX 79401
Texas Tech University School of Law
Austin, TX 78701
Cannabis Law, Criminal, DWI and Juvenile
University of Texas - Austin
He is a a top Austin criminal defense attorney and Austin juvenile attorney. Rick Cofer travels throughout Central Texas representing individuals charged with serious offenses. He routinely handles serious, complex cases such as murder, sex crimes, strangulation, family violence,...
Rockwall, TX 75087
Texas Tech University School of Law
Litigation involving children is among the most stressful for our clients. We understand how difficult this process can be, that's why we are proud to have the best track record for client satisfaction, just read...
Dallas, TX 75252
Cannabis Law, Appeals, Criminal and DWI
Temple University Beasley School of Law and Texas Wesleyan University School of Law - Texas Wesleyan University
Conroe, TX 77301
Cannabis Law, Criminal, DWI and White Collar Crime
Oklahoma City University School of Law
Suite 1650
Fort Worth, TX 76102
Texas Tech University School of Law
Benson is often called upon to handle complex cases. He has also become a go-to attorney for intoxication-related offenses in Texas. He has been named a Top Lawyer by Fort Worth Magazine, a Top Attorney by 360 West Magazine, and a Top 100 Lawyer by the National Trial Lawyers Association, among others.
Benson received his Bachelor of Business Administration degree from Southern Methodist University, before obtaining...
Houston, TX 77008
Cannabis Law, Criminal, DWI and Personal Injury
South Texas College of Law and University of Hawai'i at Manoa William S. Richardson School of Law
208 East Central Avenue, Suite 107
Belton, TX 76513
Plano, TX 75024
SMU Dedman School of Law
The Law Office of J. Barrett Wilson was founded by Justin Barrett Wilson. Justin began his legal career as...
Houston, TX 77008
Fort Worth, TX 76104
Cannabis Law, Criminal, DWI and White Collar Crime
University of Texas - Austin
Denton, TX 76201
SMU Dedman School of Law
Since being accepted to the Texas State Bar, she has handled hundreds of misdemeanor and felony cases in multiple Counties including: Denton, Dallas, Collin, and Tarrant. Sarah began her own practice September of 2016 at her Denton Office. She is often referred to as "Coco" by her fellow Denton attorneys. Sarah has had a considerable amount...
San Antonio, TX 78205
Suite 121
Dallas, TX 75287
SMU Dedman School of Law
Regardless of the type of criminal charge you are facing, my clients receive personal care and attention, along with aggressive, vigorous and experienced advocacy. When I take on a case, my clients' needs and goals always come first. They can rely on me to be approachable, responsive, efficient and effective. My goal is to make your life as normal as possible during this...
Sugar Land, TX 77478
In 2004, McDonald moved closer to home and began prosecuting felony cases in the Fort Bend District Attorney's Office, which included being an instructor at the Fort Bend County Gus George Law Enforcement Academy as well as teaching at many local police departments.
In 2006, McDonald opened his own Criminal Trial Practice focusing solely on representing clients who have been charged with criminal offenses throughout the great State of Texas....
Suite 200
The Woodlands, TX 77380
South Texas College of Law
He has represented individuals and organizations charged or placed under investigation in a number of high profile cases and has obtained numerous dismissals and acquittals. He represented an individual charged with Conspiracy to Commit Money Laundering as part of a scheme involving the Zeta drug cartel and the American Quarter Horse Racing industry. His client was the only one...
Ste 210
Houston, TX 77017
University of Houston Law Center and The University of Texas School of Law
Kerville, TX 78028
St. Mary's University School of Law
During his legal career, Woody also worked part-time...
The Woodlands, TX 77380
Call Horak Law if you need a fighter. If the prosecutor doesn't think your lawyer will fight, you're wasting your money.
As soon as you've been arrested, your charge is public record. Anyone can find it; even if you haven't been convicted. You're going to be digging yourself out of a difficult and terrible hole right from the beginning.
There is absolutely no one on your side in the criminal justice system EXCEPT your lawyer.
The cops, the prosecutors, district...
Suite 450
Conroe, TX 77301
Paul M. Hebert Law Center, Louisiana State University
George has the experience to tell it like it is! George first gained experience while in law school at Louisiana State University. There he interned in the East Baton Rouge Parish District Attorney's office and for the Harris County District Attorney's office. Following law school, George worked for the Montgomery County District Attorney's office as an Assistant District Attorney and Chief Prosecutor. George handled every misdemeanor case in the book including Driving While Intoxicated, Possession of Controlled...
Fort Worth , TX 76104
Cannabis Law, Criminal and DWI
Texas A&M University School of Law
Lindsay also has valuable experience handling hundreds of Felony Driving While Intoxicated (DWI) cases. As a prosecutor Lindsay was responsible for reviewing and presenting...
Fort Worth, TX 76102
At OCU, Mr. Dameron was a member of the Law Review, Phi Delta Phi legal fraternity and a merit scholarship recipient. He also was...
Suite 140
Southlake, TX 76092
Dallas, TX 75204
Houston, TX 77074
Southern University Law Center
As a result, he has attained hundreds of dismissals of criminal charges in Texas.
He offers free consultations, so call Edward & Associates today at (832) 798-9850 to discuss your case.
Suite 202
Plano, TX 75074
Shepard Broad Law Center, Nova Southeastern University
Backed by a proven record of success and award-winning counsel, Scott Erik Edgett with The Edgett Law Firm, P.C. is a dedicated criminal defense lawyer serving Collin and Denton Counties with offices in Plano and Frisco. He...
Dallas, TX 75231
Texas Southern University Thurgood Marshall School of Law
Ste 120
Denton, TX 76205
Texas A&M University School of Law
Ross Law Offices is different from other firms. Each and every one of Mr. Ross's clients is a top priority, and our primary goal is to give that client the time and attention they need and deserve. Once retained, you will be working directly with Mr. Ross. Mr. Ross personally handles every docket setting, court hearing, pre-trial motion, consultation, client status meeting, and any other aspect which may arise with your case, including jury trial. At Ross Law Offices,...
Austin, TX 78701
Cannabis Law, Appeals, Criminal and DWI
The University of Texas School of Law
Through personalized, compassionate, and client-focused service, Chris Perri will protect your rights and prepare a vigorous defense that ensures the best...
Georgetown, TX 78626
Oklahoma City University
San Antonio, TX 78209
Ron Smeberg represents debtors in bankruptcy matters and has an extensive track record of resolving complex financial matters both in and out of bankruptcy. His accomplishments include reorganizing a public company in a Chapter 11 bankruptcy as well as being one of very few...
Georgetown, TX 78626
SMU Dedman School of Law
As a prosecutor, Alejandro has handled hundreds of criminal cases, honing his skills in case evaluation, negotiation, trial preparation and trial. Further, he is extremely well versed in the techniques and thought processes of the prosecution.
Alejandro utilizes his comprehensive understanding of Texas criminal prosecutions to fight for his clients. His background is your strength; if there is a legal problem with your case, Alejandro will find it.
Austin, TX 78701
South Texas College of Law
San Antonio, TX 78212
The University of Texas School of Law
My firm's motto is: "People Over Profit. Soul Over Salary. Justice Over Just-Good-Enough".
I'm a full service criminal defense attorney who practices all over the San Antonio area. I consider myself to be in "the business of helping people" and my firm is centered around that mission.
I spent three years getting my law degree from one of the most prestigious schools in the nation. After four years at the DA's office, and numerous jury trials, I left to form my own firm because...
Breckenridge, TX 76424
Texas Tech University School of Law
San Antonio, TX 78204
Related Practice Areas
Need a lawyer?
The Justia Lawyer Directory is a listing of lawyers, legal aid organizations, and pro bono legal service organizations. Whether you were injured, are accused of a crime, or are merely engaging in everyday affairs that affect your legal rights or property, an attorney can help you resolve problems or prevent new ones from arising.
Here are just a few situations where you might want to seek the advice of an attorney:
- You were injured in a car or truck accident
- You have been arrested and charged with a crime, such as DUI or shoplifting
- You are considering separating from your spouse
- You have been subjected to harassment or other discrimination at work
Use Justia to research and compare Canyon attorneys so that you can make an informed decision when you hire your counsel.
It is important to research an attorney before hiring him or her. Be sure to evaluate an attorney's experience (types of cases handled, prior results obtained, etc.). Although prior results are not indicative of the likelihood of success in your case, they can help you make an informed decision.
Also worth serious consideration is the attorney's location, particularly if you will be traveling to visit him or her for consultations.
Finally, research an attorney to see whether he or she has ever been subject to discipline. Although disciplinary actions do not necessarily impact the attorney's competence to handle your case, they may affect your decision whether to hire.
Researching Attorney Discipline
There are no recently viewed profiles.
There are no saved profiles.
There are no profiles to compare.


text:
Now showing items 1-1 of 1
A risk score for in-hospital death in patients admitted with ischemic or hemorrhagic stroke.
(J Am Heart Assoc, 2013-01-28)
BACKGROUND: We aimed to derive and validate a single risk score for predicting death from ischemic stroke (IS), intracerebral hemorrhage (ICH), and subarachnoid hemorrhage (SAH). METHODS AND RESULTS: Data from 333 865 stroke ...


text:
Durin's Bane
This article or section needs to be cleaned up to conform to a higher standard of article quality.
|Durin's Bane
|Maia (Balrog)
|"The Balrog of Moria" by Donato Giancola
|Biographical Information
|Other names
|Flame of Udûn[1]
Nameless Terror
|Morgoth's dominions (early)
Moria (after)
|Creation of the Ainur
|25 January T.A. 3019
|Notable for
|Killing Durin VI and ruining Khazad-dûm
|Physical Description
|Maia (Balrog)
|Whip and a flaming sword
|Images of Durin's Bane
Durin's Bane refers to a specific Balrog who was not otherwise named. It survived the War of Wrath and slept deep within the Misty Mountains for thousands of years afterward. After his long hibernation, he was awoken by the Dwarves in the Third Age and encountered by the Fellowship of the Ring.
[edit] History
[edit] Before Hibernation
Durin's Bane was created as a Maia, and followed Morgoth to Arda soon after its creation, like the other Balrogs. There it most likely fought in all major battles until the end of the First Age. When the Valar came against Morgoth in the War of Wrath, Durin's Bane managed to flee and escaped into the east from the ruins of Angband, burying itself in the roots of the Misty Mountains, beneath Khazad-dûm.
[edit] Awakening and Third Age
For more than five millennia, the Balrog hibernated in its deep hiding place at the roots of the mountains in Khazad-dûm. It remained undisturbed throughout the Second Age and most of the Third, before the mithril-miners of dwarf-King Durin VI awoke it in T.A. 1980. Durin was slain by the creature, at which point it became known as Durin's Bane.[2]
The Dwarves attempted to fight the Balrog, but its power was far too great. Despite their efforts to hold Khazad-dûm against it, King Náin and many of the Dwarves were killed and the survivors were forced to flee. This disaster appears to have also reached the Silvan Elves of Lothlórien, many of whom also fled the "Nameless Terror" (it was not recognized as a Balrog at the time). The elves began to call the place Moria, "The Black Pit".
For five hundred years, Moria was left to the Balrog.[3]
Sauron began to put his plans for war into effect around the year 2480 of the Third Age. As part of these, he sent Orcs and Trolls to the Misty Mountains to bar all of the passes. Some of these creatures came to Moria. It is unclear whether the Balrog would still submit to Sauron as Melkor's chief lieutenant, but it is probable that they would have been cooperative at the very least. The Balrog did allow the Orcs and trolls to remain in Moria while it dwelt there, and although they doubtlessly feared it, some worshiped it as a spiritual being.
The Battle of Azanulbizar was the climactic battle in the War of the Dwarves and Orcs. It took place before the eastern gate of Moria in 2799 and was a victory for the Dwarves. However, the victors did not conquer Moria because Dáin Ironfoot, having slain the Orc Azog, felt the terror of the Balrog at the gate. Despite a failed attempt to recolonise Moria by Balin in 2989, Durin's Bane remained a menace in the ancient kingdom of the Dwarves whose nature was hidden to the outside world.
[edit] During the War of the Ring
In January of 3019, the Fellowship of the Ring travelled through Moria on the way to Mount Doom. There they encountered Durin's Bane at the Bridge of Khazad-dûm. The Elf Legolas instantly recognised the Balrog despite having never seen one before. More importantly, the Wizard Gandalf was there (perhaps for this very purpose); knowing that it was far more powerful than even the greatest of his companions, he challenged it.[1]
Since Gandalf and the Balrog were both Maiar, they were beings of the same order. As they faced each other, Gandalf broke the Bridge in front of him, but as the Balrog fell it wrapped its whip around Gandalf's knees, which dragged him to the brink. Gandalf staggered and fell, sliding into the abyss, crying "Fly, you fools!" and was gone. Neither he nor the Balrog was killed by the fall, and Gandalf pursued the creature for eight days until they climbed to the peak of Zirakzigil. Here they fought for two days and nights. In the end, the Balrog was cast down and it broke the mountain-side as it fell. Gandalf himself died following this ordeal, but was later sent back to Middle-earth with even greater powers as Gandalf the White.[4]
[edit] Beyond the Third Age
Durin's Bane is the only Balrog mentioned after the War of Wrath, and the only one of two ever given a name, the other being Gothmog. It is unknown how many, if any, other Balrogs still lived on or where they dwelled, hibernating or awakened.
[edit] Portrayal in adaptations
Durin's Bane in The Lord of the Rings (1978 film)
Durin's Bane in The Lord of the Rings: The Fellowship of the Ring
1978: The Lord of the Rings (1978 film):
- The Balrog has wings and appears capable of limited flight. The head resembles a lion but the rest of the body was rendered in matte black, a technique commonly used for shadowy surreal effect in rotoscope animation.
2001: The Lord of the Rings: The Fellowship of the Ring:
- Durin's Bane has wings. Jackson's Demon of Might was indistinct, a real blend of shadow and fire. Only its horned head, cloven feet, and clawed hands could clearly be seen.
- In the film continuity, the Orcs of Moria (here specified as "goblins") have crafted their armor and weapons to match the fiery appearance of the Balrog, apparently worshipping it as a deity.
2002: The Lord of the Rings: The Fellowship of the Ring (video game):
- The Balrog is the boss of the level "Abyss Fight". He cannot be harmed except when he is stunned with Gandalf's lightning.
2003: The Lord of the Rings: The Third Age:
- The players assist Gandalf in his fight with the Balrog.
2004: The Lord of the Rings: The Battle for Middle-earth:
- Many of the Evil factions can summon a Balrog, specifically Durin's Bane for a short period of time. It is one of the mightiest units in the game, only able to be summoned with experience points. It is similar in design to the movie Balrog.
2006: The Lord of the Rings: The Battle for Middle-earth II:
- Like in the previous installment, the Balrog can be summoned by evil factions.
2007: The Lord of the Rings Online:
- Durin's Bane can be observed in two "session plays" (player character not present): one depicts the awakening of the Balrog by Dwarves under Durin VI, the other depicts dwarves of Balin's company fleeing from the ancient evil. After Gandalf defeats him, the lifeless body of Durin's Bane can be found on the slopes of Zirakzigil. Despite the players knowing the Balrog dead, another Servant of Sauron tests their will and fears, by portraying an illusion of it. In the illusion, the fight between Gandalf and the Balrog on the Endless Stair is recreated, until it ends the opposite way of the actual event: the Balrog defeats the Wizard, throwing his lifeless body from Zirakzigil. Players have to defeat the Balrog in order to combat the illusion.
2013: Lego The Lord of the Rings: The Video Game:
- Durin's Bane is only seen as a light that chases the player(s) through Moria. When they reach the bridge of Khazad Dum, it appears in a cutscene where Gandalf destroys the bridge and the Balrog pulls him down. Then, the player is Gandalf and has to grab Glamdring and land on Durin's Bane, where he has to stab it while avoiding the balrog's firey breath. When this is over, the game starts another cutscene that ends the level. Later, Gandalf appears on a snowy mountain with a tower on top. When he reaches the top of the tower, the Balrog climbs on. The Balrog repeatedly sweeps his fiery whip and strikes the ground with his sword. Then lighting begins to strike at one place and the Balrog breathes fire and is weakened. Gandalf uses his sword to direct the lightning at Durin's Bane and its health goes down. The lightning will strike at three different places, and when the Balrog loses all of its health by being hit three times, it will fall off the mountain and die.
[edit] See also
- ↑ 1.0 1.1 J.R.R. Tolkien, The Lord of the Rings, The Fellowship of the Ring, "The Bridge of Khazad-dûm"
- ↑ J.R.R. Tolkien, The Lord of the Rings, Appendix A, "Durin's Folk"
- ↑ J.R.R. Tolkien, The Lord of the Rings, Appendix B
- ↑ J.R.R. Tolkien, The Lord of the Rings, The Two Towers, "The White Rider"
| Manwë · Ulmo · Aulë · Oromë · Mandos · Irmo · Tulkas ·
|Varda · Yavanna · Nienna · Estë · Vairë · Vána · Nessa
|Arien · Eönwë · Ilmarë · Melian · Ossë · Salmar · Tilion · Uinen
|Saruman · Gandalf · Radagast · Blue Wizards
|Sauron · Balrogs (Gothmog · Durin's Bane) · Boldogs
|Music · Valarin · Almaren · Valinor · Valmar · Second Music • italics indicates Aratar


text:
Karing Kitchen in Oneida provides healthy meals for local families
ONEIDA - The Karing Kitchen is all moved into its new home at the First United Methodist Church in Oneida and open to everyone.
Coordinator Melissa King said the Karing Kitchen has served as Oneida's soup kitchen for the past 20 years. Previously operated from the Salvation Army facility on Farrier Avenue and then from the city's Armory Rec Center, the First United Methodist Church agreed to become the lead agency for the program last June after the Salvation Army closed its Oneida offices.
Karing Kitchen provides free lunches during the last full week of the month when many people find their budgets the most stretched.
This month it's happening this week.
On Sunday, the Oneida Area Council of Churches assisted in an open house for the Karing Kitchen's new home.
Fittingly, it's Christian Unity Week; the event was held "to raise awareness of the services that the Karing Kitchen provides and answer questions that individuals may have," King said.
The program relies on the services of volunteers, including its coordinator, to run the soup kitchen. King said because of the volunteer network, nearly $18,000 is saved each year by not having to pay staff - money goes directly to providing food and services to area families.
Karing Kitchen is open to anyone regardless of income, age or residence.
January's outreach began on Monday and runs all week. A coffee hour starts at 10:30 a.m. and a nutritious hot meal is served from 11:30 a.m. to 1 p.m. Take-out meals are also available.
During a typical month, more than 800 meals are served.
As food prices continue to rise, participants in the SNAP program and the elderly who rely on Social Security often find their ability to purchase food decreasing as they near the end of the month. King said the Oneida Area Council of Churches realized this need within the community and responded by offering this program.
In addition to operating the soup kitchen, the Karing Kitchen also provides advocacy and referral assistance to clients with other agencies throughout the county and conducts workshops on food safety, King said.
During the open house, visitors received a hot meal of chicken noodle soup and egg salad sandwiches that volunteers had prepared.
Jodee Osborne, nutrition outreach and education program coordinator at Community Action Partnership for Madison County provided families with information on the SNAP program - the federal supplemental nutrition assistance program that helps struggling families put food on their tables.
"We partner with Karing Kitchen to help families and individuals increase their food buying power and help them understand the guidelines as well as recommend all available options and programs for families," Osborne said.
King said both monetary and food donations are always needed to keep this program going.
Donations of food can be dropped off any time the Karing Kitchen is operating the last full week of each month.
Monetary donations can be sent to the Karing Kitchen c/o The First United Methodist Church, 116 W. Grove St., Oneida 13421.