Concurrent Revisions Daniel W. H. James @dwhjames 

This is not the Akka talk you were looking for… 

What if your program could be concurrent in the same way that you use git? 

research.microsoft.com/ en-us/projects/revisions Disclosure: not my work! 

Sebastian Burckhardt, Alexandro Baldassion, and Daan Leijen. Concurrent Programming with Revisions and Isolation Types. In Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA’10), ACM SIGPLAN, Reno, NV, October 2010 Daan Leijen, Sebastian Burckhardt, and Manuel Fahndrich. Prettier Concurrency: Purely Functional Concurrent Revisions. In Haskell Symposium 2011 (Haskell’11), ACM SIGPLAN, Tokyo, Japan, 7 July 2011 Disclosure: not my work! 

val v = VersionedValue(0) isolation type -> 

val v = VersionedValue(0) 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } assert(v.value === 0) 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } assert(v.value === 0) Revision.join(r) assert(v.value === 1) 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } v.value = 2 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } v.value = 2 assert(v.value === 2) 

val v = VersionedValue(0) val r = Revision.fork { assert(v.value === 0) v.value = 1 } v.value = 2 assert(v.value === 2) Revision.join(r) assert(v.value === 1) 

git merge -X theirs myRev 

val v = CumulativeValue(1, addMerge) isolation type -> merge fn -> 

val v = CumulativeValue(1, addMerge) 

val v = CumulativeValue(1, addMerge) val r = Revision.fork { assert(v.value === 1) v.value += 2 } 

val v = CumulativeValue(1, addMerge) val r = Revision.fork { assert(v.value === 1) v.value += 2 } v.value += 3 

val v = CumulativeValue(1, addMerge) val r = Revision.fork { assert(v.value === 1) v.value += 2 } v.value += 3 assert(v.value === 4) 

val v = CumulativeValue(1, addMerge) val r = Revision.fork { assert(v.value === 1) v.value += 2 } v.value += 3 assert(v.value === 4) Revision.join(r) assert(v.value === 6) 

val addMerge = (root: Int, main: Int, join: Int) => main + join - root 

v = 1 v += 2 v += 3 assert(v === 6) 

val x = VersionedValue(0) val y = VersionedValue(0) val r = Revision.fork { if (x.value == 0) y.value += 1 } if (y.value == 0) x.value += 1 Revision.join(r) assert(x.value === ???) assert(y.value === ???) 

x = 0 y = 0 if(y==0) x++ assert(???) if(x==0) y++ 

x = 0 y = 0 if(y==0) x++ assert((x==0 && y==1) || (x==1 && y==0) || (x==1 && y==1)) if(x==0) y++ sequential consistency 

x = 0 y = 0 lock.synchronized { if(y==0) x++ } assert((x==0 && y==1) || (x==1 && y==0)) lock.synchronized { if(x==0) y++ } mutex lock 

x = 0 y = 0 atomic { if(y==0) x++ } assert((x==0 && y==1) || (x==1 && y==0)) atomic { if(x==0) y++ } transactional memory 

x = 0 y = 0 if(y==0) x++ assert(x==1 && y==1) if(x==0) y++ concurrent revisions 

github.com/dwhjames/ scala-concurrent-revisions 

Demo!