folien.tex

\documentclass[12pt,compress,ngerman]{beamer}
\usepackage{ragged2e}
\usepackage{amsmath}
\usepackage{url}
\usepackage{ucs}
\usepackage[utf8x]{inputenc}
\usepackage[ngerman]{babel}
\usepackage[normalem]{ulem}  % sout
\usepackage{multicol}
\usepackage[protrusion=true,expansion=false]{microtype}

% Manual syntax highlighting
\newcommand{\synfunc}   [1]{\color{blue!50!black}#1\color{black}}
\newcommand{\synstr}    [1]{\color{red!50!black}#1\color{black}}
\newcommand{\synvar}    [1]{\color{purple!50!black}#1\color{black}}
\newcommand{\synclass}  [1]{\color{green!50!black}#1\color{black}}
\newcommand{\syncomment}[1]{\color{blue!20!black}#1\color{black}}
\newcommand{\syncool}   [1]{\color{beamer@blendedblue}#1\color{black}}
\newcommand{\synoder}      {\ \ \color{black}$\vee$\ \ }
\newcommand{\hr}        {\rule[4pt]{\textwidth}{0.1pt}\\}
\newcommand{\hicolor}   [1]{\color[rgb]{0.6,0.2,0.8}#1\color{black}}
\newcommand{\synhilight}[1]{\hicolor{\textbf{#1}}}

\newcommand{\synType}   [1]{\color{red!38!black}#1\color{black}}
\newcommand{\synSym}    [1]{\color{blue!56!black}#1\color{black}}
\newcommand{\synKey}    [1]{\color{blue!56!black}#1\color{black}}
\newcommand{\synLit}    [1]{\color{green!19!black}#1\color{black}}
\newcommand{\synOp}     [1]{\color{green!38!black}#1\color{black}}

\newcommand{\doofcomment}{\ \ \syncomment{\# :-(}}
\newcommand{\gutcomment} {\ \ \syncomment{\# :)}}

\newcommand{\T}[1]{\mathbf{#1}}
\newcommand{\Spur}[1]{\operatorname{Spur}{#1}}
\newcommand{\ul}[1]{\mathcal{#1}}

\definecolor{backblue}{rgb}{0.84,0.84,0.94}
\definecolor{backgrey}{rgb}{0.84,0.84,0.84}

\newcommand{\floatbox}[3]{%
  \raisebox{0pt}[0pt][0pt]{%
    \begin{picture}(0,0)(#1,#2)#3\end{picture}%
  }%
}

\title{Haskell, \\eine rein funktionale Programmiersprache}
\author[Augsburg.pm]{Ingo Blechschmidt \\ \texttt{<iblech@web.de>}}
\date{Augsburg.pm \\ 3. Juni 2014}

\usetheme{Warsaw}  %Warsaw, Berkeley?
\usecolortheme{seahorse}
\usefonttheme{serif}
\useinnertheme{rectangles}
\usepackage{bookman}
%\usepackage{kurier}
\setbeamercovered{invisible}

\setbeamertemplate{navigation symbols}{}
%\setbeamertemplate{headline}{}

\begin{document}

\logo{\begin{picture}(0,0)(80,0)\includegraphics[scale=0.4]{images/haskell-logo.png}\end{picture}}
\frame{\titlepage}
\logo{}

\frame[plain]{\begin{center}
  \includegraphics[scale=0.35]{images/learn-you-a-haskell-for-great-good.png}

  Fragen zu jeder Zeit willkommen!
\end{center}}

\frame[plain]{\justifying\fontsize{7pt}{8.4}\selectfont
  \setlength{\columnsep}{2em}
  \begin{multicols}{2}
  Was ist schneller als C++, prägnanter als Perl, regelmäßiger als Python,
  flexibler als Ruby, typisierter als C\#, robuster als Java und hat
  absolut nichts mit PHP gemeinsam? Es ist Haskell!
  \medskip

  Haskell ist eine moderne und innovative Programmiersprache, die sich von
  bekannten imperativen Sprachen in vielerlei Hinsicht deutlich
  unterscheidet: Ein Haskell-Programm besteht nicht etwa aus einer Abfolge
  von auszuführenden Anweisungen, sondern aus einer Ansammlung von
  Deklarationen, deren Reihenfolge keine Rolle spielt. Auch gibt es keine
  veränderlichen Variablen, und ausgewertet wird nur, was wirklich
  benötigt wird; unendliche Datenstrukturen sind möglich und sinnvoll.
  \medskip

  Dieses Denkparadigma mag anfangs sehr ungewohnt sein, zieht jedoch eine
  Reihe von Vorteilen mit sich: Da es keine Nebenwirkungen wie
  beispielsweise globale Variablen gibt, kann man Code rein lokal
  verstehen. Damit wird es einfacher, modular Komponenten zusammenzubauen,
  sich Datenflüsse klarzumachen und Code auf seine Korrektheit hin zu
  überprüfen. Insbesondere vereinfacht sich die Programmierung mit Threads
  enorm.
  \medskip

  Ferner ist Haskells starkes statisches Typ\-system eine große Hilfe beim
  Programmieren und verhindert viel mehr Fehler schon während des
  Kompilierens, als man vielleicht aus anderen Sprachen gewohnt ist.
  Es gibt das Motto, dass, wenn Haskell-Code erst einmal erfolgreich durchkompiliert, er dann
  auch schon korrekt ist. Das ist sicherlich übertrieben, hat aber einen
  erstaunlich wahren Kern.
  \medskip

  Der Vortrag wird einen subjektiven Über\-blick über die Fähigkeiten und
  typischen Anwendungsgebiete von Haskell geben. Beim Erlernen von Haskell
  lernt man viele neue Herangehensweisen kennen, die auch in anderen
  Sprachen nützlich sind; das ist einer der Hauptvorteile an Haskell, der
  auch dann noch relevant ist, wenn man aus verschiedenen Gründen nicht in
  Haskell programmieren möchte.
  \end{multicols}
}

%\frame[t]{\begin{multicols}{2}\small\tableofcontents\end{multicols}}
\frame[t]{\scriptsize\tableofcontents}

\section{Grundlegendes}
\frame[t]{\frametitle{Über Haskell}
  \floatbox{-225}{200}{\includegraphics[scale=0.35]{images/committee.png}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Hochsprache, rein funktional, \\
          statisch stark typisiert, "`nicht-strikt"'
    \item Sprachspezifikation durch ein Komitee
    \item Veröffentlichung von Haskell 1.0: 1990
    \item Kompiliert und interpretiert
    \item REPL
  \end{itemize}
}

\frame[t]{\frametitle{Imperative Sprachen}
  \floatbox{-180}{200}{\includegraphics[scale=0.4]{images/standard.jpg}}%
  Kennzeichen imperativer Sprachen:
  \begin{itemize}
    \item \textcolor{white}{keine} Anweisungen
    \item \textcolor{white}{keine} veränderliche Variablen
    \item \textcolor{white}{keine} Nebenwirkungen
  \end{itemize}
}

\frame[t]{\frametitle{Haskell ist komisch!}
  \floatbox{-210}{190}{\includegraphics[scale=0.2]{images/endo.png}}%
  Haskell ist rein funktional:
  \begin{itemize}
    \item keine Anweisungen
    \item keine veränderliche Variablen
    \item keine Nebenwirkungen
  \end{itemize}
}

\frame[plain]{\begin{center}
  \includegraphics[scale=0.35]{images/wtf.jpg}\hfill\phantom{a}

  \vfill

  \hfill\includegraphics[scale=0.4]{images/do-stuff.jpeg}
\end{center}}

\subsection[Variablen]{Keine Variablen}
\frame[t]{\frametitle{Erstes Beispiel}
  \floatbox{-260}{180}{\includegraphics[scale=0.1]{images/variable.jpg}}%
  \texttt{%
    \syncomment{\# Perl} \\
    \synfunc{sub}\ main \{\\
    \ \ \ \ \synfunc{my}\ \synvar{\$radius}\ \ \ \ = \synLit{42}; \\
    \ \ \ \ \synfunc{my}\ \synvar{\$quadriert}\ = \synvar{\$radius}\ ** \synLit{2}; \\
    \ \ \ \ \synfunc{my}\ \synvar{\$flaeche}\ \ \ = \synvar{\$quadriert}\ * pi; \\
    \ \ \ \ \synfunc{print}\ \synvar{\$flaeche}; \\
    \}
  }
  \vfill

  \only<2>{
    \texttt{%
      \syncomment{-- Haskell} \\
      main \synSym{=}\\
      \ \ \ \ \synKey{let}\ radius\ \ \ \ \synSym{=}\ \synLit{42} \\
      \ \ \ \ \ \ \ \ quadriert \synSym{=}\ radius\synOp{\^{}}\synLit{2} \\
      \ \ \ \ \ \ \ \ flaeche\ \ \ \synSym{=}\ quadriert \synOp{*}\ pi \\
      \ \ \ \ \synKey{in}\ print\ flaeche
    }
  }

  \only<3>{
    \texttt{%
      \syncomment{-- Haskell} \\
      main \synSym{=}\\
      \ \ \ \ \synKey{let}\ flaeche\ \ \ \synSym{=}\ quadriert \synOp{*}\ pi \\
      \ \ \ \ \ \ \ \ quadriert \synSym{=}\ radius\synOp{\^{}}\synLit{2} \\
      \ \ \ \ \ \ \ \ radius\ \ \ \ \synSym{=}\ \synLit{42} \\
      \ \ \ \ \synKey{in}\ print\ flaeche
    }
  }

  \only<4>{
    \texttt{%
      \syncomment{-- Haskell} \\
      main \synSym{=}\ print\ flaeche \\
      \ \ \ \ \synKey{where} \\
      \ \ \ \ flaeche\ \ \ \synSym{=}\ quadriert \synOp{*}\ pi \\
      \ \ \ \ quadriert \synSym{=}\ radius\synOp{\^{}}\synLit{2} \\
      \ \ \ \ radius\ \ \ \ \synSym{=}\ \synLit{42}
    }
  }
}

\subsection[Nebenwirkungen]{Keine Nebenwirkungen}
\frame[t]{\frametitle{Keine Nebenwirkungen}
  \floatbox{-280}{190}{\includegraphics[scale=0.9]{images/tablette.png}}%
  \vspace{-2em}\setlength{\columnsep}{0pt}%
  \begin{multicols*}{2}
    \texttt{%
      \syncomment{\# Perl} \\
      \synfunc{my}\ \synvar{\$a}\ = f(\synvar{\$x}); \\
      \synfunc{my}\ \synvar{\$b}\ = f(\synvar{\$x}); \\
      \ldots; \\
      \syncomment{\# Ist \$a == \$b?}
    }

    \columnbreak

    \pause
    \texttt{%
      \syncomment{-- Haskell} \\
      \synKey{let}\ a = f x \\
      \ \ \ \ b = f x \\
      \synKey{in}\ \ldots \\
      \syncomment{-- a == b gilt stets.}
    }
  \end{multicols*}

  \vfill
  \pause
  \begin{itemize}
    \item Gleiche Argumente $\leadsto$ gleiche Rückgaben
    \item Keine Ein-/Ausgabe, \\ keine Zustandsveränderungen, \ldots
    \item Rein lokales Codeverständnis!
    \item Tiefgreifende Optimierungsmöglichkeiten!
  \end{itemize}
}

\subsection[Eingabe/Ausgabe]{Keine Ein-/Ausgabe}
\frame[t]{\frametitle{Keine Eingabe/Ausgabe}
  \floatbox{-230}{180}{\visible<2->{\includegraphics[scale=0.2]{images/io.jpg}}}%
  \texttt{%
    \visible<2->{\syncomment{-- Compile-Zeit-Fehler!}} \\
    \synKey{let}\ x \synSym{=}\ getLine \\
    \synKey{in}\ print (x \synOp{++}\ x)
  }

  \vspace{1em}
  vs.
  \vspace{1em}

  \texttt{%
    \visible<2->{\syncomment{-- Compile-Zeit-Fehler!}} \\
    print (getLine \synOp{++}\ getLine)
  }

  \pause
  \pause
  \vfill
  \begin{itemize}
    \item Aktionen $\neq$ Werte
    \item Explizite Unterscheidung \\
          durchs Typsystem (s. gleich)
  \end{itemize}
}

\frame[t,plain]{
  \begin{itemize}
    \item Mit \texttt{\synSym{let}} werden nur Abkürzungen eingeführt.
    \item Die linke Seite einer solchen Zuweisung darf man daher überall durch
          die rechte ersetzen.
    \item Bei dem angegebenen Beispiel mit \texttt{getLine}
          wäre diese Erwartung verletzt.
    \item Zum Glück werden aber beide Code-Schnipsel wegen eines Typfehlers
          vom Compiler abgelehnt.
    \item Die Ausführung von Aktionen muss man in Haskell \emph{explizit} angeben.
  \end{itemize}
}

\subsection[Beispiele]{Erste Beispiele: Aufsummieren und Quicksort}
\frame[t]{\frametitle{Beispiel: Aufsummieren einer Zahlenliste}
  \floatbox{-210}{195}{\includegraphics[scale=0.35]{images/kasse.jpg}}%
  Deklaration durch Musterabgleich: \\
  \texttt{%
    sum []\ \ \ \ \ \synSym{=}\ \synLit{0} \\
    sum (x\synSym{:}xs) \synSym{=}\ x \synOp{+}\ sum xs
  }

  \vfill
  Beispielauswertung: \\
  \texttt{%
    \ \ \ sum [\synLit{1},\synLit{2},\synLit{3}] \\
    == \synLit{1}\ \synOp{+}\ sum [\synLit{2},\synLit{3}] \\
    == \synLit{1}\ \synOp{+}\ (\synLit{2}\ \synOp{+}\ sum [\synLit{3}]) \\
    == \synLit{1}\ \synOp{+}\ (\synLit{2}\ \synOp{+}\ (\synLit{3}\ \synOp{+}\ sum [])) \\
    == \synLit{1}\ \synOp{+}\ (\synLit{2}\ \synOp{+}\ (\synLit{3}\ \synOp{+}\ \synLit{0})) \\
    == \synLit{6}
  }
}

\frame[t]{\frametitle{Beispiel: Quicksort}
  \floatbox{-230}{175}{\includegraphics[scale=0.7]{images/sort.jpg}}%
  \vspace{\topskip}%
  \begin{minipage}{20cm}
    \texttt{%
      qsort []\ \ \ \ \ \synSym{=}\ [] \\
      qsort (x\synSym{:}xs) \synSym{=} \\
      \phantom{ }\ \ \ qsort kleinere \synOp{++}\ [x] \synOp{++}\ qsort groessere \\
      \phantom{ }\ \ \ \synKey{where} \\
      \phantom{ }\ \ \ kleinere\ \ \synSym{=}\ [ y \synSym{|}\ y \synSym{<-}\ xs, y \synOp{<}\ \ x ] \\
      \phantom{ }\ \ \ groessere \synSym{=}\ [ y \synSym{|}\ y \synSym{<-}\ xs, y \synOp{>=}\ x ]
    }
  \end{minipage}
}

\section{Typsystem}
\subsection{Grundtypen}
\frame[t]{\frametitle{Werte und Typen}
  \floatbox{-250}{35}{\includegraphics[scale=0.25]{images/types.jpg}}%
  \newcommand{\hatTyp}{\texttt{\synSym{::}}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Statische starke Typisierung; \\
          jeder Wert ist von genau einem Typ.
    \item Keine impliziten Typumwandlungen
    \item Enorm hilfreich!
    \pause
    \item Primitive Typen:
      \begin{tabbing}
        \texttt{"Hallo, Welt!12"} \= \hatTyp\ \= \texttt{Integer\ \ } \= \kill
        \texttt{\synLit{"Hallo, Welt!"}} \> \hatTyp \> \texttt{\synType{String}} \\
        \texttt{\synLit{True}} \> \hatTyp \> \texttt{\synType{Bool}} \\
        \texttt{\synLit{37}} \> \hatTyp \> \texttt{\synType{Integer}} \> (beliebige Größe) \\
        \texttt{\synLit{37}} \> \hatTyp \> \texttt{\synType{Int}} \> (mind. 31 Bit)
      \end{tabbing}

    \item Zusammengesetzte Typen:
      \begin{tabbing}
        \texttt{"Hallo, Welt!12"} \= \hatTyp\ \= \kill
        \texttt{[\synLit{'A'}, \synLit{'B'}, \synLit{'C'}]} \> \hatTyp \> \texttt{[\synType{Char}]} \\
        \texttt{[[\synLit{1},\synLit{2}], [\synLit{3}], []]} \> \hatTyp \> \texttt{[[\synType{Integer}]]}
      \end{tabbing}
  \end{itemize}
}

\frame[t]{\frametitle{Werte und Typen (Forts.)}
  \floatbox{-250}{35}{\includegraphics[scale=0.25]{images/types.jpg}}%
  \newcommand{\hatTyp}{\texttt{\synSym{::}}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Funktionstypen:
      \begin{tabbing}
        \texttt{"Hallo,e"} \= \hatTyp\ \= \kill
        \texttt{head}                \> \hatTyp \> \texttt{[a] \synSym{->}\ a} \\
        \texttt{\syncomment{-- Bsp.:}\ head [1,2,3] == 1} \\
        \\
        \texttt{tail}                \> \hatTyp \> \texttt{[a] \synSym{->}\ [a]} \\
        \texttt{\syncomment{-- Bsp.:}\ tail [1,2,3] == [2,3]} \\
        \\
        \texttt{\syncomment{-- Operatoren:}} \\
        \texttt{(\synOp{\&\&})} \> \hatTyp \> \texttt{Bool \synSym{->}\ Bool \synSym{->}\ Bool} \\
        \texttt{(\synOp{++})} \> \hatTyp \> \texttt{[a]\ \ \synSym{->}\ [a]\ \ \synSym{->}\ [a]} \\
      \end{tabbing}
  \end{itemize}
}

\subsection{Typerschließung}
\newcommand{\unhappy}{{\setlength{\tabcolsep}{0pt}\footnotesize\begin{tabular}c.\thinspace.\\[-1ex]\texttt{\char'015}\\[-1.1em]$\frown$\\[ -1.5em]\large$\bigcirc$\end{tabular}}}
\frame[plain]{\begin{center}
  \Huge java.io.InputStreamReader

  \vspace{-1em}
  \scalebox{8}{\unhappy}
\end{center}}

\frame[t]{\frametitle{Automatische Typerschließung}
  \floatbox{-210}{190}{\includegraphics[scale=0.3]{images/katze.jpg}}%
  Automatische Erschließung nicht angegebener Typen durch den Compiler

  \texttt{%
    \ \\
    \visible<2->{%
      greet \synSym{::}\ \synType{String}\ \synSym{->}\ \synType{String}
    } \\
    greet name \synSym{=}\ \synLit{"Hallo "}\ \synOp{++}\ name \synOp{++}\ \synLit{"!"} \\
    \ \\
    \visible<4->{%
      dup \synSym{::}\ [a] \synSym{->}\ [a]
    } \\
    \visible<3->{%
      dup xs \synSym{=}\ xs \synOp{++}\ xs \\
      \syncomment{-- Bsp.:} \\
      \syncomment{\ \ \ dup [1,2,3] ==} \\
      \syncomment{\ \ \ [1,2,3,1,2,3]}
    }
  }
}

\subsection{Aktionstypen}
\frame[t]{\frametitle{Typen von Ein-/Ausgabe-Operationen}
  \newcommand{\hatTyp}{\texttt{\synSym{::}}}%
  \begin{minipage}{11.3cm}\begin{itemize}
    \item \texttt{\synType{IO}\ \synType{Foo}} meint: \\
          Wert vom Typ \texttt{\synType{Foo}} produzierende IO-Aktion
    \item Häufig benutzte Ein-/Ausgabe-Operationen: \\
      \begin{tabbing}
        \texttt{readFile} \= \hatTyp\ \= \kill
        \texttt{getLine} \> \hatTyp \> \texttt{\colorbox{backblue}{\synType{IO}}\ \synType{String}} \\
        \texttt{putStr}  \> \hatTyp \> \texttt{\synType{String}\ \ \ \synSym{->}\ \colorbox{backblue}{\synType{IO}}\ ()} \\
        \texttt{readFile} \> \hatTyp \> \texttt{\synType{FilePath}\ \synSym{->}\ \colorbox{backblue}{\synType{IO}}\ \synType{String}}
      \end{tabbing}
    \pause
    \item Zum früheren Beispiel: \\
      \setlength{\columnsep}{35pt}%
      \begin{multicols*}{2}
        \texttt{%
          main \synSym{::}\ \synType{IO}\ () \\
          main \synSym{=}\ \synKey{do} \\
          \ \ \ \ x \synSym{<-}\ getLine \\
          \ \ \ \ print (x \synOp{++}\ x) 
        }

        \columnbreak

        \texttt{%
          main \synSym{::}\ \synType{IO}\ () \\
          main \synSym{=}\ \synKey{do} \\
          \ \ \ \ x \synSym{<-}\ getLine \\
          \ \ \ \ y \synSym{<-}\ getLine \\
          \ \ \ \ print (x \synOp{++}\ y) 
        }
      \end{multicols*}
  \end{itemize}\end{minipage}
}

\frame[plain]{\begin{center}
  \includegraphics[scale=0.6]{images/effects.png}

  Grafik gestohlen von: Simon Peyton Jones
\end{center}}

\section[Weiteres]{Weitere Fähigkeiten}
\subsection{Aktionsarten}
\frame[t]{\frametitle{Arten von Aktionen}
  \floatbox{-235}{90}{\includegraphics[scale=0.4]{images/gargoyle.png}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item IO (Eingabe/Ausgabe)
    \item Parser
    \item Maybe (Behandlung von Fehlerfällen)
    \item Reader (vererbende Umgebung)
    \item State (veränderlicher Zustand)
    \item Writer (Logging)
    \item Listen (Nichtdeterminismus und Logikprogrammierung)
    \item Cont (Continuations)
    \item \ldots
  \end{itemize}
}

\frame[t,plain]{
  \scriptsize
  \begin{itemize}
    \item Das Fachwort für Aktionen ist \emph{Monaden}.
    \item In der Kategorientheorie, einem abstrakten Teilgebiet der Mathematik,
          waren Monaden schon seit etwa den 1950er Jahren bekannt.
    \item In die Informatik kamen sie hauptsächlich durch einen wegweisenden
          Artikel von Eugenio Moggi im Jahr 1991.
    \item Funktionen können auch \emph{polymorph} in der Monade sein, wenn
          sie keine Besonderheiten einer bestimmten Monade ausnutzen.
    \item Monadische Werte sind wie andere Werte auch \emph{first-class},
          können also etwa in Datenstrukturen gespeichert werden.
          \vspace{1em}

          \texttt{%
            main \synSym{=}\ sequence\textunderscore\ [putStrLn "{}abc", putStrLn "{}def"] \\
            \ \\
            \syncomment{-- aus der Standardbibliothek} \\
            sequence\textunderscore\ \synSym{::}\ (Monad m) \synSym{=>}\ [m a] \synSym{->}\ m () \\
            sequence\textunderscore\ []\ \ \ \ \ \synSym{=}\ return () \\
            sequence\textunderscore\ (x\synSym{:}xs) \synSym{=}\ \synSym{do} \\
            \ \ \ \ x \\
            \ \ \ \ sequence\textunderscore\ xs \\
            \syncomment{-- oder: sequence\textunderscore\ (x:xs) = x >> sequence\textunderscore\ xs}
          }
  \end{itemize}
}

\frame[t]{\frametitle{State-Aktionen}
  \begin{itemize}
    \item Veränderlicher Zustand kann man dadurch emulieren,
          indem man ihn explizit durchfädelt:
          \vspace{1em}

          \small
          \texttt{%
            -- Zustand von irgendeinem Typ St. \\
            foo :: St \synSym{->}\ Integer \synSym{->}\ (St, Double) \\
            bar :: St \synSym{->}\ Double\ \ \synSym{->}\ (St, String) \\
            \ \\
            baz :: St \synSym{->}\ Integer \synSym{->}\ (St, String) \\
            baz s x = \\
            \ \ \ \ let (s',\ \ y) = foo s\ \ x \\
            \ \ \ \ \ \ \ \ (s'', z) = bar s' y \\
            \ \ \ \ in\ \ (s'', z)
          }

    \item Das ist aber umständlich und fehleranfällig (wenn man
          aus Versehen alten Zustand wiederverwendet).
  \end{itemize}
}

\frame[t]{\frametitle{State-Aktionen (Forts.)}
  \begin{itemize}
    \item Eleganter geht es mit der State-Aktion:
          \vspace{1em}
          
          \texttt{%
            import Control.Monad.State \\
            \ \\
            foo :: Integer \synSym{->}\ State St Double \\
            bar :: Double\ \ \synSym{->}\ State St String \\
            \ \\
            baz :: Integer \synSym{->}\ State St String \\
            baz x = \synSym{do} \\
            \ \ \ \ y \synSym{<-}\ foo x \\
            \ \ \ \ z \synSym{<-}\ bar y \\
            \ \ \ \ return z \\
            \syncomment{-- oder: baz x = foo x >>= bar}
          }
  \end{itemize}
}

\frame[t,plain]{
  \begin{itemize}
    \item Ein Wert vom Typ \texttt{State s a} ist eine Aktion,
          die einen Wert vom Typ \texttt{a} berechnet und als Nebenwirkung eine
          Zustandsvariable vom Typ \texttt{s} verändert.

    \item \texttt{get :: State s s}
    \item \texttt{put :: s -> State s ()}

    \item \texttt{evalState :: State s a -> s -> a}
  \end{itemize}
}

\subsection[Parser]{Parser-Aktionen}
\frame[t]{\frametitle{Parser-Aktionen}
  \floatbox{-250}{190}{\includegraphics[scale=0.13]{images/regex.png}}%
  Parser für Perl-Bezeichner (z.B. \texttt{\$foo}, \texttt{@bar123}):
  \vfill

  \texttt{%
    perlBezeichner \synSym{::}\ \synType{Parser}\ \synType{String} \\
    perlBezeichner \synSym{=}\ \synKey{do} \\
    \ \ \ \ sigil \synSym{<-}\ oneOf \synLit{"\$@\%\&"} \\
    \ \ \ \ name\ \ \synSym{<-}\ many alphaNum \\
    \ \ \ \ return (sigil \synOp{:}\ name)
  }

  \vfill
  Dabei verwendete Funktionen aus Parser-Bibliothek:
  \newcommand{\hatTyp}{\texttt{\synSym{::}}}
  \begin{tabbing}
    \texttt{alphaNum} \= \hatTyp\ \= \kill
    \texttt{oneOf} \> \hatTyp \> \texttt{[\synType{Char}] \synSym{->}\ \synType{Parser}\ \synType{Char}} \\
    \texttt{alphaNum} \> \hatTyp \> \texttt{\synType{Parser}\ \synType{Char}} \\
    \texttt{many} \> \hatTyp \> \texttt{\synType{Parser}\ a \synSym{->}\ \synType{Parser}\ [a]}
  \end{tabbing}
}

\subsection[Laziness]{Bedarfsauswertung}
\frame[t]{\frametitle{Bedarfsauswertung}
  \floatbox{-230}{195}{\includegraphics[scale=0.17]{images/lazy.jpg}}%
  \texttt{%
    \syncomment{-- 100. Zeile aus Datei ausgeben} \\
    main \synSym{=}\ \synKey{do} \\
    \ \ \ \ daten \synSym{<-}\ readFile \synLit{"große-datei.txt"} \\
    \ \ \ \ print (lines daten \synOp{!!}\ 99)
  }

  \pause
  \vfill
  \begin{itemize}
    \item Auswertung von Ausdrücken erst dann, wenn Ergebnisse wirklich benötigt
    \item Wegabstraktion des Speicherkonzepts!
    \item Somit Fähigkeit für \\
          unendliche Datenstrukturen: \\
          Potenzreihen, Zeitreihen, \\
          Entscheidungsbäume, \ldots
  \end{itemize}
}

\frame[t]{\frametitle{Bedarfsauswertung (Forts.)}
  \floatbox{-230}{150}{\includegraphics[scale=0.17]{images/lazy.jpg}}%
  \begin{minipage}{20cm}
    \texttt{%
      natürlicheZahlen \synSym{=}\ [\synLit{1}..] \\
      \syncomment{-- [1,2,3,4,\ldots] } \\
      \ \\
      \pause
      ungeradeZahlen \synSym{=}\ filter odd [\synLit{1}..] \\
      \syncomment{-- [1,3,5,7,\ldots] } \\
      \ \\
      \pause
      fibs \synSym{=}\ \synLit{0}\ \synOp{:}\ \synLit{1}\ \synOp{:}\ zipWith\ \synOp{(+)}\ fibs (tail fibs) \\
      \syncomment{-- [0,1,1,2,3,5,8,13,21,34,\ldots]}
    }
  \end{minipage}
}

\subsection{QuickCheck}
\frame[t]{\frametitle{QuickCheck}
  \floatbox{-253}{200}{\includegraphics[scale=0.2]{images/pruefung.jpg}}%
  \texttt{%
    \syncomment{\# Perl} \\
    \synfunc{is}(\synfunc{sqrt}(0), \ 0, \synstr{"{}sqrt(0) ist ok"}); \\
    \synfunc{is}(\synfunc{sqrt}(1), \ 1, \synstr{"{}sqrt(1) ist ok"}); \\
    \synfunc{is}(\synfunc{sqrt}(4), \ 2, \synstr{"{}sqrt(4) ist ok"}); \\
    \synfunc{is}(\synfunc{sqrt}(9), \ 3, \synstr{"{}sqrt(9) ist ok"}); \\
    \synfunc{is}(\synfunc{sqrt}(16), 4,  \synstr{"{}sqrt(16) ist ok"}); \\
    \ldots;\ \ \syncomment{\# ??}
  }

  \vfill
  \pause
  \texttt{%
    \syncomment{-- Haskell mit QuickCheck} \\
    propSqrt \synSym{::}\ \synType{Double}\ \synSym{->}\ \synType{Bool} \\
    propSqrt x \synSym{=} \\
    \ \ \ \ sqrt (x \synOp{*}\ x) \synOp{==}\ x
  }
}

\frame[t]{\frametitle{QuickCheck (Forts.)}
  \floatbox{-253}{200}{\includegraphics[scale=0.2]{images/pruefung.jpg}}%
  \texttt{%
    propSqrt \synSym{::}\ \synType{Double}\ \synSym{->}\ \synType{Bool} \\
    propSqrt x \synSym{=}\ sqrt (x \synOp{*}\ x) \synOp{==}\ x \\
    \ \\
    ghci> quickCheck propSqrt \\
    Falsifiable, after 6 tests: \\
    -4
  }
  \pause

  \vfill
  \texttt{%
    propSqrt' \synSym{::}\ \synType{Double}\ \synSym{->}\ \synType{Bool} \\
    propSqrt' x \synSym{=}\ sqrt (x \synOp{*}\ x) \synOp{==}\ \colorbox{backblue}{abs} x \\
    \ \\
    ghci> quickCheck propSqrt' \\
    OK, passed 100 tests.
  }
}

\frame[t]{\frametitle{QuickCheck (Forts.)}
  \floatbox{-253}{200}{\includegraphics[scale=0.2]{images/pruefung.jpg}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Spezifikationsüberprüfung durch zufällig generierte Stichproben
    \item Enorm hilfreich!
    \pause
    \vfill
    \item Implementierung durch Typklasse: \\
      \texttt{%
        \synKey{class}\ \synType{Arbitrary}\ a \synKey{where} \\
        \ \ \ \ arbitrary \synSym{::}\ \synType{Gen}\ a
      }
    \item Instanzen von \texttt{\synType{Arbitrary}} nicht nur für
          primitive, sondern automatisch auch \\
          für zusammengesetzte Typen
  \end{itemize}
%  \texttt{%
%    \synKey{import}\ Data.Char \\
%    kleinbuchstabe \synSym{::}\ \synType{Gen}\ \synType{Char} \\
%    kleinbuchstabe \synSym{=}\ \synKey{do} \\
%    \ \ \ \ c \synSym{<-}\ arbitrary \\
%    \ \ \ \ return (toUpper c)
%  }
}

\subsection[Web]{Webprogrammierung}
\frame[t]{\frametitle{Webprogrammierung}
  \begin{itemize}
    \item Wieso Haskell fürs Web?
    
    Effizienz, Sicherheit \& die üblichen Vorteile

    \item Webframeworks: Happstack, Snap, Yesod

    \item Leichtgewichtige Threads, asynchrone IO

    \item Minimalbeispiel:

          \texttt{%
            mainLoop sock \synSym{=}\ forever \synSym{\$}\ \synSym{do} \\
            \ \ \ \ conn \synSym{<-}\ accept sock \\
            \ \ \ \ forkIO \synSym{\$}\ runConn conn
          } \\
          \ \\
          \scriptsize\url{http://www.haskell.org/haskellwiki/Implement_a_chat_server}
  \end{itemize}
}

\section{Gemeinschaft}
\subsection{Hackage}
\frame[t]{\frametitle{Paketarchiv Hackage}
  \vspace{-0.5em}%
  \begin{itemize}
    \item Entstehung 2007, mittlerweile $7000^+$ Pakete
    \item Installationswerkzeug cabal-install
  \end{itemize}

  \vspace{-0.6em}
  \begin{center}
    \includegraphics[scale=0.35]{images/cloud.png}
  \end{center}
}

\subsection{Größere Anwendungen}
\frame[t]{\frametitle{Größere Anwendungen}
  \begin{itemize}
    \item Glasgow Haskell Compiler (GHC)
    \item darcs, verteiltes Versionskontrollsystem
    \item xmonad, "`tiling"' Fenstermanager
    \item Pugs, Perl-6-Prototyp
    \item Cryptol, Sprache für Kryptographie
    \item Criterion, Benchmarktoolkit
  \end{itemize}

  \begin{center}
    \hfill
    \includegraphics[scale=0.9]{images/darcs.png}
    \hfill
    \includegraphics{images/xmonad.png}
    \hfill
    \includegraphics[scale=0.8]{images/cryptol.png}
    \hfill
  \end{center}
}

\subsection{Einstiegspunkte}
\frame[t]{
  \floatbox{-240}{100}{\includegraphics[scale=0.2]{images/rwh.jpg}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item \url{http://haskell.org/}
          \vspace{2\itemsep}
    \item zum Herumspielen im Browser: \\
          \url{http://tryhaskell.org/}
    \item interaktive Haskell-Shell: \\
          \texttt{\$ apt-get install ghc} \\
          \texttt{\$ ghci}
          \vspace{2\itemsep}
    \item \url{http://learnyouahaskell.com/}
    \item Buch: Real World Haskell, O'Reilly
          \vfill
    \item Teile dieses Vortrags inspiriert von einem Vortrag von
          Audrey Tang: \\
          \url{http://feather.perl6.nl/~audreyt/osdc/haskell.xul}
  \end{itemize}
}

\frame{\begin{center}
  \floatbox{-140}{120}{\includegraphics[scale=0.5]{images/thankyou.png}}%
  \includegraphics[scale=0.6]{images/haskell-logo.png}
  \vspace{4em}

  \hyperlink{bonus}{\scalebox{2}{\beamergotobutton{Bonusfolien}}}
\end{center}}

\appendix
\frame[label=bonus]{
  \floatbox{-225}{220}{\includegraphics[scale=0.25]{images/present.png}}%
  \begin{center}\Huge Bonusfolien\end{center}
  \vspace{2em}

  \tableofcontents
}

\section[Typsystem]{Details zum Typsystem}
\subsection{Typklassen}
\frame[t]{\frametitle{Typklassen ($=$ Schnittstellen, Rollen)}
  \begin{itemize}
    \item Typklassen für ad-hoc Polymorphismus:

      \texttt{%
        \visible<2->{%
          add37 \synSym{::}\ \visible<3->{\colorbox{backblue}{(Num a) \synSym{=>}}} a \synSym{->}\ a
        } \\
        add37 x \synSym{=}\ x \synOp{+}\ 37 \\
        \syncomment{-- Bsp.: add37 5 == 42} \\
        \ \\
        \visible<5->{%
          min \synSym{::}\ \colorbox{backblue}{(Ord a) \synSym{=>}} a \synSym{->}\ a \synSym{->}\ a
        } \\
        \visible<4->{%
          min x y \synSym{=}\ \synKey{if}\ x \synOp{<=}\ y \synKey{then}\ x \synKey{else}\ y \\
          \syncomment{-- Bsp.: min 19 17 == 17}
        }
      }

    \pause\pause\pause\pause\pause
    \item
      Deklaration: \\
      \texttt{%
        \synKey{class}\ \synType{Num}\ a \synKey{where} \\
        \ \ \ \ \synOp{(+)}\ \synSym{::}\ a \synSym{->}\ a \synSym{->}\ a \\
        \ \ \ \ \synOp{(-)}\ \synSym{::}\ a \synSym{->}\ a \synSym{->}\ a \\
        \ \ \ \ \synOp{(*)}\ \synSym{::}\ a \synSym{->}\ a \synSym{->}\ a \\
        \ \ \ \ \ldots
      }
  \end{itemize}
}

\frame[t,plain]{
  \begin{itemize}
    \item Keine impliziten Casts zwischen \texttt{\synType{Integer}},
          \texttt{\synType{Float}}, \texttt{\synType{Double}}, \ldots
    \item Aber: Zahlliterale sind automatisch von dem Typ, den der Kontext
          erwartet.
    \item \texttt{\synLit{7}} ist syntaktischer Zucker für
          \texttt{fromInteger \synLit{7}}:

          \texttt{fromInteger :: (\synType{Num}\ a) \synSym{=>}\ \synType{Integer}\ -> a}
    \item So ist etwa \texttt{x + 7} auch für \texttt{x :: \synType{Double}}
          okay.
    \item Für Casts müssen weder Quell- noch Zieltyp angegeben werden:
          \vspace{1em}

          \scriptsize
          \texttt{fromIntegral :: (\synType{Integral}\ a, \synType{Num}\ b) \synSym{=>}\
          a \synSym{->}\ b}
  \end{itemize}
}

\subsection[Datentypen]{Benutzerdefinierte Datentypen}
\frame[t]{\frametitle{Benutzerdefinierte Datentypen}
  \floatbox{-220}{190}{\scalebox{0.7}{\input{images/baum.pspdftex}}}%
  \texttt{%
    \synKey{data}\ \synType{Tree}\ \synSym{=}\ Leaf \synType{Int}\ \synSym{|}\ Fork \synType{Tree}\ \synType{Tree}
  }
  Konstruktoren: \\
  \texttt{Leaf \synSym{::}\, Int \synSym{->}\ Tree} und \\
  \texttt{Fork \synSym{::}\, Tree \synSym{->}\ Tree \synSym{->}\ Tree}

  \vfill
  \pause
  \texttt{%
    beispielBaum \synSym{=}\ Fork \\
    \ \ \ \ (Fork (Leaf \synLit{17}) (Leaf \synLit{37}))\\
    \ \ \ \ (Fork\\
    \ \ \ \ \ \ \ \ (Fork (Leaf \synLit{42}) (Leaf \synLit{0}))\\
    \ \ \ \ \ \ \ \ (Leaf \synLit{41}))
  }

  \vfill
  \pause
  \texttt{%
    komischerBaum \synSym{=}\ \\
    \ \ \ \ Fork (Leaf \synLit{23}) komischerBaum
  }
}

\frame[t]{\frametitle{Benutzerdefinierte Datentypen (Forts.)}
  \floatbox{-223}{75}{\scalebox{0.7}{\input{images/baum.pspdftex}}}%
  \hspace*{-1em}\begin{minipage}{20cm}
  \texttt{%
    \only<1>{%
      \synKey{data}\ \synType{Tree}\ \ \ \synSym{=}\ Leaf \synType{Int}\ \synSym{|}\ Fork \synType{Tree}\ \synType{Tree}
    }%
    \only<2->{\sout{%
      \synKey{data}\ \synType{Tree}\ \ \ \synSym{=}\ Leaf \synType{Int}\ \synSym{|}\ Fork \synType{Tree}\ \synType{Tree}
    }} \\
    \ \\
    \pause
    \synKey{data}\ \synType{Tree}\ a \synSym{=}\ Leaf a \ \ \synSym{|}\ Fork (\synType{Tree}\ a) (\synType{Tree}\ a)
    \pause
    \ \\
    \ \\
    \syncomment{-- Gesamtzahl Blätter zählen} \\
    size \synSym{::}\ \synType{Tree}\ a \synSym{->}\ \synType{Integer} \\
    size (Leaf \symbol{95})\ \ \ \ \ \ \ \ \ \ \ \ \synSym{=}\ \synLit{1} \\
    size (Fork links rechts) \synSym{=}\\
    \phantom{ }\ \ \ size links \synOp{+}\ size rechts
    \ \\
    \ \\
    \pause
    \syncomment{-- Blätter als Liste zurückgeben} \\
    inorder \synSym{::}\ \synType{Tree}\ a \synSym{->}\ [a] \\
    inorder (Leaf x)\ \ \ \ \ \ \ \ \ \ \ \  \synSym{=}\ [x] \\
    inorder (Fork links rechts) \synSym{=} \\
    \phantom{ }\ \ \ inorder links \synOp{++}\ inorder rechts
  }
  \end{minipage}
}

\subsection[Fehlende Werte]{Umgang mit fehlenden Werten}
\frame[t]{\frametitle{Umgang mit fehlenden Werten}
  \floatbox{-260}{120}{\includegraphics[scale=0.25]{images/bug.png}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item "`Null References: The Billion Dollar Mistake`` (Tony Hoare)
    \item In Haskell: Explizite Kennzeichnung von möglicherweise fehlenden
          Werten durch Maybe-Typen
  \end{itemize}
  \vfill

  \texttt{%
    \synKey{data}\ \synType{Maybe}\ a \synSym{=}\ Nothing \synSym{|}\ Just a \\
    \ \\
    lookupFarbe \synSym{::}\ \synType{String}\ \synSym{->}\ \colorbox{backblue}{\synType{Maybe}} \synType{Color} \\
    \syncomment{-- Bsp.:} \\
    \syncomment{\ \ \ lookupFarbe "{}Simpsons"{} == Just YELLOW} \\
    \syncomment{\ \ \ lookupFarbe "{}Simqsons"{} == Nothing} \\
  }
}

\frame[t]{\frametitle{Maybe-Ketten}
  Anwendbarkeit des syntaktischen Zuckers von Aktionstypen für Maybe:
  \vfill

  \texttt{%
    berechneA \synSym{::}\ \synType{Integer}\ \ \synSym{->}\ \synType{Maybe}\ \synType{String} \\
    berechneB \synSym{::}\ \synType{Integer}\ \ \synSym{->}\ \synType{Maybe}\ [\synType{Double}] \\
    berechneC \synSym{::}\ [\synType{Double}]\ \synSym{->}\ \synType{Maybe}\ \synType{String} \\
    \ \\
    berechne \synSym{::}\ \synType{Integer}\ \synSym{->}\ \synType{Maybe}\ \synType{String} \\
    berechne x \synSym{=}\ \synKey{do} \\
    \ \ \ \ teil1\ \ \synSym{<-}\ berechneA x \\
    \ \ \ \ teil2\ \ \synSym{<-}\ berechneB x \\
    \ \ \ \ teil2'   \synSym{<-}\ berechneC teil2 \\
    \ \ \ \ return (teil1 \synOp{++}\ teil2)
  }
}

\section[FFI]{Foreign Function Interface}
\frame[t]{\frametitle{Foreign Function Interface}
  \floatbox{-270}{75}{\includegraphics[scale=0.7]{images/jabberwocky.jpg}}%
  \texttt{%
    \syncomment{\{-\# INCLUDE <math.h> \#-\}} \\
    foreign \synKey{import}\ ccall unsafe "{}sin"{}\\
    \ \ \ \ c\_{}sin \synSym{::}\ \synType{CDouble}\ \synSym{->}\ \synType{CDouble} \\
  }

  \vfill
  \begin{itemize}
    \item Einbindung von (C-)Bibliotheken
    \item Keine besondere Handhabung der importierten Funktionen
    \item Callbacks aus dem C-Code heraus möglich
  \end{itemize}
}

\section{Nebenläufigkeit}
\frame[t]{\frametitle{Nebenläufigkeit}
  \floatbox{-235}{200}{\includegraphics[scale=0.45]{images/philosophen.png}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Aufgabenparallelismus: \\
          Software Transactional Memory
          \hyperlink{stm}{\beamergotobutton{weiter}}
    \item Datenparallelismus: \\
          Data Parallel Haskell
          \hyperlink{dph}{\beamergotobutton{weiter}}
  \end{itemize}
}

\subsection{Software Transactional Memory}
\frame[t,label=stm]{\frametitle{Traditionelles Locking}
  \floatbox{-265}{200}{\includegraphics{images/lock.jpg}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Schwierigkeiten bei traditionellem Locking: \\
          nichtlokales Denken, Deadlocks, Livelocks, Prioritätsinversion
    \item "`lock-based programs do not compose"'
  \end{itemize}
}

\frame[t]{\frametitle{Traditionelles Locking (Forts.)}
  \floatbox{-265}{200}{\includegraphics{images/lock.jpg}}%
  \vspace{-\topsep}%
  \begin{enumerate}
    \item \texttt{%
      \syncomment{\# Perl} \\
      \synvar{\$x}->\synfunc{withdraw}(3); \\
      \synvar{\$y}->\synfunc{deposit}(3); \\
      \syncomment{\# Race Condition!}
    }

    \pause\vfill
    \item \texttt{%
      \synvar{\$x}->\synfunc{lock}(); \synvar{\$y}->\synfunc{lock}();
      \synvar{\$x}->\synfunc{withdraw}(3); \\
      \synvar{\$y}->\synfunc{deposit}(3); \\
      \synvar{\$y}->\synfunc{unlock}(); \synvar{\$x}->\synfunc{unlock}(); \\
    }

    \pause\vfill
    \item \texttt{%
      \{ \synvar{\$x}->\synfunc{lock}(); \synvar{\$y}->\synfunc{lock}(); \ldots; \} \\
      vs. \\
      \{ \synvar{\$y}->\synfunc{lock}(); \synvar{\$x}->\synfunc{lock}(); \ldots; \} \\
      \syncomment{\# Deadlock!}
    }
  \end{enumerate}
}

\frame[t]{\frametitle{Software Transactional Memory}
  \floatbox{-240}{200}{\includegraphics[scale=0.25]{images/stm.jpg}}%
  \vspace{-\topsep}%
  \begin{itemize}
    \item Transaktionsvorstellung: \\
          Unabhängige, einfädige Ausführung jeder Transaktion
    \item Implementierung durch Schreiben in temporären Puffer;
          Commit nur, wenn gelesene Variablen noch unverändert,
          sonst Neustart
    \item Vorteile: \\
          keine expliziten Locks, \\
          keine Race Conditions, \\
          Komponierbarkeit
  \end{itemize}
}

\frame[t]{\frametitle{Software Transactional Memory (Forts.)}
  \floatbox{-240}{200}{\includegraphics[scale=0.25]{images/stm.jpg}}%
  \texttt{%
    \syncomment{-- Haskell} \\
    withdraw \synSym{::}\ \synType{Account}\ \synSym{->}\ \synType{Int}\ \synSym{->}\ \synType{STM}\ () \\
    deposit\ \ \synSym{::}\ \synType{Account}\ \synSym{->}\ \synType{Int}\ \synSym{->}\ \synType{STM}\ () \\
    \ \\
    atomically \synOp{\$}\ \synKey{do} \\
    \ \ \ \ withdraw x \synLit{3} \\
    \ \ \ \ deposit\ \ y \synLit{3}
  }
}

\subsection{Data Parallel Haskell}
\frame[t,label=dph]{\frametitle{Flat/Nested Data Parallelism}
  \begin{itemize}
    \item Flat Data Parallelism: \\
          \texttt{%
            \synfunc{for}\ \synfunc{my}\ \synvar{\$i}\ (1..\synvar{\$N}) \{ \\
            \ \ \ \ \synvar{work}(\synvar{\$i}); \\
            \}
          }
    \item Parallelisierung durch einfaches Aufteilen der Fälle auf
          die Prozessoren
    \item Effizienz verschenkt, wenn \texttt{\synvar{work}()} selbst
          parallel arbeiten könnte!
  \end{itemize}
}

\frame[t]{\frametitle{Data Parallel Haskell}
  \begin{itemize}
    \item Umsetzung von Nested Data Parallelism
    \item Automatische Programmtransformationen: \\
          Flattening (global), Fusion (lokal)
    \item Wesentliche Abhängigkeit von Haskells reiner Funktionalität
  \end{itemize}

  \pause
  \texttt{%
    \syncomment{-- Komponentenweise Vektor-Addition} \\
    addP \synSym{::}\ (\synType{Num}\ a) \synSym{=>}\ [:a:] \synSym{->}\ [:a:] \synSym{->}\ [:a:] \\
    addP xs ys \synSym{=} \\
    \ \ \ \ [: x \synOp{+}\ y \synSym{|}\ x \synSym{<-}\ xs \synSym{|}\ y \synSym{<-}\ ys :] \\
    \ \\
    \syncomment{-- Skalarprodukt} \\
    dotP \synSym{::}\ (\synType{Num}\ a) \synSym{=>}\ [:a:] \synSym{->}\ [:a:] \synSym{->}\ a \\
    dotP xs ys \synSym{=}\ sumP (mulP xs ys)
  }
}

\section{Bildquellen}
\frame[t]{\frametitle{Bildquellen}
  \tiny
  \vspace{-1.7em}
  \begin{itemize}
    \item \url{http://betr1ebsrat.files.wordpress.com/2009/10/zeitungs-logo-standard.jpg}
    \item \url{http://de.academic.ru/pictures/dewiki/100/dining_philosophers.png}
    \item \url{http://i.ehow.com/images/a04/8i/g0/show-real-smile-photographs-800X800.jpg}
    \item \url{http://imgs.xkcd.com/comics/regular_expressions.png}
    \item \url{http://learnyouahaskell.com/splash.png}
    \item \url{http://media.nokrev.com/junk/haskell-logos/logo7.png}
    \item \url{http://otierney.net/images/perl6.gif}
    \item \url{http://perl.plover.com/yak/presentation/samples/present.gif}
    \item \url{http://save-endo.cs.uu.nl/target.png}
    \item \url{http://theleftwinger.files.wordpress.com/2010/01/lazy.jpg}
    \item \url{http://upload.wikimedia.org/wikipedia/commons/7/7d/Bug.png}
    \item \url{http://upload.wikimedia.org/wikipedia/commons/c/c6/Metal_movable_type_edit.jpg}
    \item \url{http://upload.wikimedia.org/wikipedia/commons/d/d0/Jabberwocky.jpg}
    \item \url{http://wordaligned.org/images/the-challenge-of-effects.jpg}
    \item \url{http://www.coverbrowser.com/image/oreilly-books/42-1.jpg}
    \item \url{http://www.ctri.co.uk/images/cat30.jpg}
    \item \url{http://www.darcs.net/logos/logo.png}
    \item \url{http://www.fos.org.au/custom/files/media/sort_it_cover_300.jpg}
    \item \url{http://www.galois.com/~dons/images/cloud.png}
    \item \url{http://www.galois.com/files/Cryptol/Cryptol_logo_image.png}
    \item \url{http://www.homemortgagerates.us/variable-rates-636.jpg}
    \item \url{http://www.lakehousecreations.com/images/ThankYou/Thank\%20You\%202003\%20(12).jpg}
    \item \url{http://www.nataliedee.com/093009/death-is-a-side-effect-of-most-things.jpg}
    \item \url{http://www.quickmeme.com/img/bd/bdb89c032c3c7c09a86897422bf3bd32a0bb65731c7fd38ba5ea67741621ad35.jpg}
    \item \url{http://www.simpsonsline.com/rb/fakten/vorspann/02_kasse.jpg}
    \item \url{http://www.sketchybeast.com/wp-content/uploads/2007/12/input_output.jpg}
    \item \url{http://www.sopaed-lern.uni-wuerzburg.de/uploads/pics/Pruefung.jpg}
    \item \url{http://www.wfu.edu/nanotech/Microscopy\%20Facility/stm_view.jpg}
    \item \url{http://www.wishlist.nu/wp-content/uploads/2007/10/gargoyle.jpg}
    \item \url{http://xmonad.org/images/logo.png}
  \end{itemize}
}

\end{document}

Webframeworks erwähnen
Hackage-Folie aktualisieren
neue Paradebeispiele finden
Mehr auf die Community eingehen! "One does not simply troll #haskell"


Abstract Audrey Tang:
https://web.archive.org/web/20080820010426/http://conferences.oreillynet.com/cs/eurooscon/view/e_sess/7231

What's faster than C++, more concise than Perl, more regular than Python, more
flexible than Ruby, more typeful than C#, more robust than Java, and has
absolutely nothing in common with PHP? It's Haskell!

Tired of writing unit tests to cover corner cases? Let the computer write it
for you with QuickCheck. Find regex-based parsing unmaintainable? Learn how to
write a complete parser for Perl 6's grammar in 15 minutes with Parsec. Stuck
in deadlocks and race conditions? STM solves all your concurrency woes. XS and
SWIG gives you headaches? FFI lets you embed C code quickly and safely.

Haskell is an emerging general-purpose functional language, with unique
features that enable extremely rapid development of bug-free, concise, and
maintainable code. This talk shows how to apply Haskell to day-to-day tasks,
tips for integrating it with other languages, and secrets for boosting your
productivity by an order of magnitude.