Software Transactional Memory

This project seems to us as very risky, for the following reasons:

• it is not strongly related to type systems
• neither Atze nor I are experts in concurrency
• EHC has currently no support for concurrency at all
• a group size of 4 is relatively large

In other words, you should evaluate again if this is really what you want to be doing, or if you could imagine to do something else instead. If you are sure, however, we won't stand in the way, and try to see where it leads us all.

In addition to the Haskell-STM papers, it might also be interesting to look at

• at least one paper describing STM in a non-Haskell context
• the older MVar/Channel approach to concurrency in Haskell
• the paper "Beauty in the Beast" by Wouter Swierstra and Thorsten Altenkirch
• Tomasz Zielonka's FakeSTM. An implementation of STM on top of good old standard MVar's/Chan's.

(plus certainly more)

Students who have voted for this project, please add your names to this page, together with a statement regarding the concerns I voiced above.

-- AndresLoeh - 06 Sep 2007

After thinking about it, I would rather do "tracking kinds in type signatures" or "co- and contravariance of type constructors". My main motivation is that the staff is more knowledgeable on these topics and thus I would learn more than I would with STM. Since one of the concerns is the group size, my departure hopefully benefits the other three students (if they are willing to continue).

-- JeielSchalkwijk - 07 Sep 2007

I had the impression that Maaike would have preferred to do "co- and contravariance of type constructors", but not alone. So maybe we could have three projects in total?

-- AndresLoeh - 07 Sep 2007

I'm not sure in what way it is related with STM (yet), but what I had in mind when I said I wanted to do something with concurrency I had in mind the paper on Data Parallel Haskell. It seems it needs Associated Types and another extension (see Section 4). I'll try to get everything clear for myself over the weekend.

-- EelcoLempsink - 07 Sep 2007

Well, actually I am quite pleased with the topic on associated types. So I would rather not switch.

-- MaaikeGerritsen? - 08 Sep 2007

The slides about NDP were for a presentation which has been put online: SPJ talks about NDP (although I unfortunately get a blank page right now) The current version needs associated datatypes, although there is an older research project An approach to fast arrays in Haskell doing more or less the same in a time before associated types. (The hackery needed when without associated datatypes may have been the reason why that version never really took of.)

In the Haskell world at least, a distinction is usually made between concurrency and paralellism: Concurrency is a programming model for (conceptually) doing multiple things at once, while parallelism is about being faster by using more processors. STM is about concurrency (although it is of course very nice if having more CPUs makes your program faster too...), while NDP is about parallelism. One might say that NDP has nothing to do with concurrency: Concurency is fundamentally non-deterministic, while NDP is completely deterministic.

-- RemiTurk - 08 Sep 2007

Thanks Remi, I was indeed confused about the distinction between concurrency and parallelism. I like how in de NDP slides it's called respectively 'task parallelism' and 'data parallelism'. After reading some websites and papers I'm not entirely sure the Haskell world entirely agrees on the strict distinction, since 'concurrency' and 'parallelism' seem to be used almost interchangeably.

-- EelcoLempsink - 09 Sep 2007

I guess we can talk with Stefan about the alternatives, tomorrow during the meeting.

-- ChrisEidhof - 10 Sep 2007