Frege is a Haskell for the JVM and can as such support STM with all the benefits of a purely functional language. In particular, Frege guarantees through the type system that no transactional variable (TVar) can be accessed outside a transaction and no side effect can happen inside a transaction.

1. STM
Software Transactional Memory
in Frege - a purely functional JVM language
Quickie
OOP 2016

2. Dierk König
Canoo
mittie

3. Dierk König
Canoo
mittie

4. Silly Clock
10010

5. Silly Clock
10010 every ms

6. Silly Clock
10010 every ms
on overflow

7. Silly Clock
10010 every ms
on overflow
every so often

8. Transactional Variables
10010
CounterCounter
millissecs
TVar Int

9. Create new TVar
type Counter = TVar Int
newCounter :: STM Counter
newCounter = TVar.new 0
STM action type

10. Read & Write TVar
tick :: Counter -> STM ()
tick counter = do
value <- counter.read
counter.write (value + 1)
STM action (no IO)

11. Check transaction invariant
maxTick :: Counter -> Int -> STM ()
maxTick counter max = do
tick counter
value <- counter.read
check (value <= max)

12. Check transaction invariant
maxTick :: Counter -> Int -> STM ()
maxTick counter max = do
tick counter
value <- counter.read
check (value <= max)
Composition !

13. Consistent update
onOverflow :: Counter->Counter->Int->STM ()
onOverflow counter overflowCounter max = do
value <- counter.read
check (value == max)
tick overflowCounter
reset counter
Composition !

14. Type of reset enforced
reset :: Counter -> STM ()
reset counter = counter.write 0
must be STM action

15. Atomically
report :: Counter -> Counter -> IO ()
report millis secs = do
(millisValue, secsValue) <- atomically $ do
a <- millis.read
b <- secs.read
return (a, b)
println $ show secsValue ++ " " ++ show millisValue
Transaction demarcation
calls STM action inside IO action

16. Starting the threads
main _ = do
millis <- atomically newCounter
secs <- atomically newCounter
milliOverflow = 1000
runTicker = maxTick millis milliOverflow
runSec = onOverflow millis secs milliOverflow
forkOS $ forever (atomically runTicker >> Thread.sleep 1)
forkOS $ forever (atomically runSec )
forever (report millis secs >> Thread.sleep 100)

17. STM
Works like compare and swap but for all
TVars inside an atomically function
plus invariants (check)
plus alternatives (orElse)
plus proper exception handling
No locks -> No deadlocks

18. First one wins
isolated work commit
fail
retry

19. STM
Replaces all your locks just like GC
replaces manual memory management
Makes compositional and modular code
Is optimistic and thus works best in low
contention scenarios
Is not a panacea (sorry).

20. Classic: Account transfer
deposit :: Account -> Int -> STM ()
deposit account amount = do
balance <- account.read
account.write (balance + amount)
withdraw :: Account -> Int -> STM ()
withdraw account amount =
deposit account (- amount) -- composed
limitedWithdraw :: Account -> Int -> STM ()
limitedWithdraw account amount = do
withdraw account amount -- composed
balance <- account.read
check (balance >= 0)
transfer :: Account -> Account -> Int -> STM ()
transfer from to amount = do
limitedWithdraw from amount -- composed
deposit to amount -- composed

21. Classic: Ant colony
Ants
Food
Pheromones
Evaporation
Reporter

23. STM relies upon

24. STM relies upon
No access to TVars outside transactions
No side effects inside transactions

25. STM relies upon
No access to TVars outside transactions
No side effects inside transactions
TYPE SYSTEM (pure FP)
Developer discipline (everybody else)

26. STM relies upon
No access to TVars outside transactions
No side effects inside transactions
TYPE SYSTEM (pure FP)
Developer discipline (everybody else)
www.frege-lang.org
is the only option on the JVM

27. Dierk König
canoo
mittie
Credits
Volker Steiss
master thesis
Simon Peyton-Jones
Beautiful concurrency

28. Dierk König
canoo
mittie
Please give feedback!
Credits
Volker Steiss
master thesis
Simon Peyton-Jones
Beautiful concurrency