%!TEX root = Programmierparadigmen.tex
\chapter{X10}\index{X10|(}%
X10 ist eine objektorientierte Programmiersprache, die 2004 bei IBM entwickelt
wurde.

Wie in Scala sind auch in X10 Funktionen First-Class Citizens.

X10 nutzt das PGAS-Modell:

\begin{definition}[PGAS\footnotemark]\xindex{PGAS}%
    PGAS (partitioned global address space) ist ein Programmiermodell für
    Mehrprozessorsysteme und massiv parallele Rechner. Dabei wird der globale
    Adressbereich des Arbeitsspeichers logisch unterteilt. Jeder Prozessor
    bekommt jeweils einen dieser Adressbereiche als lokalen Speicher zugeteilt.
    Trotzdem können alle Prozessoren auf jede Speicherzelle zugreifen, wobei auf
    den lokalen Speicher mit wesentlich höherer Geschwindigkeit zugegriffen
    werden kann als auf den von anderen Prozessoren.
\end{definition}
\footnotetext{\url{https://de.wikipedia.org/wiki/PGAS}}

Im PGAS-Modell gibt es \texttt{places}. Diese sind Platzhalter für Aktivitäten
und Objekte.

\begin{itemize}
    \item \texttt{Place.FIRST\_PLACE} ist der place 0.
    \item \texttt{here} ist der Prozess-eigene place und \texttt{here.next()} ist
          der darauf folgende Place.
    \item \texttt{main} wird in \texttt{place 0} ausgeführt.
    \item \texttt{Place.places()} liefert einen Iterator für alle verfügbaren places.
          Ein spezifischer Place kann durch \texttt{Place(n)} ausgewählt werden.
\end{itemize}

\section{Erste Schritte}
Als erstes sollte man x10 von \url{http://x10-lang.org/x10-development/building-x10-from-source.html?id=248} herunterladen.

Dann kann man die \texttt{bin/x10c} zum erstellen von ausführbaren Dateien nutzen.
Der Befehl \texttt{x10c HelloWorld.x10} erstellt eine ausführbare Datei namens
\texttt{a.out}.

\inputminted[numbersep=5pt, tabsize=4, frame=lines, label=HelloWorld.x10]{cpp}{scripts/x10/HelloWorld.x10}

\section{Syntax}
Genau wie Scala nutzt X10 \texttt{val}\xindex{val (X10)@\texttt{val} (X10)} und \texttt{var}\xindex{var (X10)@\texttt{var} (X10)}, wobei \texttt{val} für
\enquote{value} steht und ein unveränderbarer Wert ist. \texttt{var} hingegen
steht für \enquote{variable} und ist veränderbar.

Eine Besonderheit sind sog. \textit{Constrianed types}\xindex{types!constrained}:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/constrained-type-example.x10}

\subsection{Logische Operatoren}
\begin{table}[H]
    \centering
    \begin{tabular}{CCCC}
    UND    & ODER     & Wahr  & Falsch \\ \hline\hline
    \&\&   & ||       & true  & false \\[4ex]
    GLEICH & UNGLEICH & NICHT & ~     \\ \hline\hline
    ==     & !=       & !     & ~     \\
    \end{tabular}
    \caption{Logische Operatoren in X10}\xindex{Logische Operatoren!X10}
\end{table}

\subsection{Closures}\xindex{closure}%

Closres werden unterstützt:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/closures-example.x10}

\subsection{async}\xindex{async}%

Durch \texttt{async S} kann das Statement \texttt{S} asynchron ausgeführt werden.
Das bedeutet, dass ein neuer Kindprozess (eine Kind-Aktivität) erstellt wird, die
\texttt{S} ausführt. Dabei wird nicht auf das Beenden von \texttt{S} gewartet.
Will man das, so muss \texttt{finish}\xindex{finish (X10)@\texttt{finish} (X10)} vor das Statement gestellt werden.

\subsection{atomic}\xindex{atomic}%
Durch \texttt{atomic S} wird das Statement \texttt{S} atomar ausgeführt. Auch
Methoden können atomar gemacht werden.

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/atomic-example.x10}

\subsection[Bedingtes Warten]{Bedingtes Warten\footnote{WS 2013/2014, Kapitel 43, Folie 22}}\xindex{when (X10)@\texttt{when} (X10)}%
Durch \texttt{when (E) S} kann eine Aktivität warten, bis die Bedingung \texttt{E}
wahr ist um dann das Statement \texttt{S} auszuführen.

An \texttt{E} werden einige Forderungen gestellt:

\begin{itemize}
    \item \texttt{E} muss ein boolescher Ausdruck sein.
    \item \texttt{E} darf nicht blockieren.
    \item \texttt{E} darf keine nebenläufigen Aktivitäten erstellen, muss also
          sequenziell laufen.
    \item \texttt{E} darf nicht auf \textit{remote data} zugreifen, muss also
          lokal arbeiten.
    \item \texttt{E} muss frei von Seiteneffekten sein.
\end{itemize}

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/when-example.x10}

\subsection{Lokalisierung}\footnote{WS 2013/2014, Kapitel 43, Folie 23}\xindex{at}%
Durch \texttt{at (p) S} wird sichergestellt, dass das Statement \texttt{S} auf
dem place \texttt{p} ausgeführt wird. Dabei ist zu beachten, dass die Eltern-Aktivität
so lange blockiert, bis \texttt{S} beendet.

Es wird eine Deep-Copy des lokalen Objektgraphen auf den place \texttt{p} erstellt.

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/at-example.x10}

\section{Datentypen}
Byte, UByte, Short, UShort, Char, Int, UInt, Long, ULong, Float, Double, Boolean,
Complex, String, Point, Region, Dist, Array

\subsection{Arrays}%
Arrays werden in X10 wie folgt definiert:

\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/array-example.x10}

Das ergibt den Array \texttt{[ 0, 2, 4, 6, 8 ]}.

\subsection{struct}\xindex{struct (X10)@\texttt{struct} (X10)}%
In X10 gibt es, wie auch in C, den Typ \texttt{struct}. Dieser erlaubt im Gegensatz
zu Objekten keine Vererbung, kann jedoch auch interfaces implementieren.

Alle Felder eines X10-Structs sind \texttt{val}.

Structs werden verwendet, da sie effizienter als Objekte sind.

\begin{beispiel}[struct]
    \inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/x10-struct-example.x10}
\end{beispiel}

\section{Beispiele}

\todo[inline]{ACHTUNG: Das folgende Beispiel kompiliert noch nicht!}
\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=Fibonacci.x10]{scala}{scripts/x10/Fibonacci.x10}

\section{Weitere Informationen}
\begin{itemize}
    \item \url{http://x10-lang.org/}
\end{itemize}
\index{X10|)}