text: Keke Rosberg twice bettered his Formula One qualifying record Saturday to take the pole position for Sunday`s British Grand Prix in Silverstone, England. Getting maximum power from his Williams, Rosberg first lopped 14-100ths of a second off his previous record with a time of 1:05.967 despite a slow leak in his front left tire. The time converted to an average speed of 159.668 miles an hour. On his last effort, after rain had caused a 20-minute delay, Rosberg was timed in 1:05.591, averaging 160.925 m.p.h. ``At Silverstone, pole position is not that important. It gives you pleasure, that`s all,`` Rosberg said. ``It`s the race that counts.``


text:
Kareem Abdul-Jabbar Isn't That Impressed by Girls
He wrote a review.
Your newest celebrity-critic over at HuffPo? Kareem Abdul-Jabbar, who watched Lena Dunham's Daily Show performance and decided to respond on behalf of the "58-year-old men who didn't understand." His findings: Last season's show was too white (it could leave a viewer "snow blind"), but Donald Glover's character was forced; the characters talk about sex more than they have it; and they're not that funny. He's on Team Adam, though. Everyone is Team Adam.

subset: commoncrawl


text:
Executive Vice President
Intelligent Solutions, Inc.
Jonathan Geiger, CBIP, is an executive vice president with Intelligent Solutions, Inc. Jonathan has been involved in many Corporate Information Factory projects in several industries. He presents frequently at national and international conferences, has written more than 60 articles, and is a coauthor of three books: Data Stores, Data Warehousing, and the Zachman Framework: Managing Enterprise Knowledge; Building the Customer-Centric Enterprise; and Mastering Data Warehouse Design.
Rest easy—online registrations for this seminar are secure. Our secured server environment keeps your information private.
Register Now


text:
PBSKids.com and SproutOnline.com both offer free flash-based "Caillou" games that are easy for kids to understand. There are a variety of options on each website.Continue Reading
At PBS Kids, there are a variety of interactive games. The main game page begins in Caillou's house and features items in the room that the player can click on to start a mini-game. A variety of mini-games are available.
Sprout Online features games like "Gardening with Caillou," "Caillou the Cook," "Building with Caillou," "The Caillou Memory Game" and "Caillou Follow the Stars. Others include "The Caillou Puzzle Game," "Spelling with Caillou" and "Caillou Painting Activity."Learn more about Internet & Networking


text:
Chelsea Spreeman
Director of Development, Davidson Honors College and University Initiatives
email@example.com | 406.830.8836 | 406.243.2567
Chelsea joined the Foundation with a background in non-profit management and development. Most recently she served as development director at Big Top Chautauqua, where she led donor communications, events, annual and major giving. She holds a B.A. in political science from Lawrence University and a certificate in fund development from the University of Wisconsin. Chelsea is pleased to support the continued growth and education of the highly accomplished students of the Davidson Honors College. Chelsea enjoys cooking and is an avid snowboarder, spending most of her free time in the mountains.


text:
At least two die in attack on Indian army camp in held Kashmir
A gunfight between the militants and Indian army took place in Tangdhar region of Kashmir's Kupwara district today. A soldier of Indian army and a civilian said to be killed in the incident.
According to media reports three to four attackers attacked the army camp from a mountain ridge near the camp. They used heavy weapons and also hurled grenades. An army oil depot also caught fire in the attack.
The army has launched a counter offensive. There are about 80 soldiers in the base.
Army sources say the terrorists have been firing from a distance. There are no reports of casualties.
J&K: Militants Attack Army Camp in Tangdhar by arynews
Tangdhar sector is said to be close to the Line of Control (LoC) in Kupwara district of the Indian occupied Kashmir territory.
The gunbattle was said to be going on till last reports.


text:
What Influences Student Teachers' Ability to Promote Dialogic Talk in the Primary Classroom?
Fisher, Anne
Date issued
Thesis or dissertation
University of Exeter
This thesis examines what it is that enables postgraduate student teachers to promote the recently introduced curriculum innovation, dialogic talk, in primary classrooms. Drawing on literature relating to the way talk has been enacted in English classrooms for the last thirty five years, it suggests that patterns of verbal interaction have continued to prove resistant to change, despite policy imperatives and university courses. Adopting a collaborative action research approach, data were collected in three cycles over three years to investigate the perceptions of three successive cohorts of postgraduate students of the role of talk in learning, and the place of the teacher in developing it. Using a sociocultural lens, students' conceptual and pedagogic understanding of dialogic talk, and their ability to promote it, is examined in depth through nine case studies, as are the factors which the participants themselves identify as enabling or inhibiting engagement with innovation. It is suggested that the lack of a commonly agreed definition, and of readily available theoretical guidance, has reduced dialogic talk to just another label. As such, it can play no significant part in developing practice beyond rapid question-and-answer routines of 'interactive teaching' and the potentially reductive IRF (Initiation, Response, Feedback) script recorded by researchers (Mroz et al, 2000; Myhill, 2006) before, and after the inception of the National Literacy Strategy (1998a). Turning to the role of the university, it questions the place of the 'demonstration lesson' and whole cohort lectures, urging that significant changes need to be made to the role of the teaching practice tutor, and the nature of 'partnership' between schools and university departments. Finally, it speculates that without a significant change in the way university departments examine, and address, the values, attitudes and memories of talk that student teachers bring with them from their own primary classrooms, there will continue to be replication of practice.
Myhill, Debra
Kleine-Staarman, Judith
Degree title
PhD in Education
Qualification level
Qualification name


text:
Pick Up a Free and Warming New MP3 From the Morning Benders
"Excuses": A warm and instrument-driven track off their upcoming album.
"Excuses" is the beautifully waltzy and instrument-driven first track off the Morning Benders' upcoming album, Big Echo (out March 9), and it's a very pleasant listen. Plus there's a video, too, featuring cameos from their buddies John Vanderslice, Chris from Girls, former Rogue Wave-r Gram LeBron, and a handful of other indie-rock scenesters. Download it here if you like.


text:
Sen. Landrieu announces $28.7M in hurricane disaster aid
Grants to fund repairs for Katrina, Isaac
Sen. Landrieu announces $28.7M in hurricane disaster aid
Grants to fund repairs for Katrina, Isaac
U.S. Sen. Mary L. Landrieu, D-La., announced $28.7 million in disaster grants on Thursday related to Hurricanes Katrina and Isaac.
Landrieu, chair of the Senate Homeland Security Appropriations Subcommittee, said the funds are provided by the Federal Emergency Management Agency's Public Assistance Program.
"With the help of these FEMA grants, communities in south Louisiana can continue their rebuilding process," Landrieu said. "Repairing and replacing damaged buildings and equipment is an important step on the path to recovery for many of our parishes."
The grants include:
- $9.5 million to the Louisiana Department of Transportation and Development for emergency transportation of evacuees to shelters and other emergency protective measures required as a result of Hurricane Isaac.
- $8.2 million to the LSU Health Care Services Division/ Medical Center of Louisiana at New Orleans for the replacement of building contents lost as a result of Hurricane Katrina.
- $4.3 million to East Baton Rouge Parish to remove and dispose of approximately 503 tons of debris resulting from Hurricane Isaac.
- $2.7 million to the Louisiana National Guard for emergency protective measures as a result of Hurricane Isaac.
- $2.3 million to the Plaquemines Parish Sheriff's Office to restore damaged building contents and equipment for several of its facilities that sustained high-wind and flood damage as a result of Hurricane Katrina.
- $1.7 million to Plaquemines Parish Government for the repair of the elevated roadway on the secondary levee that was damaged as a result of Hurricane Isaac.


text:
This chapter is based on the Lua 5.0 Reference Manual, written by Roberto Ierusalimschy, Luiz Henrique de Figueiredo and Waldemar Cele. Edits and editions created by members of the Strata team. This portion of the Lua Scripting documentation is Copyright © 1994-2008 Lua.org, PUC-Rio.
[Lua Manual to be edited to reflect Strata concepts and sample code. NOTE: links in blue will take you to the lua.org site version of the manual. This will be changed in the future.]
1 - Introduction
In this section we'll go into the core elements of the
Lua scripting language, how it's integrated into Strata Design 3D and
what you can do with it.
Lua is an extension programming language designed to support
general procedural programming with data description
facilities. [what did he just say?]
It also offers good support for object-oriented programming,
functional programming, and data-driven programming.
Being an extension language, Lua has no notion of a "main" program:
it only works embedded in a host client,
called the embedding program or simply the host.
In this case, Strata Design 3D is the host program. This host program can invoke functions to execute a piece of Lua code,
can write and read Lua variables,
and can register C functions to be called by Lua code.
2 - The Language
This section describes the lexis, the syntax, and the semantics of Lua. In other words, this section describes which tokens [what's a "token"? This word/concept needs to be introduced in the Basic Concepts chapter.] are valid, how they can be combined, and what their combinations mean.
The language constructs will be explained using the usual extended BNF [what's this?] notation,
in which
{a} means 0 or more a's, and
[a] means an optional a.
Non-terminals are shown like non-terminal,
keywords are shown like kword,
and other terminal symbols are shown like `=´.
The complete syntax of Lua can be found in §8
at the end of this manual. [each of these terms need to be explained much better]
2.1 - The "Words" of Lua - Lexical Conventions
Names (also called identifiers) in Lua can be any string of letters, digits, and underscores, not beginning with a digit. This coincides with the definition of names in most languages. (The definition of letter depends on the current locale: any character considered alphabetic by the current locale can be used in an identifier.) Identifiers are used to name variables and table fields.
The following keywords are reserved and cannot be used as names:
and break do else elseif
Lua is a case-sensitive language:
The following strings denote other tokens:
+ - * / ^ =
Literal strings can be delimited by matching single or double quotes, and can contain the following C-like escape sequences:
Moreover, a `
(that is, a backslash followed by a real newline)
results in a newline in the string.
A character in a string may also be specified by its numerical value
using the escape sequence `
where ddd is a sequence of up to three decimal digits.
Strings in Lua may contain any 8-bit value, including embedded zeros,
which can be specified as `
Literal strings can also be delimited by matching double square brackets
(1) "alo\n123\""
Numerical constants may be written with an optional decimal part and an optional decimal exponent. Examples of valid numerical constants are
3 3.0 3.1416 314.16e-2 0.31416E1
Comments start anywhere outside a string with a
double hyphen (
For convenience,
the first line of a chunk is skipped if it starts with
2.2 - Values and Types
Lua is a dynamically typed language. That means that variables do not have types; only values do. There are no type definitions in the language. All values carry their own type.
There are eight basic types in Lua:
nil, boolean, number,
string, function, userdata, thread, and table.
Nil is the type of the value nil,
whose main property is to be different from any other value;
usually it represents the absence of a useful value.
Boolean is the type of the values false and true.
In Lua, both nil and false make a condition false;
any other value makes it true.
Number represents real (double-precision floating-point) numbers.
(It is easy to build Lua interpreters that use other
internal representations for numbers,
such as single-precision float or long integers.)
String represents arrays of characters.
Lua is 8-bit clean:
Strings may contain any 8-bit character,
including embedded zeros (
Functions are first-class values in Lua. That means that functions can be stored in variables, passed as arguments to other functions, and returned as results. Lua can call (and manipulate) functions written in Lua and functions written in C (see 2.5.7).
The type userdata is provided to allow arbitrary C data to be stored in Lua variables. This type corresponds to a block of raw memory and has no pre-defined operations in Lua, except assignment and identity test. However, by using metatables, the programmer can define operations for userdata values (see 2.8). Userdata values cannot be created or modified in Lua, only through the C API. This guarantees the integrity of data owned by the host program.
The type thread represents independent threads of execution and it is used to implement coroutines.
The type table implements associative arrays,
that is, arrays that can be indexed not only with numbers,
but with any value (except nil).
tables can be heterogeneous,
that is, they can contain values of all types (except nil).
Tables are the sole data structuring mechanism in Lua;
they may be used to represent ordinary arrays,
symbol tables, sets, records, graphs, trees, etc.
To represent records, Lua uses the field name as an index.
The language supports this representation by
Like indices, the value of a table field can be of any type (except nil). In particular, because functions are first class values, table fields may contain functions. Thus tables may also carry methods (see 2.5.8).
Tables, functions, and userdata values are objects: variables do not actually contain these values, only references to them. Assignment, parameter passing, and function returns always manipulate references to such values; these operations do not imply any kind of copy.
The library function
Lua provides automatic conversion between
string and number values at run time.
Any arithmetic operation applied to a string tries to convert
that string to a number, following the usual rules.
Conversely, whenever a number is used where a string is expected,
the number is converted to a string, in a reasonable format.
For complete control of how numbers are converted to strings,
use the
2.3 - Variables
Variables are places that store values. There are three kinds of variables in Lua: global variables, local variables, and table fields.
A single name can denote a global variable or a local variable (or a formal parameter of a function, which is a particular form of local variable):
var ::= Name
Variables are assumed to be global unless explicitly declared local (see 2.4.7). Local variables are lexically scoped: Local variables can be freely accessed by functions defined inside their scope (see 2.6).
Before the first assignment to a variable, its value is nil.
Square brackets are used to index a table:
var ::= prefixexp `[´ exp `]´
The first expression (prefixexp)should result in a table value; the second expression (exp) identifies a specific entry inside that table. The expression denoting the table to be indexed has a restricted syntax; see 2.5 for details.
The syntax
var ::= prefixexp `.´ Name
The meaning of accesses to global variables
and table fields can be changed via metatables.
An access to an indexed variable
All global variables live as fields in ordinary Lua tables,
called environment tables or simply environments.
Functions written in C and exported to Lua (C functions)
all share a common global environment.
Each function written in Lua (a Lua function)
has its own reference to an environment,
so that all global variables in that function
will refer to that environment table.
When a function is created,
it inherits the environment from the function that created it.
To change or get the environment table of a Lua function,
you call
An access to a global variable
gettable_event(_env, "x")
_env is the environment of the running function.
_env variable is not defined in Lua.
We use it here only for explanatory purposes.)
2.4 - Statements
Lua supports an almost conventional set of statements, similar to those in Pascal or C. This set includes assignment, control structures, procedure calls, table constructors, and variable declarations.
The unit of execution of Lua is called a chunk. A chunk is simply a sequence of statements, which are executed sequentially. Each statement can be optionally followed by a semicolon:
chunk ::= {stat [`;´]}
Lua handles a chunk as the body of an anonymous function (see 2.5.8). As such, chunks can define local variables and return values.
A chunk may be stored in a file or in a string inside the host program. When a chunk is executed, first it is pre-compiled into opcodes for a virtual machine, and then the compiled code is executed by an interpreter for the virtual machine.
Chunks may also be pre-compiled into binary form;
see program
2.4.2 - BlocksA block is a list of statements; syntactically, a block is equal to a chunk:
block ::= chunk
A block may be explicitly delimited to produce a single statement:
stat ::= do block end
Explicit blocks are useful to control the scope of variable declarations. Explicit blocks are also sometimes used to add a return or break statement in the middle of another block (see 2.4.4).
2.4.3 - Assignment
Lua allows multiple assignment. Therefore, the syntax for assignment defines a list of variables on the left side and a list of expressions on the right side. The elements in both lists are separated by commas:
stat ::= varlist1 `=´ explist1
Expressions are discussed in 2.5.
Before the assignment, the list of values is adjusted to the length of the list of variables. If there are more values than needed, the excess values are thrown away. If there are fewer values than needed, the list is extended with as many nil's as needed. If the list of expressions ends with a function call, then all values returned by that function call enter in the list of values, before the adjustment (except when the call is enclosed in parentheses; see 2.5).
The assignment statement first evaluates all its expressions and only then are the assignments performed. Thus the code
i = 3
a[3] to 20, without affecting
because the
i in
a[i] is evaluated (to 3)
before it is assigned 4.
Similarly, the line
x, y = y, x
exchanges the values of
x and
The meaning of assignments to global variables
and table fields can be changed via metatables.
An assignment to an indexed variable
An assignment to a global variable
settable_event(_env, "x", val)
_env is the environment of the running function.
_env variable is not defined in Lua.
We use it here only for explanatory purposes.)
2.4.4 - Control StructuresThe control structures if, while, and repeat have the usual meaning and familiar syntax:
stat ::= while exp do block end
Lua also has a for statement, in two flavors (see 2.4.5).
The condition expression exp of a control structure may return any value. Both false and nil are considered false. All values different from nil and false are considered true (in particular, the number 0 and the empty string are also true).
The return statement is used to return values from a function or from a chunk. Functions and chunks may return more than one value, so the syntax for the return statement is
stat ::= return [explist1]
The break statement can be used to terminate the execution of a while, repeat, or for loop, skipping to the next statement after the loop:
stat ::= break
A break ends the innermost enclosing loop.
For syntactic reasons, return and break
statements can only be written as the last statement of a block.
If it is really necessary to return or break in the
middle of a block,
then an explicit inner block can be used,
as in the idioms
2.4.5 - For Statement
The for statement has two forms: one numeric and one generic.
The numeric for loop repeats a block of code while a control variable runs through an arithmetic progression. It has the following syntax:
stat ::= for Name `=´ exp `,´ exp [`,´ exp] do block end
The block is repeated for name starting at the value of the first exp, until it passes the second exp by steps of the third exp. More precisely, a for statement like
for var = e1, e2, e3 do block end
is equivalent to the code:
Note the following:
The generic for statement works over functions, called iterators. For each iteration, it calls its iterator function to produce a new value, stopping when the new value is nil. The generic for loop has the following syntax:
stat ::= for Name {`,´ Name} in explist1 do block end
A for statement like
for var_1, ..., var_n in explist do block end
is equivalent to the code:
Note the following:
2.4.6 - Function Calls as StatementsTo allow possible side-effects, function calls can be executed as statements:
stat ::= functioncall
In this case, all returned values are thrown away. Function calls are explained in 2.5.7.
2.4.7 - Local DeclarationsLocal variables may be declared anywhere inside a block. The declaration may include an initial assignment:
stat ::= local namelist [`=´ explist1]
If present, an initial assignment has the same semantics of a multiple assignment (see 2.4.3). Otherwise, all variables are initialized with nil.
A chunk is also a block (see 2.4.1), so local variables can be declared in a chunk outside any explicit block. Such local variables die when the chunk ends.
The visibility rules for local variables are explained in 2.6.
2.5 - Expressions
The basic expressions in Lua are the following:
exp ::= prefixexp
Numbers and literal strings are explained in 2.1; variables are explained in 2.3; function definitions are explained in 2.5.8; function calls are explained in 2.5.7; table constructors are explained in 2.5.6.
An expression enclosed in parentheses always results in only one value.
Expressions can also be built with arithmetic operators, relational operators, and logical operators, all of which are explained below.
2.5.1 - Arithmetic OperatorsLua supports the usual arithmetic operators: the binary
+ (addition),
- (subtraction),
* (multiplication),
/ (division), and
^ (exponentiation);
and unary
- (negation).
If the operands are numbers, or strings that can be converted to
numbers (see 2.2.1),
then all operations except exponentiation have the usual meaning.
Exponentiation calls a global function
otherwise, an appropriate metamethod is called (see 2.8).
The standard mathematical library defines function
giving the expected meaning to exponentiation
(see 5.5).
2.5.2 - Relational OperatorsThe relational operators in Lua are
== ~= < > <= >=
These operators always result in false or true.
Equality (
You can change the way that Lua compares tables and userdata using the "eq" metamethod (see 2.8).
The conversion rules of 2.2.1
do not apply to equality comparisons.
The operator
The order operators work as follows. If both arguments are numbers, then they are compared as such. Otherwise, if both arguments are strings, then their values are compared according to the current locale. Otherwise, Lua tries to call the "lt" or the "le" metamethod (see 2.8).
2.5.3 - Logical OperatorsThe logical operators in Lua are
and or not
Like the control structures (see 2.4.4), all logical operators consider both false and nil as false and anything else as true.
The operator not always returns false or true.
The conjunction operator and returns its first argument if this value is false or nil; otherwise, and returns its second argument. The disjunction operator or returns its first argument if this value is different from nil and false; otherwise, or returns its second argument. Both and and or use short-cut evaluation, that is, the second operand is evaluated only if necessary. For example,
10 or error() -> 10
2.5.4 - ConcatenationThe string concatenation operator in Lua is denoted by two dots (`
If both operands are strings or numbers, then they are converted to
strings according to the rules mentioned in 2.2.1.
Otherwise, the "concat" metamethod is called (see 2.8).
2.5.5 - PrecedenceOperator precedence in Lua follows the table below, from lower to higher priority:
You can use parentheses to change the precedences in an expression. The concatenation (`
..´) and exponentiation (`
operators are right associative.
All other binary operators are left associative.
2.5.6 - Table ConstructorsTable constructors are expressions that create tables. Every time a constructor is evaluated, a new table is created. Constructors can be used to create empty tables, or to create a table and initialize some of its fields. The general syntax for constructors is
tableconstructor ::= `{´ [fieldlist] `}´
Each field of the form
a = {[f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45}
is equivalent to
If the last field in the list has the form
The field list may have an optional trailing separator, as a convenience for machine-generated code.
2.5.7 - Function CallsA function call in Lua has the following syntax:
functioncall ::= prefixexp args
In a function call, first prefixexp and args are evaluated. If the value of prefixexp has type function, then that function is called with the given arguments. Otherwise, its "call" metamethod is called, having as first parameter the value of prefixexp, followed by the original call arguments (see 2.8).
The form
functioncall ::= prefixexp `:´ Name args
can be used to call "methods". A call
is syntactic sugar for
except that
v is evaluated only once.
Arguments have the following syntax:
args ::= `(´ [explist1] `)´
All argument expressions are evaluated before the call. A call of the form
f{...} is syntactic sugar for
f({...}), that is,
the argument list is a single new table.
A call of the form
f"..." or
f[[...]]) is syntactic sugar for
f('...'), that is,
the argument list is a single literal string.
Because a function can return any number of results (see 2.4.4), the number of results must be adjusted before they are used. If the function is called as a statement (see 2.4.6), then its return list is adjusted to zero elements, thus discarding all returned values. If the function is called inside another expression or in the middle of a list of expressions, then its return list is adjusted to one element, thus discarding all returned values except the first one. If the function is called as the last element of a list of expressions, then no adjustment is made (unless the call is enclosed in parentheses).
Here are some examples:
f() -- adjusted to 0 results
If you enclose a function call in parentheses, then it is adjusted to return exactly one value:
return x,y,(f()) -- returns x, y, and the first value from f()
As an exception to the free-format syntax of Lua,
you cannot put a line break before the `
a = f
Lua would read that as
a = f(g).x(a).
So, if you want two statements, you must add a semi-colon between them.
If you actually want to call
you must remove the line break before
A call of the form
return (f(x)) -- results adjusted to 1
2.5.8 - Function Definitions
The syntax for function definition is
function ::= function funcbody
The following syntactic sugar simplifies function definitions:
stat ::= function funcname funcbody
The statement
function f () ... end
translates to
f = function () ... end
The statement
function t.a.b.c.f () ... end
translates to
t.a.b.c.f = function () ... end
The statement
local function f () ... end
translates to
local f; f = function () ... end
A function definition is an executable expression, whose value has type function. When Lua pre-compiles a chunk, all its function bodies are pre-compiled too. Then, whenever Lua executes the function definition, the function is instantiated (or closed). This function instance (or closure) is the final value of the expression. Different instances of the same function may refer to different external local variables and may have different environment tables.
Parameters act as local variables that are initialized with the argument values:
parlist1 ::= namelist [`,´ `...´]
When a function is called, the list of arguments is adjusted to the length of the list of parameters, unless the function is a variadic or vararg function, which is indicated by three dots (`
...´) at the end of its parameter list.
A vararg function does not adjust its argument list;
instead, it collects all extra arguments into an implicit parameter,
The value of
arg is a table,
with a field `
n´ that holds the number of extra arguments
and with the extra arguments at positions 1, 2, ...,
As an example, consider the following definitions:
function f(a, b) end
Then, we have the following mapping from arguments to parameters:
Results are returned using the return statement (see 2.4.4). If control reaches the end of a function without encountering a return statement, then the function returns with no results.
The colon syntax
is used for defining methods,
that is, functions that have an implicit extra parameter
function t.a.b.c:f (...) ... end
is syntactic sugar for
t.a.b.c.f = function (self, ...) ... end
2.6 - Visibility Rules
Lua is a lexically scoped language. The scope of variables begins at the first statement after their declaration and lasts until the end of the innermost block that includes the declaration. For instance:
x = 10 -- global variable
Notice that, in a declaration like
local x = x,
the new
x being declared is not in scope yet,
and so the second
x refers to the outside variable.
Because of the lexical scoping rules, local variables can be freely accessed by functions defined inside their scope. For instance:
local counter = 0
A local variable used by an inner function is called an upvalue, or external local variable, inside the inner function.
Notice that each execution of a local statement defines new local variables. Consider the following example:
a = {}
The loop creates ten closures (that is, ten instances of the anonymous function). Each of these closures uses a different
y variable,
while all of them share the same
2.7 - Error Handling
Because Lua is an extension language, all Lua actions start from C code in the host program calling a function from the Lua library (see 3.15). Whenever an error occurs during Lua compilation or execution, control returns to C, which can take appropriate measures (such as print an error message).
Lua code can explicitly generate an error by calling the
2.8 - Metatables
Every table and userdata object in Lua may have a metatable.
This metatable is an ordinary Lua table
that defines the behavior of the original table and userdata
under certain special operations.
You can change several aspects of the behavior
of an object by setting specific fields in its metatable.
For instance, when an object is the operand of an addition,
Lua checks for a function in the field
We call the keys in a metatable events
and the values metamethods.
In the previous example, the event is
You can query and change the metatable of an object
through the
A metatable may control how an object behaves in arithmetic operations, order comparisons, concatenation, and indexing. A metatable can also define a function to be called when a userdata is garbage collected. For each of those operations Lua associates a specific key called an event. When Lua performs one of those operations over a table or a userdata, it checks whether that object has a metatable with the corresponding event. If so, the value associated with that key (the metamethod) controls how Lua will perform the operation.
Metatables control the operations listed next.
Each operation is identified by its corresponding name.
The key for each operation is a string with its name prefixed by
two underscores;
for instance, the key for operation "add" is the
The code shown here in Lua is only illustrative;
the real behavior is hard coded in the interpreter
and it is much more efficient than this simulation.
All functions used in these descriptions
This should be read as
rawget(metatable(obj) or {}, event)
That is, the access to a metamethod does not invoke other metamethods, and the access to objects with no metatables does not fail (it simply results in nil).
2.9 - Garbage Collection
Lua does automatic memory management. That means that you do not have to worry about allocating memory for new objects and freeing it when the objects are no longer needed. Lua manages memory automatically by running a garbage collector from time to time to collect all dead objects (that is, those objects that are no longer accessible from Lua). All objects in Lua are subject to automatic management: tables, userdata, functions, threads, and strings.
Lua uses two numbers to control its garbage-collection cycles. One number counts how many bytes of dynamic memory Lua is using; the other is a threshold. When the number of bytes crosses the threshold, Lua runs the garbage collector, which reclaims the memory of all dead objects. The byte counter is adjusted, and then the threshold is reset to twice the new value of the byte counter.
Through the C API, you can query those numbers
and change the threshold (see 3.7).
Setting the threshold to zero actually forces an immediate
garbage-collection cycle,
while setting it to a huge number effectively stops the garbage collector.
Using Lua code you have a more limited control over garbage-collection cycles,
through the
2.9.1 - Garbage-Collection Metamethods
Using the C API, you can set garbage-collector metamethods for userdata (see 2.8). These metamethods are also called finalizers. Finalizers allow you to coordinate Lua's garbage collection with external resource management (such as closing files, network or database connections, or freeing your own memory).
Free userdata with a field
function gc_event (udata)
At the end of each garbage-collection cycle, the finalizers for userdata are called in reverse order of their creation, among those collected in that cycle. That is, the first finalizer to be called is the one associated with the userdata created last in the program.
2.9.2 - Weak Tables
A weak table is a table whose elements are weak references. A weak reference is ignored by the garbage collector. In other words, if the only references to an object are weak references, then the garbage collector will collect that object.
A weak table can have weak keys, weak values, or both.
A table with weak keys allows the collection of its keys,
but prevents the collection of its values.
A table with both weak keys and weak values allows the collection of
both keys and values.
In any case, if either the key or the value is collected,
the whole pair is removed from the table.
The weakness of a table is controlled by the value of the
After you use a table as a metatable,
you should not change the value of its field
2.10 - Coroutines
Lua supports coroutines, also called semi-coroutines or collaborative multithreading. A coroutine in Lua represents an independent thread of execution. Unlike threads in multithread systems, however, a coroutine only suspends its execution by explicitly calling a yield function.
You create a coroutine with a call to
When you first call
A coroutine can terminate its execution in two ways:
Normally, when its main function returns
(explicitly or implicitly, after the last instruction);
and abnormally, if there is an unprotected error.
In the first case,
A coroutine yields by calling
As an example, consider the next code:
function foo1 (a)
When you run it, it produces the following output:
co-body 1 10
3 - The Application Program Interface
This section describes the C API for Lua, that is,
the set of C functions available to the host program to communicate
with Lua.
All API functions and related types and constants
are declared in the header file
Even when we use the term "function", any facility in the API may be provided as a macro instead. All such macros use each of its arguments exactly once (except for the first argument, which is always a Lua state), and so do not generate hidden side-effects.
3.1 - States
The Lua library is fully reentrant:
it has no global variables.
The whole state of the Lua interpreter
(global variables, stack, etc.)
is stored in a dynamically allocated structure of type
Before calling any API function,
you must create a state by calling
lua_State *lua_open (void);
To release a state created with
void lua_close (lua_State *L);
This function destroys all objects in the given Lua state (calling the corresponding garbage-collection metamethods, if any) and frees all dynamic memory used by that state. On several platforms, you may not need to call this function, because all resources are naturally released when the host program ends. On the other hand, long-running programs, such as a daemon or a web server, might need to release states as soon as they are not needed, to avoid growing too large.
3.2 - The Stack and Indices
Lua uses a virtual stack to pass values to and from C. Each element in this stack represents a Lua value (nil, number, string, etc.).
Whenever Lua calls C, the called function gets a new stack, which is independent of previous stacks and of stacks of C functions that are still active. That stack initially contains any arguments to the C function, and it is where the C function pushes its results to be returned to the caller (see 3.16).
For convenience,
most query operations in the API do not follow a strict stack discipline.
Instead, they can refer to any element in the stack by using an index:
A positive index represents an absolute stack position
(starting at 1);
a negative index represents an offset from the top of the stack.
More specifically, if the stack has n elements,
then index 1 represents the first element
(that is, the element that was pushed onto the stack first)
index n represents the last element;
index -1 also represents the last element
(that is, the element at the top)
and index -n represents the first element.
We say that an index is valid
if it lies between 1 and the stack top
(that is, if
At any time, you can get the index of the top element by calling
int lua_gettop (lua_State *L);
Because indices start at 1, the result of
lua_gettop is equal to the number of elements in the stack
(and so 0 means an empty stack).
When you interact with Lua API, you are responsible for controlling stack overflow. The function
int lua_checkstack (lua_State *L, int extra);
grows the stack size to
top + extra elements;
it returns false if it cannot grow the stack to that size.
This function never shrinks the stack;
if the stack is already larger than the new size,
it is left unchanged.
Whenever Lua calls C,
it ensures that at least
Most query functions accept as indices any value inside the
available stack space, that is, indices up to the maximum stack size
you have set through
(index < 0 && abs(index) <= top) || (index > 0 && index <= stackspace)
Note that 0 is never an acceptable index.
Unless otherwise noted, any function that accepts valid indices can also be called with pseudo-indices, which represent some Lua values that are accessible to the C code but are not in the stack. Pseudo-indices are used to access the global environment, the registry, and the upvalues of a C function (see 3.17).
3.3 - Stack Manipulation
The API offers the following functions for basic stack manipulation:
void lua_settop (lua_State *L, int index);
#define lua_pop(L,n) lua_settop(L, -(n)-1)
which pops
n elements from the stack.
As an example, if the stack starts as
lua_pushvalue(L, 3) --> 10 20 30 40 50 30*
3.4 - Querying the Stack
To check the type of a stack element, the following functions are available:
int lua_type (lua_State *L, int index);
These functions can be called with any acceptable index.
const char *lua_typename (lua_State *L, int type);
The API also contains functions to compare two values in the stack:
int lua_equal (lua_State *L, int index1, int index2);
compares the values for primitive equality, without metamethods. These functions return 0 (false) if any of the indices are non-valid.
lua_equal and
are equivalent to their counterparts in Lua (see 2.5.2).
3.5 - Getting Values from the Stack
To translate a value in the stack to a specific C type, you can use the following conversion functions:
int lua_toboolean (lua_State *L, int index);
These functions can be called with any acceptable index. When called with a non-valid index, they act as if the given value had an incorrect type.
3.6 - Pushing Values onto the Stack
The API has the following functions to push C values onto the stack:
void lua_pushboolean (lua_State *L, int b);
These functions receive a C value,
convert it to a corresponding Lua value,
and push the result onto the stack.
In particular,
You can also push "formatted" strings:
const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
These functions push onto the stack a formatted string and return a pointer to that string. They are similar to
sprintf and
but with some important differences:
The function
void lua_concat (lua_State *L, int n);
concatenates the
n values at the top of the stack,
pops them, and leaves the result at the top.
n is 1, the result is that single string
(that is, the function does nothing);
n is 0, the result is the empty string.
Concatenation is done following the usual semantics of Lua
(see 2.5.4).
3.7 - Controlling Garbage Collection
Lua uses two numbers to control its garbage collection: the count and the threshold (see 2.9). The first counts the amount of memory in use by Lua; when the count reaches the threshold, Lua runs its garbage collector. After the collection, the count is updated and the threshold is set to twice the count value.
You can access the current values of these two numbers through the following functions:
int lua_getgccount (lua_State *L);
Both return their respective values in Kbytes. You can change the threshold value with
void lua_setgcthreshold (lua_State *L, int newthreshold);
Again, the
newthreshold value is given in Kbytes.
When you call this function,
Lua sets the new threshold and checks it against the byte counter.
If the new threshold is less than the byte counter,
then Lua immediately runs the garbage collector.
In particular
lua_setgcthreshold(L,0) forces a garbage collection.
After the collection,
a new threshold is set according to the previous rule.
3.8 - Userdata
Userdata represents C values in Lua. Lua supports two types of userdata: full userdata and light userdata.
A full userdata represents a block of memory. It is an object (like a table): You must create it, it can have its own metatable, and you can detect when it is being collected. A full userdata is only equal to itself (under raw equality).
A light userdata represents a pointer. It is a value (like a number): You do not create it, it has no metatables, it is not collected (as it was never created). A light userdata is equal to "any" light userdata with the same C address.
In Lua code, there is no way to test whether a userdata is full or light;
both have type
You can create a new full userdata with the following function:
void *lua_newuserdata (lua_State *L, size_t size);
This function allocates a new block of memory with the given size, pushes on the stack a new userdata with the block address, and returns this address.
To push a light userdata into the stack you use
When Lua collects a full userdata,
it calls the userdata's
3.9 - Metatables
The following functions allow you to manipulate the metatables of an object:
int lua_getmetatable (lua_State *L, int index);
lua_getmetatable pushes on the stack the metatable of a given object.
If the index is not valid,
or if the object does not have a metatable,
lua_getmetatable returns 0 and pushes nothing on the stack.
3.10 - Loading Lua Chunks
You can load a Lua chunk with
typedef const char * (*lua_Chunkreader)
The return values of
lua_load are:
If there are no errors,
lua_load pushes the compiled chunk as a Lua
function on top of the stack.
Otherwise, it pushes an error message.
In the current implementation,
the reader function cannot call any Lua function;
to ensure that, it always receives
The chunkname is used for error messages and debug information (see 4).
See the auxiliary library (
3.11 - Manipulating Tables
Tables are created by calling the function
void lua_newtable (lua_State *L);
This function creates a new, empty table and pushes it onto the stack.
To read a value from a table that resides somewhere in the stack, call
void lua_gettable (lua_State *L, int index);
index points to the table.
lua_gettable pops a key from the stack
and returns (on the stack) the contents of the table at that key.
The table is left where it was in the stack.
As in Lua, this function may trigger a metamethod
for the "index" event (see 2.8).
To get the real value of any table key,
without invoking any metamethod,
use the raw version:
void lua_rawget (lua_State *L, int index);
To store a value into a table that resides somewhere in the stack, you push the key and then the value onto the stack, and call
void lua_settable (lua_State *L, int index);
index points to the table.
lua_settable pops from the stack both the key and the value.
The table is left where it was in the stack.
As in Lua, this operation may trigger a metamethod
for the "settable" or "newindex" events.
To set the real value of any table index,
without invoking any metamethod,
use the raw version:
void lua_rawset (lua_State *L, int index);
You can traverse a table with the function
int lua_next (lua_State *L, int index);
wherereturns 0 (and pushes nothing). Use a
index points to the table to be traversed.
The function pops a key from the stack,
and pushes a key-value pair from the table
(the "next" pair after the given key).
If there are no more elements, then
lua_nextnil key to signal the start of a traversal.
A typical traversal looks like this:
/* table is in the stack at index `t' */
While traversing a table,
do not call
3.12 - Manipulating Environments
All global variables are kept in ordinary Lua tables,
called environments.
The initial environment is called the global environment.
This table is always at pseudo-index
To access and change the value of global variables, you can use regular table operations over an environment table. For instance, to access the value of a global variable, do
lua_pushstring(L, varname);
You can change the global environment of a Lua thread using
The following functions get and set the environment of Lua functions:
void lua_getfenv (lua_State *L, int index);
lua_getfenv pushes on the stack the environment table of
the function at index
index in the stack.
If the function is a C function,
lua_getfenv pushes the global environment.
lua_setfenv pops a table from the stack and sets it as
the new environment for the function at index
index in the stack.
If the object at the given index is not a Lua function,
lua_setfenv returns 0.
3.13 - Using Tables as Arrays
The API has functions that help to use Lua tables as arrays, that is, tables indexed by numbers only:
void lua_rawgeti (lua_State *L, int index, int n);
3.14 - Calling Functions
Functions defined in Lua and C functions registered in Lua can be called from the host program. This is done using the following protocol: First, the function to be called is pushed onto the stack; then, the arguments to the function are pushed in direct order, that is, the first argument is pushed first. Finally, the function is called using
void lua_call (lua_State *L, int nargs, int nresults);
nargs is the number of arguments that you pushed onto the stack.
All arguments and the function value are popped from the stack,
and the function results are pushed.
The number of results are adjusted to
nresults is
In that case, all results from the function are pushed.
Lua takes care that the returned values fit into the stack space.
The function results are pushed onto the stack in direct order
(the first result is pushed first),
so that after the call the last result is on the top.
The following example shows how the host program may do the equivalent to this Lua code:
a = f("how", t.x, 14)
Here it is in C:
lua_pushstring(L, "t");
Note that the code above is "balanced": at its end, the stack is back to its original configuration. This is considered good programming practice.
(We did this example using only the raw functions provided by Lua's API, to show all the details. Usually programmers define and use several macros and auxiliary functions that provide higher level access to Lua. See the source code of the standard libraries for examples.)
3.15 - Protected Calls
When you call a function with
int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
nargs and
nresults have the same meaning as
If there are no errors during the call,
lua_pcall behaves exactly like
However, if there is any error,
lua_pcall catches it,
pushes a single value at the stack (the error message),
and returns an error code.
lua_pcall always removes the function
and its arguments from the stack.
Typically, the error handler function is used to add more debug
information to the error message, such as a stack traceback.
Such information cannot be gathered after the return of
3.16 - Defining C Functions
Lua can be extended with functions written in C.
These functions must be of type
typedef int (*lua_CFunction) (lua_State *L);
A C function receives a Lua state and returns an integer, the number of values it wants to return to Lua.
In order to communicate properly with Lua, a C function must follow the following protocol, which defines the way parameters and results are passed: A C function receives its arguments from Lua in its stack in direct order (the first argument is pushed first). So, when the function starts, its first argument (if any) is at index 1. To return values to Lua, a C function just pushes them onto the stack, in direct order (the first result is pushed first), and returns the number of results. Any other value in the stack below the results will be properly discharged by Lua. Like a Lua function, a C function called by Lua can also return many results.
As an example, the following function receives a variable number of numerical arguments and returns their average and sum:
static int foo (lua_State *L) {
To register a C function to Lua, there is the following convenience macro:
#define lua_register(L,n,f) \
which receives the name the function will have in Lua and a pointer to the function. Thus, the C functionabove may be registered in Lua as
average by calling
lua_register(L, "average", foo);
3.17 - Defining C Closures
When a C function is created, it is possible to associate some values with it, thus creating a C closure; these values are then accessible to the function whenever it is called. To associate values with a C function, first these values should be pushed onto the stack (when there are multiple values, the first value is pushed first). Then the function
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
is used to push the C function onto the stack, with the argument
n telling how many values should be
associated with the function
lua_pushcclosure also pops these values from the stack);
in fact, the macro
lua_pushcfunction is defined as
lua_pushcclosure with
n set to 0.
Then, whenever the C function is called,
those values are located at specific pseudo-indices.
Those pseudo-indices are produced by a macro
For examples of C functions and closures,
see the standard libraries in the official Lua distribution
3.18 - Registry
Lua provides a registry,
a pre-defined table that can be used by any C code to
store whatever Lua value it needs to store,
specially if the C code needs to keep that Lua value
outside the life span of a C function.
This table is always located at pseudo-index
The integer keys in the registry are used by the reference mechanism, implemented by the auxiliary library, and therefore should not be used by other purposes.
3.19 - Error Handling in C
Internally, Lua uses the C
If an error happens outside any protected environment,
Lua calls a panic function
and then calls
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
Your new panic function may avoid the application exit by never returning (e.g., by doing a long jump). Nevertheless, the corresponding Lua state will not be consistent; the only safe operation with it is to close it.
Almost any function in the API may raise an error,
for instance due to a memory allocation error.
The following functions run in protected mode
(that is, they create a protected environment to run),
so they never raise an error:
There is yet another function that runs a given C function in protected mode:
int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);
lua_cpcall calls
func in protected mode.
func starts with only one element in its stack,
a light userdata containing
In case of errors,
lua_cpcall returns the same error codes as
(see 3.15),
plus the error object on the top of the stack;
otherwise, it returns zero, and does not change the stack.
Any value returned by
func is discarded.
C code can generate a Lua error calling the function
void lua_error (lua_State *L);
The error message (which actually can be any type of object) must be on the stack top. This function does a long jump, and therefore never returns.
3.20 - Threads
Lua offers partial support for multiple threads of execution. If you have a C library that offers multi-threading, then Lua can cooperate with it to implement the equivalent facility in Lua. Also, Lua implements its own coroutine system on top of threads. The following function creates a new thread in Lua:
lua_State *lua_newthread (lua_State *L);
This function pushes the thread on the stack and returns a pointer to a
lua_State that represents this new thread.
The new state returned by this function shares with the original state
all global objects (such as tables),
but has an independent run-time stack.
Each thread has an independent global environment table. When you create a thread, this table is the same as that of the given state, but you can change each one independently.
There is no explicit function to close or to destroy a thread. Threads are subject to garbage collection, like any Lua object.
To manipulate threads as coroutines, Lua offers the following functions:
int lua_resume (lua_State *L, int narg);
To start a coroutine, you first create a new thread; then you push on its stack the body function plus any eventual arguments; then you call
narg being the number of arguments.
This call returns when the coroutine suspends or finishes its execution.
When it returns, the stack contains all values passed to
or all values returned by the body function.
lua_resume returns 0 if there are no errors running the coroutine,
or an error code (see 3.15).
In case of errors,
the stack contains only the error message.
To restart a coroutine, you put on its stack only the values to
be passed as results from
and then call
return lua_yield (L, nresults);
When a C function calls
lua_yield in that way,
the running coroutine suspends its execution,
and the call to
lua_resume that started this coroutine returns.
The parameter
nresults is the number of values from the stack
that are passed as results to
To exchange values between different threads,
you may use
void lua_xmove (lua_State *from, lua_State *to, int n);
It pops
n values from the stack
and puhses them into the stack
4 - The Debug Interface
Lua has no built-in debugging facilities. Instead, it offers a special interface by means of functions and hooks. This interface allows the construction of different kinds of debuggers, profilers, and other tools that need "inside information" from the interpreter.
4.1 - Stack and Function Information
The main function to get information about the interpreter runtime stack is
int lua_getstack (lua_State *L, int level, lua_Debug *ar);
This function fills parts of a
lua_Debug structure with
an identification of the activation record
of the function executing at a given level.
Level 0 is the current running function,
whereas level n+1 is the function that has called level n.
When there are no errors,
lua_getstack returns 1;
when called with a level greater than the stack depth,
it returns 0.
The structure
typedef struct lua_Debug {
lua_getstack fills only the private part
of this structure, for later use.
To fill the other fields of
lua_Debug with useful information,
int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
This function returns 0 on error (for instance, an invalid option in
Each character in the string
what selects some fields of the structure
ar to be filled,
as indicated by the letter in parentheses in the definition of
S´ fills in the fields
l´ fills in the field
currentline, etc.
Moreover, `
f´ pushes onto the stack the function that is
running at the given level.
To get information about a function that is not active
(that is, not in the stack),
you push it onto the stack
and start the
lua_Debug ar;
The fields of
lua_Debug have the following meaning:
4.2 - Manipulating Local Variables and Upvalues
For the manipulation of local variables and upvalues, the debug interface uses indices: The first parameter or local variable has index 1, and so on, until the last active local variable. Upvalues have no particular order, as they are active through the whole function.
The following functions allow the manipulation of the local variables of a given activation record:
const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
The parameter
ar must be a valid activation record that was
filled by a previous call to
lua_getstack or
given as argument to a hook (see 4.3).
lua_getlocal gets the index
n of a local variable,
pushes the variable's value onto the stack,
and returns its name.
lua_setlocal assigns the value at the top of the stack
to the variable and returns its name.
Both functions return
when the index is greater than
the number of active local variables.
The following functions allow the manipulation of the upvalues of a given function (unlike local variables, the upvalues of a function are accessible even when the function is not active):
const char *lua_getupvalue (lua_State *L, int funcindex, int n);
These functions operate both on Lua functions and on C functions. (For Lua functions, upvalues are the external local variables that the function uses, and that consequently are included in its closure.)
funcindex points to a function in the stack.
lua_getupvalue gets the index
n of an upvalue,
pushes the upvalue's value onto the stack,
and returns its name.
lua_setupvalue assigns the value at the top of the stack
to the upvalue and returns its name.
Both functions return
when the index is greater than the number of upvalues.
For C functions, these functions use the empty string
as a name for all upvalues.
As an example, the following function lists the names of all local variables and upvalues for a function at a given level of the stack:
int listvars (lua_State *L, int level) {
4.3 - Hooks
Lua offers a mechanism of hooks, which are
user-defined C functions that are called during the program execution.
A hook may be called in four different events:
a call event, when Lua calls a function;
a return event, when Lua returns from a function;
a line event, when Lua starts executing a new line of code;
and a count event, which happens every "count" instructions.
Lua identifies these events with the following constants:
A hook has type
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
You can set the hook with the following function:
int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
func is the hook.
mask specifies on which events the hook will be called:
It is formed by a disjunction of the constants
count argument is only meaningful when the mask
For each event, the hook is called as explained below:
A hook is disabled by setting
You can get the current hook, the current mask, and the current count with the following functions:
lua_Hook lua_gethook (lua_State *L);
Whenever a hook is called, its
While Lua is running a hook, it disables other calls to hooks. Therefore, if a hook calls back Lua to execute a function or a chunk, that execution occurs without any calls to hooks.
5 - Standard Libraries
The standard libraries provide useful functions
that are implemented directly through the C API.
Some of these functions provide essential services to the language
All libraries are implemented through the official C API and are provided as separate C modules. Currently, Lua has the following standard libraries:
To have access to these libraries,
the C host program must first call the functions
5.1 - Basic Functions
The basic library provides some core functions to Lua. If you do not include this library in your application, you should check carefully whether you need to provide some alternative implementation for some of its facilities.
Home > Strata Design 3D CX Scripting > Scripting Reference >


text:
Featured News - Current News - Archived News - News Categories
Islanders celebrated a windy Veterans Day at the Memorial Wall on Bedell Road last Friday. Members of the DeGlopper VFW Post No. 9249, American Legion Post No. 1346, and Disabled American Veterans Chapter 168 were on hand for the ceremony, which included a salute to Korean War vets.


text:
The Organic Pharmacy Phytonutrient Capsules
Please select a color and size before adding to your cart.
Please select a color and size before adding to your Wish List.
Please select a color and size before adding to your Gift List.
The Organic Pharmacy
Phytonutrient Capsules
Free Shipping & Returns on All U.S. Orders. See Details
Based entirely on organic green superfoods, nutrients and antioxidants, this formula also includes Digestive Enzymes, Immune enhancing Mushrooms, Acidophilus, Linseed and MSM making this a perfect daily vitamin supplement and for strong hair, skin and nails. Unlike most synthetic supplements, your body will recognize these nutrients and readily absorb them.
3 capsules provide: MSM 1000mg, Spirulina 100mg, Alfalfa 50mg, Barley grass 50mg, Wheat grass 50mg, Fruit oligosaccharides 15mg, Bilberry fruit (4:1) 15mg, Maitake mushroom 15mg, Reishi mushroom 15mg, Cordyceps sinensis 15mg, Shitake mushroom 15mg, Chlorella 15mg, Bromelain 15mg, Lipase 10,000u/g, Amylase 50,000 skbu/g, Bifidus 10 billion, Cranberry juice powder 15mg, Ginger root 15mg, Grape skin extract 15mg, Broccoli 15mg, Carrot 15mg, Linseed 15mg, Spinach 15mg, Horsetail 15mg, Fo Ti root 15mg, Ashwagandha root 15mg.
3 capsules daily.
Founded in 2002 by pharmacist Margo Marrone and her husband Francesco, The Organic Pharmacy skin-care brand evolved from the duo's successful London-based chain of herbal, homeopathic dispensaries and wellness clinics. Developed for a range of skin types, the clean-beauty collection of organic and fair-trade products helps to treat, repair, and improve a broad spectrum of issues. One of the brand's first products, the Carrot Butter Cleanser, is celebrated for its velvety texture and blend of all-natural ingredients which gently lift dirt and makeup without stripping the skin.
Need Help? Have Questions? Contact Us.
Please call 1.888.222.7639 to speak with a Customer Service Representative.
We're here to help you:
Monday - Friday, 9 AM - 9 PM (ET)
Saturday - Sunday, 10:30 AM - 7 PM (ET)
If you prefer email, we can be reached anytime at email@example.com.
Free Shipping & Returns on All U.S. Orders. See Details


text:
Axl Rose Admirably Continues Living Up to Rock-Star Behavioral Expectations
He's wrecking expensive cars and everything.
Furthering today's trend of famously irascible musicians behaving as expected comes news that Axl Rose is being sued for leasing a 2006 Bentley Flying Spur, then failing to pay the $73,976.42 owed on the car and returning it with a cracked windshield, two damaged tires, broken glass on a taillight, two dented doors, and a gouged bumper. No official word on how that damage was accrued, but one can safely assume it was during a criminally irresponsible early morning joyride through the streets of downtown Rio de Janeiro that was serving as the nightcap for a three-day bacchanal made up of the requisite cocaine, strippers, Jack Daniels, fistfights, Tecmo Super Bowl, some of those fake mermaids from the "Hypnotize" video, and maybe even a few Eric Dane sightings. Well done, Axl! [TMZ]


text:
- Home
- About Us
- Activities
- Research
- Publications
- Products
- Downloads
- Contact Us
- Feedback
What Mind Means
Author:- Swami Vijnananand
Language:- English
Pages:- 138
Donation contribution:- Rs.110/- Courier charges extra.
Swami Vijnananand's (the first thinker and researcher of New Way) main urge has been an intense desire to find happiness and ultimate or eternal Trust. This book fulfill the long standing need of readers desire to fathom serene depth of mind.
Some of the topics discussed in this book are as follows:-
1. Definitions and Functions
2. Mind and Marxism
3. Pavlov, Marxism and Mind
4. Mind in 'Evolution' Theory
5. Health, Mind and Its Laws


text:
Taking advantage of the beautiful grounds at Edge Grove, our Pre Prep and Lower School pupils have the opportunity of being taught the Forest School curriculum.
Each year group in the Pre Prep experiences a half termly block of two hour sessions each week that is included in their weekly timetable.
Pupils love the experience of sitting in the log circle, learning the forest rules and exploring their surroundings. They enjoy pond dipping, learning how to make camp fires and mud bathing! Through play, they learn about the natural environment, how to handle risks and most importantly to use their own initiative to solve problems and co-operate with others.


text:
Betstars offer
Bet £20 with Betstars Get £20 Free Bet
Bet £20 Get £20
New Customer Only
Betstars Bookmaker Review
Betstars is brand new bookmaker that has recently made an entry in the online betting scene as Betstars, the brand is owned by the famous poker site Pokerstars. Launched in early 2016 by world leading poker site PokerStars, the online bookmaker is sure to be the next big thing in the betting world. Presently, Betstars betting world caters for all major sports like cricket, football, basketball, tennis, and horse racing - providing great odds in a lot of markets. There are categories meant for other high-profile sports including rugby league, NFL American Football, boxing, and darts. More and more sections are being added on an everyday basis. Betstars offers all new customers a fantastic sign up offer, this offer allows new players to get a £20 free bet when they sign up and deposit £10 then place a bet. The customers is then given a £20 free bet to use as they see fit. New players are entitled to Betstars free bet of £20. Sign up Bet £10 Get £20 with Betstars.
About Betstars Bookmaker
The Betstar bookmaker will be a standalone business on betstars.com, and it will operate alongside the already popular PokerStars brand, licensed since 2001. Betstars betting markets are available for 30 sports, and they offer free bets as a part of their amazing promotions like horse racing's 'Faller Insurance'. They even have their mobile app for customers who want to bet on-the-go. The bookmaker has a great potential and is developing at a fast pace. All you need to do is create your account at Betstars and start taking advantage of excellent Betstars bonus and promo codes. Apart from this, Betstars is available in a lot of countries like Algeria, Canada, Belize, Bhutan, Australia, Bangladesh, China, France, Fiji, Germany, Georgia, India, Iraq, Japan, Kenya, Macau, Maldives, Malta, Monaco, Norway, Romania, Poland, Portugal, and many more. Betstars also offer customers enhanced odds sign up offers which are often popular so keep your eyes out for these.
Betstars Sportsbok Review
Betstars sportsbook offers new and exciting sports betting opportunities, same as the section of PokerStars. Players can play directly from their web browsers. Some of the options available for players at Betstars are:
- American Football
- Cricket
- Golf
- Boxing
- Mixed Martial Arts
- Futsal
- Basketball
- Handball
- Hockey
- Tennis
- Snooker
There are even exotic Betstars betting options on the political event, though the menu changes with the season.
Betstar Offers and Promotions
Betstars offer a great new customer sign up offer. The process of opening an account with Betstars is quite easy as you just have to click on 'Join Now' on the website's homepage. Enter your email address, pick a username and password to make a deposit and get your Betstars free bet offer. The welcome bonus gets credited to the player's account in 48 hours. It would be best to go through fairly simple terms and conditions before placing the bets. There are many other great promotion offers for Betstars players other than the sign-up bonus and spin and bet feature. Common promotions popular at Betstars are money back on American sports multiple bets, £100 extra reward on winning 10+ selection accumulator, etc. Cash out early is an option. Other than that, there are many individual team boosts on Liverpool and Leicester already.
All-in-all, there is something for everyone at Betstars as a particular section of the site is dedicated to promotions and bonuses.
Betstar Features
Betstars sports bookmaker features are quite impressive, and they keep upgrading the interface from time to time. Though the sports markets are still limited, almost all prime sports are covered. The mobile app is nicely designed and really compatible with different promotions especially the spin and bet feature.
Live Betting: One of the major strengths of Betstars is live betting. Their in-play platform is incredible and covers almost all events at all levels. Owing to their multi-year deal with Racing Victoria, they're able to stream all Victorian thoroughbred races. So all those players interested in streaming basketball, tennis and Victorian horse racing should definitely sign up at Betstars.
Spin & Win: It is a unique feature of Betstars where the company provides a Casino view to sports betting thus allowing players to place gambles on their bet. A player can game 10% of their stake and to increase the odds of winning; they need to spin.
Is Betstars Safe and Reliable?
Betstars certainly had a soft launch, but it gained traction in a small period of time. It is as safe as the parent company Amaya. With a huge backing in the gambling world, your money is safe with the bookmaker. You just need to keep your eyes open and abide by all T&C's to win money.
Betstar Payment Options
Money deposit and withdrawal at Betstars is easy. You can make payments with your credit or debit card. Other than that payments via electronic wallets such as Skrill and Entropay are an option, which are preferred by players for their quickness. Wire transfer is also preferred by some, and payments can be processed easily with mobile phones. Cashing out money is possible for players winning more than €20 without paying any extra commission. Bookies strongly suggest players make deposits and withdrawals via same financial mode. This way they can minimise the risk of criminal frauds and money laundering. Nonetheless, Betstars assures 100% safety to players when making transactions on the interface.
Betstar Customer Support
Betstars has an informative and comprehensive FAQ section that answers almost all questions of players without necessitating need for reaching out to a customer operator. If there is still a need for contacting customer service operator, one can reach out to them via email at [email protected]. Customer Support team at Betstars is available 24/7 for answering your queries, so you are covered at all times. You may also reach out to the team via filling a 'Contact Support Form'.
Is It Worth Betting At Betstars?
A lot of new online bookmakers keep popping up from time to time, but not all of them can establish a brand name in small time like Betstars. For Betstars betting bookmaker, everything worked like a breeze, undoubtedly because of the backing of a big name, PokerStars.
There is a great range of betting options available at the bookmaker. Live betting is one of the strongest features other than the spin and win promotion. Other than that, great Betstars bonus on welcome and excellent promotion offers are the highlights of betting at the bookmaker. With such outstanding features, Betstars will be able to outshine its competitors and tread ahead successfully in no time.


text:
LAW, ETHICS, POLICY, AND PRACTICE September 13-15, 2017
Halifax, Nova Scotia, Canada
We are delighted to announce the 2nd International Conference on End-of-Life Law, Ethics, Policy, and Practice to be held in Halifax, Nova Scotia, Canada in September 2017.
Your hosts, Canada's Dalhousie Health Law Institute, the Australian Centre for Health Law Research at the Queensland University of Technology, and the Dutch and Belgian Based International Collaborative for End of Life Care Research invite you to join us for a thought-provoking, informative, and timely program on a broad range of end of life issues.
This is a multidisciplinary, multisectoral, and multinational conference, with presenting disciplines including, but not limited to, law, medicine, nursing, philosophy and bioethics, and sectoral representation spanning practitioners, academics, NGOs, and regulators an policy-makers. We will engage with empirical evidence about, and legal and ethical analysis of, many of the most pressing and vexing issues of our time. Leading experts from around the world will present on their findings. Participants will engage with others who are wrestling with the challenges of end of life care. We will reflect on lessons learned from experiences in various jurisdictions (including Canada, which will be one year post the implementation of new federal medical assistance in dying legislation). Please join us for a 2 ½ day deep dive into stopping/not starting potentially life-sustaining treatment, palliative sedation, medical assistance in dying, and the next generation end of life issues.
Constance MacIntosh, Committee Chair, Canada
Kenneth Chambaere, Belgium
Luc Deliens, Belgium
Jocelyn Downie, Canada
Bregje Onwuteaka-Philipsen, The Netherlands
Hans van Delden, The Netherlands
Agnes van der Heide, The Netherlands
Ben White, Australia
Lindy Willmott, Australia


text:
This classic textbook introduces linear operators in Hilbert Space, and presents the geometry of Hilbert space and the spectral theory of unitary and self-adjoint operators. Invaluable for every mathematician and physicist. 1961, 1963 edition.5* x 8%. 65369.2 Pa. $I8.95 ELEMENTS OF REAL ANALYSIS, David A. Sprecher . ... 65385.4 AN INTRODUCTION TO MATRICES, SETS AND GROUPS FOR SCIENCE STUDENTS, G. Stephenson. Concise, readable ... $7.95 SET THEORY AND LOGIC, Robert R. Stoll. Lucid introduction to ... I07 problems, answers. 336pp.
|Theory of Linear Operators in Hilbert Space
|Naum Ilʹich Akhiezer, Izrailʹ Markovich Glazman
|Courier Corporation - 1993
You must register with us as either a Registered User before you can Download this Book. You'll be greeted by a simple sign-up page.
Once you have finished the sign-up process, you will be redirected to your download Book page.How it works:


text:
Johnny Chavez Furniture Design, 2018-08-12 07:30:27. Wicker and Rattan. If you like to change the decor of your patio frequently and dont want to have to buy new furniture every time then wicker & rattan patio furniture would be a good and decent choice for you. Wicker and rattan is the second most popular type of furniture that is made from natural materials. Both wicker and rattan furniture is durable, light weight and to a certain extent - flexible, making it great for patio furniture that needs to be brought indoors or moved frequently. Wicker is actually not a material by itself. Wicker is the end result of weaving rattan with other materials, usually bamboo slats, to make furniture. Rattan (originated from a Malay word - Rotan) is technically a tree, although it grows like a vine along the ground. They are usually found in the tropical regions of Africa, Asia and Australia. The rattan vines are cut and peeled, then steamed to make them pliable, and then they are used as rattan weaving materials. Rattan furniture can be made of stripes of Rattan that are woven together when the wood is wet. It can also be strips of Bamboo or other materials woven around straight rattan slats. Rattan easily accepts paints and stains like many other kinds of wood, so it is available in many colors and it can be worked into many styles.Both rattan and wicker furniture is a less expensive alternative to hardwood, if you want to have furniture that is made from natural sources. These types of patio furniture dont require a lot of maintenance and can be used in or outdoors all year long. It also possible to change the outlook of Wicker or Rattan furniture by giving the furniture a new coat of color. So, if youre inclined to change the decor of your patio frequently without buying new patio furniture every time, then wicker or rattan furniture would be the best choice for you.
Recent Posts
Monthly Archives
Any content, trademark/s, or other material that might be found on this site that is not this site property remains the copyright of its respective owner/s. In no way does Holohoax.info claim ownership or responsibility for such items, and you should seek legal consent for any use of such materials from its owner.


text:
Find a Local Passport Office
Looking for US passport office information? You've come to the right place. There are two types of passport offices in the United States: Passport Acceptance Facilities and Regional Passport Agencies. Passport Acceptance Facilities are local passport offices that can provide passport applications, review passport applications, and verify your identity and US citizenship as a preliminary step to getting your passport. When you are applying for a first time passport, a passport for a child, or a replacement for a lost or damaged passport, the Passport Acceptance Facility will seal your application into an official envelope in a process called "executing the application."
Use our interactive map to discover which of the 8,000+ Passport Acceptance Facilities is most convenient for you.
"Me" will be used as the reference point to search from.
Enter your postal code or a city to modify your current location:
Expedited Passport Service at Passport Acceptance Facilities
The local passport office can send in your application for expedited passport service by mail, which will take 2-3 weeks to complete. If you need faster service, such as to get your passport expedited in 24 hours, ask the Passport Acceptance Agent to give you your sealed envelope so you can send it to a registered passport expeditor company.
Passport Offices Near You
Hector P Garcia Main Post Office
Distance: 0.73 Miles (Approx.)At the Passport Acceptance Facility in the Hector p garcia main post office in Corpus christi, Texas, you can pick up blank passport applications, turn in completed applications for passport processing by mail, or have applications for New Passports, Minor Passports, and Replacement of Lost, Stolen or Damaged Passports executed by a Passport Acceptance Agent. The execution service consists of having the agent review the application, confirm your identity, and seal your application into an official envelope required for processing. Passport service is provided by appointment only; see below for contact details and office hours.
Address: 809 Nueces Bay Boulevard Corpus Christi, TX, United States
Zip: 78469
Phone: (361) 886-2238
Category: TX
Expedited Passport Services available to process your passport in 24 hours


text:
Racing Cane Half Marathon
Race Information
This half marathon is not only fast and great for its participants, but is saturated in purpose. Included with the half marathon will be a blistering fast 5k and a family friendly kids race. This event benefits children living in the impoverished sugar cane shack communities of the Dominican Republic who walk over 5 kilometers to school – many without shoes on their feet.


text:
Lady Gaga's New Single "Chart-Ineligible" In UK
Do What U Want will not feature in the Top 40 this weekend...
Lady Gaga's new single has been deemed "chart-ineligible" by the Official Charts Company.
Mother Monster only recently decided to make her R. Kelly collaboration Do What U Want an official single after previously releasing it to fans who pre-ordered her new album, ARTPOP.
After the tune climbed to the top of the iTunes charts on both sides of the Atlantic, fans had expected to see Gaga's latest offering in this week's countdown - but when the Official Chart Update was released, it had failed to make the Top 40.
The Official Charts Company explained: "Lady Gaga's Do What U Want (featuring R Kelly) will become chart eligible once the related album pre-order promotion ends. Official Chart rules, as agreed in committee with the British music industry, allow one 'instant grat' promotion per album, i.e a single track download given away as an album pre-order incentive.
"Do What U Want is the second track to be delivered to fans who pre-order ARTPOP, the track will become eligible to chart once the current chosen promotional period ends and the full album is released on 11 November."
The news comes after they changed their rules in February this year, which stated that any instant grat tracks would be unable to chart.
Gaga's new album ARTPOP, which also features originally-planned single Venus, is due for release on November 11.


text:
|Message view
|« Date » · « Thread »
|« Date » · « Thread »
|Jan Lehnardt <...@apache.org>
|Re: Rep. bug in R...... 1.0.1?
|Sun, 19 Sep 2010 12:34:13 GMT
Hi Nikolai, sorry to be terse, but can you provide a short script that exercises the behaviour? Ideally with placeholders for the two CouchDB URLs so we can fill in values for our testing environment. Cheers Jan -- On 11 Sep 2010, at 20:16, Nikolai Teofilov wrote: > Hi Adam, > > The words "pull" in step 4 and "push" in step 6 are correct. I exchanged the places of the curl commands ... > > The idea is common scenario ... to have master db and each slave server get local copy of the master, make local changes ... (attach new files) and send the modified copy back to the master. The problem appears only if the documents have been updated with new attachments and only between databases on two different servers. It looks like by sending back a document updated with new attachment will affect the _rev number and a kind of side effect appears so if you try to delete those document on the remote db the last revision of the document before the update will be still in the database. It could be that this is correct but I think the delete operation of a document should remove all its revisions as well, correct? > > > 1. - make remote_db (on different machine!) > 2. - create a doc on the remote_db > 3. - make local_db (on different machine from the remote couchdb!) > 4. - (trigger from the local couchdb!) remote_db->local_db > 5. - put an attachment on local_db/doc > 6. - trigger from local couchdb! local_db -> remote_db > 7. - try to delete the remote_db/doc > the result should be the last _rev is deleted but a copy of the doc is still in the remote_db with the initial _rev number. > > I am almost sure it is a bug because if you try this on a one couchdb server there is no such a problem. If you try with document without attachment there is no problem as well and the documents in both last cases are deleted completely. > > Cheers > Nikolai > > > On 10.09.2010, at 01:44, Adam Kocoloski wrote: > >> Hi Nikolai, I'm not sure I understand. In step 4 you said "pull ......." but what you actually did was push the local (empty?) test database to the remote server. After that the subsequent steps don't make sense. Can you try describing the steps again? Best, >> >> Adam >> >
|View raw message


text:
Step 1
Brush both sides of the prawns with the Sriracha sauce. Sprinkle the chipotle chilli powder on top of the prawns..
Step 2
Set up your barbecue for direct cooking. Please refer to your handbook for further instructions. Preheat your barbecue for barbecuing on high heat.
Step 3
Wrap a slice of prosciutto around each prawn. Thread onto pre-soaked wooden skewers, 2 prawns per skewer.
Step 4
Once the barbecue has preheated, leave the burner control(s) on high.Place the prawn skewers on and cook for 4 minutes, turning the skewers half way. Serve with aioli.


text:
Super Heroic: A Show About Comic Book Movies & TV Shows!
About This Show
Super Heroic is a PODCAST about Comic Books that evolve into Television Shows and Movies! Do you like movies like, Spiderman, The Dark Knight Rises, Avengers, or Fantastic Four? Are you looking forward to movies like Batman vs Superman or Captain America: Civil War? Can you get enough of TV Shows like The Walking Dead, Flash, Gotham, or Arrow? Well, then this is the show for you! Mick Montgomery & Guests discuss the latest news, do reviews on movies and tv shows, discuss the latest Trailers, and a whole bunch more!Read more »


text:
Thomas Kirwan: Government to review knife crime sentencing
The government has said it will review sentences for knife crime after a man was stabbed to death outside a Wolverhampton nightclub.
The death of Tom Kirwan, 23, was discussed in Parliament on Tuesday.
Mr Kirwan's family have started a petition calling for similar punishments for people convicted of having a knife as those who carry guns.
Although no-one has been charged with his death, his family claim stronger sentences would stop similar incidents.
His girlfriend Jade Elwell, 21, said: "People don't think of the consequences or the heartache they can cause by carrying a knife, but they would think twice if punishments were stronger.
"At the moment they think nothing of it because the sentence that they get doesn't always reflect the crime."
Mr Kirwan, who worked in a factory in Shropshire, was stabbed near the Uberra Club on 8 July.
Five people, four men and a woman, arrested in connection with his death were bailed by police in September.
'Endemic problem'
In Parliament on Tuesday, justice minister Jeremy Wright paid tribute to Mr Kirwan's family and said the government would look at sentencing options for judges.
He said: "This is an endemic problem and one that we need to tackle, particularly among young people who persist in the wrong belief that they are safer carrying a knife than without one."
Ms Elwell said about 3,000 people had signed her petition calling for stronger sentences for knife crime.
"Tom's death has affected so many people and we need that number of signatures to keep going up for us to be able to take the petition to the government," she said.
A new offence for aggravated possession of a knife was introduced by ministers earlier this month.
Judges must now impose a custodial sentence for those who wield knives in public to threaten and create a risk of serious physical harm.
In the year up to June 2012 there were 29,613 offences involving knives in England and Wales, which was a reduction of 9% on the previous year.
During the same time, 200 people were murdered in knife incidents.


text: This is a wonderful recipe I had published in my very first book around 12 years ago. It's a quick and simple healthy meal that I love making at home. These fritters marry perfectly with fresh tomato salsa and smashed avocado scented with jalapeño and freshly squeezed limes. The secret to making them so very delicious is to use fresh corn and not the frozen variety. It's also important not to rush the process of cooking them. I like to do a test fritter just to make sure it cooks properly in the pan – I taste and adjust where necessary. It's important that the heat is lovely and gentle which makes sure your fritter won't burn and it cooks gently through the middle.


text:
For students who may have social emotional or academic challenges they may need additional prep time to get ready for the next step. This will be the third year for our transitions camp and we have seen some great outcomes preparing our students. This year we will be doing 2 weeks.
June 18th - June 22nd and July 16th - July 20th.
These are mini life boot camp on looking at what we really want to do in life. Looking at aptitude tests and seeing what areas are best suited for the next step. If college is where we want to go looking at planning on what happens in high school to get us ready. If we want to go to trade school or right into job force what do we need to do to hold down a job. How do you write a resume and fill out an application. What social skills do we need to move forward in life.
How do we go to the grocery store, create a budget, how much money do we need to make to live on our own? Want a car? What do you have to do to be a responsible car owner? License, insurance, gas and maintenance all those things that we don't think about. Life can be hard for our students but if we can prepare them for some of these challenges and have them thinking about the next step they will do great!
Camp starts daily at 9:30 and goes to 3:30; Cost is $150 for the week. (Autism Scholarship and Jon Peterson Scholarship can be used for these camps) My Place to Be also has additional scholarships available to families in need. Any questions please contact Christa Milner at [email protected] or call 740-899-4296.
All Children need a little help, a little hope and someone who believes in them
Magic Johnson


text:
(WASHINGTON, Pa.) – The second-seeded Thomas More College baseball team went 1-1 today (Friday, May 12, 2017) and saw it's run end at the Presidents' Athletic Conference (PAC) Championship Tournament at Ross Memorial Park in Washington, Pennsylvania. The Saints defeated fourth-seeded Thiel College, 6-5, in the first elimination game and then fell, 10-1, to top-seeded Washington & Jefferson College in the second elimination game.
The Saints end the season with a 27-12 overall record.
In the first game of the day, Thomas More scored one run in the first, one in the second and Thiel scored one in the second, one in the third, two in the fifth and one in the seventh to build a 5-2 lead. The Saints plated four runs in the eighth and then held Thiel scoreless in its last two innings at bat for the 6-5 victory.
Senior third baseman Bailey Abbatiello (Cincinnati, Ohio/LaSalle) led the Saints at the plate as he was two-for-four with a home run, two runs scored and three runs batted-in. Two other Saints had multiple hits as junior second baseman Ben Laumann (Cincinnati, Ohio/Oak Hills) was two-for-five and sophomore first baseman Sean Lawrence (Independence, Ky./Simon Kenton) was two-for-three with a run scored and a RBI.
Junior pitcher Jayson Essell (Cincinnati, Ohio/Oak Hills) had a no-decision on the mound as he pitched four innings giving up four runs (three earned) on seven hits and struck out one. Senior pitcher Josh Cain (Cold Spring, Ky./Newport Central Catholic) pitched four innings of relief and gave up one run (earned) on two hits and struck out five. Senior pitcher Ken Ruberg (Cincinnati, Ohio/LaSalle) a shutout nine inning and recorded the save, while striking out one.
In the second game, Washington & Jefferson led 3-0 after six and a half innings as it scored two in the first and one in the seventh, but Thomas More scored one in the seventh to cut the lead to 3-1. W&J then scored two in the eighth and five in the ninth for the 10-1 victory.
Five Saints each had a hit in the game for Thomas More. Junior pitcher Brandon Eliadis (Lawrenceburg, Ky./Anderson County) suffered the loss on the mound as he pitched seven innings giving up three runs (one earned) on six hits and struck out two.


text:
I believe that a belief in creationism – or not – does not belong in a list of essential Christian beliefs. I believe this falls into the same category as the "essential" belief by the church long ago that the sun revolved around the earth. Official church doctrine, based on sincere but erroneous interpretation of the Bible at the time, was that the earth was the center of the universe and therefore the sun must revolve around the earth. The church "proved" this concept by their interpretation of the Bible. This concept was considered a fundamental, essential belief, and people who expressed the idea that the earth revolved around the sun were thrown out of the church. Unfortunately, and unnecessarily, the faith of many people depended on this fallacy, since it was considered an essential tenet of the faith. I believe people today who are unaware of or reject current scientific findings are making the same mistake when they define a Christian as one who necessarily must believe in creationism. There are other reasonable, alternative interpretations of the Bible that are consistent with the main points, and I believe, the main goal of the Bible. I take the Bible seriously as the Word of God. I continually try to ask the question of each Bible passage "What's the point?" and "What is God trying to tell me?" In this case the main point is that God created everything: Heaven, earth, all living organisms, and all the laws of nature. Acknowledging God as the Creator is essential. Period. How He did it is not an essential point of Christianity. I believe no conflict exists between the concept of God being the Creator and the concept of evolution. I believe that God created all natural laws of the universe. There are consistent views expressing this idea of NO CONFLICT. I strongly recommend that you read the book The Language of God (2006) by Francis S. Collins. The point is that the two ideas of God being the Creator and evolution need not be thought of as mutually exclusive – as believed, unfortunately, by many Christians AND many scientists. The creationists will claim their revelation is through prayer and a sincere faith and belief that they have the correct interpretation of the Bible. Christians who also believe that evolution has occurred make exactly the same claim. I believe that someone who thinks that a person is not really a Christian if he believes that evolution has occurred is someone who is really expressing the same pious, arrogant, (but sincere) attitude and ignorance expressed by those church leaders long ago who believed it was essential to believe that the sun revolved around the earth. I fear that people today whose faith depends on a belief on any natural phenomenon are doomed to have their faith unnecessarily shaken when even they are overwhelmed by the scientific evidence about some natural event or process – as occurred with the sun revolving around the earth example.
If you enjoyed this essay, please consider making a tax-deductible contribution to This I Believe, Inc.