important news: refocusing discussion

[Neil Mitchell]

> it's too hard to implement (and it's not always hard
> - the YHC guys
> managed it in a matter of days

Tom is the one who implemented it in Yhc, and details can be found
http://www.haskell.org/haskellwiki/Yhc/RTS/Concurrency

but some of the reasons that it was easier than in other compilers are:

* We compile to byte code, then execute the bytecode. Because of this,
to add support for concurrency only really changes the executer, which
is a standalone program.

* Bytecode also means we can just schedule each process for n instructions.

* Its simulated concurrency, if you have two processors, only one will
ever be used.  The only exception is FFI, where a number of FFI calls
can run in parallel with some Haskell code. This means that no locking
is needed on the global heap.

If compiling to native code, and aiming for proper concurrency at the
operating system level, it would be a lot more work! If you wanted
high performance concurrency, like GHC, you would need to do that
extra work.

Thanks

Neil