Scala begonnen; Nachtrag zu Monitor / Semaphore

documents/Programmierparadigmen/Parallelitaet.tex

@@ -140,4 +140,48 @@ Semaphoren können eingesetzt werden um Wettlaufsituationen zu verhindern.
     Bedingung ist.
 \end{definition}
 
+Monitore können mit einer Semaphore, bei der $c=1$ ist, implementiert werden. 
+Monitore sorgen dafür, dass auf die Methoden der Objekte, die sie repräsentieren, 
+zu jedem Zeitpunkt nur ein mal ausgeführt werden können. Sie sorgen also für
+\textit{gegenseitigen Ausschluss}.
+
+\begin{beispiel}[Monitor]
+    Folgendes Beispiel von \url{https://en.wikipedia.org/w/index.php?title=Monitor_(synchronization)&oldid=596007585} verdeutlicht den Nutzen eines Monitors:
+
+\begin{verbatim}
+monitor class Account {
+  private int balance := 0
+  invariant balance >= 0
+
+  public method boolean withdraw(int amount)
+     precondition amount >= 0
+  {
+    if balance < amount:
+        return false
+    else:
+        balance := balance - amount
+        return true
+  }
+
+  public method deposit(int amount)
+     precondition amount >= 0
+  {
+    balance := balance + amount
+  }
+}
+\end{verbatim}
+\end{beispiel}
+
+\section{Parallelität in Java}
+Java unterstützt mit der Klasse \texttt{Thread} und dem Interface \texttt{Runnable}
+Parallelität.
+
+Interessante Stichwörder sind noch:
+\begin{itemize}
+    \item ThreadPool
+    \item Interface Executor
+    \item Interface Future<V>
+    \item Interface Callable<V>
+\end{itemize}
+
 \index{Parallelität|)}

documents/Programmierparadigmen/Scala.tex

@@ -2,10 +2,75 @@
 \index{Scala|(}
 
 Scala ist eine funktionale Programmiersprache, die auf der JVM aufbaut
-und in Java Bytecode kompiliert wird.
+und in Java Bytecode kompiliert wird. Scala bedeutet \underline{sca}lable
+\underline{la}nguage.
+
+Mit sog. \enquote{actors} bietet Scala eine Unterstützung für die Entwicklung
+prallel ausführender Programme.
+
+Weitere Materialien sind unter \url{http://www.scala-lang.org/} und
+\url{http://www.simplyscala.com/} zu finden.
+
+\section{Erste Schritte}
+Scala kann auf Debian-basierten Systemen durch das Paket \texttt{scala} installiert
+werden.
+
+\subsection{Hello World}
+\subsubsection{Interaktiv}
+Folgendes Beispiel stammt von \url{http://wiki.ubuntuusers.de/Scala}.
+\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=scala-test.scala]{scala}{scripts/scala/scala-test.scala}
+Es kann mit \texttt{./scala-test.scala Scala funktioniert} ausgeführt werden.
+
+\subsubsection{Kompiliert}
+\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=hello-world.scala]{scala}{scripts/scala/hello-world.scala}
+
+Dieses Beispiel kann mit \texttt{scalac hello-world.scala} kompiliert und mit
+\texttt{scala HelloWorld} ausgeführt werden.
+
+\section{Vergleich mit Java}
+Scala und Java haben einige Gemeinsamkeiten, wie den Java Bytecode, aber auch
+einige Unterschiede.
+
+\noindent\parbox[t]{2.4in}{\raggedright%
+\textbf{\textit{Gemeinsamkeiten}}
+\begin{itemize}[topsep=0pt,itemsep=-2pt,leftmargin=13pt]
+    \item Java Bytecode
+    \item Keine Mehrfachvererbung
+    \item Statische Typisierung
+    \item Scopes
+\end{itemize}
+}%
+\parbox[t]{2.4in}{\raggedright%
+\textbf{\textit{Unterschiede}}
+\begin{itemize}[topsep=0pt,itemsep=-2pt,leftmargin=13pt]
+    \item Java hat Interfaces, Scala hat traits.
+    \item Java hat primitive Typen, Scala ausschließlich Objekte.
+    \item Scala benötigt kein \texttt{;} am Ende von Anweisungen.
+\end{itemize}
+}
+
+Weitere Informationen hat Graham Lea unter \url{http://grahamhackingscala.blogspot.de/2009/11/scala-under-hood-of-hello-world.html} zur Verfügung gestellt.
 
 \section{Syntax}
+In Scala gibt es sog. \textit{values}, die durch das Schlüsselwort \texttt{val}\xindex{val}
+angezeigt werden. Diese sind Konstanten. Die Syntax ist der UML-Syntax ähnlich.
+
+\begin{verbatim}
+val name: type = value
+\end{verbatim}
+
+Variablen werden durch das Schlüsselwort \texttt{var}\xindex{var} angezeigt:
+
+\begin{verbatim}
+var name: type = value
+\end{verbatim}
+
+Methoden werden mit dem Schlüsselwort \texttt{def}\xindex{def} erzeugt:
+
+\begin{verbatim}
+def name(parameter: String): Unit = { code body... }
+\end{verbatim}
+
 \section{Beispiele}
 
 \index{Scala|)}
-

documents/Programmierparadigmen/Vorwort.tex

@@ -1,9 +1,10 @@
 %!TEX root = Programmierparadigmen.tex
 \chapter*{Vorwort}
 Dieses Skript wird/wurde im Wintersemester 2013/2014
-von Martin Thoma zur Vorlesung von Prof.~Dr.~Snelting geschrieben. Dazu wurden
+von Martin Thoma zur Vorlesung von Prof.~Dr.~Snelting und Jun.-Prof.~Dr.~Hummel 
-die Folien von Prof.~Dr.~Snelting benutzt, die Struktur sowie einige Beispiele,
+geschrieben. Dazu wurden
-Definitionen und Sätze übernommen.
+die Folien von Prof.~Dr.~Snelting und Jun.-Prof.~Dr.~Hummel benutzt, die Struktur
+sowie einige Beispiele, Definitionen und Sätze übernommen.
 
 Das Ziel dieses Skriptes ist vor allem
 in der Klausur als Nachschlagewerk zu dienen; es soll jedoch auch

documents/Programmierparadigmen/scripts/scala/hello-world.scala

@@ -0,0 +1,5 @@
+object HelloWorld {
+    def main(args: Array[String]) {
+        println("Hello World!")
+    }
+}

documents/Programmierparadigmen/scripts/scala/scala-test.scala

@@ -0,0 +1,6 @@
+#!/usr/bin/env scala
+!#
+def promptprint (s: String) = {println ("> " + s)}
+
+println ("Hallo ")
+args foreach promptprint