The document describes how Ozma extends the Scala programming language with constructs for declarative concurrency including thread for spawning concurrent tasks, Port for asynchronous message passing, and byNeedFuture and .lazified for lazy evaluation. It provides examples of using these features to concurrently map a function over a list, implement an agent that displays squared even numbers, and execute tasks with a partial barrier. The methodology is to start with sequential programs and add concurrency features where needed to introduce parallelism without changing results.

1. Ozma: Extending Scala with Oz concurrency
Sébastien Doeraene

2. Tail recursion modulo cons
def append[A](front: List[A], back: List[A]): List[A] =
if (front.isEmpty) back
else front.head :: append(front.tail, back)

3. Declarative concurrency
def map[A, B](list: List[A], f: A => B): List[B] =
if (list.isEmpty) Nil
else f(list.head) :: map(list.tail, f)
def cmap[A, B](list: List[A], f: A => B): List[B] =
if (list.isEmpty) Nil
else thread(f(list.head)) :: cmap(list.tail, f)

4. Declarative agents
def displayEvenSquares() {
val integers = thread(gen(0))
val evens = thread(integers filter (_ % 2 == 0))
val evenSquares = thread(evens map (x => x*x))
evenSquares foreach println
}
def gen(from: Int): List[Int] =
from :: gen(from+1)

5. Lazy execution
def displayEvenSquares() {
val integers = gen(0)
val evens = integers.lazified filter (_ % 2 == 0)
val evenSquares = evens.lazified map (x => x*x)
evenSquares foreach println
}
def gen(from: Int): List[Int] = byNeedFuture {
from :: gen(from+1)
}

6. Ports
def partialBarrier(m: Int, tasks: List[() => Unit]) {
val (stream, port) = Port.newPort[Unit]
for (task <­ tasks)
thread { task(); port.send(()) }
stream(m­1) // wait until has at least m elements
}
println("start")
partialBarrier(2, List(
() => { sleep(1000); println("a") },
() => { sleep(3000); println("b") },
() => { sleep(2000); println("c") }
))
println("peekaboo")

7. Methodology (if still time remaining)
● Start with straightforward functional programs on lists
● Proove correctness with sequential methods
● Add thread expressions where needed
● Add concurrency, does not change result
● Add ports where needed
● Add nondeterminism exactly where needed, not more
● Add byNeedFuture and .lazified where needed
● Make computations optional, does not change result