concurrency in the news

8.15: news.adda/ROS (robot`OS)/summary:

. recently it was conjectured that the best chance for a

prog'lang that features concurrency better than threads

is going to be the use of a configuration co.language

which coordinates the modules of a system

while the user's prefered language defines the modules .

. now it's been reported by Kurzweil

that several university labs have settled on a configuration lang

for the problem of needing a standard platform for robotics development .

. there is currently an impl' for python,

giving that a healthy concurrency model,

and making it mixable with other languages .

. see ROS: an open-source Robot Operating System (pdf) .

. the project is hosted sourceforge.net .

12.16: todo.adda/e`promises/lots of interesting unfamiliars here:

http://wiki.erights.org/wiki/Promise

http://en.wikipedia.org/wiki/Futures_and_promises

In E a future is represented by a pair of values

called a "promise/resolver pair".

The promise represents the read-only view,

and the resolver is required in order to set the future's value.

Support for read-only views is consistent with the Principle of Least Authority,

since it enables the ability to set the value

to be restricted to subjects that need to set it.

In a system that also supports pipelining,

the sender of an asynchronous message (with result)

receives the read-only promise for the result,

and the target of the message receives the resolver.

Promise pipelining should be distinguished from

parallel asynchronous message passing.

In a system supporting parallel message passing

but not pipelining,

the message sends x <- a() and y <- b() in the above example

could proceed in parallel,

but the send of t1 <- c(t2)

would have to wait until both t1 and t2 had been received,

even when x, y, t1, and t2 are on the same remote machine.

The relative latency advantage of pipelining

becomes even greater in more complicated situations

involving many messages.

Promise pipelining also should not be confused with

pipelined message processing in Actor systems,

where it is possible for an actor to specify and begin executing

a behaviour for the next message

before having completed processing of the current message.

. a promise pipelining system has first-class promise values

when an argument to, and the value returned by a call or send

can directly be a promise .

12.19: news.adda/concurrency:

humans are actually quite adept at concurrency

. web for adda/0908's source of

"(humans are actually quite adept at reasoning about concurrent systems)

[PDF] Are new languages necessary for multicore?

ptolemy.eecs.berkeley.edu/.../CGO_Panel_PositionStatement_Lee.pdf

[PDF] Cyber-Physical Systems - Are Computing Foundations Adequate?

mesl.ucsd.edu/gupta/cse237b/Readings/Lee_CPS_PositionPaper.pdf -

Symposium on Code Generation and Optimization (CGO) ` CGO-2007 Panel

www.cgo.org/cgo2007/html/panel.html