In the fall of 1990, one of us (Rakitzis) re-implemented the Plan 9 command interpreter, rc, for use as a UNIX shell. Experience with that shell led us to wonder whether a more general approach to the design of shells was possible, and this paper describes the result of that experimentation. We applied concepts from modern functional programming languages, such as Scheme and ML, to shells, which typically are more concerned with UNIX features than language design. Our shell is both simple and highly programmable. By exposing many of the internals and adopting constructs from functional programming languages, we have created a shell which supports new paradigms for programmers.
Note:
This web page is an HTML version of a paper which was presented at the
Winter 1993 Usenix Conference in San Diego, California.
The paper corresponds to an out-of-date release of es; see
the Errata section for changes which affect parts of the paper.
Source code for the current version of es and
a
PostScript copy of this paper,
from which the version appearing in the proceedings was typeset,
are available by anonymous FTP.
Table of Contents
Although most users think of the shell as an interactive command
interpreter, it is really a programming language in which each
statement runs a command. Because it must satisfy both the interactive
and programming aspects of command execution, it is a strange
language, shaped as much by history as by design.
-- Brian Kernighan & Rob Pike [1]
Introduction
A shell is both a programming language and the core of an interactive
environment. The ancestor of most current shells is the 7th Edition
Bourne shell[2], which is characterized by simple
semantics, a minimal set of interactive features, and syntax that is
all too reminiscent of Algol. One recent shell, rc
[3], substituted a cleaner syntax but kept most of
the Bourne shell's attributes. However, most recent developments in
shells (e.g., csh, ksh, zsh) have focused on
improving the interactive environment without changing the structure
of the underlying language -- shells have proven to be resistant to
innovation in programming languages.
While rc was an experiment in adding modern syntax to Bourne shell semantics, es is an exploration of new semantics combined with rc-influenced syntax: es has lexically scoped variables, first-class functions, and an exception mechanism, which are concepts borrowed from modern programming languages such as Scheme and ML. [4, 5]
In es, almost all standard shell constructs (e.g., pipes and redirection) are translated into a uniform representation: function calls. The primitive functions which implement those constructs can be manipulated the same way as all other functions: invoked, replaced, or passed as arguments to other functions. The ability to replace primitive functions in es is key to its extensibility; for example, a user can override the definition of pipes to cause remote execution, or the path-searching machinery to implement a path look-up cache.
At a superficial level, es looks like most UNIX shells. The syntax for pipes, redirection, background jobs, etc., is unchanged from the Bourne shell. Es's programming constructs are new, but reminiscent of rc and Tcl[6].
Es is freely redistributable, and is available by anonymous ftp
from ftp.white.toronto.edu
.
Using es Commands
For simple commands, es resembles other shells. For
example, newline usually acts as a command terminator. These are
familiar commands which all work in es:
cd /tmp rm Ex* ps aux | grep '^byron' | awk '{print $2}' | xargs kill -9For simple uses, es bears a close resemblance to rc. For this reason, the reader is referred to the paper on rc for a discussion of quoting rules, redirection, and so on. (The examples shown here, however, will try to aim for a lowest common denominator of shell syntax, so that an understanding of rc is not a prerequisite for understanding this paper.)
fn d { date +%y-%m-%d }Functions can also be called with arguments. Es allows parameters to be specified to functions by placing them between the function name and the open-brace. This function takes a command
cmd
and arguments args
and applies the
command to each argument in turn:
fn apply cmd args { for (i = $args) $cmd $i }For example: [Footnote 1]
es> apply echo testing 1.. 2.. 3.. testing 1.. 2.. 3..Note that
apply
was called with more than two arguments;
es assigns arguments to parameters one-to-one, and any
leftovers are assigned to the last parameter. For example:
es> fn rev3 a b c { echo $c $b $a } es> rev3 1 2 3 4 5 3 4 5 2 1If there are fewer arguments than parameters, es leaves the leftover parameters null:
es> rev3 1 1So far we have only seen simple strings passed as arguments. However, es functions can also take program fragments (enclosed in braces) as arguments. For example, the
apply
function
defined above can be used with program fragments typed directly on the
command line:
es> apply @ i {cd $i; rm -f *} /tmp /usr/tmpThis command contains a lot to understand, so let us break it up slowly.
In any other shell, this command would usually be split up into two separate commands:
es> fn cd-rm i { cd $i rm -f * } es>Therefore, the constructapply cd-rm /tmp /usr/tmp
@ i {cd $i; rm -f *}is just a way of inlining a function on the command-line. This is called a lambda. [Footnote 2] It takes the form
@
parameters{
commands}
In effect, a lambda is a procedure "waiting to happen." For example, it is possible to type:
es> @ i {cd $i; rm -f *} /tmpdirectly at the shell, and this runs the inlined function directly on the argument
/tmp
.
There is one more thing to notice: the inline function that was
supplied to apply
had a parameter named i
,
and the apply
function itself used a reference to a
variable called i
. Note that the two uses did not
conflict: that is because es function parameters are
lexically scoped, much as variables are in C and Scheme.
Variables
The similarity between shell functions and lambdas is not
accidental. In fact, function definitions are rewritten as assignments
of lambdas to shell variables. Thus these two es commands are
entirely equivalent:
fn echon args {echo -n $args} fn-echon = @ args {echo -n $args}In order not to conflict with regular variables, function variables have the prefix
fn-
prepended to their names. This
mechanism is also used at execution time; when a name like
apply
is seen by es, it first looks in its symbol
table for a variable by the name fn-apply
. Of course, it
is always possible to execute the contents of any variable by
dereferencing it explicitly with a dollar sign:
es> silly-command = {echo hi} es> $silly-command hiThe previous examples also show that variables can be set to contain program fragments as well as simple strings. In fact, the two can be intermixed:
es> mixed = {ls} hello, {wc} world es> echo $mixed(2) $mixed(4) hello, world es> $mixed(1) | $mixed(3) 61 61 478Variables can hold a list of commands, or even a list of lambdas. This makes variables into versatile tools. For example, a variable could be used as a function dispatch table.
i
, the following scoping syntax can be
used:
let (var = value) { commands which use $var }Lexical binding is useful in shell functions, where it becomes important to have shell functions that do not clobber each others' variables.
Es code fragments, whether used as arguments to commands or stored in variables, capture the values of enclosing lexically scoped values. For example,
es> let (h=hello; w=world) { hi = { echo $h, $w } } es> $hi hello, worldOne use of lexical binding is in redefining functions. A new definition can store the previous definition in a lexically scoped variable, so that it is only available to the new function. This feature can be used to define a function for tracing calls to other functions:
fn trace functions { for (func = $functions) let (old = $(fn-$func)) fn $func args { echo calling $func $args $old $args } }The
trace
function redefines all the functions which are
named on its command line with a function that prints the function
name and arguments and then calls the previous definition, which is
captured in the lexically bound variable old
. Consider a
recursive function echo-nl
which prints its arguments,
one per line:
es> fn echo-nl head tail { if {!~ $#head 0} { echo $head echo-nl $tail } } es> echo-nl a b c a b cApplying
trace
to this function yields:
es> trace echo-nl es> echo-nl a b c calling echo-nl a b c a calling echo-nl b c b calling echo-nl c c calling echo-nlThe reader should note that
!
cmd
is es's "not" command, which inverts the sense of the return
value of cmd, and
~
subject pattern
matches subject against pattern and returns true if the
subject is the same as the pattern. (In fact, the matching is a bit
more sophisticated, for the pattern may include wildcards.)
Shells like the Bourne shell and rc support a form of local assignment known as dynamic binding. The shell syntax for this is typically:
var=
value command
That notation conflicts with es's syntax for assignment (where
zero or more words are assigned to a variable), so dynamic binding has
the syntax:
local (var = value) { commands which use $var }The difference between the two forms of binding can be seen in an example:
es> x = foo es> let (x = bar) { echo $x fn lexical { echo $x } } bar es> lexical bar es> local (x = baz) { echo $x fn dynamic { echo $x } } baz es> dynamic foo
fn-
) for function execution
described earlier, es uses another prefix to search for
settor variables. A settor variable set-
foo
is a variable which gets evaluated every time the variable foo
changes value. A good example of settor variable use is the
watch
function:
fn watch vars { for (var = $vars) { set-$var = @ { echo old $var '=' $$var echo new $var '=' $* return $* } } }
Watch
establishes a settor function for each of its
parameters; this settor prints the old and new values of the variable
to be set, like this:
es> watch x es> x=foo bar old x = new x = foo bar es> x=fubar old x = foo bar new x = fubar
The return value of a command is accessed by
prepending the command with <>
:
[Errata note 2]
es> fn hello-world { return 'hello, world' } es> echo <>{hello-world} hello, worldThis example shows rich return values being used to implement hierarchical lists:
fn cons a d { return @ f { $f $a $d } } fn car p { $p @ a d { return $a } } fn cdr p { $p @ a d { return $d } }The first function,
cons
, returns a function which takes
as its argument another function to run on the parameters
a
and d
. car
and
cdr
each invoke the kind of function returned by
cons
, supplying as the argument a function which returns
the first or second parameter, respectively. For example:
es> echo <>{car <>{cdr <>{ cons 1 <>{cons 2 <>{cons 3 nil}} }}} 2
throw
raises an exception, which
typically consists of a string which names the exception and other
arguments which are specific to the named exception type. For example,
the exception error
is caught by the default interpreter
loop, which treats the remaining arguments as an error message.
[Errata note 3]
Thus:
es> fn in dir cmd { if {~ $#dir 0} { throw error 'usage: in dir cmd' } fork # run in a subshell [Errata note 4] cd $dir $cmd } es> in usage: in dir cmd es> in /tmp ls webster.socket yacc.312By providing a routine which catches
error
exceptions, a
programmer can intercept internal shell errors before the message gets
printed.
Exceptions are also used to implement the break
and
return
control flow constructs, and to provide a way for
user code to interact with UNIX signals. While six error types
are known to the interpreter and have special meanings, any set of
arguments can be passed to throw
.
Exceptions are trapped with the built-in catch
, which
typically takes the form
catch @ e args { handler } { body }
Catch
first executes body; if no exception is
raised, catch
simply returns, passing along body's
return value. On the other hand, if anything invoked by body
throws an exception, handler is run, with e
bound
to the exception that caused the problem. For example, the last two
lines of in
above can be replaced with:
catch @ e msg { if {~ $e error} { echo >[1=2] in $dir: $msg } { throw $e $msg } } { cd $dir $cmd }to better identify for a user where an error came from:
es> in /temp ls in /temp: chdir /temp: No such file or directory
ls > /tmp/foois internally rewritten as
%create 1 /tmp/foo {ls}before it is evaluated.
%create
is the built-in function
which opens /tmp/foo
on file-descriptor 1 and
runsls
.
The value of this rewriting is that the %create
function
(and that of just about any other shell service) can be
spoofed, that is, overridden by the user: when a new
%create
function is defined, the default action of
redirection is overridden.
Furthermore, %create
is not really the built-in file
redirection service. It is a hook to the primitive
$&create
, which itself cannot be overridden. That
means that it is always possible to access the underlying shell
service, even when its hook has been reassigned.
Keeping this in mind, here is a spoof of the redirection operator that
we have been discussing. This spoof is simple: if the file to be
created exists (determined by running test -f
), then the
command is not run, similar to the C-shell's "noclobber" option:
fn %create fd file cmd { if {test -f $file} { throw error $file exists } { $&create $fd $file $cmd } }In fact, most redefinitions do not refer to the
$&
-forms explicitly, but capture references to them
with lexical scoping. Thus, the above redefinition would usually
appear as
let (create = $fn-%create) fn %create fd file cmd { if {test -f $file} { throw error $file exists } { $create $fd $file $cmd } }The latter form is preferable because it allows multiple redefinitions of a function; the former version would always throw away any previous redefinitions.
Overriding traditional shell built-ins is another common example of
spoofing. For example, a cd
operation which also places
the current directory in the title-bar of the window (via the
hypothetical command title
) can be written as:
let (cd = $fn-%cd) fn cd { $cd $* title `{pwd} }Spoofing can also be used for tasks which other shells cannot do; one example is timing each element of a pipeline by spoofing
%pipe
, along the lines of the pipeline profiler suggested
by Jon Bentley[7]; see Figure 1.
[Errata note 5]
es> let (pipe = $fn-%pipe) { fn %pipe first out in rest { if {~ $#out 0} { time $first } { $pipe {time $first} $out $in {%pipe $rest} } } } es> cat paper9 | tr -cs a-zA-Z0-9 '\012' | sort | uniq -c | sort -nr | sed 6q 213 the 150 a 120 to 115 of 109 is 96 and 2r 0.3u 0.2s cat paper9 2r 0.3u 0.2s tr -cs a-zA-Z0-9 \012 2r 0.5u 0.2s sort 2r 0.4u 0.2s uniq -c 3r 0.2u 0.1s sed 6q 3r 0.6u 0.2s sort -nr
Many shells provide some mechanism for caching the full pathnames of
executables which are looked up in a user's $PATH
.
Es does not provide this functionality in the shell, but it can
easily be added by any user who wants it. The function
%pathsearch
(see Figure 2) is invoked to lookup
non-absolute file names which are used as commands.
let (search = $fn-%pathsearch) { fn %pathsearch prog { let (file = <>{$search $prog}) { if {~ $#file 1 && ~ $file /*} { path-cache = $path-cache $prog fn-$prog = $file } return $file } } } fn recache { for (i = $path-cache) fn-$i = path-cache = }
One other piece of es which can be replaced is the interpreter loop. In fact, the default interpreter is written in es itself; see Figure 3.
fn %interactive-loop { let (result = 0) { catch @ e msg { if {~ $e eof} { return $result } {~ $e error} { echo >[1=2] $msg } { echo >[1=2] uncaught exception: $e $msg } throw retry } { while {} { %prompt let (cmd = <>{%parse $prompt}) { result = <>{$cmd} } } } } }
A few details from this example need further explanation. The
exception retry
is intercepted by catch
when
an exception handler is running, and causes the body of the
catch
routine to be re-run. %parse
prints
its first argument to standard error, reads a command (potentially
more than one line long) from the current source of command input, and
throws the eof
exception when the input source is
exhausted. The hook %prompt
is provided for the user to
redefine, and by default does nothing.
Other spoofing functions which either have been suggested or are in
active use include: a version of cd
which asks the user
whether to create a directory if it does not already exist; versions
of redirection and program execution which try spelling correction if
files are not found; a %pipe
to run pipeline elements on
(different) remote machines to obtain parallel execution; automatic
loading of shell functions; and replacing the function which is used
for tilde expansion to support alternate definitions of home
directories. Moreover, for debugging purposes, one can use
trace
on hook functions.
Implementation
Es is implemented in about 8000 lines of C. Although we
estimate that about 1000 lines are devoted to portability issues
between different versions of UNIX, there are also a number of
work-arounds that es must use in order to blend with
UNIX. The path
variable is a good example.
The es convention for path searching involves looking through
the list elements of a variable called path
. This has the
advantage that all the usual list operations can be applied equally to
path
as any other variable. However, UNIX
programs expect the path to be a colon-separated list stored in
PATH
. Hence es must maintain a copy of each
variable, with a change in one reflected as a change in the other.
Initialization
Much of es's initialization is actually done by an
es script, called initial.es
, which is converted
by a shell script to a C character string at compile time and stored
internally. The script illustrates how the default actions for
es's parser is set up, as well as features such as the
path
/PATH
aliasing mentioned above.
[Errata note 6]
Much of the script consists of lines like:
fn-%and = $&and fn-%append = $&append fn-%background = $&backgroundwhich bind the shell services such as short-circuit-and, backgrounding, etc., to the
%
-prefixed hook variables.
There are also a set of assignments which bind the built-in shell functions to their hook variables:
fn-. = $&dot fn-break = $&break fn-catch = $&catchThe difference with these is that they are given names invoked directly by the user; "
.
" is the Bourne-compatible
command for "sourcing" a file.
Finally, some settor functions are defined to work around UNIX path searching (and other) conventions. For example,
set-path = @ { local (set-PATH = ) PATH = <>{%flatten : $*} return $* } set-PATH = @ { local (set-path = ) path = <>{%fsplit : $*} return $* }A note on implementation: these functions temporarily assign their opposite-case settor cousin to null before making the assignment to the opposite-case variable. This avoids infinite recursion between the two settor functions.
Having functions in the environment brings them into the same conceptual framework as variables -- they follow identical rules for creation, deletion, presence in the environment, and so on. Additionally, functions in the environment are an optimization for file I/O and parsing time. Since nearly all shell state can now be encoded in the environment, it becomes superfluous for a new instance of es, such as one started by xterm (1), to run a configuration file. Hence shell startup becomes very quick.
As a consequence of this support for the environment, a fair amount of es must be devoted to "unparsing" function definitions so that they may be passed as environment strings. This is complicated a bit more because the lexical environment of a function definition must be preserved at unparsing. This is best illustrated by an example:
es> let (a=b) fn foo {echo $a}which lexically binds
b
to the variable a
for the scope of this function definition. Therefore, the external
representation of this function must make this information
explicit. It is encoded as:
es> whatis foo %closure(a=b)@ * {echo $a}(Note that for cultural compatibility with other shells, functions with no named parameters use "
*
" for binding
arguments.)
The exception mechanism has similar problems. When an exception is raised from a shell function, it propagates as expected; if raised from a subshell, it cannot be propagated as one would like it to be: instead, a message is printed on exit from the subshell and a false exit status is returned. We consider this unfortunate, but there seemed no reasonable way to tie exception propagation to any existing UNIX mechanism. In particular, the signal machinery is unsuited to the task. In fact, signals complicate the control flow in the shell enough, and cause enough special cases throughout the shell, so as to be more of a nuisance than a benefit.
One other unfortunate consequence of our shoehorning es onto UNIX systems is the interaction between lexically scoped variables, the environment, and subshells. Two functions, for example, may have been defined in the same lexical scope. If one of them modifies a lexically scoped variable, that change will affect the variable as seen by the other function. On the other hand, if the functions are run in a subshell, the connection between their lexical scopes is lost as a consequence of them being exported in separate environment strings. This does not turn out to be a significant problem, but it does not seem intuitive to a programmer with a background in functional languages.
One restriction on es that arose because it had to work in a traditional UNIX environment is that lists are not hierarchical; that is, lists may not contain lists as elements. In order to be able to pass lists to external programs with the same semantics as passing them to shell functions, we had to restrict lists to the same structure as exec-style argument vectors. Therefore all lists are flattened, as in rc and csh.
Garbage Collection
Since es incorporates a true lambda calculus, it includes the
ability to create true recursive structures, that is, objects which
include pointers to themselves, either directly or indirectly. While
this feature can be useful for programmers, it has the unfortunate
consequence of making memory management in es more complex than
that found in other shells. Simple memory reclamation strategies such
as arena style allocation [8] or reference counting are unfortunately
inadequate; a full garbage collection system is required to plug all
memory leaks.
Based on our experience with rc's memory use, we decided that a copying garbage collector would be appropriate for es. The observations leading to this conclusion were: (1) between two separate commands little memory is preserved (it roughly corresponds to the storage for environment variables); (2) command execution can consume large amounts of memory for a short time, especially when loops are involved; and, (3) however much memory is used, the working set of the shell will typically be much smaller than the physical memory available. Thus, we picked a strategy where we traded relatively fast collection times for being somewhat wasteful in the amount of memory used in exchange. While a generational garbage collector might have made sense for the same reasons that we picked a copying collector, we decided to avoid the added complexity implied by switching to the generational model.
During normal execution of the shell, memory is acquired by incrementing a pointer through a pre-allocated block. When this block is exhausted, all live pointers from outside of garbage collector memory, the rootset, are examined, and any structure that they point to is copied to a new block. When the rootset has been scanned, all the freshly copied data is scanned similarly, and the process is repeated until all reachable data has been copied to the new block. At this point, the memory request which triggered the collection should be able to succeed. If not, a larger block is allocated and the collection is redone.
During some parts of the shell's execution -- notably while the yacc parser driver is running -- it is not possible to identify all of the rootset, so garbage collection is disabled. If an allocation request is made during this time for which there is not enough memory available in the arena, a new chunk of memory is grabbed so that allocation can continue.
Garbage collectors have developed a reputation for being hard to debug. The collection routines themselves typically are not the source of the difficulty. Even more sophisticated algorithms than the one found in es are usually only a few hundred lines of code. Rather, the most common form of GC bug is failing to identify all elements of the rootset, since this is a rather open-ended problem which has implications for almost every routine. To find this form of bug, we used a modified version of the garbage collector which has two key features: (1) a collection is initiated at every allocation when the collector is not disabled, and (2) after a collection finishes, access to all the memory from the old region is disabled. [Footnote 3] Thus, any reference to a pointer in garbage collector space which could be invalidated by a collection immediately causes a memory protection fault. We strongly recommend this technique to anyone implementing a copying garbage collector.
There are two performance implications of the garbage collector; the first is that, occasionally, while the shell is running, all action must stop while the collector is invoked. This takes roughly 4% of the running time of the shell. More serious is that at the time of any potential allocation, either the collector must be disabled, or all pointers to structures in garbage collector memory must be identified, effectively requiring them to be in memory at known addresses, which defeats the registerization optimizations required for good performance from modern architectures. It is hard to quantify the performance consequences of this restriction.
The garbage collector consists of about 250 lines of code for the
collector itself (plus another 300 lines of debugging code), along
with numerous declarations that identify variables as being part of
the rootset and small (typically 5 line) procedures to allocate, copy,
and scan all the structure types allocated from collector space.
Future Work
There are several places in es where one would expect to
be able to redefine the built-in behavior and no such hook exists. The
most notable of these is the wildcard expansion, which behaves
identically to that in traditional shells. We hope to expose some of
the remaining pieces of es in future versions.
One of the least satisfying pieces of es is its parser. We have talked of the distinction between the core language and the full language; in fact, the translation of syntactic sugar (i.e., the convenient UNIX shell syntax presented to the user) to core language features is done in the same yacc-generated parser as the recognition of the core language. Unfortunately, this ties the full language in to the core very tightly, and offers little room for a user to extend the syntax of the shell.
We can imagine a system where the parser only recognizes the core language, and a set of exposed transformation rules would map the extended syntax which makes es feel like a shell, down to the core language. The extend-syntax [9] system for Scheme provides a good example of how to design such a mechanism, but it, like most other macro systems designed for Lisp-like languages, does not mesh well with the free-form syntax that has evolved for UNIX shells.
The current implementation of es has the undesirable
property that all function calls cause the C stack to nest. In
particular, tail calls consume stack space, something they could be
optimized not to do. Therefore, properly tail recursive functions,
such as echo-nl
above, which a Scheme or ML programmer
would expect to be equivalent to looping, have hidden costs. This is
an implementation deficiency which we hope to remedy in the near
future.
Es, in addition to being a good language for shell programming, is a good candidate for a use as an embeddable "scripting" language, along the lines of Tcl. Es, in fact, borrows much from Tcl -- most notably the idea of passing around blocks of code as unparsed strings -- and, since the requirements on the two languages are similar, it is not surprising that the syntaxes are so similar. Es has two advantages over most embedded languages: (1) the same code can be used by the shell or other programs, and many functions could be identical; and (2) it supports a wide variety of programming constructs, such as closures and exceptions. We are currently working on a "library" version of es which could be used stand-alone as a shell or linked in other programs, with or without shell features such as wildcard expansion or pipes.
There are two central ideas behind es. The first is that a system can be made more programmable by exposing its internals to manipulation by the user. By allowing spoofing of heretofore unmodifiable shell features, es gives its users great flexibility in tailoring their programming environment, in ways that earlier shells would have supported only with modification of shell source itself.
Second, es was designed to support a model of programming where code fragments could be treated as just one more form of data. This feature is often approximated in other shells by passing commands around as strings, but this approach requires resorting to baroque quoting rules, especially if the nesting of commands is several layers deep. In es, once a construct is surrounded by braces, it can be stored or passed to a program with no fear of mangling.
Es contains little that is completely new. It is a synthesis of the attributes we admire most from two shells -- the venerable Bourne shell and Tom Duff's rc -- and several programming languages, notably Scheme and Tcl. Where possible we tried to retain the simplicity of es's predecessors, and in several cases, such as control flow constructs, we believe that we have simplified and generalized what was found in earlier shells.
We do not believe that es is the ultimate shell. It has a cumbersome and non-extensible syntax, the support for traditional shell notations forced some unfortunate design decisions, and some of es's features, such as exceptions and rich return values, do not interact as well with UNIX as we would like them to. Nonetheless, we think that es is successful as both a shell and a programming language, and would miss its features and extensibility if we were forced to revert to other shells.
We'd like to thank the many people who helped both with the development of es and the writing of this paper. Dave Hitz supplied essential advice on where to focus our efforts. Chris Siebenmann maintained the es mailing list and ftp distribution of the source. Donn Cave, Peter Ho, Noel Hunt, John Mackin, Bruce Perens, Steven Rezsutek, Rich Salz, Scott Schwartz, Alan Watson, and all other contributors to the list provided many suggestions, which along with a ferocious willingness to experiment with a not-ready-for-prime-time shell, were vital to es's development. Finally, Susan Karp and Beth Mitcham read many drafts of this paper and put up with us while es was under development.
Footnotes
1.
In our examples, we use "es>
" as es's
prompt. The default prompt, which may be overridden, is
";
" which is interpreted by es as a null
command followed by a command separator. Thus, whole lines, including
prompts, can be cut and pasted back to the shell for re-execution. In
examples, an italic fixed width font indicates user input.
2.
The keyword @
introduces the lambda. Since @
is not a special character in es it must be surrounded by white
space. @
is a poor substitute for the Greek letter
lambda, but it was one of the few characters left on a standard
keyboard which did not already have a special meaning.
3.
This disabling depends on operating system support.
Errata
This section covers changes to es since original publication of
the paper. If you are aware of any undocumented differences, please
contact the authors.
1. Haahr's present affiliation is Jive Technology, and he can be reached by email at<EMAIL_ADDRESS>2.
The <>
operator for obtaining the return value of a
command has been renamed <=
to avoid conflicting with
the POSIX-compatible defintion of <>
as "open for
reading and writing."
3.
error
exceptions now have an additional piece of
information. The second word (the one after error
) is
now the name of the routine which caused the error. Thus, in the new
version of in
below, the throw
command has
an extra in
in it.
4.
This example users an obsolete version of the fork
builtin. The in
function should now be
fn in dir cmd { if {~ $#dir 0} { throw error in 'usage: in dir cmd' } fork { # run in a subshell cd $dir $cmd } }
5.
The pipe timing example may not work on all systems. It depends on
having a version of time
that understands es,
either by building it in to es or having an external time use
the SHELL
environment variable. Es will include a
(minimal) time function if it is built with the compilation option
BUITIN_TIME
.
6. The initialization procedure as originally described lead to performance problems, for two reasons. The first is the time needed to parse and run the initialization code; the second that the data created by running the code (variable names and function definitions, for example) had to be garbage collected. Es solves both problems by moving this work to compile-time.
When es is built, an executable called esdump
is
created, which is a trimmed down version of the shell. That program
is run, with the initialization file initial.es
as its
input. The last thing done in the initialization file is a call to a
primitive $&dump
, which is only included in
esdump
, that writes out the entire memory state of the
shell as declarations in C source code. The generated C code is
compiled and linked with the rest of the source to produce the real
shell executable. The data from the dumping is not garbage collected
and is declared const
so that the C compiler can put it
into read-only memory, if possible.
References
1.
Brian W. Kernighan and Rob Pike, The UNIX Programming
Environment, Prentice-Hall, 1984.
2. S. R. Bourne, "The UNIX Shell," Bell Sys. Tech. J., vol. 57, no. 6, pp. 1971-1990, 1978.
3. Tom Duff, "Rc -- A Shell for Plan 9 and UNIX Systems," in UKUUG Conference Proceedings, pp. 21-33, Summer 1990.
4. William Clinger and Jonathan Rees (editors), The Revised^4 Report on the Algorithmic Language Scheme, 1991.
5. Robin Milner, Mads Tofte, and Robert Harper, The Definition of Standard ML, MIT Press, 1990.
6. John Ousterhout, "Tcl: An Embeddable Command Language," in Usenix Conference Proceedings, pp. 133-146, Winter 1990.
7. Jon L. Bentley, More Programming Pearls, Addison-Welsey, 1988.
8. David R. Hanson, "Fast allocation and deallocation of memory based on object lifetimes," Software -- Practice and Experience, vol. 20, no. 1, pp. 5-12, January, 1990.
9.
R. Kent Dybvig, The Scheme Programming Language, Prentice-Hall,
1987.
Author Information
Paul Haahr is a computer scientist at Adobe Systems Incorporated where
he works on font rendering technology. His interests include
programming languages, window systems, and computer architecture. Paul
received an A.B. in computer science from Princeton University in
1990. He can be reached by electronic mail at<EMAIL_ADDRESS>or by surface mail at Adobe Systems Incorporated, 1585 Charleston
Road, Mountain View, CA 94039. [Errata note 1]
Byron Rakitzis is a system programmer at Network Appliance Corporation, where he works on the design and implementation of their network file server. In his spare time he works on shells and window systems. His free-software contributions include a UNIX version of rc, the Plan 9 shell, and pico, a version of Gerard Holzmann's picture editor popi with code generators for SPARC and MIPS. He received an A.B. in Physics from Princeton University in 1990. He has two cats, Pooh-Bah and Goldilocks, who try to rule his home life. Byron can be reached at<EMAIL_ADDRESS>or at Network Appliance Corporation, 2901 Tasman Drive, Suite 208, Santa Clara, CA 95054.


Posts with the tag "album":
Spring 2021
Here are some photos I took in spring in Copenhagen (CPH), Denmark and Essen, Germany.
Lyngby, Winter 2021
Here are some photos I took in winter in Lyngby, Denmark.
Here are some photos I took in spring in Copenhagen (CPH), Denmark and Essen, Germany.
Here are some photos I took in winter in Lyngby, Denmark.


EBD - Easton Bible DIctionary
Baalis
BAALIS
"BAALIS "king of the Ammonites at the time of the Babylonian captivity(
Jeremiah 40:14
). He hired Ishmael to slay Gedaliah who had been appointed governor over the cities of Judah.
"BAALIS "king of the Ammonites at the time of the Babylonian captivity(Jeremiah 40:14). He hired Ishmael to slay Gedaliah who had been appointed governor over the cities of Judah.


Ryan Dahl created node.js to solve a concurrency problem1. He wanted the server to send messages without the client needing to request them every time.
It only seemed sensible to borrow the V8 engine that the Google team made for Chrome. A JavaScript runtime compiler is the perfect solution to an asynchronicity problem.
Node's power is in the "Event Loop". Everything happens inside of Node is a reaction to an event that's managed within that event loop2. The event loop is what allows Node to handle I/O on a single thread.
Netflix, PayPal, Uber, and Walmart didn't start using Node because they're hipsters. They started using Node because it solved the problem of how to get a single thread to handle thousands of concurrent requests.


Littering a dark and dreary road lay the past relics of browser-specific tags, incompatible DOMs, and broken CSS support.
Download the sample html file and css file
There is clearly a need for CSS to be taken seriously by graphic artists. The Zen Garden aims to excite, inspire, and encourage participation. To begin, view some of the existing designs in the list. Clicking on any one will load the style into sheet into this very page. The code remains the same, the only thing that has changed is the external .css file. Yes, really.
 The only way this can be illustrated in a way that gets people excited is by demonstrating what it can truly be, once the reins are placed in the hands of those able to create beauty from structure. To date, most examples of neat tricks and hacks have been demonstrated by structurists and coders. Designers have yet to make their mark. This needs to change.
We would like to see as much CSS1 as possible. CSS2 should be limited to widely supported elements only. The css Zen Garden is about functional, practical CSS and not the latest bleeding-edge tricks viewable by 2% of the browsing public. The only real requirement we have is that your CSS validates.


*Internet of Things (Internet vạn vật)
+ Amazon Web Service (AWS)
+ IoT AWS IoT Microsoft Azure
+ Google Cloud Platform Thing Worx
+IoT platform IBM Watson
Design a website with transactions, promotions and information . Study web with 3 skills :
+ Front-End
+Back-End
+Full-Stack
*Artificial Intelligence:
+ Sample identification;
+ Optical character recognition;
+ Face,Speech recognition;
+ Natural language processing;
+ Game TTNT and Computer game botplanning.
To learn about the group's activities, we invite you to meet some of the members of the following group
Thank you for visiting our website, wishing you interesting experiences and finding useful things from us.
Linh Trung Street
Nong Lam University ,VietNam Country
+ Mail<EMAIL_ADDRESS>+ Hotline:<PHONE_NUMBER> (ms.Duyen)


Header Documentation¶
Contents
Macros¶
Macro |
Remark |
|---|---|
|
Current major version |
|
Current minor version |
|
Current revision |
|
Full version string |
|
Check compatible version of SAP |
To check if the header is a compatible version of X.Y (i.e. the major version is equal to X and the minor version is at least Y), use
if (SAP_H_VERSION_CHECK(X, Y)) {
// error
}
Structs¶
Main configuration¶
The main configuration is done using SapConfig
. Metadata for the
application is set in these fields, and a list of argument
configurations is set in arguments
.
-
struct
SapConfig
¶ Struct containing configuration of application and arguments.
Public Members
-
const char *
name
¶ Name of the application.
-
unsigned int
version_major
¶ Major version.
-
unsigned int
version_minor
¶ Minor version.
-
unsigned int
version_patch
¶ Patch version.
Author’s name.
-
const char *
about
¶ Short description of program.
-
SapArgument *
arguments
¶ List of argument configurations.
-
unsigned int
argcount
¶ Number of argument configurations in arguments.
-
const char *
Argument configuration¶
This struct will contain the configuration, and later the result, of each argument the application expects / can handle.
-
struct
SapArgument
¶ Struct containing single argument configuration.
The application will set up shortopt, longopt, help and type, then set and value will be set by sap_parse_args().
Public Members
-
char
shortopt
¶ Short option.
-
const char *
longopt
¶ Long option name / argument name.
-
const char *
help
¶ Short help message.
-
SapArgumentType
type
¶ Type of argument.
-
int
required
¶ 1 if argument is required, 0 otherwise
All arguments of type SAP_ARG_POSITIONAL are considered required regardless of this value
-
int
set
¶ Will be set to 1 if argument has been provided, 0 otherwise.
-
const char *
value
¶ Value set for this argument.
-
char
Argument types¶
Argument types are specified using this enum:
Functions¶
After configuration, these 2 functions are used for the actual processing.
-
int
sap_parse_args
(SapConfig config, int argc, char **argv)¶ Parses arguments provided with the provided configuration, prints help message if unsuccessful.
Stores parsed argument values into config.
- Return
0 If arguments parsed succesfully
- Return
1 If arguments were invalid
- Parameters
config
: The SapConfig to useargc
: Argument countargv
: Argument values


{% extends "base.html" %} {% block title %}
Medieval catalogues > BENEDICTINES: THE SHORTER CATALOGUES > Rochester > Indenture, 1391
{% endif %}10 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


-
admin.js | Level 4
Checks if the user has a role matching the admin role specified in your initial config
adminRole: "role-name"
If no role is specified or the user doesn't have a role like this the bot will not execute the command. -
moderator.js | Level 3
Checks if the user has a role matching the mod role specified in your initial config
modRole: "role-name"
If no role is specified or the user doesn't have a role like this the bot will not execute the command. -
member.js | Level 0
Always allows execution of the command.
-
owner.js | Level 10
Allows execution of command if the command is run by the creator of the bot.


Coffee of Boston
Home
About
Sign in
News
The USA
Europe
Middle East
Sign in Form
First name
Last name
Username
City
State
Zip
__Agree to terms and conditions
Submit form


Pumping test in a double porosity aquifer
This demonstrates the interpretation of a pumping test with the Warren and Root (1965) solution
MIT License Copyright (c) 2017 Philippe Renard - University of Neuchâtel (CHYN)
Contents
The data set for this example comes from the following reference: Moench, A. 1984. Double porosity model for a fissured groundwater reservoir with fracture skin. Water Resources Research, 20(7), 831-846. Table 2, Page 838.
General Information:
Fissured tertiary volcanic rocks in the vicinity of the Yucca Mountain at Nevada Test Site. One pumped well UE-25b#1 and one observation well UE-25a#1. Pumping duration was about three days.
Let us first load the data and plot the diagnostic.
clear
| HYTOOL Demo |
We then define the values of the field parameters that are required for the interpretation:
e=400; % Estimated reservoir thickness in m rw=0.11; % Radius of well in m rc=0.11; % Radius of casing in m Q=3.58e-2; % Flow rate m3/s
Once the data have been loaded and the parameter defined, we can interpret the data. We do that as usually in two steps. First the parameters p of the model are estimated with the function war_gss. Then we find an optimum fit.
p=war_gss(t,s); p=fit('war',p,t,s); trial('war',p,t,s)
Norm of Norm of Iteration SSE Gradient Step ----------------------------------------------------------- 0 166.887 1 120.147 936.56 3103.73 2 90.2622 1107.05 3279.48 3 20.032<PHONE_NUMBER>.85 4 17.169 1537.2 13436.9 5 11.4444 829.59 3314.15 6 6.99002 119.415 59.8061 7 6.3463 52.1156 50.003 8 5.9563 39.4448 146.165 9 5.60526 33.9259 164.469 10 5.33282<PHONE_NUMBER>.37 11 4.15449 202.694 367.221 12 2.37682 89.6147 454.105 13 1.43344 40.9653 297.199 14 0.976386 18.4723 224.053 15 0.970898 40.1327 522.947 16 0.598836 12.7197 97.715 17 0.541449 0.515313 15.5706 18 0.541295 0.00320084 2.53045 19 0.541295 0.000502889 0.0380495 20 0.541295 0.00093249 0.0116161 Iterations terminated: relative change in SSE less than OPTIONS.TolFun
We can then display the result of the interpretation. Hytool find that the folowing values fort the transmissivity :
Pumping well :T = 2.1 e-3 m2/s
war_rpt(p,t,s,[Q,rw],'Diagnostic plot')
The results are in reasonable agreement with the values found by Moench (1984): T = 3.3 E-3 m2/s
We then find that the fits are rather similar and both acceptable.


Using alternative hierarchy for mapping
1) If you add another financial document, it will be convenient to isolate the description of the subquery to calculate the amount of the document in a separate intermediate class.
* Once again, it is necessary to recall that the example is synthetic and is intended only to explain the topic of the lesson on very simple concepts. Believe me, when mapping becomes so large, when this technique becomes effective, the idea sinks in detail. And perhaps specifically this intermediate class could also be distinguished in the main hierarchy of classes, but for training purposes we omit this...
using System.Linq.Expressions;
using XData;
using XData.Mapping.Dynamic;
namespace <..Your namespace..>.Models
{
public class FinanceDoc : ISqlObject
{
public decimal Amount {get; set;}
private static Expression<CustomMapping<FinanceDoc>> _ =
() => XDataMapping.UseMapping<FinanceDoc, Doc>()
.Subquery<DocSpecAmount>("A", x => x.GetProperty("Amount"),
DataGrouping.Sum, x => x.SubqueryLink("DocId"))
.ReadOnlyProperty(x => x.Amount,
x => x.Expr<decimal?>(null, DataExpressionType.SubQuery,
"A", DbType.Decimal, z => z.Size(17, 5)))
.Map();
}
}
2) And rewrite mapping for Invoice
using System.Linq.Expressions;
using XData;
using XData.Mapping.Dynamic;
namespace <..Your namespace..>.Models
{
public partial class Invoice : Doc
{
private static Expression<CustomMapping<Invoice>> _ =
() => XDataMapping.UseMapping<Invoice, FinanceDoc>()
.Map();
}
}
3) Note that we used another overload of the XDataMapping.UseMapping method and despite the fact that the main inheritance hierarchy remains as convenient for the application, the mapping will be built taking into account an alternative hierarchy.


You are about to remove your account from "Todolist MVC". This will completely delete all your data and you will be no more able to use your account. Please be sure.
Delete my account
Are you sure to delete your account?


|
MyoBridge Library
1.0
A high-level Arduino library to work with MyoBridge Firmware for the HM-11 SoC.
|
These functions set the so called callback functions for specific events. More...
Functions | |
| void | MyoBridge::setIMUDataCallBack (void(*onIMUDataEvent)(MyoIMUData &)) |
| Callback function for IMU data, packed in the MyoIMUData data type. More... | |
| void | MyoBridge::setIMUMotionCallBack (void(*onIMUMotionEvent)(MyoIMUMotion)) |
| Callback function for IMU motion data, packed in the MyoIMUMotion data type. More... | |
| void | MyoBridge::setPoseEventCallBack (void(*onPoseEvent)(MyoPoseData &)) |
| Callback function for Pose data, packed in the MyoPoseData data type. More... | |
| void | MyoBridge::setEMGDataCallBack (void(*onEMGDataEvent)(int8_t[8])) |
| Callback function for EMG data, as array of 8-Bit signed numbers. More... | |
These functions set the so called callback functions for specific events.
If you do not know what a callback function does, read about that first (http://playground.arduino.cc/Main/MIDILibraryCallbacks). They are the functions called, when a specific event happens, like data arriving from the Armband. Dont let your program spend too much time in these functions, because sensor data might arrive at a fast pace. If you need some time, consider disabling data messages by calling disableAllMessages() first.
| void MyoBridge::setEMGDataCallBack | ( | void(*)(int8_t[8]) | onEMGDataEvent | ) |
Callback function for EMG data, as array of 8-Bit signed numbers.
| void MyoBridge::setIMUDataCallBack | ( | void(*)(MyoIMUData &) | onIMUDataEvent | ) |
Callback function for IMU data, packed in the MyoIMUData data type.
| void MyoBridge::setIMUMotionCallBack | ( | void(*)(MyoIMUMotion) | onIMUMotionEvent | ) |
Callback function for IMU motion data, packed in the MyoIMUMotion data type.
| void MyoBridge::setPoseEventCallBack | ( | void(*)(MyoPoseData &) | onPoseEvent | ) |
Callback function for Pose data, packed in the MyoPoseData data type.


---
title: Blackfynn
keywords: documentation theme, jekyll, technical writers, help authoring tools, hat replacements
last_updated: Dec 03, 2018
sidebar: matlab_docs_sidebar
permalink: blackfynn.html
folder: mydoc
---
Blackfynn Main class for interacting with Blackfynn platform.
OBJ = BLACKFYN() opens a Blackfynn session with your default
profile.
OBJ = Blackfynn('profile') opens a Blackfynn session with a
specific profile as defined by the Blackfynn configuration.
Blackfynn.SETUP() creates a configuration file for the client
Blackfynn.PROFILES() shows a list of profiles that have been setup.
|
|
createDataset |
Creates a new dataset in organization |
|
|
deleteDataset |
Delete a dataset from the platform |
|
|
get |
Returns any object based on its Blackfynn ID. |
| Static
|
gotoSite |
Opens the Blackfynn platform in an external browser. |
|
|
listDatasets |
Displays a list of datasets |
| Sealed
|
methods |
Shows all methods associated with the object. |
|
|
organizations |
Returns all organizations for the user. |
| Static
|
profiles |
Returns all Blackfynn configuration profiles. |
| Static
|
setup |
Setup a profile for the Blackfynn client. |
|
|
upload |
Upload files to the Blackfynn platform |


{{ctrl.selectedSpan._source.name}}
| Tag name | Tag value |
|---|---|
| {{prop.propName}} | {{prop.value}} |
The call tree might not contain all executed methods.
Showing all methods can result in performance problems when rendering and
navigating the call tree. That's why by default, only methods are shown which took longer than 0.5% of the
total
execution time. To change this, change the configuration option with the key
stagemonitor.profiler.minExecutionTimePercent
.
There is another configuration option (stagemonitor.profiler.minExecutionTimeNanos
) which
excludes very fast method invocations, as these are typically not very interesting.


 You can find more information about cookies at www.allaboutcookies.org
In order to be able to identify your authenticated session, we need to set a session cookie to operate properly. It will allow us to provide the requested services such authentication and authorization. If these are deactivated, a user will not be able to aut.


|
Bendix is located in Elyria, Ohio and makes braking systems for medium to heavy-duty trucks. I was an intern focused upon the HIL (Hardware-In-The-Loop) lab, running automated tests on all aspects of our braking systems. A large part of my role at Bendix was using real data to improve the ABS (Antilock Braking System) testing and automating a number of testing procedures. I also worked to install and debug sensors and hardware that was added to the lab to ensure accurate real-time sensing of all pneumatic components. By automating the testing procedures a full test for a new vehicle design, or changing the hardware in a vehicle was able to be done over the course of a weekend, rather than by an operator over the course of a week, this saved a large amount of time and money for the testing team at Bendix.
|
|


Amazon offers free music streaming service; rival Spotify slips
Amazon.com Inc said on Monday it has introduced an ad-supported free version of its music streaming service "Amazon Music".
REUTERS: Amazon.com Inc said on Monday it has introduced an ad-supported free version of its music streaming service "Amazon Music".
Amazon offers paid plans for its music service starting at US$9.99 per month. It is also part of its prime bundle. The company launched free version of its music service for Alexa users on Echo devices in September.
Rival Spotify Technologies also offers a "freemium" model that includes a free ad-supported version along with a paid ad-free version at US$9.99 per month.
Amazon shares were up nearly 0.5per cent, while those of rival Spotify Technologies fell about 5per cent.
(Reporting by Amal S in Bengaluru; Editing by Arun Koyyur)


IT 4203 Individual Project
Milestone #1: JSON
Parts
IT Ebooks Search List
Google Books Single Book
Google Books Search List
Home


Welcome to the
Click here for more about
this website
Click here to go to the MCHS
website
Click here to go to the MCC
of OGS website
|
CDs of
important |
1849
Ault, Frederick Ault
Spirit of Democracy,
The St. Clairsville Gazette, of
yesterday says: We regret to announce that the
Cholera has appeared in
The disease is said to be spreading in
Blum, Robert Blum
Spirit of Democracy,
The following interesting account of the heroic bearing of
Blum, the German patriot, on the occasion of his brutal assassination by the
barbarian minions of the Austrian tyrant, will interest all who sympathize in
the struggles of
LEIPSIC,
About two hours before the time appointed for his
execution, a chaplain was deputed to visit him, and prepare him for death, of which
he had received no previous notice. At first he could not believe the messenger
of death, but the gloomy tidings were soon corroborated by a judge. He appeared
quite calm and collected, remarking to the chaplain, You know, perhaps that I
am a German Catholic; I believe, therefore, you, will exempt me from auricular
confession. The minister being of the same persuasion, of course assented.
 After some moments
of conversation with the chaplain, during which he was perfectly calm, he said,
I am exceedingly happy to have made the acquaintance of so worthy and
Christian a man; I wish to leave you a remembrance, but have nothing but a hair
brush left; will you accept that for me, and thereby afford me my last
pleasure! He was now summoned to the place of execution.
Believe me, I will make no effort to escape spare me from your chains. His
request was granted, and the procession moved on, guarded by two thousand
military. On his way, he became affected to tears, and remarked to those around
him. Robert Blum has indeed wept, but not to delegate Blum; he dies with a
free conscious. The husband, the father weeps. I was thinking of my dear wife
and children.
At 7 a.m. they arrived at the place of execution. Blum
stepped out of the carriage and asked who was to shoot him. On being told the Jager, he said, I am glad of
that, the Jager aim well: on the 26th of
October they wounded me. As they proceeded to blind his eyes, he said, No,
let me look death in the face, but upon being told that the Jager could take better aim if they did not see his eyes,
he answered, In that is the case I willingly
submit. He then repeated his last words the rallying words of German s noblest
sons: I die for German freedom for that I have fought my country, forget me
not. And as customary the provost begged three times for mercy a solemn
mockery and nine soldiers stepped forward and fired. Two balls struck him, one
in the eye, the other on the left side of the breast death was doubtless, instaneous.
The following is the letter written by this glorious
patriot, to his wife, a few moments before he was ordered out to die:
My dear, good wife Farewell, farewell for the
time men called eternity, but which will not be so.  Sell our little property with the aid of our friends. God and all good
will help you also. All that I feel and would say at this moment escapes me in
tears; only once more then, farewell, my dearest. Consider our children a
treasure of which you must make the best use, and honor thus the memory of your
faithful husband. Farewell, farewell; receive the last kisses of your Robert.
P.S. I had forgotten the rings; on that of our betrothel I press for you a last kiss; my seal ring is for
Hans, the watch for Richard, the diamond stud for Ida, the chain for Alfred, as
memorials. All the rest divide as you please.
They are coming, farewell.
Clay, Cassius M. Clay
Spirit of Democracy,
DESPERATE AND FATAL ENCOUNTER
At a public meeting or discussion of slavery emancipation,
which took place on Saturday last, in
This dreadful tragedy has caused great excitement and much
sorrow among the friends of both parties.
Durbin, William Durbin
Spirit of Democracy,
Death of Hon. William Durbin By the
On Tuesday morning last we addressed a letter to Judge
Durbin, expecting it to find him enjoying good health in the bosom of his
family; but he had already been called to his long home.
Dye, Sarah Jane Dye
Spirit of Democracy,
Died On Monday, the 8th inst. at her residence,
in this county, SARAH JANE DYE, wife of John L. Dye, aged 22 years and 3
months.
.
How sweet the hour of closing day,
When all
is peaceful and serene;
And when the sun with cloudless ray,
Sheds mellow luster o er the scene.
.
Such is this sister s parting hour
So
peacefully she sinks to rest,
When faith, endued from Heaven with power,
Sustains
and cheers her languid breast.
.
Mark but that patience of her eye
That smile upon her wasted cheek;
They tell us of her glory nigh,
In language that no tongue can speak.
.
A beam from Heaven is sent to cheer
The
pilgrim on her gloomy road;
And angels are attending near,
To bear her to their bright abode.
.
Who would not wish to die like those
Whom God s
own spirit deigns to bless?
To sink into that soft repose
Then wake
to perfect happiness.
Gaines, Edmund Pendleton Gaines
Spirit of Democracy,
EDMUND PENDLETON GAINES
FAREWELL TO THEE
PATTERN OF OLD FIDELITY
That staunch and veteran patriot and soldier, whom our
citizens have so long delighted to look upon as almost the sole representative
of olden time, the infant days of this Republic, departed this life in this
city early yesterday morning.
He died of cholera. By no lingering disease, and through no
prolonged debility and decrepitude, but suddenly and without pain or suffering,
he passed from the active arena of life to a glorious immortality, at the
advanced age of seventy-eight. But a few days ago his erect military figure,
his mild, benignant face and ever courteous bearing, so long familiar to our
people attracted the respect and involuntary homage of all beholders. He was
truly a link, uniting chivalry of the present with that of the revoluntionary times.
His green old age left undiminished that ardor of
patriotism, that heroic firmness, that lofty sense of duty, which, nutured by intercourse with heros, and sages of our early colonial struggles,
were tried and strengthened by an active participation in all the subsequent
military events in our history. He grew up with the Republic, having embarked
in life shortly after the adoption of the present Constitution, and lived to
see the
A brief and necessarily hurried sketch, of the long and
eventful life of this brave old patriot, may not be uninteresting to our
readers.
EDMUND P. GAINES was born in Culpepper county,
Virginia. His father had been engaged in the early Indian Wars of the Colony,
and in the Revolution of 1776. His uncle was the celebrated Edmund Pendleton,
Chief Justice of the Court of Appeals of Virginia, one of the purest and most
Cato-like men whom the Old Dominion ever produced. Before Edmund Pendelton had arrived at man s estate, his father was
compelled to move into
In 1806, by order of the President, Gaines arrested Aaron
Burr in this city, and took him on to
In the interval between Burr s trial and the War of 1812,
Capt. Gaines remained in the army, from which he was about to retire into the walks
of civil life, when he was dissuaded by the threatening aspect of our relations
with
During the whole war which followed, Capt. Gaines was
actively engaged in nearly all the expedition against the allied British and
Indians on the North-Eastern frontier. Having been promoted to a colonecy, he commanded the hard-fought battle of Ghrystersfields, where he held the British army in check,
defeating the 89th British, under Colonel Morrison, and converting a
route into a drawn battle.
It was on that occasion that the British commander, who had
witnessed Gaines steadiness, sent him his card, with a high compliment to his
gallantry. On
On
During the contest, the magazine exploded and destroyed
many lives. For his conduct on this occasion General Gaines received the brevet
of Major General. Shortly after, being badly wounded, he retired from the
command. For his conduct at Fort Erie, General Gaines received complimentary
swords from the States of Virginia,
After the war, General Gaines, was assigned to the command
of
By order of General Jackson, General Gaines presided over
the Court Martial which condemned Arbuthnot and Amburton
to be hung. In the capture of St. Marks,
About
When the Seminole war raged in 1836, and the honor of our
arms, and the safety of our troops seemed to require some vigorous action,
General Gaines raised a strong force in this city, and landing at Tampa Bay,
marched to the Withlacoochie where he fought a severe
battle with the Indians, and held his position under the most embarrassing
circumstances, until he was superseded by General Scott.
Gen. Gaines returned to this city, where he remained, as
commander of this Division, until the Mexican War broke out. His prompt and
soldier-like conduct in calling out a large and effective force to send to the
aid of General Taylor, when the reports of the critical position of Gen. Taylor
on the Rio Grande reached this city, have since received the sanction and
approval of the whole nation. Had his views been carried out, the war would
have terminated earlier than it did.
Thus have we hastily run over the chief events in the
stirring life of the brave old soldier, whom we have been so long accustomed to
love, cherish and admire. The soul of General Gaines was pure of spot or
taint his heart knew no guile his spirit was brave, gallant, and chivalric. His
courtesy and kindness were inexhaustible; his charity and benevolence were
boundless. A lofty sense of duty and of honor, an inflexible patriotism,
presided over all his thoughts, actions and sentiments.
Gallatin, Albert Gallatin
Spirit of Democracy,
Albert Gallatin Dead ALBERT GALLATIN, formerly Secretary of
the Treasury under Mr. Jefferson, died in New York, early on Monday at a very
advanced age.
Hangley, Mrs. Hangley
Hangley, (daughter) Hangley
Casey, Young child Casey
Spirit of Democracy,
An incident of the cholera occurred in this city, a few
days since, which, for several reasons, we thing [sic] worth recording.
Among the households which had been entered and stricken by
all that fatal disease, was that of Mr. Hangley, a
worthy Irishman, who has long been employed by the Commissioners of streets.
His wife, a warm
hearted motherly woman, devotedly attached to children and self-sacrificing to
promote their welfare and happiness, was taken with the cholera and died, and
was buried on Thursday, Sept. 20th.
Next, a lovely daughter, seven years of age was taken sick,
and she too died, and her body was laid out and her limbs adjusted in the
embrace of the king of terrors.
The father appealed to Alderman Wingate for a coffin, but
for some cause it could not be had immediately, and its delivery was postponed for
an hour or two; during this time Mr. Hangley
returned, when the supposed dead child stretched forth her arms, with the
exclamation, Oh father! I have been to heaven, and it is a beautiful place!
After the surprise and the excitement of the girl had subsided,
she gave a relation of what she had seen, as she expressed it, in Heaven.
She saw her mother in Heaven, and she was taking care of
little children, many of whom she called by name, and among them were four
children of Uncle Hangley, and three children of
Uncle Casey s. Aunt Lynch is not there now, but she will be to-morrow; and on
Sunday I shall go back again.
But said an older sister, it cannot be so dearest, for
there are but two of Uncle Casey s children dead!
Yes, I saw three of them in Heaven and dear mother was
taking care of them, all were dressed in white, and all were very happy and the
children playing. Oh! it was beautiful there; and I
shall go there again next Sunday afternoon at
Mr. Hangley immediately informed
Mr. Wingate that his daughter was not dead; when he, in the company with Dr.
Morrison, visited the house, and the little girl
related substantially the same story. It seems, too, that shortly after this
relation of the little girl, of what she had heard and seen in Heaven, a
message came from Mr. Casey, in
Of the four children of her Uncle Hangley,
two died in this city and two were drowned on their passage from
We called on Saturday to see and talk with this little
girl, but she was very feeble and just then in a drowse, and we would not allow
her to be disturbed. She is said to have a very thoughtful and serious
countenance, and to be a very interesting child. She had no wish to live, but
preferred returning to her mother. The father and the sisters are seriously,
but very happily impressed with the relations of this sweet child, and joyfully
believe the story she tells. Their house is a pattern of neatness, and they all
possess hearts overflowing with affection, and are sincerely happy on account
of their heavenly messenger.
I was sorry, said Mr. H. to Dr. Morrison, in the honest,
truthful simplicity of his heart, when my good wife died, but I m not now, but
only wish to be with her. The elder sisters too, live now in joyful hope of
meeting at length, and they care not how soon, if it be God s time, their dear
mother, in Heaven, where she has been seen by their angel sister, who has been
permitted to return to the earth, and make the fact known to them.
Since the above was published there have been a great many inquires respecting this little girl, some of which we will
not answer.
Although at the time of the seeming death of this child it
was not supposed that her AUNT LYNCH was dangerously ill, she not having the
cholera but attacked with dysentery. But she died the next day as stated.
On Sunday afternoon, Mr. Daniel Warren, a very worthy
religious man, who has been much among the cholera patients, and feeling,
perhaps a little moved by curiosity, called to see the little girl, and
addressed her cheerfully and told her that she appeared better and would soon
be well, and get out in a day or two.
But I m going to mother again at
When, to-morrow?
No, to-day.
Mr. Warren endeavored to turn her attention to hopeful
prospects of recovery; but the little sufferer was fast sinking away the death
rattle was heard, and she soon ceased to breathe, her pulse stopped, and the
fixedness of death was impressed upon her beautiful countenance. She was dead!
Mr. Warren looked at the town clock, in the distance, from
the window, for there was no clock in the house, and it was
While pondering upon, to him the singular co-incidents, in
this case, and about half an hour had passed, new signs of life appeared, and
again the spirit of the sweet girl returned. She asked for water and said she
was tired, and sunk away into a quiet sleep.
Since then she has been gradually recovering, but her elder sister, who watched her so
tenderly, and who would so willingly have accompanied her blessed mother in
Heaven, was the next day taken with the cholera and the following died and was
buried.
The father of this girl is ignorant, yet a fine specimen of
a pure warm heart, with all the unsophisticated simplicity and truthfulness of
nature. He is poor. He had a large family; and he says that for the whole
season he had but two pounds of butter in his house, and they had only had meat
but twice. They had lived almost wholly upon bread and tea.
There were many of them, he said, and
his own hands must earn their living, and by prudence a barrel of flour would
last them four weeks, and he must do what he could for himself and the
children, and they all were quite happy.
The little boys had by their labor picked up the boards out
of which his dwelling had been constructed, and he hoped after a while to have
it all of their own.
Perhaps a more united, loving and contented family, where
all were willing to do and suffer for each other, cannot be found.
Such are the simple facts in the case, which we leave for
the present without comment or attempt explanation.
Hutchinson, William Hutchinson
Spirit of Democracy,
Died On Thursday, the 15th inst, at his
residence, in this township, WILLIAM HUTCHINSON, aged 65 years.
Low, Nimrod Low
Spirit of Democracy,
Died On Thursday last, at his residence in this township,
MR. NIMROD LOW, aged about 30 years.
Marshall, Adam Marshall
Spirit of Democracy,
HORRID MURDER On last Saturday
evening a number of neighbors had assembled at the house of Mr. Kountz, in Enoch township, who was very ill and not
expected to live.
While they were thus surrounding the couch of the sick man,
Reuben Johnston (who lived in the adjoining house) assaulted his wife with a
dirk knife, and stabbed her in the side, when his daughter and Mrs. Kountz ran to her assistance and shared the same fate.
MR. ADAM MARSHALL then ran in to save the lives of the
women, whose shrieks called him to the scene of blood. As soon as he entered
the room
The females are badly wounded; the daughter was not
expected to live at our last advices. Mrs. Kountz and
the wife of this monster in human shape are recovering.
Mason, J. Patterson Mason
Spirit of Democracy,
On Monday last, at the residence of his father, in this
place, J. PATTERSON MASON, in the 27th year of his age.
Morris, Matthew Morris
Spirit of Democracy,
Died On Monday last, at the residence of his father, in
Perkins, Mr. Perkins
Spirit of Democracy,
The Rev. Mr. Perkins, Pastor of the
He was doubtless laboring under sanity. He was much
esteemed by all who knew him, and leaves an interesting family to mourn his
loss.
Roe, Mr. Roe
Snyder, A. Snyder
Ebbert,
Spirit of Democracy,
The Steamer Virginia, plying as a daily between this city
and
A portion
of the wounded were brought to
this city last evening by the steamer Shenandoah, the clerk of which furnished
us with the subjoined list of the killed, missing and wounded. We are also
indebted to the Captain and Clerk of the Zachary Taylor which came down soon
after, for particulars of the horrible castrophe.
From these gentlemen and two or three others, passengers, we gathered the facts
of this article; which are all that they had been able to collect in reliable
shape, amid the excitement and confusion at the scene of the disaster, or from
the survivors of the castrophe. It is said that the
Captain of the boat,
As almost the whole of the boat above the hull so shattered
that it sunk at once there can be but little doubt that all the missing are
dead. Mr. Snyder of this city, (glass blower), who lost both his legs, it is said cannot probably survive many hours.
The explosion took place whilst the boat was landing, Mr.
Roe, one of the killed. He was upon the plank going ashore at the time, and his
body was cut into three pieces by the explosion!
We give the facts as fully and accurately as we can. We
shall doubtless be able to give fuller details on Monday.
Dead MR. ROE, of
Wounded Mr. Boles and lady,
Missing Ebbert of Wheeling;
Samuel, a colored fireman and about eight others whose names are not yet
known.
WHEELING GAZETTE
Since the awful explosion of the steamer
WHEELING ARGUS
Smith, Ruth Smith nee Ford
Spirit of Democracy,
Died In this place, on Tuesday evening
last, at
Sudden and severe is the shock produced by the death of
this amiable lady, which is felt by a large circle of relatives and friends.
For ten years has she lived among us, and during all that time she so conducted
herself as to each day strengthen those bonds of affection and esteem which
were first woven by her kindness of heart, courtesy of manners, and genuine
friendship.
All mourn but all are not alike bereaved.
She has left a kind and affectionate husband, and four
small children to mourn the loss of a wife and mother. To them we can offer
another consolation than that their loss is her eternal gain. She cannot come
to them, but they can go to her, and enjoy an eternity of uninterrupted
happiness, where parting is no more. And may God in his mercy so sanctify this
affliction, to them, as to lead them all to purity of thought and conduct, and
eventually to a resting place with her in Heaven.
St. John, Mary Ann St. John
Spirit of Democracy,
On Thursday last, of this place, MARY ANN ST. JOHN, in the
10th year of her age.
Vernon, Benjamin Vernon
Spirit of Democracy,
Died On the 22d ultimo, at the residence of his father, in
Seneca township,
On motion,
RESOLVED, That these be a committee of three appointed to
draft a preamble and resolutions expressive of the deep regret entertained by
this Division for the early death of our much esteemed Brother, consisting of
Brothers L. F. Ellsworth, S. Truax and Levi Tuttle,
who reported the following, which were unanimously adopted:
WHEREAS, It has pleased Almighty God in his wisdom, to take
from us, by the hand of death, our beloved Brother Benjamin Vernon, Therefore,
RESOLVED, Though we bow in humble
submission to the Divine will, yet we feel grieved at the sad event which has
deprived our community of a highly esteemed and promising young man, our Order
of an exemplary and consistent member, and our Division of a worthy brother.
RESOLVED, That we sincerely
sympathize with the bereaved family of our deceased brother.
RESOLVED,That
the members of this Division, in taken of their high regard, wear their colors
for thirty days.
RESOLVED, That the R. S. forward a copy of the foregoing
preamble and resolutions to the bereaved family, and by their consent to the
Spirit of Democracy for publication.
L. F. ELLSWORTH, R.S
Warfield, Scyntha Ann
Warfield
Spirit of Democracy,
Departed this life on the 29th day of August,
MRS. SCYNTHA ANN WARFIELD, of Stock township, in this county, in the 21st
year of her age.
Wright, Sarah Wright
Spirit of Democracy,
Died At her residence in Centre township,
on Saturday the 10th inst; MRS. SARAH WRIGHT, aged 22 years.
Last
modified Oct. 12, 2009 by reh
Click here for the Short-Cut Table of Contents


The excerpt from this podcast will be added here. So to atleast to give your audience an idea on what the podcast could contain aside from the provided title of the episode..
Listen to PodcastEpisodes to Listen
Ep. 1 - Thinking Right to Left. Achieving financial freedom simply
Ep. 2 - Thinking Right to Left. Achieving financial freedom simply
The excerpt from this podcast will be added here. So to atleast to give your audience an idea on what the podcast could contain aside from the provided title of the episode..
Listen to PodcastEp. 3 - Thinking Right to Left. Achieving financial freedom simply
The excerpt from this podcast will be added here. So to atleast to give your audience an idea on what the podcast could contain aside from the provided title of the episode..
Listen to PodcastTo load more episodes, Click here!
Why Thinking Right to Left?
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse eget sem et velit finibus finibus. Fusce vel orci in justo ullamcorper pellentesque varius sit amet dui. In a velit non est egestas consequat eget eu tortor. Aliquam luctus, tellus vitae ornare dignissim, odio metus sodales quam, non elementum tellus nisl sit amet dui. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus ullamcorper, massa at dignissim aliquet, urna enim accumsan justo, at placerat lectus enim ut dolor.
Read More..Why Thinking Right to Left?
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse eget sem et velit finibus finibus. Fusce vel orci in justo ullamcorper pellentesque varius sit amet dui. In a velit non est egestas consequat eget eu tortor. Aliquam luctus, tellus vitae ornare dignissim, odio metus sodales quam, non elementum tellus nisl sit amet dui. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus ullamcorper, massa at dignissim aliquet, urna enim accumsan justo, at placerat lectus enim ut dolor.
Read More..


A workspace for constructing and publishing semantic
knowledge networks.
/ {% block breadcrumbs %}{% endblock %}
{% block content %}
The content block need to be overrided!
{% endblock %}
Welcome!
This application is an attempt to collaborative
framework for online construction and publication of
semantic knowledge networks and ontologies.
Currently this application provides support for
Metatypes and Objecttypes. Using metatypes you can
define different kinds of concepts, like "concept
names", "action names", "scientific concept", "phylem"
etc. Objecttypes are any regular classes, which can be
defined as members of Metatypes. Next release will have
a way of subtyping Objecttypes, along with many more
features. We are just beginning to shape this project,
if you are interested in joining, visit us
at metastudio.org.


noVNC is a browser based VNC client implemented using HTML5 Canvas
and WebSockets. You will either need a VNC server with WebSockets
support (such as libvncserver)
or you will need to use
websockify
to bridge between your browser and VNC server. See the noVNC
README
and website
for more information.


You are currently not signed up and thus using a guest account. To benefit from and access multiple functions through the Asergis Property website, make sure to create a real live account and you will immediately be granted access to the full experience once the Sign Up process is done. Hope you enjoy your time surfing through our website. Should you have any questions or queries please visit our FAQ page or get in touch through the Contact Us page.


Aligning some text next to a div (or image or icon) can be quite confusing and counter-intuitive.
In the following examples I will an icon as an example, but the same will apply for an image or any other block element.
floating the icon to the left is usually enough, as long as the text isn't taller than the element. If it is longer, the text wraps under the element.
I found this cool trick to stop the text wrapping underneath the element. This looks similar to a unordered list, where the 2nd line indents. Some might argue that a semantically correct html list should be used instead of this trick, but there are cases when you're not trying to create a list.
The fix is a simple 1 line CSS change:
.text { overflow: hidden; }


You are missing out on features! We can't grab your mouse pointer with your current browser, so you are likely to leave the window with your mouse and disrupt mouse movement. Please use Firefox or Chromium for mouse grab support.
Welcome!
Please double check that you have installed the IKBD Injector in your ST as well as the keyboard injection cable from CosmosEx to the ST.
Now you can remote control your ST with this webapp.
- move your finger on this webpage to move your STs mouse
- double tap with one finger to left click on the ST
- double tap with two fingers to doubleclick on the ST
- right mouse button is not supported yet on touch devices
- use the ST Keyboard image to type. Just tap the Key you want to enter. You can tap multiple keys (e.g. CTRL ALT DEL for reset if your TOS supports it)
- hide ST keyboard with "Toggle ST Keyboard"
- show the touch devices keyboard with "Toggle system keyboard"
- recieve a screencast from ST (you must have started ce_cast.prg on the ST) by tapping "Start Screencast"
There is now Joystick support in this remote.
ST Screencast
This is a highly experimental feature and will cause instabilities with older software. You will need a bleeding edge browser for this (read: Chrome or Safari). It only works with "clean" ST software, it will not work with games or demos. Do not start ce_cast.prg in your AUTO folder.
Problems? Read this. If this doesn't solve the issue, send a mail!
Welcome!
Please double check that you have installed the IKBD Injector in your ST as well as the keyboard injection cable from CosmosEx to the ST.
Now you can remote control your ST with this webapp.
- move your mouse on this webpage to move your STs mouse
- left click in the browser to left click on the ST
- right click in the browser to right click on the ST
- click "Grab mouse" (if available in your browser) to attach your mouse to the browser, so you won't leave its boundaries. Press ESC to leave this mode.
- use your PCs keyboard to type
- for Special Keys you can click "Toggle ST keyboard" to show a ST Keyboard. Just click the Key you want to enter
- recieve a screencast from ST (you must have started ce_cast.prg on the ST) by clicking "Start Screencast"
There is now Joystick support in this remote.
ST Screencast
This is a highly experimental feature and will cause instabilities with older software. You will need a bleeding edge browser for this (read: Chromium or Chrome). It only works with "clean" ST software, it will not work with games or demos. It will only work with the most current HDDRIVER. Do not start ce_cast.prg in your AUTO folder.
Problems? Read this. If this doesn't solve the issue, send a mail!


THIS IS SPARTA!
Grind 4 Success
Ballers DNA podcast
ICT & BTMM method
Breaker
Source
Order block
Quarter Points
Hesitation Zone
Hesitation
25 fig
75 fig
50 fig
whole number
Round number
Midpoint


{% trans "This case type has been deprecated in the Data Dictionary." %}
{% trans "Case types can only include the characters a-z, 0-9, '-' and '_'" %}
{% blocktrans with case_type=module.case_type %}
You have cases associated with the {{ case_type }} Case Type.
Making this change will NOT affect your existing cases.
Only new cases will be affected.
{% endblocktrans %}


WebEvent Sample
Subscribe to 10 Seconds Timer
Unsubscribe from 10 Seconds Timer
Subscribe to 60 Seconds Timer
Unsubscribe from 60 Seconds Timer
Subscribe to Client
Unsubscribe from Client
Send Client Notification
Subscribe all
Unsubscribe all