\begin{slide}{STM in Clojure (Beispiele)}

Clojure $=$ LISP für JVM

\begin{verbatim}
(def foo (ref "bar"))  -- newTVar

(deref foo)            -- readTVar
@foo

(ref-set foo "oof")    -- writeTVar
(dosync (ref-set foo "oof"))
\end{verbatim}
Quellen:
\begin{itemize}
\item 
Kap. 6 \emph{Concurrency} aus: Stuart Halloway, \emph{Programming Clojure},
Pragmatic Bookshelf, 2009;
\item
\url{http://clojure.org/refs}
\end{itemize}

\end{slide}

\begin{slide}{STM in Clojure (Sicherheit)}

Transaktionsvariablen ohne Transaktion benutzen:
\begin{itemize}
\item Haskell: statischer Typfehler
\item Clojure: Laufzeitfehler
\end{itemize}

IO innerhalb einer Transaktion:
\begin{itemize}
\item Haskell: statischer Typfehler
\item Clojure: 
``I/O and other activities with side-effects 
should be avoided in transaction\dots''
\end{itemize}

Übung: ein Programm konstruieren, bei dem eine IO-Aktion
innerhalb einer Transaktion stattfindet, aber die Transaktion
nicht erfolgreich ist.

\end{slide}

\begin{slide}{Transaktion mit Nebenwirkung}
Transaktionen:
\begin{verbatim}
(def base 100)
(def source (ref (* base base)))
(def target (ref 0))
(defn move [foo]
   (dotimes [x base]
      (dosync (ref-set source (- @source 1))
	      (ref-set target (+ @target 1))) ))
(def movers (for [x (range 1 base)] (agent nil)))
(dorun (map #(send-off % move) movers))
\end{verbatim}
Nebenwirkung einbauen:
\begin{verbatim}
(def c (atom 0)) ... (swap! c inc) ... 
(printf c)
\end{verbatim}

\end{slide}

\begin{slide}{STM und persistente Datenstrukturen}

``The Clojure MVCC STM is designed to work with the persistent collections, and it is strongly recommended that you use the Clojure collections as the values of your Refs. Since all work done in an STM transaction is speculative, it is imperative that there be a low cost to making copies and modifications.''

``The values placed in Refs must be, or be considered, immutable!!''

Beispiel Suchbäume:
\begin{itemize}
\item destruktiv: Kind-Zeiger der Knoten verbiegen,
\item persistent: neue Knoten anlegen.
\end{itemize}

Bsp: persistenter Suchbaum in Haskell 

\end{slide}
