text:
![Build Status](https://api.travis-ci.org/justinvdm/sig.png)

high-level reactive-style programming in javascript

```javascript
var s = sig()

s.map(function (x) {
  return x + 1
})
  .filter(function (x) {
    return !(x % 2)
  })
  .each(sig.log)
  .done()

s.put(1) // 2
  .put(2)
  .put(3) // 4
```

## docs

- [overview](#overview)
- [api](#api)
- [install](#install)

## overview

### sources and targets

Signals can have at most one source and multiple targets, where values and
errors flow from the source to its targets.

### value propagation

Values propagate from a source signal to its target signals using
[`.put()`](#put). `.put()` sends the given value to the value handler of each of
its targets. [`.then()`](#then-fn) is used to create a new target signal with a
given handler function. To further propagate the value, handler functions should
use `.put()` to send the value from the relevant signal (provided as the `this`
context) to its target signals. Once the the handler function has completed its
processing, it should tell the signal that its ready to handle the next value or
error using [`.next()`](#next).

```javascript
var s = sig()

var t1 = s.then(function (v) {
  this.put(v + 1).next()
})
var u1 = t1.each(sig.log)
u1.done()

var t2 = s.then(function (v) {
  this.put(v * 2).next()
})
var u2 = t2.each(sig.log)
u2.done()

s.put(3)
// -- s --
// | 3   | 3
// v     v
// t1    t2
// | 4   | 6
// v     v
// u1    u2
```

If any new values or errors are received before `.next()` has been called, they
will get buffered, then popped off once the signal is ready to process them.

Since sychronous handlers are likely to always call `.next()` at the end,
[`.each()`](#each) is available as a thin wrapper around `.then()` that calls
`.next()` itself once the given function has been called.

### error handling

Errors propagate from a source signal to its target signals using
[`.throw()`](#throw), much in the same way values propagate with
[`.put()`](#put). [`catch`](#catch) is used to create a new target signal with a
given error handler. As is the case for value propagation, the error handler
needs to call [`.next()`](#next) to tell the signal to handle the next value or
error.

```javascript
var s = sig()

var t1 = s.catch(function (e) {
  this.throw(e).next()
})
var u1 = t1.catch(sig.log)
u1.done()

var t2 = s.catch(function (e) {
  this.throw(e).next()
})
var u2 = t2.catch(sig.log)
u2.done()

s.throw(new Error('o_O'))
// ---- s ----
// | o_O     | o_O
// v         v
// t1        t2
// | o_O     | o_O
// v         v
// u1        u2
```

Error handler functions can also propagate values, which is useful for cases
where a signal can recover from an error.

```javascript
var s = sig()

s.catch(function () {
  this.put(null).next()
})
  .each(sig.log)
  .done()

s.put(21) // 21
  .throw(new Error('o_O')) // null
  .put(23) // 23
```

If an error has put the signal into a state it cannot recover from,
[`.kill()`](#kill) can be used to end the signal, regardless of whether there
are still values to be sent.

```javascript
var s = sig()
  .catch(function () {
    this.kill()
  })
  .done()
```

Note that `.throw()` and `.catch()` should always be used as a way to propagate
and handle errors occuring in a chain of signals, as opposed to javascript's
native `throw` and `try`-`catch` error handling, since signal processing can
occur asynchronously (depending on how sig is being used).

### ending chains

Once a signal chain has been set up, and values and errors can not propagate any
further, [`.done()`](#done) should be used to declare the end of the signal
chain. Once the end of the signal chain is declared, the signals in the chain
are [`unpaused`](#pausing-resuming) for the first time to allow values and
errors to start propagating.

```javascript
sig([23])
  .each(sig.log) // (nothing has been logged yet)
  .done() // 23 (the chain has been started, `23` has been logged)
```

If no function is given to `.done()`, it will rethrow unhandled errors using
javascript's native `throw`, then kill the last signal in the chain with
[`.kill()`](#kill).

```javascript
var s = sig()

s.map(function (v) {
  return v + 1
})
  .filter(function (x) {
    return !(x % 2)
  })
  .each(sig.log)
  .done()

s.put(1) // 2
  .put(2)
  .put(3) // 4
  .throw(':/') // Error: :/
```

`.done()` accepts a node.js-style callback function. If an error reaches the end
of the signal chain, the callback function is called with the error as its first
argument, then the last signal in the chain is killed using [`.kill()`](#kill).

```javascript
var s = sig()

s.map(function (v) {
  return v + 1
})
  .filter(function (x) {
    return !(x % 2)
  })
  .each(sig.log)
  .done(function (e) {
    sig.log(e || 'done!')
  })

s.put(1) // 2
  .put(2)
  .put(3) // 4
  .throw(':/') // :/
  .put(4)
  .put(5)
```

If a signal in the chain has ended, the callback function is invoked without any
arguments.

```javascript
var s = sig()

s.map(function (v) {
  return v + 1
})
  .filter(function (x) {
    return !(x % 2)
  })
  .each(sig.log)
  .done(function (e) {
    sig.log(e || 'done!')
  })

s.put(1) // 2
  .put(2)
  .put(3) // 4
  .end() // done!
```

If any values propogate to the end of the signal chain, [`.done()`](#done) will
discard them.

```javascript
// nothing will get logged, `.done()` has discarded the values
sig([1, 2, 3]).done().each(sig.log)
```

### disposal

When a signal is no longer needed, [`.end()`](#end) should be used. Ending a
signal causes the signal to end each of its targets (and in turn, each target
will end their own targets) and [disconnects](#disconnects) the signal from its
source. Once the signal no longer has buffered values that it needs to send, its
[teardowns](#teardown) are called, its state is cleared and it is marked as
ended. Signals marked as ended treat [`.put()`](#put), [`.throw()`](#throw) and
[`.then()`](#then-fn) as no-ops. The immediate disconnecting of a signal is
necessary to avoid memory leaks caused by signals with buffers that never clear.

```javascript
var s = sig()

s.each(sig.log).done()

s.teardown(sig.log, 'ended').pause().put(23).end()

s.resume()
// 23
// ended
```

If the signal needs to be ended immediately, regardless of whether it still has
values it needs to send, [`kill`](#kill) should be used.

```javascript
var s = sig()

s.each(sig.log).done()

s.teardown(sig.log, 'ended').pause().put(23).kill() // ended
```

Note that creating signals without ending them when their work is done will lead
to memory leaks for the same reasons not removing event listeners will when
using an event listener pattern.

### disconnects

When a signal is ended, the chain of signals ending with it (if any) will no
longer be sending values to it, so it can be removed from the chain. However,
other signals in the chain cannot be ended, as sibling targets (targets with the
same source) might still be around listening for new values. To prevent chains
of unused target signals being kept in memory as a result of this, source
signals forget a target signal when the target no longer has its own targets,
putting the target in a 'disconnected' state. Targets keep a reference to their
source, so a signal chain will be reconnected if a new target gets added at the
end of the chain.

```javascript
var a = sig()
var b = sig()
var c = sig()
var d = sig()
var e = sig()

a.then(b)
b.then(c).done()
b.then(d).done()
//       a
//       |
//       v
//  ---- b
// |     |
// v     v
// c     d     e

c.end()
//       a
//       |
//       v
//       b
//       |
//       v
// c     d     e

d.end()
//       a
//
//
//       b
//
//
// c     d     e

b.then(e).done()
//       a
//       |
//       v
//       b ----
//             |
//             v
// c     d     e
```

### pausing and resuming

When a signal is paused using [`pause`](#pause), any values given to it by
[`put`](#put) are buffered. When the signal is resumed using
[`resume`](#resume), any buffered values are sent to the signal's targets, and
any new values will be sent straight to the signal's targets (and not get
buffered).

```javascript
var s = sig()

s.each(sig.log).done()

s.pause().put(21).put(23)

s.resume()
// 21
// 23
```

Note that signals start off paused and are unpaused for the first time either
once the [end of the signal chain](#ending-chains) is declared or once
[`.resume()`](#resume) is called explicitly.

### redirection

Sometimes, a function will return a single signal, though it has created one or
more signal chains to send values to the returned signal.

Redirecting using [`.put()`](#put) from a different signal's value handling
function will cause the signal to continue running indefinitely instead of
disconnecting with its targets:

```javascript
function join(a, b) {
  var out = sig()
  var badRedirA = a.each(badRedir)
  var badRedirB = b.each(badRedir)

  function badRedir(v) {
    out.put(v)
    this.next()
  }

  return out
}

var a = sig()
var b = sig()
var out = join(a, b)
var logOut = out.each(sig.log)
logOut.done()

// single line for targets, double line for redirections
//
//   a                      b
//   |                      |
//   v                      v
// badRedirA ==> out <== badRedirB
//                |
//                v
//             logOut

a.put(21) // 21
b.put(23) // 23

out.end()

// redirA and redirB are still connected :/
//
//   a                  b
//   |                  |
//   v                  v
// redirA ==> out <== redirB
//
//
//          logOut
```

To redirect without this unwanted behaviour, [`.to()`](#to) should be used to
redirect values and errors to the returned signal, and to set these chains to
disconnect when the returned signal is disconnected.

If a function creates a signal chain, but the chain isn't returned, redirected
or ended, this will lead to memory leaks. Rule of thumb: If you have a signal
that outputs values, either return the signal, or redirect it to another
returned signal.

```javascript
function join(a, b) {
  var out = sig()
  var redirA = a.to(out)
  var redirB = b.to(out)
  return out
}

var a = sig()
var b = sig()
var out = join(a, b)
var logOut = out.each(sig.log)
logOut.done()

// single line for targets, double line for redirections
//
//   a                  b
//   |                  |
//   v                  v
// redirA ==> out <== redirB
//             |
//             v
//          logOut

a.put(21) // 21
b.put(23) // 23

out.end()

// redirA and redirB are disconnected!
//
//   a                  b
//
//
// redirA     out     redirB
//
//
//          logOut
```

Note that [`.to()`](#to) calls [`.done()`](#done). This means calling
[`.to()`](#to) declares the end of a signal chain and starts the signal chain,
and [`.done()`](#done) does not need to be called on redirected chains.

### sticky signals

Sometimes, a signal needs to hold onto the last value it has sent out. When new
targets arrive, they need to receive this last value instead of having them
'miss the bus' and only receive new values sent from the source signal. Sticky
signals allow this.

Sticky signals can be created using [`val`](#val).

```javascript
var v = sig.val(23)
v.each(sig.log) // 23
v.each(sig.log) // 23
```

## api

#### `sig([values])`

Creates a new signal. If a `values` array is given, it is used as the initial
values sent from the signal.

```javascript
var s = sig([1, 2, 3])
```

### functions and methods

The following sig methods are also accessible as static functions taking a
signal as the first argument:

`put`, `then`, `done`, `next`, `end`, `kill`, `resolve`, `putTo`, `putEach`,
`throw`, `catch`, `teardown`, `pause`, `resume`, `map`, `each`, `tap`, `filter`,
`flatten`, `limit`, `once`, `then`, `to`, `redir`, `update`, `append`, `call`,
`event`

For example, using the static counterpart of [`.put`](#put) would look something
like:

```javascript
var s = sig()

s.each(sig.log).done()

sig.put(s, 21) // 21
sig.put(s, 23) // 23
```

### event catalogue

#### `disconnect`

Emitted when a connected signal [disconnects](#disconnects).

#### `reconnect`

Emitted when a disconnected signal [reconnects](#disconnects).

#### `flush`

Emitted _after_ a signal has propagated any buffered values or errors, if any,
after being [resumed](#pausing-resuming).

#### `end`

Emitted once a signal is about to end, _before_ the signal clears its state and
gets marked as ended. See [disposal](#disposal).

#### `ending`

Emitted once a signal has been scheduled to end via [.end()](#end) or
[.kill()](#kill). See [disposal](#disposal).

### `.put([v])`

Puts the value `v` through the signal, where `v` can be a value of any type.

```javascript
var s = sig()

s.each(sig.log).done()

s.put(21) // 21
  .put(21) // 23
```

### `.next()`

Tells the calling signal that it is done processing its most recent value or
error, if any, and is ready to processing the next value or error.

```javascript
var s = sig()
var t = s.then(sig.log)
t.done()

s.put(1) // 1
  .put(2)

t.next() // 2
```

### `.throw(e)`

Propogates the error instance `e` from the signal.

```javascript
var s = sig()

s.catch(sig.log).done()

s.throw(new Error('o_O')) // o_O
```

### `.end()`

Ends the given signal, causing it to end its target signals and disconnect from
its source, then clear its state once the signal no longer has values to send.
See [disposal](#disposal).

```javascript
var s = sig()

s.each(sig.log).done()

s.put(21) // 21
  .end()
  .put(23)
```

### `.kill()`

Ends the given signal immediately, regardless of whether the signal still has
values it needs to send. See [disposal](#disposal).

```javascript
sig().teardown(sig.log, 'Ended').end().kill() // Ended
```

### `.then(fn[, args...])`

Creates and returns a new target signal with `fn` as its value handler. `fn` is
called with each received value as its first argument and the created signal as
its `this` context. The target signal is returned to allow for further signal
chaining.

```javascript
var s = sig()

s.then(function (v) {
  this.put(v + 2).next()
})
  .each(sig.log)
  .done()

s.put(21) // 23
```

If extra arguments are provided, they are used as extra arguments to each call
to `fn`.

```javascript
var s = sig()

s.then(
  function (a, b, c) {
    this.put(a + b + c).next()
  },
  1,
  2
)
  .each(sig.log)
  .done()

s.put(20) // 23
```

### `.then(t)`

Sets the calling signal as the source of the signal `t` and returns `t`.

```javascript
var s = sig()
var t = s.then(sig())

t.each(sig.log).done()

s.put(23) // 23
```

### `.done([fn])`

Ends a chain of signals (see [ending chains](#ending-chains)). If an unhandled
error reaches the end of the signal chain `fn` will be called with the error as
its first argument and the last signal in the chain will be [killed](#kill). If
the signal ends without any errors `fn` will be called with no arguments. If
`fn` isn't given, the first unhandled error will be rethrown using javascript's
native `throw`.

```javascript
var s = sig()

s.map(function (v) {
  return v + 1
})
  .filter(function (x) {
    return !(x % 2)
  })
  .each(sig.log)
  .done(function (e) {
    sig.log(e || 'done!')
  })

s.put(1) // 2
  .put(2)
  .put(3) // 4
  .throw(':/') // :/
  .put(4)
  .put(5)
```

### `.resume()`

Resumes the signal, causing the buffered values to propagate to the signal's
targets and causing any new values to be sent to the signal's targets.

```javascript
var s = sig()

s.each(sig.log).done()

s.put(21) // 21
  .pause()
  .put(23)
  .resume() // 23
```

### `.catch(fn[, args...])`

Creates and returns a new target signal with `fn` set as its error handler. `fn`
is called with each thrown error as its first argument and the created signal as
its `this` context. The created signal is returned to allow for further signal
chaining.

```javascript
var s = sig()

s.catch(function (e) {
  sig.log(e)
  this.next()
}).done()

s.throw(new Error('o_O')) // o_O
```

If extra arguments are provided, they are used as extra arguments to each call
to `fn`.

```javascript
var s = sig()

s.catch(function (a, b, c) {
  sig.log(a, b, c)
  this.next()
}).done()

s.throw(new Error('o_O'), '-_-', ':/') // o_O -_- :/
```

### `.each(fn[, args...])`

Creates and returns a new target signal with a value handler that calls `fn`,
then calls [`.next()`](#next) immediately afterwards. This is useful for
synchronous signals, where the value handler will almost always end with
`.next()`. The target signal is returned to allow for further signal chaining.
`fn` is called with each received value as its first argument and the created
signal as its `this` context.

```javascript
var s = sig()

s.each(function (v) {
  this.put(v + 2)
})
  .each(sig.log)
  .done()

s.put(21) // 23
```

Note that if the handler is doing asynchronous work, it would make more sense to
use [`.then`](#then-fn), then call `.next()` when the asynchronous work
completes.

If extra arguments are provided, they are used as extra arguments to each call
to `fn`.

```javascript
var s = sig()

s.each(
  function (a, b, c) {
    this.put(a + b + c)
  },
  1,
  2
)
  .each(sig.log)
  .done()

s.put(20) // 23
```

Since `.each()` is intended for use with synchronous functions, if `fn` throws
an error using javascript's native `throw`, the error will be caught and as an
error in the signal chain.

### `.tap(fn[, args...])`

Creates and returns a new target signal with a value handler that calls `fn`,
then propogates the received value unchanged, allowing a function to 'tap' into
a signal chain.

```javascript
var s = sig()

s.map(function (v) {
  return v + 1
})
  .tap(sig.log)
  .filter(function (v) {
    return !(v % 2)
  })
  .done()

s.put(21) // 22
  .put(22) // 23
  .put(23) // 24
```

### `.map(fn[, args...])`

Creates and returns a new target signal with a value handler that calls `fn` and
outputs its return value. `fn` is called with each received value as its first
argument and the created signal as its `this` context.

```javascript
var s = sig()

s.map(function (v) {
  return v + 2
})
  .each(sig.log)
  .done()

s.put(21) // 23
```

If extra arguments are provided, they are used as extra arguments to each call
to `fn`.

```javascript
var s = sig()

s.map(
  function (a, b, c) {
    this.put(a + b + c)
  },
  1,
  2
)
  .each(sig.log)
  .done()

s.put(20) // 23
```

### `.map(v)`

Creates and returns a new signal with a value handler that simply outputs `v`
for every value received by the signal. The created signal uses `s` as its
source signal. `fn` is called with each received value as its first argument and
the created signal as its `this` context.

```javascript
var s = sig()

s.map(function (v) {
  return v + 2
})
  .each(sig.log)
  .done()

s.put(21) // 23
```

If extra arguments are provided, they are used as extra arguments to each call
to `fn`.

```javascript
var s = sig()

s.map(
  function (a, b, c) {
    this.put(a + b + c)
  },
  1,
  2
)
  .each(sig.log)
  .done()

s.put(20) // 23
```

### `.filter([fn[, args...]])`

Creates and returns a new taret signal with a value handler that calls `fn` to
determine whether to output a recieved value. `fn` is called with each received
value as its first argument and the created signal as its `this` context.

```javascript
var s = sig()

s.filter(function (v) {
  return v % 2
})
  .each(sig.log)
  .done()

s.put(22).put(23) // 23
```

If extra arguments are provided, they are used as extra arguments to each call
to `fn`.

```javascript
var s = sig()

s.filter(
  function (a, b, c) {
    return (a + b + c) % 2
  },
  1,
  2
)
  .each(sig.log)
  .done()

s.put(22) // 22
  .put(23)
```

If `fn` isn't provided, an identity function is used, filtering values based on
their truthyness.

```javascript
var s = sig()

s.filter().each(sig.log).done()

s.put(0).put(1) // 1
```

### `.to(t)`

Redirects values and errors sent from the calling signal to signal `t`. The
returned signal is a new signal that controls this redirection. When either it,
`s` or `t` are ended, the redirection ends. `to` behaves differently to `then`,
as it does not set the calling signal as the source of `t`.

```javascript
function join(a, b) {
  var out = sig()
  a.to(out)
  b.to(out)
  return out
}

var a = sig()
var b = sig()

join(a, b).each(sig.log).done()

a.put(21) // 21
b.put(23) // 23
```

### `.redir(t)`

Alias for [`.to()`](#to).

```javascript
function join(a, b) {
  var out = sig()
  a.redir(out)
  b.redir(out)
  return out
}

var a = sig()
var b = sig()

join(a, b).each(sig.log).done()

a.put(21) // 21
b.put(23) // 23
```

### `.tap(t)`

Redirects values propagated by the calling signal to another signal `t` and
returns a new signal that propagates the source signal's values unchanged. This
allows a signal to 'tap' into another signal chain. Note that unlike
[`.to()`](#to), `.tap()` does not implicately declare the end of a signal chain
with [`.done()`](#done).

```javascript
var s = sig()
var t = sig()

t.each(sig.log).done()

s.map(function (v) {
  return v + 1
})
  .tap(t)
  .filter(function (v) {
    return !(v % 2)
  })
  .done()

s.put(21) // 22
  .put(22) // 23
  .put(23) // 24
```

Redirection will stop when `t` disconnects, when the returned signal disconnects
or when the source signal disconnects. When `t` disconnects, the returned signal
will continue to propagate the source signal's values.

### `.flatten()`

Creates and returns a new target signal that outputs each non-array value in a
series of possibly nested arrays.

```javascript
var s = sig()

s.flatten().each(sig.log).done()

s.putEach([1, [2, [3, [4, 5, [6, 7, 8, [9, [10]]]]]]])
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

### `.limit(n)`

Creates and returns a new target signal that only propogates the first `n`
values it receives.

```javascript
var s = sig()

s.limit(3).each(sig.log).done()

s.put(21) // 21
  .put(22) // 22
  .put(23) // 23
  .put(24)
  .put(25)
```

### `.once()`

Special case of `limit` where `n === 1`.

```javascript
var s = sig()

s.once().each(sig.log).done()

s.put(21) // 21
  .put(22)
  .put(23)
```

### `.update(fn[, args...])`

Returns a new target signal that 'updates' to proxy the signal most recently
generated by a function `fn` mapping the calling signal's output values.

```javascript
var s = sig()

var lookup = {
  t: sig()
  u: sig()
}

s.update(function(k) { return lookup[k] })
 .each(sig.log)
 .done()

s.put('t')

lookup.t
 .put(1)  // 1
 .put(2)  // 2
 .put(3)  // 3

s.put('u')

lookup.u
 .put(4)  // 4
 .put(5)  // 5
 .put(6)  // 6

lookup.t
 .put(7)
 .put(8)
 .put(9)
```

If `fn` returns a non-signal, its result is ignored.

If `fn` isn't given, an identity function is used as the default. This can be
useful for turning a signal of signals into a single signal.

```javascript
var s = sig()
var t = sig()
var u = sig()

s.update().each(sig.log).done()

s.put(t)

t.put(1) // 1
  .put(2) // 2
  .put(3) // 3

s.put(u)

u.put(4) // 4
  .put(5) // 5
  .put(6) // 6

t.put(7).put(8).put(9)
```

### `.append(fn[, args...])`

Returns a new target signal that proxies every signal generated by a function
`fn` mapping the calling signal's output values. Each time a new signal is
generated, it is 'appended' to the signals being tracked, so outputs of previous
signals will still be proxied when a new signal is generated by `fn`.

```javascript
var s = sig()

var lookup = {
  t: sig()
  u: sig()
}

s.append(function(k) { return lookup[k] })
 .each(sig.log)
 .done()

s.put('t')

lookup.t
 .put(1)  // 1
 .put(2)  // 2
 .put(3)  // 3

s.put('u')

lookup.u
 .put(4)  // 4
 .put(5)  // 5
 .put(6)  // 6

lookup.t
 .put(7)  // 7
 .put(8)  // 8
 .put(9)  // 9
```

If `fn` returns a non-signal, its result is ignored.

If `fn` isn't given, an identity function is used as the default. This can be
useful for turning a signal of signals into a single signal.

```javascript
var s = sig()
var t = sig()
var u = sig()

s.append().each(sig.log).done()

s.put(t)

t.put(1) // 1
  .put(2) // 2
  .put(3) // 3

s.put(u)

u.put(4) // 4
  .put(5) // 5
  .put(6) // 6

t.put(7) // 7
  .put(8) // 8
  .put(9) // 9
```

### `.call(fn[, args...])`

Calls a function `fn` with the calling signal as its first argument and `args`
as the remaining arguments. Useful for hooking custom functions into a signal
chain.

```javascript
var s = sig()

s.call(mul, 2).each(sig.log).done()

s.putEach([1, 2, 3])
// [2, 4, 6]

function mul(s, n) {
  return s.map(function (v) {
    return v * n
  })
}
```

### `.event(name)`

Returns a new signal that propagates each event with the given `name` emitted by
the signal. See the [event catalogue](#event-catalogue) for the events emitted
by the signal.

```javascript
var s = sig()

s.event('flush')
  .each(function () {
    sig.log('flush!')
  })
  .done()

s.pause()
  .resume() // flush!
  .pause()
  .resume() // flush!
```

### `.teardown(fn[, args...])`

Schedules `fn` to be called when the calling signal has ended. `fn` is called
with the calling signal as its `this` context. Any state used by the signal
should be deconstructed inside a teardown function. If the calling signal has
already ended, `fn` is called immediately. See [disposal](#disposal).

```javascript
function tick() {
  var s = sig()
  var id = setInterval(resolve, 200, s)

  s.teardown(function () {
    clearInterval(id)
  })

  return s
}

var s = tick()

s.each(sig.log).done()

// this will cause the teardown function to get called
s.end()
```

### `.resolve([v])`

Sends the value `v` (or `undefined` if no value is given) from the calling
signal, then ends the signal.

```javascript
var s = sig()

s.each(sig.log).done()

s.resolve(21) // 21
  .put(23)
```

### `.putEach()`

Sends each value in a `values` array from the calling signal.

```javascript
var s = sig()

s.each(sig.log).done()

s.putEach([1, 2, 3])
// 1
// 2
// 3
```

### `.putTo(t)`

Sends the signal as a value to signal `t`.

```javascript
var s = sig()

s.update().each(sig.log).done()

var t = sig()
t.putTo(s).put(23) // 23
```

### `sig.val([v])`

Creates and returns a new [sticky](#sticky) signal. If `v` is given, it is used
as the initial value for the created signal.

```javascript
var v = sig.val(23)
v.each(sig.log).done() // 23
v.each(sig.log).done() // 23
```

### `sig.ensureVal(v)`

If a `v` is given, a sticky signal is returned with `v` as its initial value. If
`v` is a signal, a new sticky signal is returned with `v` as its source.

```javascript
var v = sig.ensureVal(23)
v.each(sig.log).done() // 23

var s = sig()
var t = sig.ensureVal(s)

s.put(23)
t.each(sig.log).done() // 23
t.each(sig.log).done() // 23
```

### `sig.any(values)`

Accepts an array of `values`, where each value can be either a signal or
non-signal, and returns a signal that outputs an array containing the value and
its corresponding signal's index in the array whenever one of the signals in the
array changes.

```javascript
var s = sig()
var t = sig()

sig.any([s, 23, t]).each(sig.spread, sig.log).done()

s.put(1) // 1 0
t.put(3) // 3 2
s.put(2) // 2 0
t.put(1) // 1 2
s.put(3) // 3 0
```

### `sig.any(obj)`

Identical to [`sig.any(values)`](#any-values), except it handles an object of
key-value pairs instead of an array, where each value can be either a signal or
non-signal. The values outputted from the signal are arrays, each containing the
given value and its corresponding signal's key in the object.

```javascript
var s = sig()
var t = sig()

sig
  .any({
    a: s,
    b: 23,
    c: t
  })
  .each(sig.spread, sig.log)
  .done()

s.put(1) // 1 a
t.put(3) // 3 c
s.put(2) // 2 a
t.put(1) // 1 c
s.put(3) // 3 a
```

### `sig.all(values)`

Accepts an array of `values`, where each value can be either a signal or
non-signal, and returns a signal that outputs an array of the current values of
each signal and non-signal each time one of the values changes. Note that the
returned signal will only start outputting once each signal in the array has put
through its first value.

```javascript
var s = sig()
var t = sig()

sig.all([s, 23, t]).each(sig.log).done()

s.put(1)
t.put(3) // [1, 23, 3]
s.put(2) // [2, 23, 3]
t.put(1) // [2, 23, 1]
s.put(3) // [3, 23, 1]
```

### `sig.all(obj)`

Identical to [`sig.all(values)`](#all-values), catch it handles an object of
key-value pairs instead of an array, where each value can be either a signal or
non-signal.

```javascript
var s = sig()
var t = sig()

sig
  .all({
    a: s,
    b: 23,
    c: t
  })
  .each(sig.log)
  .done()

s.put(1)

t.put(3)
// {
//   a: 1,
//   b: 23,
//   c: 3
// }

s.put(2)
// {
//   a: 2,
//   b: 23,
//   c: 3
// }

t.put(1)
// {
//   a: 2,
//   b: 23,
//   c: 1
// }

s.put(3)
// {
//   a: 3,
//   b: 23,
//   c: 1
// }
```

### `sig.merge(values)`

Accepts an array of `values`, where each value can be either a signal or
non-signal, and returns a signal that outputs the values put through each signal
in the array.

```javascript
var s = sig()
var t = sig()

sig.merge([s, 23, t]).each(sig.log).done()

s.put(1) // 1
t.put(3) // 3
s.put(2) // 2
t.put(1) // 1
s.put(3) // 3
```

### `sig.merge(obj)`

Identical to [`sig.merge(values)`](#merge-values), except it handles an object
of key-value pairs instead of an array, where each value can be either a signal
or non-signal. The values outputted from the signal are the values sent from
each signal in the object.

```javascript
var s = sig()
var t = sig()

sig
  .merge({
    a: s,
    b: 23,
    c: t
  })
  .each(sig.log)
  .done()

s.put(1) // 1
t.put(3) // 3
s.put(2) // 2
t.put(1) // 1
s.put(3) // 3
```

### `sig.isSig(v)`

Returns `true` if `v` is a signal, `false` if it is not.

```javascript
sig.isSig(23) // => false
sig.isSig(sig()) // => true
```

### `sig.log(v)`

Logs the given arguments. Similar to `console.log`, except it does not rely on
`console` as its `this` context and returns its first argument.

```javascript
var s = sig()

s.filter()
  .map(sig.log)
  .map(function (v) {
    return v * 2
  })
  .each(sig.log)
  .done()

s.putEach([0, 1, 1, 0])
// 1
// 1
// 2
// 2
```

### `sig.putTo(v, s)`

The static form of [`.putTo()`](#putTo), except `v` can be a value of any time
(it does not have to be a signal).

## install

You can use this library as the npm package `sig-js`:

```
npm i sig-js
# or
yarn add sig-js
```

It can be used in both es-module-aware and commonjs bundlers/environments.

```js
// es module
import sig from 'sig-js'

// commonjs
const sig = require('sig-js')
```

It can also be used a `<script>`:

```html
<script crossorigin src="https://unpkg.com/sig-js/dist/umd/sig.js"></script>

<script>
  sig()
</script>
```


text:
NOTED: GALLERIES
37 THE POWER STATION
The Power Station consistently presents a wide range of installation pieces by emerging artists. In October and November a show of Walead Beshty's work will be on display. powerstationdallas.com
38 THE PUBLIC TRUST
William Binnie: Terra Incognita will be displayed in the gallery through Oct. 12. Binnie's research interests, as of late, have turned toward the use of militarized drones. trustthepublic.com
39 RE GALLERY
Benjamin Terry's work remains on display through Oct. 19. Next, RE collaborates with Make Art with Purpose in an exhibit titled REwork: Adaptive Reuse of Architecture and Urban Revitalization Oct. 25-Nov. 2. Varied works by Eli Walker will be spotlighted Nov. 8-30. regallerystudio.com
40 READ CONTEMPORARY DALLAS
Chad Attie creates a distorted, picturesque reflection of the natural landscape that reveals the impossibility of attaining perfection. His work remains on display in an exhibition titled Eden through Oct. 26. The gallery also carries fine aboriginal art. readcontemporary.com
41 THE READING ROOM
Inspired by Jonathan Lethem's novel Chronic City, Asteroid Belt of Trash Blocking Transmissions of Love, a project by The Art Foundation for the Texas Biennial 2013, runs through Nov. 2. thereadingroom-dallas.com.

redpajama_set_name: RedPajamaCommonCrawl


For all the popularity of Nike Free — and the innovation truly has changed footwear — the minimalist technology has not generally been seen as an everyday training option, due to the (by design) lesser support and cushioning, forgone in favor of a more "barefoot" feel. That all changes with the latest model — the Nike Free RN Distance.
Designed for daily use and long-distance runs — ohhhhhh; that's why they call it that — the new model still features many of the hallmarks of a Nike Free model: lack of a heel-counter; largely unstructured upper; flexible sole with a natural range of motion; minimal (4mm here) heel-to-toe offset.
But the Free RN Distance updates those tenets for a longer-distance run as well. Cushier Lunarlon foam is used in the midsole, a tried and true technology that's been used in distance-running shoes for years, and the hexagonal flex pattern in the Free outsole is reimagined; larger hexagons provide more lateral stability and protection. Finally, the dual-stacked foam set-up puts the foot a bit farther off the ground than on previous Free shoes. Think of it as barefoot, in terms of range of motion and flexibility, but not necessarily minimalist.
The Nike Free RN Distance begins hitting stores worldwide today, November 19. Nike.com availability hasn't been announced yet, but it should be just around the corner.
The post Nike Free RN Distance | The Long-Distance Free appeared first on NikeBlog.com.


Earning an IIBA® professional certification offers many benefits to both the individual and the organization employing or engaging them.
•	Competence in the principles and practices of business analysis.
•	Participation in a recognized professional group.
•	Recognition of professional competence by professional peers and management.
•	Advanced career potential due to recognition as a professional business analysis practitioner.
•	Personal satisfaction of accomplishing a milestone in their BA careers.
•	Certification can improve overall performance, remove uncertainty and widen market opportunities.
•	The process of achieving and maintaining certification helps ensure you are continually improving and refining your activities.
•	Potentially higher income for being formally recognized as an experienced BA professional. Recognizes individuals who have invested in their BA careers and encourages them to keep doing so.
•	Provides professional development, advancement and recognition opportunities for staff.
•	Demonstrates to customers, competitors, suppliers, staff and investors that you use industry-standard business analysis practices.
•	Demonstrates to your stakeholders that your business is run effectively.
•	The regular assessment process will improve staff responsibility, commitment and motivation.
•	Establishment and implementation of business analysis practices as outlined in A Guide to the Business Analysis Body of Knowledge® (BABOK®) Guide by individuals recognized as being knowledgeable and skilled.
•	More reliable, higher quality results produced with increased efficiency and consistency by BA professionals who use industry standard BA techniques.
•	Identification of professional business analysts to clients and business partners.
•	Demonstrated commitment to the field of business analysis, increasingly recognized as a vital component of any successful project.
More than 225 million people use LinkedIn, not everyone knows how to use it most effectively. According to career experts, job searchers particularly put themselves behind the eight ball when they under use or misuse the tool.
Use keywords. Not everyone knows it, but most recruiters and hiring managers who search for candidates on LinkedIn do so largely through a keyword search. That means you should pay special attention to words and titles when writing your profile. "If you are an outside sales professional and your profile uses that exact terminology, you may also want to use terms like 'business development' or 'relationship building' somewhere in your text, because it's possible that a recruiter would use those keywords in their search instead of outside sales,". "In other words, give some real thought to synonymous titles and terms, and utilize them in your profile. The more effectively you can do this, the more likely you will be to appear in someone's search results."Help people to "get you." One of the main purposes for using LinkedIn is to introduce yourself to professional contacts and potential employers before they meet you in person. That means one of your goals in creating an effective LinkedIn presence should be to "channel" yourself, so to speak, onto your profile page — particularly in your summary section.
Once you are certified in any SAP module it becomes extremely important to prepare yourself to face your first SAP Interview.
The first step to prepare for the Interview is to know more about the Real life Projects and the prospective questions which may come up during the Interview.
This session is intended Certified SAP Students to walk them through all the Project Scenarios so that they can acquire knowledge about real life projects and confidently appear in the Interview.


text:
Man admits moving body of alleged Teignmouth murder victim
Hinton also lied police probing the death of 39-year-old Matthew Jackson
Paul Greaves
A man has admitted moving a body and lying to police investigating an alleged murder in Teignmouth.
Neal Hinton, 39, pleaded guilty to perverting the course of justice during a short hearing at Exeter Crown Court on Thursday morning.
He admitted that between June 1 and June 5 this year he did a series of acts which had a tendency to pervert the course of public justice in that he moved the body of Matthew Jackson and lied in his subsequent police interviews.
Round up of the latest court action
Teenage burglar ransacked charity
Suspicious girlfriend blamed for breach
Christians in court battle
Exeter mags court to be moved
The defendant, of Ness View Road, spoke only to enter a guilty plea.
He was represented at court by Heather Hope who said he should be sentenced at a later date.
Simon Laws QC represented the Crown at the hearing.
Matthew Jackson was found dead in Teignmouth
Hinton will be sentenced on December 3. He was granted bail till then by judge Peter Johnson who presided over the hearing via video link from Plymouth Crown Court.
Facebook group for Exeter & Devon Court Cases
The courts produce plenty of news - and you can keep up to date with cases in our dedicated Facebook group. Just click here to join on Facebook
Mr Jackson, 38, from Bishopsteignton, was found dead in Barnpark Terrace in Teignmouth on June 3.
A man is due to stand trial accused of his murder.
David Ablett, 52, has already pleaded not guilty to killing Mr Jackson.
His trial, which is due to last seven days, will begin at Exeter Crown Court on November 19.


text:
LawCustoms Project
Law Office of Yuri Starikov, LLC | 157-11 Rockaway Blvd., Suite 209, Jamaica, NY 11434 | yuri@starikovlaw.com | + 1 (347) 871 2759
Customs Broker Exam
Exam History Compilations
5th Ed. Vol. 1 Chpt. 1
5th Ed. Vol. 1 Chpt. 10
Excercise Book
Web Supplements
5th Ed. Q.'s 1-299
5th Ed. Q. 3
5th Ed. Q. 10
5th Ed. Q. 101
5th Ed. Q.'s 300-399
Home > Oil & Gas Products
Published April 27, 2012 by Yuri Starikov
Exporting Carbon Fiber Products from the United States
As a subscriber to Bureau of Industry and Security (BIS) email notifications, I received a letter about two entities being charged with attempt (conspiracy) to export carbon fiber. The letter is reproduced below. I would like to draw LawCustoms guests attention not to the penalty details, but to the extent of export control regime related to carbon fibers in the civil industrial context. More specifically, to the finished product being exported made of controlled carbon fiber. The centerpiece of the charge was the Export Control Classification Number (ECCN) 1C210, which provides for certain "fibrous or filamentary material." We know that because 1C210 is in the "C" product group, it deals with materials, rather than the finished product which is usually provided in the "A" product group. See e.g. BIS's Export Control Basics overview. The relevant ECCN in "A" group is 1A002, which provides for "Composite" structures or laminates wich certain characteristics. Provided that the characteristics are there, Note 2 to ECCN 1A002 provides an exception: "1A002 does not control finished or semi-finished items, specially designed for purely civilian applications as follows: (a) sporting goods; (b) automotive industry; (c) machine tool industry; (d) medical applications." This means that if the otherwise qualified item is used in any other…
Read More Exporting Carbon Fiber Products from the United States
Product Regulation U.S. Federal Agencies
Bureau of Industry and Security ECCN 1A002 ECCN 1C210 Export Administration Regulations Food Products Industrial Products Oil & Gas Products
Published December 13, 2011 by Yuri Starikov
Useful Links: Oil & Gas Industry
Drillopedia Compressed Air Glossary of Terms (by Pneumatic Source) Dictionary of Mining, Mineral, and Related Terms (Hacettepe University Department of Mining Engineering) Oilwell-Tools.com Oil Drilling (howstuffworks) Oil & Gas Drilling & Servicing e-Tool (OSHA) Schlumberger Oilfield Glossary
Read More Useful Links: Oil & Gas Industry
Product Regulation Useful Links
Oil & Gas Products
Classification Principles: Whether the product is a "Drilling Part" of "Downhole Part" (8431.43 v. 8479.89)
When the equipment parts have downhole applications, they are to be classified as a boring or sinking machinery (8431.43…) only if these parts are directly related (emphasis added) to the function / facilitation of boring or sinking. Otherwise, they are to be classified as downhole equipment under 8479.89. N076953 (Machinery for fishing, coring, washover… is 8479.89, machinery for facilitation of drilling is 8431.43); N072426 (Machinery used in production phase, post drilling phase, extraction phase is not "boring or sinking machinery" under 8431.43, but rather downholle machinery under 8479.89); N084298 (casing hangers / bracket supports designed to fit on a wellhead in order to suspend the weight of casing strings in the well, although used in wells, are associated with well boring or sinking but rather well casing – 8479.89 therefore applies); N018132 (Liner hangers used during the drilling process to join casing to liner are not pars of drilling machinery but are components of well completion process, thus 8479.89 applies); I888206 (Crossover subs are part of the drilling process, thus classified as a part of the drilling machinery under 8431.43)
Read More Classification Principles: Whether the product is a "Drilling Part" of "Downhole Part" (8431.43 v. 8479.89)
Product Regulation
Harmonized Tariff Schedule Classification HTS Heading 8431 HTS Heading 8479 Oil & Gas Products
Published December 8, 2011 by Yuri Starikov
Classification Principles: Whether the product is a "Part of Offshore Platform" or is classified elsewhere (8431.43.40 v. other)
When the primary application of the product is on offshore drill platform (as opposed to having both land and offshore applications), that product is classified as the platform (8431.43.40). See N025539 (classifying drill collar bars used primarily on offshore drill platforms, as the parts of offshore production platforms).
Read More Classification Principles: Whether the product is a "Part of Offshore Platform" or is classified elsewhere (8431.43.40 v. other)
Harmonized Tariff Schedule Classification HTS Heading 8431 Oil & Gas Products
Published March 25, 2009 by Yuri Starikov
Blowout Preventer Valves (BOPs)
The CBP decision in HQ H007677 regarding blowout preventers (BOP) is another example to the oilfield industry that customary practices of using "blanket" HTS for all of its products, such as 8431.43 (parts of offshore oil and natural gas drilling and production platforms; parts of oil and gas filed machinery) may not always work. At least in those situations where duty is involved. The counsel tried really hard to persuade CBP that BOP is actually a part of the entire blowout preventer control system that is part of boring machinery (8431.43 / Duty Free). And it succeeded on the merits. CBP agreed thatt "BOPs are integral constituent component of oil and gas drilling activity and are in fact "parts" desinged for use therein. Counsel's argument, however, did not survive procedural scrutiny. Counsel cited Mitsibishi v. US, 22 F.3D 1102 (CAFC 1993), where slag box was found to be integral part of casting machine despite the fact that it was not involved in the casting process. While analagy parallels the issue, the thrust of the argument needed to focus on why Section XVI Note 2(a) should not be dispositive. Citing legal notes and expanatory text, CBP held that BOPs are appropriately…
Read More Blowout Preventer Valves (BOPs)
Customs and Border Protection Harmonized Tariff Schedule Classification HTS Heading 8431 Oil & Gas Products
Published February 18, 2009 by Yuri Starikov
Exports to International Waters (vessels, buoys, offshore iinstallations)
I highly reccomend to review news posted by Douglas N. Jacobson. Yersterday, Mr. Jacobson recited Census Bureau memorandum called FTR Letter No. 3. Several issues worth noting and for some of us revisiting. First, the AES filers must utilize new "IW" export information code. Second, if one exports BIS licensed commodity, filer must use country of destination and ultimate consignee as indicated on that license. Third, if one exports non-BIS licensed commodity, then filer must use "nationality of the person(s) or entity assuming control of the item(s)." Lastly, AES filers are to report only those commodities that are valued over $2500 / Shedule B and/or those commodities that are subject to license (regardless of value).
Read More Exports to International Waters (vessels, buoys, offshore iinstallations)
Automated Export System Bureau of Industry and Security Census Bureau Oil & Gas Products
Published September 11, 2008 by Yuri Starikov
Scope of License Exception AVS (drilling rigs/platforms)
For the purposes of 15 CFR 740.15, do offshore oil drilling rigs / platforms qualify as Vessels? Offshore drilling rigs and platforms do not constitute "vessels" for the purposes of License Exception AVS eligibility, as described in Section 740.15 of the Export Administration Regulations (EAR) (15 CFR Parts 730-774). The items that are eligible for export or reexport under License Exception AVS are, for the most part, those necessary for the proper operation (e.g., propulsion, navigation) of an aircraft or vessel or those intended for use as plane or ship stores. The scope of items that may be necessary for the proper operation of an offshore drilling rig or platform (even one that is self-propelled) might well include platform stabilization and drilling or oil exploration equipment that would go well beyond the scope of items contemplated under License Exception AVS as eligible for export/reexport to, or on board, vessels and aircraft. For additional information on the EAR requirements described in this e mail, you may wish to view the EAR on-line, at: www.access.gpo.gov/bis/index.html. Should you have additional questions about the requirements in the EAR, you may wish to contact the Outreach and Educational Services Division, at: (202) 482-4811.
Read More Scope of License Exception AVS (drilling rigs/platforms)
Bureau of Industry and Security Export Administration Regulations Oil & Gas Products
Scope of ECCN 2B999.g controls
This inquiry concerns control 2B999.g of the Commerce Control List. Specifically, the list provides for 304 and 316 stainless steel valves, piping, tanks and vessels. One possible interpretation of the control is that the whole product in its entirety must be made from 304 or 316 stainless steel. Another possible interpretation of the control is that only those products that contain 304 or 316 stainless steel that perform essential function of the product (e.g. inner part of the piping that comes into direct control with the liquid or gas; valve that is made from bronze, but contains 316 stainless steel parts such as butterfly disc). The BIS position on the 2B999.g? The ECCN 2B999.g controls on 304 and 316 stainless steel valves, piping, tanks and vessels should be interpreted consistent with the controls on chemical manufacturing equipment described in ECCN 2B350. Therefore, if all surfaces of the valves, piping, tanks and vessels that come in direct contact with the chemical(s) being processed or contained are made from 304/316 stainless steel, they would be controlled under 2B999.g — in this instance, the entire item would not have to be made of 304/316 stainless steel in order for it to be controlled…
Read More Scope of ECCN 2B999.g controls
Bureau of Industry and Security ECCN 2B350 ECCN 2B999 Export Administration Regulations Industrial Products Oil & Gas Products
Published August 8, 2008 by Yuri Starikov
Actuator may be, prima facie, a part of the valve with which it is used, but actuators for valves, imported / exported separately are not provided in the valve heading 8481. Actuator is a gear assembly and is more specifically provided in heading 8483. Actuator, when presented separately, is 8483.40.5010 HTSUS or 8483.40.4010 Schedule B, which provides for fixed ratio speed changers Source: N025719
Read More Actuator
Harmonized Tariff Schedule Classification HTS Heading 8483 Industrial Products Oil & Gas Products Schedule B
Internal Blowout Pressure Valve (IBOP)
An IBOP is typically a ball valve or other type of valve that is connected in line with the drills string. It can be closed to isolate the kick inside the drill string. Because an IBOP and its associated actuator is connected in line with the drill string, it will rotate with the drill string during drilling operations. Typically, IBOP's are pneumatically powered. The air source, typically a pressurized cylinder, is generally stationary. Thus, the challenge is to get the air power from the stationary source to the rotating IBOP actuator. It is noted that often drilling is stopped before the IBOP is actuated, but for safety reasons, the IBOP must be connected to an air supply at all times during drilling operations. Source
Read More Internal Blowout Pressure Valve (IBOP)
Search LawCustoms Content
No events scheduled at this time
Sovereign Nations
U.S. Federal Courts
Topics & Discussions
Agricultural Marketing Service Animal and Plant Inspection Service Antidumping Automated Export System Bureau of Industry and Security Census Bureau Chemical Products Communication and Network Products Computers & Electronic Products Consumer Product Safety Commission Consumer Product Safety Improvement Act Country of Origin Court of Appeals for the Federal Circuit Court of International Trade Customs and Border Protection Department of Commerce Department of Justice Directorate of Defense Trade Controls Drugs & Pharmaceutical Products Electric Products Environmental Protection Agency Export Administration Regulations Food and Drug Administration Food Drug and Cosmetic Act Food Products Food Safety Inspection Service Freedom of Information Act Harmonized Tariff Schedule Classification Home & Garden Products HTS Heading 8431 HTS Heading 8479 HTS Heading 9405 Industrial Products International Trade Administration Labeling & Marking Lacey Act Office of Foreign Assets Control Oil & Gas Products Post Entry Amendment Protest Schedule B Textile & Apparel Products Toxic Substances Control Act United States Department of Agriculture World Trade Organization
Please enter your email address to receive free updates about trade, customs and other developments.
Disclaimer, Copyright, Licensing, and LawCustoms Store Terms & Conditions
All postings on this website should not be treated as a legal advice. The information may be outdated and may reflect views that are different from the position of government officials or other persons. Certain statements may be construed as "Attorney Advertising." Prior results do not guarantee a similar outcome.
Except as otherwise noted, information on this website was written by Law Office of Yuri Starikov, LLC. The Office retains the copyright to its writings.
UNLESS SPECIFIED OTHERWISE, you may use LawCustoms Project online publications subject to the Creative Commons Attribution 4.0 International License. Under the license terms, you may use our Office web publications as you see fit, so long as you identify LawCustoms Project as the source.
LAWCUSTOMS STORE TERMS & CONDITIONS
All purchases from LawCustoms Store are governed by Terms & Conditions, which specify the return policy, shipping, and licensing of products that are available.
BIS Commerce Control List
CBP's ADD / CVD Search
CBP's Bulletin
CBP's Cargo Systems Messaging Service (CSMS)
CBP's CROSS
CBP's Directives and Handbooks
CBP's Informed Compliance Publications
CBP's IPR Recordations
CBP's Liquidation Status
Code of Federal Regulations (unofficial eCFR version)
DDTC's CJ Final Determinations
HTS Online Reference Tool
HTSUS
Schedule B Search Engine
U.S. Trade Courts Opinion Search Tool
© 2019 LAW OFFICE OF YURI STARIKOV, LLC


HD Buckets are designed and tested in the most arduous of conditions.
Triangular folded section for greater structural strength.
Tapered design reduces drag improving both loading and unloading.
Dual radius profile increases heal clearance, reducing drag and wear.
400BHN cutting edge, side plates and wear straps.
Cast wear shrouds as standard equipment prevent wear, yet do not add width to your bucket.
Horizontal wear straps with wraparound straps that overlap the bucket, protecting structural welds.
Buckets come standard with a lift eye.
Full range of tooth styles and brands available.


Last year, I wrote about my involvement in the marching band, so this year, I thought that I would discuss something a little different for my favorite student involvement. The American Institute of Chemical Engineers is a national organization for chemical engineers to network, share ideas, and connect with one another. USC has a chapter on its campus, and I have been a member for the last two years.
I am not going to say that I have been the most active member, but I really do enjoy going to different AIChe events throughout the year. My freshmen year, I went to lecture given by a professor from the Middle East talking about his biofuel research. I also went to a session with a representative from Southern California Edison, where he discussed the company and internship opportunities.
Last year, the president of AIChe was Anastasia Barge, who is a former VSA. The best event I went to last year was a info session given by the US Nuclear Navy. They discussed one of their programs where they pay for a student's tuition to get their engineering degree and then you go work for the navy doing nuclear engineering work. It was really interesting. You can check out their programs here.
I really hope to get more involved in AIChe this year. It's a great organization to be a part of and there are so many neat things to do. If you are interested in hearing what AIChe is like from a perspective of a board member, check out Lyssa's post on AIChe here.
You can check out the AIChe – USC website here, and the national website here.
Finally, you can check out my blog post from last year – My Favorite Student Involvement – USC Trojan Marching Band.


We provide a DINITROL vehicle undersealing application service and are based in Johnstone, Scotland. The corrosion protection coatings can help in extending the life of your vehicles by preventing and protecting them from the onslaught of rust decay.
We also provide FREE yearly inspections as part of our after care service. We are Scotland's longest authorised DINITROL application specialist providing a wide range of rust treatment and rust protection products. DINITROL applications are ideal for protecting a wide range of vehicles including: classic cars, campers, motorhomes, 4×4 off road vehicles, taxis, military vehicles, motorbikes aswell as all utility vehicles and trailers.
PLEASE NOTE: Inspections are by appointment only, please telephone or email to arrange suitable time.


text:
Review: Wheels of Aurelia
Review copy of this game provided by its developer, Santa Ragione.
Wheels of Aurelia is described by its developer, Santa Ragione, as a narrative road trip game. It is probably the most accurate way to describe the game overall.
In Wheels of Aurelia, you take control of Lella, a woman on a road trip towards France in 1970's Italy. Initially, she will have one companion with whom she can talk, but the narrative can lead to Lella picking up hitchhikers or otherwise switching (or adding) passengers on her way. Each playthrough takes around 15-20 minutes, with 16 different endings to achieve.
The gameplay consists of two distinct parts: driving whichever of the game's cars you choose at the start of the game, and making conversation (or not) with whomever you happen to be driving with. The choices you make – both in terms of conversation as well as where to drive – shape the story around you. Most of the time, the driving takes a back seat to the conversations, which require you to make your choice on a timer. Much like in a TellTale game, your options depend on a certain speed to choose your words – albeit with a much more forgiving time frame to choose than in a TellTale game.
The setting for the game feels new as well, while at the same time still managing to feel relevant to a current audience. Lella can have many interactions, ranging from the banal with hitchhikers, to deeper (well, relatively) discussions about women's rights, or even the topic of political unrest. The fact that the game draws from the actual political and societal climate of 1970s Italy makes the game a really interesting experience.
The graphics are divided into a neat, mostly sunny, isometric view of the Via Aurelia on which Lella and her companion(s) are travelling. The graphics are simple, while still managing to be nice to look at. Added to that are more detailed character models which really adds a lot of, well…Character to the characters. In fact, the design is so nice that I had not even noticed that the character models lack arms before someone pointed it out to me.
The game's soundtrack fits well with the aesthetic, and really shows a vision for how the game and its stories should be presented.
That is not to say that the game is without its flaws. I generally appreciate when games take a more narrative approach to the experience, but your mileage may vary. I am a proponent of games as art, and Wheels of Aurelia definitely feels like the indie arthouse project it is.
The actual gameplay part of the game is simple, with only small frustrations such almost-too-perfect-to-beat enemy drivers in a few races. The stories are neat, but I would sometimes hit conversation parts that felt abrupt, with some of my choices (which are at most times limited to two choices to speak, and being silent) referring back to things a character had said to Lella a while back. It would also in hindsight have been nice to see the character models not have their arms cut off, and perhaps even with a bit of animation to really drive out the character they add to the game.
When all that is said and done, there are only a few roadbumps in the way for Wheels of Aurelia. It is a neat set of experiences, with an original setting. If you're not a fan of games where narrative takes the wheel in favor of gameplay, this might not be for you. If you're interested in good storytelling, and a setting that hasn't been covered much in games in the past – get in.
We're going on a road trip.
Wheels of Aurelia is currently available through Humble, Itch.io and Steam for $9.99 / 9,99€. It will be available on PS4 and XB1 on October 5.
Tags: Review, Wheels of Aurelia


Whether a business employs five or 500 people, payroll is a complex, highly regulated process that affects employees' attitudes toward the company and its reputation in the community. In addition, payroll errors have legal ramifications, including costly fines and possible lawsuits. Payroll ethics are the structure within which payroll processes function to ensure that employees are paid the correct amount on time and the business is in compliance with federal and state laws.
Payroll ethics have several components. Everything related to payroll is confidential. This includes communications between the employer and employees and between the employer and outside agencies, such as the Internal Revenue Service. Payroll ethics means that all processes are in compliance with federal and state laws. When errors are discovered, they are corrected promptly. Information security is an essential component of ethics. All paper and electronic pay records are stored and used in a secure manner by authorized personnel only. Finally, payroll employees are properly trained and do their jobs with integrity and honesty. In addition, they keep up with regulatory and technology changes that affect payroll processing.
Payroll ethics drive process controls–the mechanisms a business uses to manage payroll. Process transaction controls focus on payroll processing; recordkeeping and compliance; and staff responsibilities. Controls include using paycheck stock that has security features. For example, the word "void" may appear when a check is photocopied but is otherwise invisible. Like employee records, blank paycheck stock is kept in a secure location and voided checks are mutilated to prevent cashing, but are not destroyed for audit purposes. Payroll audits and payroll account reconciliations are conducted on a regular basis. Policies and procedures are implemented and followed.These include requiring requests for over time, pay changes and pay advances. Policies for correcting pay errors due to overpayment or underpayment are also implemented.
Within each pay control area, duties are separated to ensure quality and avoid conflicts of interest. Ideally, there are two people assigned to each function in the payroll process and they check each other's work for accuracy. In a small business where resources are limited, a clerk may collect and report employee time and attendance data. The accounting person verifies the information and then uses to process the payroll. The human resources person checks the payroll to ensure compliance and accuracy, after which the owner or manager reviews and signs the paychecks. Then, the administrative assistant distributes the paychecks to employees.
Using an audit checklist helps a small business ensure that its payroll processing is done in an ethical manner. Answer the following questions and take corrective action as necessary. Are all employees required to report their time and attendance in a standard way? Is time and attendance approved by a worker's supervisor? Are written payroll policies in place and are they followed consistently? Are required payroll taxes and benefits deducted and deposited on time? Are payroll staff duties separated? Does the owner or financial officer review payroll records on a regular basis? Are employment records kept in compliance with federal and state regulations? Does the company keep a list of all paychecks issued and is it reviewed for uncashed checks? Is there a separate bank account for payroll?
Chinn, Diane. "Definition of Payroll Ethics." Small Business - Chron.com, http://smallbusiness.chron.com/definition-payroll-ethics-23725.html. Accessed 24 April 2019.


text:
Q: Woocommerce change order table view Good day!
I'm having a hard time how to change the order table in order confirmation email in woocommerce. See attached image thankyou!

A: Well you can edit most of the functionality and text, in the files inside this folder plugins/woocommerce/templates/emails/ To avoid loosing all the changes during a woocommerce update copy those files with that same route path inside ur child theme or Example: yourchild-theme/woocommerce/templates/emails/email-footer.php
The question would be what is it you want to change in the order confirmation.

redpajama_set_name: RedPajamaStackExchange


text:
Q: Weird behavior with local functions and shared variables I'm generating an Excel file for a budget and there is a weird behavior with the local functions. The problem seems to be with the shared variable rowIndex. For some reason, the total formula overwrites the content of the first cell of each section but the "Total active" label does not overwrite the account name. Can someone explain what is causing this weird behavior?

Code:
private void Export()
{
    var workbook = new Aspose.Cells.Workbook();
    var worksheet = workbook.Worksheets[0];

    int rowIndex = 0;

    var number = 0;
    var data = new List<dynamic>
    {
        new { Name = $"Account {++number}", Amount = 50, IsIncome = true, Active = true },
        new { Name = $"Account {++number}", Amount = 25, IsIncome = true, Active = false },
        new { Name = $"Account {++number}", Amount = 75, IsIncome = false, Active = true },
        new { Name = $"Account {++number}", Amount = 100, IsIncome = false, Active = false },
        new { Name = $"Account {++number}", Amount = 60, IsIncome = true, Active = false },
        new { Name = $"Account {++number}", Amount = 90, IsIncome = false, Active = true },
        new { Name = $"Account {++number}", Amount = 40, IsIncome = true, Active = true },
        new { Name = $"Account {++number}", Amount = 20, IsIncome = false, Active = false }
    };

    WriteExportSection("INCOME", data.Where(i => i.IsIncome).ToList());
    WriteExportSection("EXPENSES", data.Where(i => !i.IsIncome).ToList());

    workbook.Save("budget.xlsx");

    IEnumerable<int> WriteRowValues(IList<dynamic> items)
    {
        foreach(var item in items)
        {
            worksheet.Cells[rowIndex, 0].Value = item.Name;
            worksheet.Cells[rowIndex, 1].Value = item.Amount;
            worksheet.Cells[rowIndex, 2].Value = item.Active;
            if (item.Active)
            {
                yield return rowIndex;
            }
            rowIndex++;
        }
    }

    void WriteExportSection(string name, IList<dynamic> items)
    {
        worksheet.Cells[rowIndex, 0].Value = name;
        rowIndex++;
        worksheet.Cells[rowIndex, 0].Value = "Account";
        worksheet.Cells[rowIndex, 1].Value = "Amount";
        worksheet.Cells[rowIndex, 2].Value = "Is active";
        rowIndex++;
        var activeRows = WriteRowValues(items);
        rowIndex++;
        worksheet.Cells[rowIndex, 0].Value = "Total active";
        worksheet.Cells[rowIndex, 1].Formula = "SUM(" + string.Join(",", activeRows.Select(r => worksheet.Cells[r, 1].Name)) + ")";
        rowIndex++;
    }
}

A: This is because WriteRowValues is using deferred execution. Because it's using yield, it does not execute until you start iterating it with the expression:
activeRows.Select(r => worksheet.Cells[r, 1].Name))

As such, the rowIndex variable isn't incremented until you already start outputting the total rows. These lines outputting the totals:
worksheet.Cells[rowIndex, 0].Value = "Total active";
worksheet.Cells[rowIndex, 1].Formula = "SUM(" + string.Join(",", activeRows.Select(r => worksheet.Cells[r, 1].Name)) + ")";

Still have rowIndex at their original, unincremented values. That is, the "first row" for data.
The simplest fix is to just force execution immediately:
var activeRows = WriteRowValues(items).ToList();

A more proper fix is probably to just ditch the deferred execution altogether since it doesn't seem that you're taking advantage of it, and it could cause issues later (say if you end up iterating it twice):
List<int> WriteRowValues(IList<dynamic> items)
{
    var activeIndexes = new List<int>();
    foreach(var item in items)
    {
        worksheet.Cells[rowIndex, 0].Value = item.Name;
        worksheet.Cells[rowIndex, 1].Value = item.Amount;
        worksheet.Cells[rowIndex, 2].Value = item.Active;
        if (item.Active)
        {
            activeIndexes.Add(rowIndex);
        }
        rowIndex++;
    }
    return activeIndexes;
}


text:
You are here: Home>Locations>Haselor>Stocks to N of Manor House, Haselor.
Stocks to N of Manor House, Haselor.
Haselor Stocks
Description of this historic site
Stocks, a wooden structure in which offenders' hands and feet were locked as a punishment. They were in use between the Medieval and Imperial periods and are situated north of Manor House, Haselor.
Please upload a photograph of this historic site.
Notes about this historic site
1 N of the manor house and near a barn by the wayside are the ancient stocks, containing space for three cultprits. Last used about the year 1841.
2 The much restored village stocks.
3 These stocks are still intact.
For the sources of these notes, see the
Timetrail record
produced by the Historic Environment Record.
Haselor (75)
Prisons and Reformatories (65)
Stocks and Gibbets (44)
Medieval - 1066-1539 (3138)
Alternative reference number
MWA1506
More from Haselor
Lodge Farm, Haselor
Lodge Farm, a model farm which was established during the Imperial period. It is situated 600m north west of Red Hill.
Find of Roman coin in Haselor parish
The find of a Roman coin 500m east of Alcock's Arbour, 1km southwest of Upton.
Haselor/Upton Mill
A watermill at Upton/Haselor for which there is documentary evidence from the Medieval period. Its exact location is unknown.
Cross in Haselor Churchyard
The remains of a Medieval stone cross of which only the base remains. It is situated in Haselor Churchyard.
More from Prisons and Reformatories
Stocks at Lower Shuckburgh
Village stocks, in which an offender's wrists and/or ankles were held as a punishment. The stocks probably date to the Post Medieval period, and the remaining wooden stump is located 50m southwest of St John the Baptist's Church.
Coleshill Pillory
Coleshill pillory, a wooden frame with holes for the offender's neck and wrists, which dates back to the Medieval period. The pillory also has stocks attached and acted as a whipping post. Originally situated in front of the Market Hall it is now on Church Street, Coleshill.
Stocks in Market Place, Dunchurch
Dunchurch village stocks, a wooden structure in which the feet and/or hands of criminals would have been locked as a punishment. The stocks were used during the Post Medieval and Imperial periods. They were situated in Market Place, Dunchurch.
Site of Stocks in Bridge Street
The site of stocks, in which the offender's wrists and/or ankles were held as a punishment. They dated to the Imperial period, and were located at the junction of Bridge Street and School Lane, Kenilworth. They were later moved to Borrowell Lane.
More from Stocks and Gibbets
Site of Stocks at Henley in Arden
The site of the village stocks at Henley in Arden, in which the hands and/or feet of the offender would have been locked as a punishment. The stocks date back to at least the Imperial period, and were located near the Market Cross.
Stocks at Saxon Mill
Wooden stocks dating to the Post Medieval period, in which an offender's wrist's and/or ankles were locked as a punishment. The original site of these stocks is unclear. They were restored in 1957 and are now at The Saxon Mill public house just north of Warwick.
Site of Gibbet at Cranhill
The site of a gibbet, a structure from which the bodies of criminals were hung after they had been executed. The gibbet was in use during the Imperial period. It was situated at Cranhill.


text:
Jeanette Zwingenberger, née à Memmingen (Bavière) en 1962, est historienne de l'art et commissaire d'exposition indépendante. Elle enseigne à Paris 1 Panthéon-Sorbonne et elle est membre de AICA l'Association internationale des critiques d'art ainsi que du Comité consultatif pour les œuvres d'art de l'UNESCO. Auteur de nombreux catalogues d'expositions de la scène internationale et de livres monographiques, elle collabore régulièrement avec artpress, Beaux-Art, L'Œil, Connaissance des arts et en tant qu'experte d'art des nouvelles tendances.

Biographie
Jeanette Zwingenberger, docteur en histoire de l'art, publie sa thèse en 1999 chez Parkstone à Londres sur Hans Holbein le Jeune, L'Ombre de la mort. Elle se spécialise dans l'étude des anamorphoses, des images en transformations et des images doubles dans l'histoire de l'art. Elle participe à d'importantes expositions internationales sur ce sujet comme en 2009 aux Galeries nationales du Grand Palais à Paris : Une image peut en cacher une autre, Arcimboldo, Salvador Dalí, Markus Raetz. En 2011, elle organise à Paris une exposition autour du cannibalisme dans l'art : Tous cannibales, à La Maison rouge, fondation Antoine-de-Galbert. Depuis 2000, elle conçoit des expositions avec des artistes contemporains sur lesquels elle écrit, comme Jean Daviot, Max Wechsler, Laurent Mareschal, Erró, Raffi Kaiser, Marc Couturier, Gary Hill, Jean-Pierre Bertrand, Norbert Bisky, Alighiero Boetti, ...

Expositions

2021-2022: L'Afrique(s) vue par ses photographes: de Malick Sidibé à nos jours. Musée Mohammed VI d'Art Moderne et Contemporain, Rabat, Maroc 2021-2022.
2019 :
Juul Kraijer, Morphogenesis, the life of forms, Galerie Les Filles du Calvaire, Paris
2018 :
Agustin Fernandez (La Havane 1928 – New York 2006), Paradoxe de la jouissance, Mairie du , Paris, Catalogue ed. Cassi Paris et Agustin Fernandez foundation,
2017 :
Participant of the Antarctic Biennale] 16.3-28.3.2017
 Conference Pan Gongkai, Long Museum (West Bund) Shanghai, 15.4.2017
 2016 :
Who are your #femaleheroes? 24.6.2016 – 27.8.2016, Galerie Priska Pasquer, Köln
 2015 :
Oksana Mas : Get together, 12.11.2015-12.1.2016, artfactory, Istanbul.
 [curated by_Vienna "tomorrow today_2015, Condensed times and imploding worlds, Galerie Hilger 11.9. – 27.9 2015.
 2014:
Paysages métaphysiques, avec Marc Couturier, Evgeni Dybsky, Raffi Kaiser et Frank Perrin ; Galerie Artvera's, Genève.
 2013 :
EPITOPOU Nombres, lettres et traces : Parcours d'installations in situ à la Bibliothèque Kaireios avec EvaT Bony, Kostas Bassanos, Anne Brochot, Laurent Mareschal et Nina Papaconstantinou ; Andros, Cyclades,  - .
Beau paysage – nature en péril. L'âge d'or du paysage hollandais en dialogue avec la scène actuelle, Sélection de la collection de SØR Rusche Sammlung Oelde/Berlin ; Kunsthalle Dominikanerkirche, Osnabrück,  - .
 2012 :
La Plasticité du langage ; Fondation Hippocrène, Paris,  - .
 2011 :
 Biennale de Venise, Curator of the Collateral Events: Anastasia Khoroshilova, Starie Novosti (Old News), 2.2.2011 – 27.11.2011. organisée par le Musée d'art moderne de Moscou]
Tous cannibales, La Maison rouge, fondation Antoine-de-Galbert ; Paris, -.
Alles Kannibalen, Me Collectors Room, Thomas Olbricht ; Berlin, -.
Propos d'Europe 10 : Des artistes belges ; Fondation Hippocrène, Paris  - .
 2010 : Propos d'Europe 9.0 : Des Artistes espagnols ; Fondation Hippocrène, Paris,  - .
 2009 :
 Une image peut en cacher une autre, Arcimboldo, Salvador Dalí, Markus Raetz ; Galeries nationales du Grand Palais, Paris.
 Materialität der Sprache, Jean Daviot et Max Wechsler ; Fondation Hippocrène, KunstbüroBerlin, Berlin.
 Propos d'Europe 8.0 Paris/Berlin ; Fondation Hippocrène, Paris.
2007 :
Transformationen, Entgrenzungen, Körperräume ; Villa Oppenheim, Galerie für Gegenwartskunst, Berlin et château d'Oiron.
2006 :
L'Homme-Paysage, Visions artistiques du paysage anthropomorphe entre le  ; Palais des beaux-arts de Lille

Publications

Livres
Léonard de Vinci, L'énigme des images, Jeanette Zwingenberger, In Fine éditions d'art, Paris 2019, .
Egon Schiele, Parkstone ed., Londres 2001 (éd. française, anglais et allemand)
 Hans Holbein le Jeune L'Ombre de la mort, Parkstone ed., Londres 1999, .

Catalogues d'expositions
 2021 :
All I want, Portuguese Women Artists from 1900 to 2020, ed. Calouste Gulbenkian Museum, INCM, Lisboa 2021.
« Face à Arcimboldo », éd., Centre Pompidou-Metz.
2020 :
George Legrady, Interweaving Time & Fluid Spaces, University of California, Santa Barbara, 2020.
2019 :
«Abel's Eye, Jeanette Zwingenberger, Cat. Exp. Metamorfoses da Humanidade de Graça Morais, Museu Nacional de Arte Contemporânea – Museu do Chiado, 22.3.-2.6.2019, Lisboa.
 «Le corps en morceau », dans Les Monstres, impossibles possibles, TDC, n°1122, Canopé, 2019.
 «Le rapt et la sidération chez Ovide », dans cat. exp. Amour, Une histoire des manières d'aimer, Musée du Louvre-Lens 26.9.2018 – 21.1.2019, Lienart éd. 2018.
 2017 :
«A space for topological reflection, Sébastien de Ganay in Transposition and Reproduction in A Gothic Context, Kerber Verlag Bielefeld, [Kunsthalle Krems, 2017.
Vices et vertus, 18.02 - 21.05.2017 Namur. Aïdan Salakhova, Erotisme dissimulé et religions, éd. Stichting Kunstboek.
2016 :
Artistes et Architecture, Dimensions variables, Pavillon de l'Arsenal, 16.9.2015 - 17.1.2016 : Corps Réseaux et architecture organique.
 Melissa Ichiuji, "Polymorphous Doll = Obscure Object of Desire", American University Museum Katzen arts Center, Washington 12.11-18.12.2016
MAIKE FREESS - VON BLINDER GEWISSHEIT (Of Blind Certainty), Von der Heydt-Kunsthalle, Wuppertal, Germany, 30.8. 2015 - 3.1.2016, éd Kettler.
Rui Moreira, Mudam, Luxembourg. Catalogue d'exposition Oliver Dorfer Galerie Hilger, Vienne.
 Catalogue d'exposition Norbert Bisky, Kunsthalle Rostock, [Hatje Cantz Verlag] Catalogue d'exposition Dataspaces d'Erró, Galerie Ernst Hilger, Paris.
 2013 :
Evgeni Dybsky, Giotto Project.Schöne Landschaft – Bedrohte Natur, Kunsthalle Dominikanerkirche, Osnabrück.
 2012 :
Êtres chairs : Oda Jaune, Maison de la Culture, Namur.
 2010 :
Frida Kahlo's, Human landscape, rétrospective Frida Kahlo, 2010, [Martin Gropius-Bau] Berlin and Kunstforum Wien, éditions Prestel.
 2009 :
Une image peut en cacher une autre : Arcimboldo, Salvador Dalí, Raetz, Réunion des musées nationaux, Paris.
 2007 :
Carlos Pazos, En blanc et noir, Institut Cervantes, Paris, ed. Institut Raymond Lulle, Barcelone.
 2006 :
L'Homme-paysage. Visions artistiques du paysage anthropomorphe entre le , palais des beaux-arts de Lille, Paris, [Somogy].
 2007 :
Jean Daviot, Écriture de lumières, Vidéo K.01, édition Le Parvis, Pau.
 2005 :
L'Œuvre en programme, capcMusée, Bordeaux.
 2004 :
 Scène polonaise, l'Anthologie des écrits polonais, École des beaux-arts de Paris
 Alighiero Boetti. Quasi tutto, Galleria d'Arte Moderna e Contemporanea, Bergamo.
 Jean-Pierre Bertrand : Consubstantiellement, Musée Picasso, Antibes.
 2003 :
 La creazione ansiosa, Galleria Civica d'Arte Moderna et Contemporanea, Palazzo Fori, Verona, articles sur des artistes viennois : Schiele, Schönberg, Kokoschka, Gertl.
 Raffi Kaiser, Galleria del Leone, Venise.
 Kinderportait (Portrait d'enfant) Bonn, Kunst-und Ausstellungshalle der Bundesrepublik Deutschland, Bonn.

Revues
 Conception du hors série, Beaux Arts éditions, La plasticité du langage, .
 Conception du hors série, art press 2, Tous Cannibales, n° 20,
 « Corps déchets dans l'art contemporain », Journal français de psychiatrie, 2009/2 (n°33)
 Molecular interfaces, Une architecture des humeurs R&Sie(n) Le Laboratoire, Paris, n° spéciale, Mouvement, 2010
 L'art, la mode … et le corps, Arts & Mode : ® évolutions croisée, Œil de la mode, Paris 2009
Vertigo, Esthétique et Histoire du Cinéma, Quand écouter c'est voir. Dialogue entre les œuvres de Gary Hill et d'Edgard Varèse, Festival d'Automne, n° 36, 2009
 Conception du Hors séries, art press 2, Images cachées, n°13,
 Les corps mutant des artistes, Bio-art, La Revue Rue Descartes du Collège international de philosophie, n°64, La métamorphose, le monde, Puf, printemps 2009
 From micro/macrocosm to the aesthetic of ruins and waste-bodies, in RES 55/56, université Harvard, été-automne 2009
 De l'image du diable à celle de la mort, dans Le Diable, Colloque de Cérisy, Paris, 1998, éd. Dervy

Notes et références

Liens externes

 https://www.archivesdelacritiquedart.org/auteur/zwingenberger-jeanette
 https://univ-paris1.academia.edu/JeanetteZwingenberger

Naissance à Memmingen
Critique d'art
Naissance en 1962

redpajama_set_name: RedPajamaWikipedia