[pypy-dev] summer of code 2008

[Jakub Gustak]

Hello.

I am wondering if pypy is going to take part in Google Summer of Code this year.

I have an idea, which I would like to hack on (and already talked a
little about it with Armin).
But I sill am not sure if it makes much sense.

I will paste what I send to Armin some time ago:

msg << EOM
I have this weird idea of creating (yet another) scheme dialect on top of pypy
scheme interpreter.

Main features of this dialect would be:
 * strict (in definition) distinction between pure functions, and functions
  with side-effect.
 * parallelism support:
 * e.g. (parallel (f1 ...) (f2 ...)) would compute functions f1 and f2 on
       different processors (if available) and return list of results.
of course,
       f1 and f2 have to be pure functions in this case.
 * interpreter would start as many processes as processors available and
       parallel should schedule functions computation on this "nodes".
 * communication between nodes should be as much transparent as possible,
       so we can create nodes on different machines.
 * there is also another interesting pattern: map-reduce, or scatter-gather,
       which would be nice to have, if parallel back-end would be
capable of this.

We could go further, and even avoid using (parallel) construction, and
parallelize every pure function. Of course that will make sense, if computation
cost is greater than cost of spawning.

I am interested, in this, because lot of people are talking, that functional
programming is <the way> to control parallelism/concurrency, but i haven't seen
any functional language where programming "parallel applications" is like
eating cream and butter.

Similar idea is implemented in haskell, but haskell is lazy, and it works
somehow different:
http://www.haskell.org/ghc/docs/latest/html/users_guide/lang-parallel.html
http://www.haskell.org/ghc/docs/latest/html/libraries/parallel/Control-Parallel.html
EOM

Cheers,
Jakub Gustak