Sound Studios ‐ Where Technology & Art Come Together Created HTML and CSS pages Created header and footer Added image on homepage Added stylings in CSS Go to top


BY EDWIN JAHIEL
A WALK ON THE MOON **1/2 Directed by Tony Goldwyn; written by Pamela Gray; director of photography, Anthony Richmond; edited by Dana Congdon; music by Mason Daring; production designer, Dan Leigh; produced by Dustin Hoffman, Goldwyn, Jay Cohen, Neil Koenigsberg, Lee Gottsegen and Murray Schisgal; released by Miramax Films.CAST: Diane Lane (Pearl Kantrowitz), Viggo Mortensen (Walker Jerome), Liev Schreiber (Marty Kantrowitz), Anna Paquin (Alison Kantrowitz), Tovah Feldshuh (Lilian Kantrowitz), Bobby Boriello (Daniel Kantrowitz), et al. 107 minutes. R (sex).
A nice movie, even though it is too slow, too long, has overly neat and predictable developments, and is unsubtle (but then its people are unsubtle, too).
It's the first directorial effort by actor Tony Goldwyn, the grandson of the famous Sam Goldwyn who created MGM. It is also the first filmed script by Pamela Gray. She wrote it as her thesis for the UCLA Film Department, and the scenario attracted much attention.
The movie (shot in Canada's Laurentians standing in for the Catskills ) centers on Pearl Kantrowitz (Lane), a young and comely mother of two, Alison (Paquin) 14, and much younger Daniel. Her husband Marty (Schreiber) is a Brooklyn TV-repairman. The time is the summer of 1969. Marty drives his family, including his mother Lilian (Feldshuh) to the low-end Jewish resort of Dr.Fogler's bungalows. Marty, like many other, unretired men, has to go back to work and gets to the bungalows only on weekends.
Pearl is a pretty woman with a beautiful figure -- often displayed. She is vaguely dissatisfied with her life. Married to Marty when she was a teenager (and pregnant with Alison), she has known no other men (carnally, that is) and is also aware of the hippie culture of the times, and the "freedom" that goes with it.
While, at the resort, rather too neatly Alison gets her first period and her first boyfriend, Pearl meets Walker (Mortensen), aka The Blouse Man. He is a peddler of women's garments, an itinerant dweller of his bus shop-plus-home. Pearl has an affair with him. Marty finds out. But there's a probably (and certainly contrived) happy ending.
AWOTM does a good job in its observation of people, that is, its nucleus of the five Kantowitzs plus Walker. The other characters are strictly an uncluttering background, which is good -- even though contemporary Jewish-American filmmakers (Gentiles would not dare !) including this picture's, tend to overdo ethnic accents, manners and mannerisms. They add to them touches of irony (granted this is often warm) that can border on the tiresome.
However, the Kantowicz family is free of ethnic touches, except for old pro Tovah Feldshuh who portraysa most original and sweet mother-in-law. All the people in the film are real, even veristic, which amounts to their being rather dull, as most terra-firmans are. But the main problem is not there. It is in the construction.
First come the symbols, metaphors, parallels and improbabilities, starting with the movie's title. The summer of 69 was the summer of the first man to walk on the moon (Neil Armstrong on 20 July). While the gathered bungalow-dwellers watch on TV the liberation of earthlings, and rejoice, Pearl, inside Walker's bus, goes into sexual orbit and finds her own sexual liberation. Too pat.
The coincidental mother-and-daughter newfound sexuality? Too pat. Later, Walker and Pearl cavort and make love under a waterfall, but the camp's denizens do not notice. Improbable. The Woodstock Rock Festival (15-17 August), held not at Woodstock but in Bethel , N.Y., is too conveniently close to Dr. Fogler's Bungalows. Alison and new boyfriend Ross scoot over to the festival where she spots her Ma writhing with abandon with her lover. Too much. When Pearl takes to the road, in the rain, the itinerant Walker just happens to be driving by. Young Daniel gets strung by bees --at a providential time that triggers his dad's return to the resort. Too pat. And so on.
I 'll make an educated guess here. As a film student, script-writer Pamela Gray must have most certainly seen several classic movies. Her scenario is under the sign of at least three masterpieces of the 30s and 40s: The Rules of the Game (France), Casablanca (US), Brief Encounter (UK).
In The Rules of the Game, Renoir went to some careful preparations before the wife of the host, testing a small monocular, spies her husband embracing his (now-ex) mistress. In AWOTM, Alison, using unexplained binoculars, spots Pearl and Walker within a crowd of hundreds of thousands!
In Casablanca, Rick parting with Ilsa utters the famous "it doesn't take much to see that the problems of three little people don't amount to a hill of beans in this crazy world." He is right, but such is the power of that movie that, paradoxically, those problems do affect the audience. Which is not the case in AWOTM, where, as in many more movies, private or domestic problems affect the characters but not the public. Such movies do not go beyond their own borders.
Brief Encounter is a masterpiece among films in general and love stories in particular. The short-lived affair, with no sex, between married Celia Johnson and Trevor Howard is so achingly beautiful that it can haunt you for years. What is important for the characters is certainly not trite for us.
This said, the principals' performances are very good. For Diane Lane, Liev Schreiber and to an extent, Anna Paquin, their roles are difficult yet deliver the goods with great conviction. Lane's debut was as a ravishing teen-ager in A Little Romance (1979). She made a lovely Paulette Goddard in Chaplin (1992), but her career has had few memorable roles. Her Pearl feels like a comeback.
" Le mauvais gout mene au crime" (Stendhal)
Edwin Jahiel's movie reviews are at http://www.prairienet.org/ejahiel
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


A Gentle Introduction to Haskell, Version 98
This section is perhaps less "gentle" than the others. Here we address not only the language features that involve monads but also try to reveal the bigger picture: why monads are such an important tool and how they are used. There is no single way of explaining monads that works for everyone; more explanations can be found at haskell.org. Another good introduction to practical programming using monads is Wadler's Monads for Functional Programming [10].
A monad is constructed on top of a polymorphic type such as IO. The monad itself is defined by instance declarations associating the type with the some or all of the monadic classes, Functor, Monad, and MonadPlus. None of the monadic classes are derivable. In addition to IO, two other types in the Prelude are members of the monadic classes: lists ([]) and Maybe.
Mathematically, monads are governed by set of laws that should hold for the monadic operations. This idea of laws is not unique to monads: Haskell includes other operations that are governed, at least informally, by laws. For example, x /= y and not (x == y) ought to be the same for any type of values being compared. However, there is no guarantee of this: both == and /= are separate methods in the Eq class and there is no way to assure that == and =/ are related in this manner. In the same sense, the monadic laws presented here are not enforced by Haskell, but ought be obeyed by any instances of a monadic class. The monad laws give insight into the underlying structure of monads: by examining these laws, we hope to give a feel for how monads are used.
The Functor class, already discussed in section 5, defines a single operation: fmap. The map function applies an operation to the objects inside a container (polymorphic types can be thought of as containers for values of another type), returning a container of the same shape. These laws apply to fmap in the class Functor:
| fmap id | = | id |
| fmap (f . g) | = | fmap f . fmap g |
These laws ensure that the container shape is unchanged by fmap and that the contents of the container are not re-arranged by the mapping operation.

The signature of >>= helps
us to understand this operation: ma >>= \v -> mb
combines a monadic value ma containing values
of type a and a function which operates
on a value v of type a, returning the monadic value mb. The
result is to combine ma and mb into a
monadic value containing b. The >>
function is used when the function does not need the value produced by
the first monadic operator.
The precise meaning of binding depends, of course, on the monad. For example, in the IO monad, x >>= y performs two actions sequentially, passing the result of the first into the second. For the other built-in monads, lists and the Maybe type, these monadic operations can be understood in terms of passing zero or more values from one calculation to the next. We will see examples of this shortly.
The do syntax provides a simple shorthand for chains of monadic
operations. The essential translation of do is captured in the
following two rules:
do e1 ; e2 = e1 >> e2
do p <- e1; e2 = e1 >>= \p -> e2
When the pattern in this second form of do is refutable, pattern
match failure calls the fail operation. This may raise an error (as
in the IO monad) or return a "zero" (as in the list monad). Thus
the more complex translation is
do p <- e1; e2 = e1 >>= (\v -> case v of p -> e2; _ -> fail "s")
where "s" is a string identifying the location of the do statement
for possible use in an error message. For example, in the I/O monad,
an action such as 'a' <- getChar will call fail if the character
typed is not 'a'. This, in turn, terminates the program since in the
I/O monad fail calls error.
The laws which govern >>= and return are:
| return a >>= k | = | k a |
| m >>= return | = | m |
| xs >>= return . f | = | fmap f xs |
| m >>= (\x -> k x >>= h) | = | (m >>= k) >>= h |
The class MonadPlus is used for monads that have a zero element
and a plus operation:
class (Monad m) => MonadPlus m where
mzero :: m a
mplus :: m a -> m a -> m a
The zero element obeys the following laws:
| m >>= \x -> mzero | = | mzero |
| mzero >>= m | = | mzero |
For lists, the zero value is [], the empty list. The I/O monad has no zero element and is not a member of this class.
The laws governing the mplus operator are as follows:
| m `mplus` mzero | = | m |
| mzero `mplus` m | = | m |
The mplus operator is ordinary list concatenation in the list monad.
For lists, monadic binding involves joining together a set of
calculations for each value in the list. When used with lists, the
signature of >>= becomes:
(>>=) :: [a] -> (a -> [b]) -> [b]
That is, given a list of a's and a function that maps an a onto a
list of b's, binding applies this function to each of the a's in
the input and returns all of the generated b's concatenated into a
list. The return function creates a singleton list. These
operations should already be familiar: list comprehensions can easily
be expressed using the monadic operations
defined for lists. These following three
expressions are all different syntax for the same thing:
[(x,y) | x <- [1,2,3] , y <- [1,2,3], x /= y]
do x <- [1,2,3]
y <- [1,2,3]
True <- return (x /= y)
return (x,y)
[1,2,3] >>= (\ x -> [1,2,3] >>= (\y -> return (x/=y) >>=
(\r -> case r of True -> return (x,y)
_ -> fail "")))
This definition depends on the definition of fail in this monad as
the empty list. Essentially, each <- is generating a set of values
which is passed on into the remainder of the monadic computation.
Thus x <- [1,2,3] invokes the remainder of the monadic computation
three times, once for each element of the list. The returned
expression, (x,y), will be
evaluated for all possible combinations of bindings that surround it.
In this sense, the list monad can be thought of as describing
functions of multi-valued arguments. For example, this function:
mvLift2 :: (a -> b -> c) -> [a] -> [b] -> [c]
mvLift2 f x y = do x' <- x
y' <- y
return (f x' y')
turns an ordinary function of two arguments (f) into a function over
multiple values (lists of arguments), returning a value for each possible
combination of the two input arguments. For example,
| mvLift2 (+) [1,3] [10,20,30] | => | [11,21,31,13,23,33] |
| mvLift2 (\a b->[a,b]) "ab" "cd" | => | ["ac","ad","bc","bd"] |
| mvLift2 (*) [1,2,4] [] | => | [] |
This function is a specialized version of the LiftM2 function in the monad library. You can think of it as transporting a function from outside the list monad, f, into the list monad in which computations take on multiple values.
The monad defined for Maybe is similar to the list monad: the value Nothing serves as [] and Just x as [x].
Briefly, a state monad built around a state type S looks
like this:
data SM a = SM (S -> (a,S)) -- The monadic type
instance Monad SM where
-- defines state propagation
SM c1 >>= fc2 = SM (\s0 -> let (r,s1) = c1 s0
SM c2 = fc2 r in
c2 s1)
return k = SM (\s -> (k,s))
-- extracts the state from the monad
readSM :: SM S
readSM = SM (\s -> (s,s))
-- updates the state of the monad
updateSM :: (S -> S) -> SM () -- alters the state
updateSM f = SM (\s -> ((), f s))
-- run a computation in the SM monad
runSM :: S -> SM a -> (a,S)
runSM s0 (SM c) = c s0
This example defines a new type, SM, to be a computation that
implicitly carries a type S. That is, a computation of type SM t
defines a value of type t
while also interacting with (reading and writing) the state of type
S. The definition of SM is simple: it consists of functions that take a
state and produce two results: a returned value (of any type) and an
updated state. We can't use a type synonym here: we need a type name
like SM that can be used in instance declarations. The newtype
declaration is often used here instead of data.
This instance declaration defines the `plumbing' of the monad: how to sequence two computations and the definition of an empty computation. Sequencing (the >>= operator) defines a computation (denoted by the constructor SM) that passes an initial state, s0, into c1, then passes the value coming out of this computation, r, to the function that returns the second computation, c2. Finally, the state coming out of c1 is passed into c2 and the overall result is the result of c2.
The definition of return is easier: return doesn't change the state at all; it only serves to bring a value into the monad.
While >>= and return are the basic monadic sequencing operations, we also need some monadic primitives. A monadic primitive is simply an operation that uses the insides of the monad abstraction and taps into the `wheels and gears' that make the monad work. For example, in the IO monad, operators such as putChar are primitive since they deal with the inner workings of the IO monad. Similarly, our state monad uses two primitives: readSM and updateSM. Note that these depend on the inner structure of the monad - a change to the definition of the SM type would require a change to these primitives.
The definition of readSM and updateSM are simple: readSM brings the state out of the monad for observation while updateSM allows the user to alter the state in the monad. (We could also have used writeSM as a primitive but update is often a more natural way of dealing with state).
Finally, we need a function that runs computations in the monad, runSM. This takes an initial state and a computation and yields both the returned value of the computation and the final state.
Looking at the bigger picture, what we are trying to do is define an overall computation as a series of steps (functions with type SM a), sequenced using >>= and return. These steps may interact with the state (via readSM or updateSM) or may ignore the state. However, the use (or non-use) of the state is hidden: we don't invoke or sequence our computations differently depending on whether or not they use S.
Rather than present any examples using this simple state monad, we proceed on to a more complex example that includes the state monad. We define a small embedded language of resource-using calculations. That is, we build a special purpose language implemented as a set of Haskell types and functions. Such languages use the basic tools of Haskell, functions and types, to build a library of operations and types specifically tailored to a domain of interest.
In this example, consider a computation that requires some sort of
resource. If the resource is available, computation proceeds; when the
resource is unavailable, the computation suspends. We use the type R
to denote a computation using resources controlled by our monad.
The definition of R is as follows:
data R a = R (Resource -> (Resource, Either a (R a)))
Each computation is a function from available resources to remaining
resources, coupled with either a result, of type a, or a
suspended computation, of type R a, capturing the work done up
to the point where resources were exhausted.
The Monad instance for R is as follows:
instance Monad R where
R c1 >>= fc2 = R (\r -> case c1 r of
(r', Left v) -> let R c2 = fc2 v in
c2 r'
(r', Right pc1) -> (r', Right (pc1 >>= fc2)))
return v = R (\r -> (r, (Left v)))
The Resource type is used in the same manner as the state in
the state monad. This definition reads as follows: to combine two
`resourceful' computations, c1 and fc2 (a function producing
c2), pass the initial resources into c1. The result will be
either
This instance declaration defines the basic structure of the monad but
does not determine how resources are used. This monad could be
used to control many types of resource or implement many different
types of resource usage policies. We will demonstrate a very simple
definition of resources as an example: we choose Resource to be an
Integer, representing available computation steps:
type Resource = Integer
This function takes a step unless no steps are available:
step :: a -> R a
step v = c where
c = R (\r -> if r /= 0 then (r-1, Left v)
else (r, Right c))
The Left and Right constructors are part of the Either type.
This function continues computation in R by returning v so long as
there is at least one computational step resource available.
If no steps are available, the step function suspends the current
computation (this suspension is captured in c) and passes this
suspended computation back into the monad.
So far, we have the tools to define a sequence of "resourceful" computations (the monad) and we can express a form of resource usage using step. Finally, we need to address how computations in this monad are expressed.
Consider an increment function in our monad:
inc :: R Integer -> R Integer
inc i = do iValue <- i
step (iValue+1)
This defines increment as a single step of computation. The <- is
necessary to pull the argument value out of the monad; the type of
iValue is Integer instead of R Integer.
This definition isn't particularly satisfying, though, compared to the
standard definition of the increment function. Can we instead "dress
up" existing operations like + so that they work in our monadic
world? We'll start with a set of lifting functions. These
bring existing functionality into the monad. Consider the definition
of lift1 (this is slightly different from the liftM1 found in the
Monad library):
lift1 :: (a -> b) -> (R a -> R b)
lift1 f = \ra1 -> do a1 <- ra1
step (f a1)
This takes a function of a single argument, f, and creates a
function in R that executes the lifted function in a single step.
Using lift1, inc becomes
inc :: R Integer -> R Integer
inc i = lift1 (i+1)
This is better but still not ideal. First, we add lift2:
lift2 :: (a -> b -> c) -> (R a -> R b -> R c)
lift2 f = \ra1 ra2 -> do a1 <- ra1
a2 <- ra2
step (f a1 a2)
Notice that this function explicitly sets the order of evaluation in
the lifted function: the computation yielding a1 occurs before the
computation for a2.
Using lift2, we can create a new version of == in the R monad:
(==*) :: Ord a => R a -> R a -> R Bool
(==*) = lift2 (==)
We had to use a slightly different name for this new function since
== is already taken but in
some cases we can use the same name for the lifted and unlifted
function. This instance declaration allows
all of the operators in Num to be used in R:
instance Num a => Num (R a) where
(+) = lift2 (+)
(-) = lift2 (-)
negate = lift1 negate
(*) = lift2 (*)
abs = lift1 abs
fromInteger = return . fromInteger
The fromInteger function is applied implicitly to all integer
constants in a Haskell program (see Section 10.3);
this definition allows integer constants to have the type R Integer.
We can now, finally, write increment in a completely natural style:
inc :: R Integer -> R Integer
inc x = x + 1
Note that we cannot lift the Eq class in the same manner as the
Num class: the signature of ==* is not compatible with allowable
overloadings of == since the result of ==* is R Bool instead of
Bool.
To express interesting computations in R we will need a
conditional. Since we can't use if (it requires that the test be of
type Bool instead of R Bool), we name the function ifR:
ifR :: R Bool -> R a -> R a -> R a
ifR tst thn els = do t <- tst
if t then thn else els
Now we're ready for a larger program in the R monad:
fact :: R Integer -> R Integer
fact x = ifR (x ==* 0) 1 (x * fact (x-1))
Now this isn't quite the same as an ordinary factorial function but
still quite readable. The idea of providing new definitions for
existing operations like + or if is an essential part of creating
an embedded language in Haskell. Monads are particularly useful for
encapsulating the semantics of these embedded languages in a clean and
modular way.
We're now ready to actually run some programs. This function runs a
program in M given a maximum number of computation steps:
run :: Resource -> R a -> Maybe a
run s (R p) = case (p s) of
(_, Left v) -> Just v
_ -> Nothing
We use the Maybe type to deal with the possibility of the
computation not finishing in the allotted number of steps. We can now
compute
| run 10 (fact 2) | => | Just 2 |
| run 10 (fact 20) | => | Nothing |
Finally, we can add some more interesting functionality to this
monad. Consider the following function:
(|||) :: R a -> R a -> R a
This runs two computations in parallel, returning the value of the
first one to complete. One possible definition of this function is:
c1 ||| c2 = oneStep c1 (\c1' -> c2 ||| c1')
where
oneStep :: R a -> (R a -> R a) -> R a
oneStep (R c1) f =
R (\r -> case c1 1 of
(r', Left v) -> (r+r'-1, Left v)
(r', Right c1') -> -- r' must be 0
let R next = f c1' in
next (r+r'-1))
This takes a step in c1, returning its value of c1 complete or, if
c1 returns a suspended computation (c1'), it evaluates
c2 ||| c1'. The oneStep function takes a single step in its
argument, either returning an evaluated value or passing the remainder
of the computation into f. The definition of oneStep is simple:
it gives c1 a 1 as its resource argument. If a final value is
reached, this is returned, adjusting the returned step count (it is
possible that a computation might return after taking no steps so the
returned resource count isn't necessarily 0). If the computation
suspends, a patched up resource count is passed to the final
continuation.
We can now evaluate expressions like run 100 (fact (-1) ||| (fact 3)) without looping since the two calculations are interleaved. (Our definition of fact loops for -1). Many variations are possible on this basic structure. For example, we could extend the state to include a trace of the computation steps. We could also embed this monad inside the standard IO monad, allowing computations in M to interact with the outside world. While this example is perhaps more advanced than others in this tutorial, it serves to illustrate the power of monads as a tool for defining the basic semantics of a system. We also present this example as a model of a small Domain Specific Language, something Haskell is particularly good at defining. Many other DSLs have been developed in Haskell; see haskell.org for many more examples. Of particular interest are Fran, a language of reactive animations, and Haskore, a language of computer music.


- Interests
- Speciality Coffee
- My husband and dog
- Drake, Rihanna, and Beyonce
- Education
- The New School/ B.A. Sociology
- Spring 2015. New York, NY
- Work Experience
- Victrola Coffee Roasters/ Barista
- October 2015-Current
- Birch Coffee/ Shift Lead
- January 2015-October 2015
- Why Programming?
- Technology is the future. As the world goes through technological advances, the way we interact with everything is going to shift. I want to be apart of the future. I want to help program the first spaceship to carry humans to a different galaxy. I want to build a virtual reality where you can dual like in Harry Potter. Epicodus is my first step into that- the future.


org.apache.fop.render.ps
Class PSPageDeviceDictionary
java.lang.Object
java.util.AbstractMap
java.util.HashMap
org.apache.fop.render.ps.PSDictionary
org.apache.fop.render.ps.PSPageDeviceDictionary
- All Implemented Interfaces:
- java.lang.Cloneable, java.util.Map, java.io.Serializable
- public class PSPageDeviceDictionary
- extends PSDictionary
Postscript page device dictionary object
This object is used by the postscript renderer to hold postscript page device
values. It can also be used to minimize the number of setpagedevice calls when
DSC compliance is false.
- See Also:
- Serialized Form
|
Method Summary |
void |
clear()
|
java.lang.String |
getContent()
Returns a dictionary string with containing all unwritten content note:
unnecessary writes are important as there is a device specific
initgraphics call by the underlying postscript interpreter on every
setpagedevice call which can result in blank pages etc. |
boolean |
isEmpty()
Returns true if this map contains no key-value mappings. |
java.lang.Object |
put(java.lang.Object key,
java.lang.Object value)
|
void |
setFlushOnRetrieval(boolean flushOnRetrieval)
The contents of the dictionary are flushed when written |
| Methods inherited from class java.util.HashMap |
clone, containsKey, containsValue, entrySet, get, keySet, putAll, remove, size, values |
| Methods inherited from class java.lang.Object |
finalize, getClass, notify, notifyAll, wait, wait, wait |
PSPageDeviceDictionary
public PSPageDeviceDictionary()
put
public java.lang.Object put(java.lang.Object key,
java.lang.Object value)
- Parameters:
key
- key with which the specified value is to be associated.value
- value to be associated with the specified key.
- Returns:
- the previous value associated with the key or null
- See Also:
Map.put(Object, Object)
clear
public void clear()
- See Also:
Map.clear()
isEmpty
public boolean isEmpty()
- Returns true if this map contains no key-value mappings.
- Returns:
- true if this map contains no key-value mappings.
setFlushOnRetrieval
public void setFlushOnRetrieval(boolean flushOnRetrieval)
- The contents of the dictionary are flushed when written
- Parameters:
flushOnRetrieval
- boolean value
getContent
public java.lang.String getContent()
- Returns a dictionary string with containing all unwritten content note:
unnecessary writes are important as there is a device specific
initgraphics call by the underlying postscript interpreter on every
setpagedevice call which can result in blank pages etc.
- Returns:
- unwritten content dictionary string
Copyright 1999-2008 The Apache Software Foundation. All Rights Reserved.


--- title: 'Android development on Samsung Galaxy:' date: '2010-01-31T15:49:23+05:30' tags: - mobile tumblr_url: https://sureshshanmugam.com/post/363000055/android-development-on-samsung-galaxy ---
I got a new phone - Samsung i7500 Galaxy. Looks like it is going to be more fun than my older phones.
1. Samsung i7500 Galaxy runs the Android 1.5 platform. So I downloaded the sdk tools from google and then followed their readme to get started with getting the 1.5 platform specific downloads on my mac.
2. I got the Galaxy skin from rexxar, for better looks. Got eclipse and ran couple of examples on the phone.
Now I need to implement couple of ideas for the phone, first the indian real time stock market app in similar lines to google finance app and notes app which is simple enough and syncs with my dropbox account.


What is the Enumerable Module?
The Enumerable Module, is a module that you can mix in. OK, let’s stop right there. Have I already lost you? Let’s trying breaking it down into smaller components.
First of all, what is a module? A module is a toolbox that contains set methods and constants. There are so many Ruby tools in the toolbox that you will want to use, but if Ruby loaded them all every single time it ran, then it would become cluttered. Besides, even though you will want to use each tool, you will be using them at different times. Therefore, we keep them in modules and only pull out the module toolboxes when we need to use something stored inside of it!
That makes sense. So what is a mixin? That is when you mix together the behaviors of a module and a class. When a module is used to mix additional behavior and information into a class, it’s called a mixin. Coming back full circle to the Enumerable Module, can you guess what it is now? It’s a bunch of methods that work with collections. It’s essentially just a giant toolbox that we can take tools out of and use at our leisure!
The Enumerable Module empowers mostly the Array and Hash classes. You can read more about those here.
Stop Writing “For” Loops
A class that uses or “mixes in” the Enumerable Module must define the #each method. The #each method looks like this:
This method is surprisingly straightforward once the syntax is explained. For each number in the Array, I named the number “n” (But you can name it whatever you would like… “number” or “days_without_you” or anything!) and then I put “n”. This will simply list out each number:
You can manipulate “n” in a bunch of ways, depending on what you are trying to do. With each element in the array, it will execute the given block. The Enumerable Module is a toolbox of methods building upon this method. Just to name a few: all?, any?, collect, detect, each_cons, each_slice, each_with_index, enum_cons, enum_slice, enum_with_index, find, find_all, grep, include?, inject, map, max, member?, min, partition, reject, select, sort, sort_by, to_a, to_set, zip. Phew!
#map
Let’s start with an easy method, #map. This method is extremely similar to the #each method, but with one big difference. #each simply iterates over the given enumerable, running the block for each value. It dismisses the return value of the block after the method is complete. For example:
# => [4, 5, 6]
On the other hand, #map returns a new object with the changes that you make inside of the block.
# => [2, 3, 4]
Therefore it “maps” each element to a new one. It is also worth noting that #map doesn’t set an values in the original collection, but only in the returned copy of it. Also, #map and #collect are exactly the same! I have seen #map used more in practice, so I would recommend sticking with that one, but it doesn’t really matter too much.
#group_by
Can you guess what this method does just by seeing the name? That’s the entire point of Ruby – to be a programmer-friendly language! The fact that it is so easily readable is what makes it great. Let’s check out an example of #group_by:
As you can see, this method grouped each of our numbers according to their divisibility by 3. It groups the collection by the result of the block, and returns a hash where the keys are the evaluated result from the block, and the values are arrays of elements that correspond to the key.
#cycle
The last method in the Enumerable Module that we will look at today is #cycle. This method calls the block for each element repeatedly for “n” times, or forever is no time was given. If a negative integer is given or the collection is empty, then it does nothing.
And that’s it! If you have some extra time to spare, go ahead and check out the Ruby Docs on the Enumerable Module and try out some more methods!
If you have any questions or comments, please send me either an email or a tweet. Happy coding!
Posted by Morgan McCrory


--- title: Beach Camp keywords: off-site, beach, surfing, swimming, kayak, camping description: Beach Camps travel off-site to the beautiful Monterey Bay for surf lessons, boogie boarding, and camping out on the beach. name: Beach Camp --- {% block MainText %} {{ macros.render_camp_info() }}
Mt. Cross is taking camp to the beach! Each day our beach campers will travel with their cabin groups to one of the sunny beaches of Santa Cruz. Highlights of this camp will include boogie boarding, professional surfing lessons, delicious picnic lunches, a special campfire worship on the beach, high ropes and other special activities. This program is perfect for campers who are looking for a new and exciting camp experience.
Limit 24 campers per session.
*Fees include professional surfing instruction and equipment package.
Sunday
Arrive & Check-in
Challenge Course
Monday
Low Ropes & Beach time
Tuesday
Day at the Beach
Wednesday
Surfing Lessons
Campfire on the beach
Thursday
High Ropes Course
Special Beach Activities
Friday
Closing program


Zoomooz.js
Zoomooz is: 6KB gzipped and 18KB minified. This includes everything but jQuery.
Make any web page zoom.
Zoomooz is a jQuery plugin for making web page elements zoom. It can be used for making Prezi like slideshows and for zooming to images or other details.
Quirky transformations
You can zoom to elements that have been translated, scaled and skewed, and they will morph correctly.
Try by clicking on these:
There is some interesting stuff happening in the background to make the morphings work. To learn about them, read the Animate between complex transforms wiki page.
Adding Zoomooz to your web page
Just add this to your web page head and you should be up and running with Zoomooz:

The easy way to zoom
Simply add "zoomTarget" to the element you want to zoom to when clicked on:

This element zooms when clicked on.

You can also add some additional attributes for tuning the animation as data fields of the element:

This element zooms when clicked on.

For documentation of the data fields, have a look at the Settings section.
Note, that adding Zoomooz to your existing web site without doing any markup changes might not work, since calculating exact positions and transformations in browsers is a bit of tricky.
Starting with one of zoomooz examples or an empty page with minimal css markup is easier to get working than to try to bolt zoomooz into an existing, complex web page.
Here is a demo, click on the elements:
By adding a "data-closeclick" value to a zoom target, you can make the image zoom out when the element is clicked for second time, see here:
(click twice)
(click twice)
(click twice)
Zooming inside a container
You can make only part of the page zoom by adding two blocks outside the zooming elements, a "zoomContainer" and outside it a "zoomViewport":

Target 1

Target 2

Here is a demo, click on the elements:
Adding prev/next buttons
You can also add previous and next buttons for zooming to elements in a specific order. You can use this to make slide shows, for example.
To do this, add "zoomButton" elements to control the animation:

Target 1

Target 2

Here is a demo, try clicking on the arrow buttons:
Zooming jQuery way
To make an element zoom when clicked on, you can use "zoomTarget(...)":
$(document).ready(function() {
$("#element").zoomTarget();
});
This automatically makes also the parent element clickable for the user to be able to zoom back.
Another alternative is to handle the zooming yourself, with something like:
$(document).ready(function() {
$("#element").click(function(evt) {
$(this).zoomTo({targetsize:0.75, duration:600});
evt.stopPropagation();
});
});
This is more flexible, but won't give you all the automagical niceties, such as a nice pointer cursor when hovering over the element.
Settings
There are a number of settings you can add to the "zoomTarget" elements and pass to "zoomTo" functions in a map. The settings configure how the zooming behaves.
For elements with the "zoomTarget" class, you can set the settings by adding a "data-settingname" attribute to the element, for example:

Click me

List of all settings:
settings = {
// zoomed size relative to the container element
// 0.0-1.0
targetsize: 0.9,
// scale content to screen based on their size
// "width"|"height"|"both"
scalemode: "both",
// animation duration
duration: 450,
// easing of animation, similar to css transition params
// "linear"|"ease"|"ease-in"|"ease-out"|"ease-in-out"|[p1,p2,p3,p4]
// [p1,p2,p3,p4] refer to cubic-bezier curve params
easing: "ease",
// use browser native animation in webkit, provides faster and nicer
// animations but on some older machines, the content that is zoomed
// may show up as pixelated.
nativeanimation: true,
// root element to zoom relative to
// (this element needs to be positioned)
root: $(document.body),
// show debug points in element corners. helps
// at debugging when zoomooz positioning fails
debug: false,
// this function is called with the element that is zoomed to in this
// when animation ends
animationendcallback: null,
// this specifies, that clicking an element that is zoomed to zooms
// back out
closeclick: false
}
// settings can be set for both the zoomTo and zoomTarget calls:
$("#element").zoomTo(settings);
Browsers and platforms
Zoomooz works quite reliably on Firefox 3.6 or newer, on Safari 3 or newer and on recent versions of Chrome. Based on a quick test, seems to work fine on IE9 as well, but there may be bugs. Opera support has not been tested recently.
The only large group of users that is not supported at all is those still stuck with IE8. Luckily, the share of IE8 users is currently 11% and it is dropping quickly.
Zoomooz requires 1.4. or newer and has been tested with jQuery 1.9.
iPhone and iPad
Zoomooz works even on iPad and iPhone. Watch a video of Zoomooz on a first generation iPad.
Currently the zooming inside a container works much better on them than zooming the whole page. Whole page zooming can be made to work if "overflow:hidden" is set for the "html" and "body" elements, but then the page scrolling is lost.
Demos
Have a look at these:
Praise for Zoomooz
Here are some positive comments tweeted about Zoomooz:
The fantastic Javascript zooming library has been updated to work with Firefox 4.
— @azaaza
Really awesome example of a zoomable interface with JavaScript
— @tdhooper
Amazing little js library for zooming and rotating that works with JQuery
— @mike_j_edwards
#prezi like styles for your own website. damn cool and pretty easy
— @wollepb
Zoomooz in use
Some people have been brave enough to try out zoomooz themselves. Have a look at the links below and let me know if you have used it!
Very creative use of Zoomooz in this French presidential campaign web site
Aza Raskin prototyping with Zoomooz and showing how to live code in front of seventy-five people.
A photo gallery using Zoomooz for Antoine Giraldo.
A zooming comic experiment by Richard Milewski.
A virtual educational collage tool for classrooms that uses Zoomooz by Opinsys. Just create a new "pahvi", add some objects and browse in "presentation mode".
Simple HTML Slides by Richard Milewski uses Zoomooz.
A (slightly outdated) Zoomooz tutorial on Design Shack has a nice thumbnail gallery example.
Known issues & troubleshooting
Some known issues:
- On iOs devices, zooming inside container sometimes freezes the scrolling. Haven't investigated what is causing this.
- Margins on zoomable elements can cause problems.
- Having a main container inside the body tag sometimes helps with full page zooming.
- Small text renders ugly. See this example for a hack to work around this.
- Rotation goes sometimes via the wrong direction.
Building
Easiest way to use Zoomooz is to use the pre-generated "jquery.zoomooz.min.js" file. However, you may also combine and minify the javascript files by yourself.
For build instructions, have a look at the Zoomooz github page.
Related Zooming projects
Impress.js by Bartosz Szopka is an interesting take on making Prezi like slides on the web. Harish Sivaramakrishnan has started to make an editor called Impressionist for Impress.js.
Jmpress.js is a jQuery port of Impress.js with some extra features.
Presenteer.js by Willem Mulder is also a bit similar to Impress.js and Zoomooz.
Another similar project is zoom.js by Hakim Elhattab, although it would seem to be currently mostly a proof of concept
A different approach to Zooming in ZUI53 library, using pinch zoom / scroll wheel.
The whole idea of zooming to content comes from a long line of user interface research related to zooming ui:s (ZUI:s). One starting point for these is the Zooming user interface Wikipedia page.
Other links
Zoomooz uses a smart easing that works the same way as css animation easings. If you'd like to use it with other jQuery animations, check out jquery.easie.js.


Overview
Parslet is a library with a clear philosophy: It makes parser writing easy and testable. On top of that, it provides understandable error messages (“General Protection Fault”) to you, the language writer. In extension, you will hopefully manage to provide good error messages to your users. Together, we can create a better world!
Traditional texts on the subject will have you write a compiler or interpreter for a language in several stages:
- Parsing or Lexing/Parsing
- Abstract Syntax Tree construction
- Optimization and checking of the tree
- Generation of code / Execution
This library will be good for the first two stages only. After that, you’ll be on your own.
The parsing step has literally been implemented by hundreds (thousands) of clever people; No lack of alternatives. Even in Ruby, you’ll have the choice among a handful of libraries. There’s a distinction to make on this level as well:
LRk parsers and related fields Parsers in this class use a lexical analyzer (a lexer ) to transform the input text into tokens (tokenizing ). They then check if your stream of tokens has a corresponding tree that conforms to the grammar. Most of these parsers allow grammars that are ambiguous and will provide a mechanism for resolving the arising ambiguities. These are the earliest parser generators and the most widely used (yacc, bison, …) — chances are, you’ll have more than one of these libraries installed on your system.
PEG or packrat parsers Parsers in this class are based on a slightly more modern algorithm, which translates what one does when writing a parser by hand in top-down fashion. This is what we programmers do all over, methods calling methods – and its also (grossly) what these parsers do to recognize input. Left recursion is impossible to express in these grammars. No lexers are required – lexical tokenizing and parsing are one single step. Ruby has several implementations of this algorithm in library form: Treetop, Citrus, rsec and of course Parslet.
All of these generators are different in small ways; yet most implement common patterns and provide almost identical APIs. We believe this is an error: choice is good, but there should be visible attributes distinguishing the choices.
Parslet is not like the others, in fact it is radically different on some key elements.
Writing a language
Whether you write a language for a configuration file or a new computer language (the holy grail), the steps are always the same:
- Create a grammar: What should be legal syntax?
- Annotate the grammar: What is important data?
- Create a transformation: How do I want to work with that data?
The creation of grammars and the various concepts that are associated are treated in Parslet::Parser.
Transformation of the resulting intermediary tree is treated in Parslet::Transform


--- layout: post title: Lamb Shank and Veggie Soup date: 2012-03-07 11:31:40.000000000 -05:00 categories: [] tags: [] status: publish type: post published: true meta: aktt_notify_twitter: 'no' _edit_last: '1' dsq_thread_id: '1188598651' author: login: cint email<EMAIL_ADDRESS>display_name: Jacinta first_name: Jacinta last_name: '' ---
This is an all time favourite of mine. It brings back memories of sitting in my nana's kitchen, enjoying every flavoursome mouthful of homemade soupy goodness. I loved nana's soup so much, I requested it every time we went to visit. She always made the same soup and I never tired of it, ah yes, food for the soul. Nana used to add a few more ingredients, but I have simplified the recipe over the years without compromising the flavour.
I have made this recipe both on the stove top and using the slow cooker. The slow cooker certainly produces a more flavoursome soup.
Ingredients:
2 lamb shanks
2 onions, coarsely chopped
2 cloves garlic, crushed
2-4 carrots, depending on size, coarsely chopped
6 celery stems, coarsely chopped
1/2 cup pearl barley
stock powder to taste
approximately 3 litres water
1 tbsp oil
(cream optional)
Method for slow cooker:
Cooking time may vary depending on individual slow cookers
place oil and onions in a pan and cook for 2 minutes. Add lamb shanks and brown slightly. Place onions and lamb shank into slow cooker along with the other ingredients, except pearl barley. Pour in water. Cook on high for approximately 6 hours. (I often put the soup on in the evening and cook on low overnight for approximately 8-10 hours).
Carefully remove lamb shanks, ensuring there is no bone left in slow cooker. Cut off meat and set aside. With a slotted spoon, scoop out most of the veggies. When cooled slightly, place them in a food processor and blend until smooth. Add the blended veggies back into the soup along with the meat and pearl barley. Continue to cook until barley is tender. Add stock powder to taste. Serve with buttered toast if desired. For a creamy soup, once served, add a dollop of cream.
Method for stove top:
Add oil and onions to a large pot. Cook for 2 minutes. Add lamb shanks and brown on all sides. Add the garlic, carrots and celery. Pour in water and simmer soup for at least 1-2 hours, stirring occasionally. Carefully remove lamb shanks, making sure no bones are left behind. Once cool enough, cut off meat and set aside.
With a slotted spoon, scoop out most of the veggies. When they are cooled slightly, place them in a food processor and blend until smooth. Add the blended veggies back into the soup along with the meat and pearl barley. Continue to cook until barley is tender. Add stock powder to taste. Serve with buttered toast if desired. For a creamy soup, once soup is served, add a dollop of cream.
[caption id="attachment_1520" align="aligncenter" width="375" caption="This boy of mine love his soup too, or "zoop" as he calls it."][/caption]
Enjoy! Jacinta x


"ABIRAM "father of height; i.e., “proud.” (1.) One of the sons of Eliab, who joined Korah in the conspiracy against Moses and Aaron. He and all the conspirators, with their families and possessions (except the children of Korah), were swallowed up by an earthquake (Numbers 16:1-27; 26:9; Psalm 106:17). (2.) The eldest son of Hiel the Bethelite, who perished prematurely in consequence of his father’s undertaking to rebuild Jericho (1 Kings 16:34), according to the words of Joshua (6:26). (See JERICHO.)
"ABIRAM "father of height; i.e., “proud.” (1.) One of the sons of Eliab, who joined Korah in the conspiracy against Moses and Aaron. He and all the conspirators, with their families and possessions (except the children of Korah), were swallowed up by an earthquake (Numbers 16:1-27; 26:9; Psalm 106:17).
(2.) The eldest son of Hiel the Bethelite, who perished prematurely in consequence of his father’s undertaking to rebuild Jericho (1 Kings 16:34), according to the words of Joshua (6:26). (See JERICHO.)


Email Notifications
We will never spam you. We only send emails for things such as bet invites and bets marked as complete.
Push Notifications
Always keep up to date with your bets on the go. (Coming Soon!)
Max Bet Amount
Just in case you want a reminder to not bet too much.


Reimbursements
Reimbursement ID
Employee ID
Event Date
Request Date
Location
Amount
Description
Event Type
Grade Type
Status M
Status DH
Status BC
Grade Value
Passing Grade
Urgent
Back to Homepage


Toggle navigation
Year Plan Edit
Product
-- All --
ABS
AS
BE
CC-DA
CM-DCU
Family/Group
-- All --
BK2A
BK2C
EPSc
ESL3
Year
-- All --
2016
2017
2018
2019
2020
Status
-- All --
Active
InActive
Approval Status
-- All --
Approved
Back to revise
Cancel
Draft
Pending Approval
Rejected
Location
-- All --
Suzhou
Wujin
Effective Date
Expire Date
Import
Export
Query
Rev.
Product
Family/Group
BK2A
BK2C
EPSc
EPSc JAC
ESL3
Year
2016
2017
2018
2019
2020
Location
Suzhou
Wujin
PPZ
×
From week
To week
Desciption
Priority
Reference PN
操作
-- All --
High
Medium
Low
-- All --
ABS9M Line
Dip Coating1
删除


{% extends 'base.html' %} {% block content %} {% if user.is_authenticated %} {% if player.is_banned %}
You have been banned. Make a new account, try to be less like your old self. Or leave.
You are logged in as {{ user.username }} aka {{ player.name }}
{{ player.hp_current }} / {{ player.hp_max }} HP
{{ player.power_crystals }} Power Crystals
{{ player.gold }} Gold
Sorry, I am saving all my new names for the not dead. (You are very dead).
Please go and see if some other god will help you, I will not.
[Try a different god] {% else %}You are logged in as {{ user.username }} aka {{ player.name }}
{{ player.hp_current }} / {{ player.hp_max }} HP
{{ player.power_crystals }} Power Crystals
{{ player.gold }} Gold
Welcome person or persons incorperated puppeting the recent remains of a person. Do you wish to change your or your skinbags name?
{% endif %} {% endif %} {% else %}Please log in or register to play


{% extends 'base.html' %} {% block content %}
Connect all communities at ALU under one platform to share our community news and opportunities all around the world


×
Settings
Staff Profile Records
×
Create a new staff profile record entry
Record Name
Record Type
Noun (A word that indicates a name)
Text (An address, a description, etc)
Number (An integer or fractional based number)
Date (includes time)
File (A picture, a scanned document, a binary file, etc)
Record Description
×
Modify staff profile record
Record Name
Record Description