\documentclass{beamer}
\usepackage{amsmath}
\usepackage{url}
\usepackage{ucs}
\usepackage[utf8]{inputenc}
\usepackage[ngerman]{babel}
% This is a not yet finished (German) talk I'll hold at the next meeting of the
% Linux User Group Augsburg (LUGA) (on 2005-05-04).
% 
% Compile to PDF using...
%   $ pdflatex Perl6_genau_jetzt.latex
% 
% Feel free to add/change contents (don't forget to add you to the author
% list)!
% This is an experiment -- I don't think many people have used Subversion to
% collaboratively create a talk. :)
% 
% As this talk is German, the following comments are German, too.

% Zielgruppe dieses Vortrags:
% Linux-Benutzer mit Programmiererfahrung in mindestens einer Sprache (bei den
% Codebeispielen unten sind überall auch Entsprechungen in anderen Sprachen als
% Perl 5 und 6 angegeben).

% \begin{langs}
%   Perl 5: \> ... \\
%   Perl 6: \> ... \\
%   \hr
%   Ruby: \> ... \\
%   (...)
% \end{langs}
\newenvironment{langs}{
  \begin{tabbing}
    Haskell: \= ... \kill
}{\end{tabbing}}

% 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}\\}

\title{Perl 6, genau jetzt!}
\author{Ingo Blechschmidt \\\texttt{<iblech@web.de>}}
\institute{LUGA}
\date{4. Mai 2005}
% Outline:
%   - Parrot
%     - Entstehung
%     - Design
%   - Perl 6
%     - Geschichte
%     - Designideen
%     - Code-Beispiele (mit Vergleichen zu vielen anderen Sprachen)
%     - Mitgestaltungsmöglichkeiten, etc.
%   - Pugs
%     - Entstehung
%     - Überblick
%     - "Wie helfe ich?"
%   - Ausblick
%     - Perl 6 rockz
%     - Dank Pugs schon jetzt benutzbar
%     - "Man darf gespannt sein"

\usetheme{Warsaw}
\usecolortheme{seahorse}
\setbeamercovered{transparent}

\begin{document}

\frame{\titlepage}

\section{}
\frame{
  \frametitle{Inhalt}
  \tableofcontents
}

\section{Parrot}
\subsection{"Uberblick}
\frame[t]{
  \frametitle{Parrot?}

  \begin{itemize}
    \item \only<2->{Verdammt schnelle r}\only<1>{R}egisterbasierte virtuelle Maschine
    \item Plattformunabhängiger Bytecode
    \item "`One bytecode to rule them all"'
  \end{itemize}

  \pause\pause
  \[
    \begin{array}{ll}
      \text{BASIC}  & \text{Forth} \\
      \text{Lisp}   & \text{Parakeet} \\
      \text{Perl 5} & \text{Perl 6} \\
      \text{PHP}    & \text{Python} \\
      \text{Ruby}   & \text{Scheme} \\
      \text{TCL}    & \text{\ldots} \\
    \end{array}
    \leftrightarrow \text{\syncool{Parrot}} \leftrightarrow
    \begin{array}{ll}
      \text{BASIC}  & \text{Forth} \\
      \text{Lisp}   & \text{Parakeet} \\
      \text{Perl 5} & \text{Perl 6} \\
      \text{PHP}    & \text{Python} \\
      \text{Ruby}   & \text{Scheme} \\
      \text{TCL}    & \text{\ldots} \\
    \end{array}
  \]
}

\subsection{Architektur}
\frame[t]{
  \frametitle{Architektur}

  \begin{itemize}
    \item Je 64 Register der Typen \texttt{I}, \texttt{N}, \texttt{S} und \texttt{P}
	  \vspace*{-1em}
	  \begin{tabbing}
	    \texttt{I}: \= Int \\
	    \texttt{N}: \> Num \\
	    \texttt{S}: \> String \\
	    \texttt{P}: \> PMC -- Parrot Magic Cookie
	  \end{tabbing}
    \item Bereitstellung von Garbage Collection, Subroutinen, Coroutines,
	  Continuations, Klassen, Methoden
    \item Just In Time-Compiler für meist benutzte Plattformen ⇒ Speed!
    \item HLL → PIR → Bytecode → \\
	  natives Programm, C oder direkte Ausführung
  \end{itemize}
}

\subsection{Beteiligungsm"oglichkeiten}
\frame[t]{
  \frametitle{Beteiligungsmöglichkeiten}

  \begin{itemize}
    \item Mailingliste: \\
          \texttt{perl6-internals@perl.org}, \\
          \texttt{gmane.comp.lang.perl.perl6.internals}
    \item IRC: \texttt{\#parrot} auf \texttt{irc.perl.org}
    \item Auch Newbies gern gesehen
    \item Viele Beteiligungsmöglichkeiten, nicht nur für Programmierer
    \item Weitere Informationen: \url{http://www.parrotcode.org/}
  \end{itemize}
}


\section{Perl 6}
%\subsection{Entstehung}
%\frame{
%  \frametitle{Entstehungsgeschichte}
%  \begin{itemize}
%    \item Aprilscherz: Kombination von Perl 5 und Python → Parrot
%    \item ...
%  \end{itemize}
%}

\subsection{Design}
\frame{
  \frametitle{"`Die Wasserbett-Theorie"'}

  \begin{itemize}
    \item<1-> Glattes Wasserbett
    \item<2-> Eindrücken an einer Stelle (Vereinfachung) ⇒ \\
	      Hochkommen an anderen Stellen (Komplizierung)
  \end{itemize}

  \vfill\pause\pause 
  \begin{block}{Gleichgewicht}
    \begin{itemize}
      \item Sehr viele Operatoren: \texttt{+@= /\%\^{} !@=} ↔
      \item Sehr wenig Operatoren: \texttt{\synfunc{set}(\synvar{x}, \synfunc{add}(5, 3))}
    \end{itemize}
  \end{block}
}

\frame[t]{
  \frametitle{Huffmann-Komprimierung}

  \begin{itemize}
    \item Häufig genutzte Features → \\
          kurze Namen (z.B. \texttt{\synfunc{say}}, \texttt{\synfunc{cat}})
    \item Selten genutzte Features → \\
          lange Namen (z.B. \texttt{\synfunc{gethostbyname}},
	  \texttt{\synfunc{nautilus-file-management-properties}})
  \end{itemize}
}

\frame[t]{
  \frametitle{Freiheit und Anpassung}

  \begin{itemize}
    \item Kein Zwänge, nur angemessene Standards
    \item Bräuche, keine Gesetze
    \item "`Nur tote Sprachen ändern sich nicht."'
  \end{itemize}

  \vfill\pause
  \begin{block}{Möglichkeiten der Anpassung}
    \begin{itemize}
      \item Überschreiben/Erweitern von Builtins und Operatoren
      \item C-like und Lisp-like Makros
      \pause
      \item Neudefinition der Grammatik: \\
	    \texttt{%
	      \synfunc{use}\ \synclass{Grammar::Python};\\
	      \synvar{x}\ = [ \synvar{foo}(), \synvar{bar}() ]\\
	      \synvar{x}.\synvar{push}(3)
	    }
    \end{itemize}
  \end{block}
}

\frame[t]{
  \frametitle{DWIM -- Do What I Mean}

  \begin{itemize}
    \item Do What I Mean
    \item Nicht immer gleich Do What You Mean
  \end{itemize}

  \vfill\pause
  \begin{block}{Beispiele}
    \texttt{%
      5 + 3*2\ \ \ \ \ \ \ \ \# 5 + (3*2)\\
      \synfunc{s}:2nd/\synstr{foo}/\synstr{bar}/\ \syncomment{\# Zweites "foo"\ → "bar"}\\
      \synfunc{s}:2th/\synstr{foo}/\synstr{bar}/\ \syncomment{\# ditto}
    }
  \end{block}
}

\frame[t]{
  \frametitle{"`Ausleihen"'}

  \begin{itemize}
    \item "`Ausleihen"' von Features aus anderen Sprachen
    \item Zusammenarbeit zwischen den Sprachenentwicklern
  \end{itemize}

  \vfill\pause
  \begin{block}{Beispiele}
    \begin{itemize}
      \item \texttt{.} als Methodenaufrufoperator (von Python, Ruby und vielen
            anderen Sprachen)
      \item Pragmas (ursprünglich von C)
      \item Klammern: "`Oha! Hier ist etwas anders als normal!"' (Perl 5, Ruby,
            Mathematik) \\
	    \begin{itemize}
	      \item $5 + \left(3 \cdot 2\right)$ → $5 + 3 \cdot 2$
	      \item \texttt{\synfunc{say}(...)} → \texttt{\synfunc{say}\ ...}
	    \end{itemize}
    \end{itemize}
  \end{block}
}

\subsection{Codebeispiele}
\frame{
  \frametitle{"`Hello World"'}
  \begin{langs}
    Perl 6:  \> \texttt{\synfunc{say}\ \ \ "\synstr{Hello, World!}";} \\
    Perl 5:  \> \texttt{\synfunc{print}\ "\synstr{Hello, World!\textbackslash{}n}";} \\
    \hr
    C:       \> \texttt{\synfunc{printf}("\synstr{\%s\textbackslash{}n}", "\synstr{Hello, World!}");} \\
    Haskell: \> \texttt{\synfunc{putStrLn}\ "\synstr{Hello, World!}"} \\
    Lua:     \> \texttt{\synfunc{print}\ "\synstr{Hello, World!}";} \\
    PHP:     \> \texttt{\synfunc{print}("\synstr{Hello, World!\textbackslash{}n}");} \\
    Python:  \> \texttt{\synfunc{print}\ "\synstr{Hello, World!}"} \\
    Ruby:    \> \texttt{\synfunc{puts}\ \ "\synstr{Hello, World!}"} \\
    Shell:   \> \texttt{\synfunc{echo}\ \ "\synstr{Hello, World!}"} \\
    Tcl:     \> \texttt{\synfunc{puts}\ \ "\synstr{Hello, World!}"}
  \end{langs}
}

\frame[t]{
  \frametitle{Variablen}

  \begin{itemize}
    \item<1-> Haupttypen: \\
	      \texttt{\synvar{\$scalar}}, \texttt{\synvar{@array}},
              \texttt{\synvar{\%hash}}, \texttt{\synvar{\&code}}
    \item<2-> Dereferenzierung: \\
	      \texttt{\synvar{@array}[3]}, \\
              \texttt{\synvar{\%hash}\{"\synstr{key}"\}},
              \texttt{\synvar{\%hash}<\synstr{key}>}, \\
	      \texttt{\synvar{\&code}(argumente)}
    \item<3-> Slices: \\
	      \texttt{\synvar{@array}[23, 42]}, \\
              \texttt{\synvar{\%hash}\{"\synstr{ingo}", "\synstr{larry}"\}}
  \end{itemize}
}

%\frame{
%  \frametitle{Tastatureingabe}
%  \begin{langs}
%    Perl 6:  \> \texttt{\synfunc{my}\ \synvar{\${}text}\ = =\synvar{\${}*IN};} \\
%    Perl 5:  \> \texttt{\synfunc{my}\ \synvar{\${}text}\ = <\synvar{STDIN}>;} \\
%    \hr
%    C:       \> \texttt{\synfunc{scanf}("\synstr{\%s}", \&{}\synvar{text});} \\
%    Haskell: \> \texttt{\synvar{x}\ <- \synfunc{getLine}} \\
%    Lua:     \> \texttt{\synvar{text}\ = \synfunc{io.read}()} \\
%    PHP:     \> \texttt{\synvar{\${}text}\ = \synfunc{readline}();} \\
%    Python:  \> \texttt{\synvar{text}\ = \synfunc{sys.stdin.readline}()} \\
%    Ruby:    \> \texttt{\synvar{text}\ = \synfunc{gets}} \\
%    Shell:   \> \texttt{\synfunc{read}\ \synvar{text}} \\
%    Tcl:     \> \texttt{\synfunc{set}\ \synvar{text}\ [\synfunc{gets}\ \synvar{stdin}]}
%  \end{langs}
%}

\frame[t]{
  \frametitle{Operatoren}

  \begin{itemize}
    \item<1-> Standard-Operatoren:
	  \begin{itemize}
	    \item \texttt{+ * - / \~{}}
	    \item \texttt{[] \{\}}
	    \item \texttt{.}
	    \item \texttt{...} (Yadda-Yadda)
	  \end{itemize}
    \item<2-> Chained Operators: \texttt{23 < \synvar{\$a}\ < 42}
    \item<3-> Kontextspezifizierer: \\
	  \begin{itemize}
	    \item \texttt{+\synvar{@array}} (Anzahl Elemente in
	  	  \texttt{\synvar{@array}})
	    \item \texttt{\~{}\synvar{@array}} (\texttt{\synvar{@array}} als
	      	  Zeichenkette)
	    \item \texttt{?{}\synvar{@array}} ("`Enthält \texttt{\synvar{@array}}
		  Elemente?"')
	  \end{itemize}
    \item<4-> Hyper-Operatoren: \\
	  \texttt{%
	    \symbol{91}1, 2, 3] »*« 2\ \ \ \ \ \ \ \ \ \# \symbol{91}2, 4, 6]\\
	    \symbol{91}1, 2, 3] »+« \symbol{91}4, 5, 6] \# \symbol{91}5, 7, 9]\\
	  }
  \end{itemize}
}

\frame{
  \frametitle{Junctions}

  \begin{block}{"`Wenn \texttt{\$a} einen dieser Werte hat, dann..."'}
    \begin{langs}
      Perl 5: \> \texttt{\synfunc{if}(\synvar{\$a}\ == 3 || \synvar{\$a}\ == 5 || \synvar{\$a}\ == 7) \{...\}} \\
      Perl 6: \> \texttt{\synfunc{if}\ \synvar{\$a}\ == 3|5|7 \{...\}}
    \end{langs}
  \end{block}

  \pause
  \begin{block}{"`Wenn alle mindestens 18 sind, dann..."'}
    \begin{langs}
      Perl 5: \> \texttt{\synfunc{if}(\synfunc{grep}(\{ \synvar{\$\_}->\synvar{age}\ < 18 \} \synvar{@leute}) == 0) \{...\}} \\
      Perl 6: \> \texttt{\synfunc{if}\ \synfunc{all}(\synvar{@leute}».\synvar{age}) >= 18 \{...\}}
    \end{langs}
  \end{block}

  \pause
  \only<1-3>{
    \begin{block}{"`Wenn mindestens einer mindestens 18 ist, dann..."'}
      \begin{langs}
	Perl 5: \> \texttt{\synfunc{if}(\synfunc{grep}\ \{ \synvar{\$\_}->\synvar{age}\ >= 18 \} \synvar{@leute}) \{...\}} \\
	Perl 6: \> \texttt{\synfunc{if}\ \synfunc{any}(\synvar{@leute}».\synvar{age}) >= 18 \{...\}}
      \end{langs}
    \end{block}
  }

  \only<4>{
    \begin{block}{"`Wenn genau einer einer mindestens 18 ist, dann..."'}
      \begin{langs}
	Perl 5: \> \texttt{\synfunc{if}(\synfunc{grep}(\{ \synvar{\$\_}->\synvar{age}\ >= 18 \} \synvar{@leute}) == 1) \{...\}} \\
	Perl 6: \> \texttt{\synfunc{if}\ \synfunc{one}(\synvar{@leute}».\synvar{age}) >= 18 \{...\}}
      \end{langs}
    \end{block}
  }
}

\frame{
  \frametitle{Smartmatching ("`Extreme DWIM"')}

  \texttt{%
    \syncomment{\# Enthält \synvar{\$str}\ "\synstr{foo}"?}\\
    \synfunc{if}\ \synvar{\$str}\ \~{}\~{} \synfunc{m}/\synstr{foo}/\ \ \ \{...\}\\
    \ \pause\\
    \syncomment{\# Enthält \synvar{@array}\ "\synstr{ingo}"?}\\
    \synfunc{if}\ "\synstr{ingo}"\ \~{}\~{} \synvar{@array}\ \{...\}\\
    \ \pause\\
    \syncomment{\# Gibt es einen Key "\synstr{ingo}"\ in \synvar{\%hash}?}\\
    \synfunc{if}\ "\synstr{ingo}"\ \~{}\~{} \synvar{\%hash}\ \ \{...\}\\
    \ \pause\\
    \syncomment{\# Sind \synvar{@foo}\ und \synvar{@bar}\ identisch?}\\
    \synfunc{if}\ \synvar{@foo}\ \~{}\~{} \synvar{@bar}\ \ \ \ \ \{...\}\\
  }
}

\frame{
  \frametitle{Subroutines -- Definition}
  \begin{langs}
    Perl 6:  \> \texttt{\synfunc{sub}\ \synvar{foo}(\synclass{Num}\ \synvar{\${}i}) \{ \synfunc{say}\ \synvar{\$i}\ + 3 \}} \\
    Perl 5:  \> \texttt{\synfunc{sub}\ \synvar{foo}\ \{ \synfunc{my}\ \synvar{\${}i}\ = \synfunc{shift}; \synfunc{print}\ \synvar{\${}i}\ + 3, "\synstr{\textbackslash{}n}"\ \} } \\
    \hr
    C:       \> \texttt{\synclass{void}\ \synvar{foo}(\synclass{float}\ i) \{ \synfunc{printf}("\synstr{\%f\textbackslash{}n}", i + 3); \}} \\
    Haskell: \> \texttt{\synvar{foo}\ \synvar{i}\ = \synfunc{putStrLn}\ . \synfunc{show}\ \${} \synvar{i}\ + 3} \\
    Lua:     \> \texttt{\synfunc{function}\ \synvar{foo}(\synvar{i}) \synfunc{print}(\synvar{i}\ + 3) \synfunc{end}} \\
    PHP:     \> \texttt{\synfunc{function}\ \synvar{foo}(\synvar{\${}i}) \{ \synfunc{print}(\synvar{\${}i}\ + 3); \}} \\
    Python:  \> \texttt{\synfunc{def}\ \synvar{foo}(\synvar{i}): \synfunc{print}\ \synvar{i}\ + 3} \\
    Ruby:    \> \texttt{\synfunc{def}\ \synvar{foo}(\synvar{i}) \synfunc{puts}\ \synvar{i}\ + 3 \synfunc{end}} \\
    Shell:   \> \texttt{\synfunc{function}\ \synvar{foo}\ \{ \synfunc{echo}\ \${}((\${}1 + 3)); \}} \\
    Tcl:     \> \texttt{\synfunc{proc}\ \synvar{foo}\ \{\synvar{i}\} \{ \synfunc{puts}\ [\synfunc{expr}\ \${}\synvar{i}\ + 3] \}}
  \end{langs}
}

\frame{
  \frametitle{Subroutines -- Aufruf}
  \begin{langs}
    Perl 6:  \> \texttt{\synvar{foo}\ 42; \synoder \synvar{foo}\ \synstr{i}\ => 42; \synoder \synvar{foo}\ :\synstr{i}(42);} \\
    Perl 5:  \> \texttt{\synvar{foo}\ 42;}\\
    \hr
    C:       \> \texttt{\synvar{foo}(42);}\\
    Haskell: \> \texttt{\synvar{foo}\ 42}\\
    Lua:     \> \texttt{\synvar{foo}(42)}\\
    PHP:     \> \texttt{\synvar{foo}(42);}\\
    Python:  \> \texttt{\synvar{foo}(42)}\\
    Ruby:    \> \texttt{\synvar{foo}\ 42}\\
    Shell:   \> \texttt{\synvar{foo}\ 42}\\
    Tcl:     \> \texttt{\synvar{foo}\ 42}\\
  \end{langs}
}

\subsection{Objektorientierung}
\frame{
  \frametitle{Klassendefinition und -instantiierung in anderen Sprachen}
  \begin{block}{Perl 5}\texttt{%
    \synfunc{package}\ \synclass{Foo};\\
    \synfunc{sub}\ \synvar{new}\ \ \ \ \ \ \ \ \ \{ \synfunc{bless}\ \{\}, \synfunc{shift}\ \}\\
    \synfunc{sub}\ \synvar{hallo}\ \ \ \ \ \ \ \{ "\synstr{Hallo}\ "\ . \synvar{\$\_}[1] . "\synstr{!}"\ \}\\
    \synfunc{sub}\ \synvar{bar}\ :lvalue \{ \synvar{\$\_}[0]->\{\synstr{foo}\} \}\\
    \ \\
    \ \\
    \ \\
    \syncomment{\# Dann:}\\
    \synfunc{my}\ \synvar{\$obj}\ = \synclass{Foo}->\synvar{new};\\
    \synvar{\$obj}->\synvar{bar}\ = 42;\\
    \synfunc{print}\ \synvar{\$obj}->\synvar{hallo}("\synstr{Ingo}");\\
  }\end{block}
}

\frame{
  \frametitle{Klassendefinition und -instantiierung in anderen Sprachen}

  \begin{block}{PHP}\texttt{%
    \synfunc{class}\ \synclass{Foo}\ \{\\
    \ \ \synfunc{var}\ \synvar{\$bar};\\
    \ \ \synfunc{function}\ \synvar{hallo}(\synvar{\$name}) \{\\
    \ \ \ \ \synfunc{return}\ "\synstr{Hallo }\synvar{\$name}\synstr{!}";\\
    \ \ \}\\
    \}\\
    \ \\
    \syncomment{\# Dann:}\\
    \synvar{\$obj}\ = \synfunc{new}\ \synclass{Foo}();\\
    \synvar{\$obj}->\synvar{bar}\ = 42;\\
    \synfunc{print}\ \synvar{\$obj}->\synvar{hallo}("\synstr{Ingo}");\\
  }\end{block}
}

\frame{
  \frametitle{Klassendefinition und -instantiierung in anderen Sprachen}

  \begin{block}{Python}\texttt{%
    \synfunc{class}\ \synclass{Foo}:\\
    \ \ \synvar{bar}\ = \synvar{None}\\
    \ \ \synfunc{def}\ \synvar{hallo}(\synvar{self}, \synvar{name}):\\
    \ \ \ \ \synfunc{return}\ "\synstr{Hallo \%s!}"\ \% \synvar{name}\\
    \ \\
    \ \\
    \ \\
    \syncomment{\# Dann:}\\
    \synvar{obj}\ = \synclass{Foo}()\\
    \synvar{obj}.\synvar{bar}\ = 42\\
    \synfunc{print}\ \synvar{obj}.\synvar{hallo}("\synstr{Ingo}")\\
  }\end{block}
}

\frame{
  \frametitle{Klassendefinition und -instantiierung in anderen Sprachen}

  \begin{block}{Ruby}\texttt{%
    \synfunc{class}\ \synclass{Foo}\\
    \ \ \synfunc{attr\_accessor}\ :\synvar{bar}\\
    \ \ \synfunc{def}\ \synvar{hallo}(\synvar{name})\\
    \ \ \ \ \synfunc{return}\ "\synstr{Hallo \#\{}\synvar{name}\synstr{\}!}"\\
    \ \ \synfunc{end}\\
    \synfunc{end}\\
    \ \\
    \syncomment{\# Dann:}\\
    \synvar{obj}\ = \synclass{Foo}.\synvar{new}\\
    \synvar{obj}.\synvar{bar}\ = 42\\
    \synfunc{puts}\ \synvar{obj}.\synvar{hallo}("\synstr{Ingo}")\\
  }\end{block}
}

\frame{
  \frametitle{Klassendefinition und -instantiierung in Perl 6}
  \begin{block}{Perl 6}\texttt{%
    \synfunc{class}\ \synclass{Foo}\ \only<6>{\synfunc{is}\ \synclass{Baz}\ }\{\\
      \only<1> {\ \ \synfunc{has}\ \synvar{\${}.bar};\\}
      \only<2->{\ \ \synfunc{has}\ \synvar{\${}.bar}\ \synfunc{is}\ \synvar{rw};\\}
      \ \ \synfunc{method}\ \synvar{hallo}(\synclass{Str}\ \synvar{\$name}) \{\\
      \ \ \ \ \synfunc{return}\ "\synstr{Hallo \{}\synvar{\$name}\synstr{\}!}";\\
      \ \ \}\\
    \}\\
    \ \\
    \syncomment{\# Dann:}\\
    \synfunc{my}\ \only<4->{\synclass{Foo}\ }\synvar{\$obj}\ \only<5->{.}= \only<1-4>{\synclass{Foo}.}\synvar{new};\\
    \only<1> {\synfunc{say}\ \synvar{\$obj}.\synvar{bar};\\}
    \only<2->{\synvar{\$obj}.\synvar{bar}\ = 42;\\}
    \only<1-2>{\synfunc{say}\ \synvar{\$obj}.\synvar{hallo}("\synstr{Ingo}");\\}
    \only<3-> {\synfunc{say}\ \synvar{hallo}\ \synvar{\$obj}: "\synstr{Ingo}";\\}
  }\end{block}
}

\frame{
  \frametitle{Rollen}

  \texttt{%
    \synfunc{role}\ \synclass{Logger::Mail}\ \{\\
    \ \ \synfunc{method}\ \synvar{log}(\synclass{Str}\ \synvar{\$message}) \{...\}\\
    \}\\
    \ \\
    \synfunc{role}\ \synclass{Logger::Logfile}\ \{\\
    \ \ \synfunc{method}\ \synvar{log}(\synclass{Str}\ \synvar{\$message}) \{...\}\\
    \}\\
    \ \\
    \synfunc{class}\ \synclass{NormaleKlasse}\ \only<2->{\synfunc{does}\ \synclass{Logger::Mail}\ }\{...\}\\
    \ \\
    \synfunc{my}\ \synclass{NormaleKlasse}\ \synvar{\$normales\_{}obj}\ .= \synvar{new}(...);\\
    \only<1>{\synvar{\$normales\_{}obj}\ \synfunc{does}\ \synclass{Logger::Mail};}\ \\
    \synvar{\$normales\_{}obj}.\synvar{log}(...);\\
  }

%  \texttt{%
%    \synfunc{role}\ \synclass{Num::Cool}\ \{\\
%    \ \ \synfunc{method}\ \synvar{sei\_cool}(\synvar{\$self}:) \{\\
%    \ \ \ \ \synvar{\$self}\ = 42;\\
%    \ \ \}\\
%    \}\\
%    \ \\
%    \syncomment{\# Dann:}\\
%    \synfunc{my}\ \synvar{\$num}\ = 23;\\
%    \only<1>{\synvar{\$num}\ \synfunc{does}\ \synclass{Num::Cool};\\}
%    \only<2>{\synclass{Num}\ \synfunc{does}\ \synclass{Num::Cool};\\}
%    \synvar{\$num}.\synvar{sei\_cool}();\\
%    \synfunc{say}\ \synvar{\$num};\ \ \ \ \ \ \syncomment{\# 42}\\
%  }
}

\subsection{Mitgestaltungsm"oglichkeiten}
\frame[t]{
  \frametitle{Mitgestaltungsmöglichkeiten}

  \begin{itemize}
    \item Mailingliste: \\
          \texttt{perl6-language@perl.org}, \\
          \texttt{gmane.comp.lang.perl.perl6.language}
    \item IRC: \texttt{\#perl6} auf Freenode
    \item Auch Newbies gern gesehen
    \item Viele Beteiligungsmöglichkeiten, nicht nur für Programmierer
    \item Weitere Informationen: \url{http://dev.perl.org/perl6/}
  \end{itemize}
}


\section{Pugs}
\frame[t]{
  \frametitle{"`Perl 6 ist ja schön und gut, aber das dauert doch noch Jahre,
  bis es fertig ist!"'}

  \begin{itemize}
    \item Nur tote Produkte sind "`fertig"'.
    \item Parrot steht bereits.
    \item Seit dem 1. Februar gibt es nun auch einen Perl 6-Compiler.
  \end{itemize}
}

\subsection{"Ubersicht}
\frame[t]{
  \frametitle{Pugs}
  
  \begin{itemize}
    \item Ursprünglich Haskell-Projekt von Autrijus Tang "`als Übung"'
    \item Projektbeginn: 1. Februar 2005
    \item Nun fast 100 Entwickler
    \item Version 6.2.2: Beinahe Alles (!) außer Objektorientierung
  \end{itemize}
}

\subsection{Entwicklung}
\frame[t]{
  \frametitle{Entwicklung}

  \begin{itemize}
    \item "`Test-driven development"' --
    \item Camelfolks: Schreiben von Tests in Perl 6 für noch nicht
	  implementierte Features \\
	  \texttt{%
	    \ \ \synfunc{is}\ 23 + 42, 64, "\synstr{Einfache Rechnungen funzen.}";\\
	    \ \ \synfunc{is}\ \~{}\symbol{91}1, 2, 3], "\synstr{1 2 3}",\\
	    \ \ \ \ "\synstr{Arrays wandeln sich richtig in Strings um.}";\\
	    \ \ \synfunc{is}\ +\symbol{91}1, 2, 3], 3,\\
	    \ \ \ \ "\synstr{Arrays wandeln sich richtig in Ints um.}";\\
	  }
    \pause
    \item Lambdafolks: Implementierung dieser Features
    \item Ergebnis der Zusammenarbeit: \\
	  Über 4.000 funktionierende Tests
  \end{itemize}
}

\subsection{Weitere Pl"ane}
\frame[t]{
  \frametitle{Weitere Pläne}

  \begin{tabbing}
    Pugs 6.283185aaa \= ... \kill
    \color{beamer@blendedblue}Pugs 6.0 \> Erstes Release \\
    \color{beamer@blendedblue}Pugs 6.2 \> Grundlegende IO- und Kontrollflusselemente, \\\> veränderbare Variablen \\
    \color{beamer@blendedblue}Pugs 6.28 \> Klassen \\
    \color{beamer@blendedblue}Pugs 6.283 \> Rules und Grammars \\
    \color{beamer@blendedblue}Pugs 6.2831 \> Rollen \\
    \color{beamer@blendedblue}Pugs 6.28318 \> Makros \\
    \color{beamer@blendedblue}Pugs 6.283185 \> Portierung von Pugs von Haskell nach Perl 6 \\
    \color{beamer@blendedblue}Pugs $2\pi$ \> Vollendung
  \end{tabbing}
}

\subsection{Beteiligungsm"oglichkeiten}
\frame[t]{
  \frametitle{Beteiligungsmöglichkeiten}

  \begin{itemize}
    \item Mailingliste: \\
          \texttt{perl6-compiler@perl.org}, \\
          \texttt{gmane.comp.lang.perl.perl6.compiler}
    \item IRC: \texttt{\#perl6} auf Freenode
    \item Auch Newbies gern gesehen
    \item Schreiben von Tests (Perl 6), Implementierung (Haskell), Schreiben
	  von Dokumentation, Portierung von
	  Perl~5\texttt{|}Python\texttt{|}Ruby\texttt{|}\ldots-Modulen nach
	  Perl 6, \ldots
    \item Weitere Informationen: \url{http://www.pugscode.org/}
  \end{itemize}
}


\section{Ausblick}
\frame[t]{
  \frametitle{Ausblick}

  \begin{itemize}
    \item \syncool{Perl 6}\ ist verdammt cool. :)
    \item \syncool{Parrot}\ steht bereits und bringt einiges an
          Geschwindigkeit für viele Sprachen.
    \item Dank \syncool{Pugs}\ kann man schon \syncool{genau jetzt}\ in Perl 6
	  programmieren.
  \end{itemize}
}

% In der bisher noch ungeschriebenen \section über Pugs unbedingt die Sachen
% von http://sial.org/pbot/9451 einbringen! Thanks nothingmuch!

\end{document}
