[pypy-svn] r47583 - pypy/extradoc/talk/dls2007

antocuni at codespeak.net antocuni at codespeak.net
Fri Oct 19 15:04:22 CEST 2007


Author: antocuni
Date: Fri Oct 19 15:04:21 2007
New Revision: 47583

Added:
   pypy/extradoc/talk/dls2007/rpython-talk.latex
Removed:
   pypy/extradoc/talk/dls2007/rpython-talk.txt
Log:
port the talk from rst to latex beamer



Added: pypy/extradoc/talk/dls2007/rpython-talk.latex
==============================================================================
--- (empty file)
+++ pypy/extradoc/talk/dls2007/rpython-talk.latex	Fri Oct 19 15:04:21 2007
@@ -0,0 +1,390 @@
+\documentclass[14pt]{beamer}
+\usepackage[latin1]{inputenc}
+
+% settings for code snippets
+\usepackage{listings}
+\usepackage{fancyvrb}
+\lstset{language=Python,
+        basicstyle=\footnotesize\ttfamily,
+        frame=none,
+        stringstyle=\color{blue},
+        fancyvrb=true,
+        xleftmargin=2pt,xrightmargin=2pt,
+        showstringspaces=false}
+
+
+\usetheme{Boadilla}
+%\usetheme{Warsaw}
+\setbeamercovered{transparent}
+
+\title[RPython, a dynamic static language]{RPython\\A Step Towards Reconciling Dynamically and Statically Typed OO Languages}
+\author[Antonio Cuni]{Antonio Cuni -- DISI, Università degli Studi di Genova}
+\institute[DSL'07 OOPSLA]{DLS'07 OOPSLA Montreal CA}
+\date{October 22, 2007}
+
+\begin{document}
+
+\begin{frame}
+  \titlepage
+\end{frame}
+
+\begin{frame}
+  \frametitle{Dynamic languages for .NET and JVM}
+  \begin{itemize}
+  \item .NET and JVM: widespread platforms
+  \item Designed for static languages
+  \item Great Python implementations: \textbf{IronPython}, \textbf{Jython}
+  \item Much slower than e.g. C\# and Java
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Dynamic vs. static}
+  \begin{alertblock}{Dynamic languages}
+    \begin{itemize}
+    \item Flexibility
+    \item Rapid development cycle
+    \item \textbf{Metaprogramming}
+    \end{itemize}
+  \end{alertblock}
+
+  \pause
+  \begin{alertblock}{Static languages}
+    \begin{itemize}
+    \item Speed
+    \item Nothing more :-)
+    \end{itemize}
+  \end{alertblock}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{RPython Quick Facts}
+
+  \begin{itemize}
+  \item Restricted subset of Python
+  \item Statically typed (type inference)
+  \item Still allows metaprogramming
+  \item RPython programs still run under {\{}C,J,Iron{\}}Python
+  \item Three backends: C, .NET, JVM
+  \item Almost as fast as C, C{\#}, Java
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Type inference}
+  \begin{itemize}
+  \item Top-down, starting from an entry point; whole program analysis
+  \item Assign the most precise type to each variable
+  \item Fail if you try to mix incompatible types
+  \end{itemize}
+
+  \pause
+
+  \begin{columns}
+    \begin{column}{0.45\textwidth}
+      \begin{exampleblock}{RPython}
+        \begin{lstlisting}
+def main():           
+    print add(40, 2)  
+
+def add(a, b):
+    return a+b
+        \end{lstlisting}
+      \end{exampleblock}
+    \end{column}
+
+    \pause
+
+    \begin{column}{0.45\textwidth}
+      \begin{exampleblock}{Not RPython}
+        \begin{lstlisting}
+def fn(flag):     
+    if flag:               
+       return 42           
+    else:                  
+       return 'hello'
+        \end{lstlisting}
+      \end{exampleblock}
+    \end{column}
+  \end{columns}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Other restrictions}
+
+  \begin{itemize}
+  \item Globals are assumed to be constant
+  \item \texttt{yield} and generators not supported
+  \item No special \_\_methods\_\_ (except \_\_init\_\_ and \_\_del\_\_) 
+  \item No run-time definition of new functions and classes
+  \item Cannot modify classes at run-time
+  \item Cannot change the {\_}{\_}class{\_}{\_} of an object
+  \item Single inheritance, with limited support for mixins
+  \end{itemize}
+\end{frame}
+
+
+  \begin{frame}
+    \frametitle{Still pythonic, though}
+
+    \begin{itemize}
+      \item No syntactic restriction
+      \item Functions and classes are first-order values
+      \item Exceptions work
+
+      \pause
+      \begin{alertblock}{Lists and dictionaries}
+        \begin{itemize}
+        \item Work, but they must be homogeneous
+        \item list of int, dict from string to floats, etc. are OK
+        \item list of \emph{int and strings} is not
+        \item Most of methods of \texttt{list}, \texttt{dict} and
+          \texttt{str} are supported
+        \end{itemize}
+      \end{alertblock}  
+    \end{itemize}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Init-time, translation-time, run-time}
+  \begin{center}
+    \includegraphics[scale=0.45]{image/translation.pdf}
+  \end{center}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Metaprogramming}
+  \begin{itemize}
+  \item RPython restrictions only apply to live objects
+  \item No restrictions about how they are created
+    \begin{itemize}
+    \item Full Python is allowed at init-time
+    \end{itemize}
+  \item Python as a metaprogramming language for RPython
+  \item Code generation considered harmful
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Compute complex constants}
+
+  \begin{exampleblock}{Fibonacci's numbers}
+    \begin{lstlisting}
+def fibo(N):
+    sequence = []
+    a, b = 1, 1
+    for i in xrange(N):
+        sequence.append(a)
+        a, b = b, a+b
+    return sequence
+
+# computed at init-time
+fibo_numbers = fibo(100)
+    \end{lstlisting}
+  \end{exampleblock}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Metaclasses run at init-time}
+
+  \begin{exampleblock}{\texttt{\_\_extend\_\_} metaclass}
+    \begin{lstlisting}
+class MyClass(object):
+    def foo(self):  ...
+
+class __extend__(MyClass):
+    def bar(self):  ...
+
+def main():
+    obj = MyClass()
+    obj.bar()
+  \end{lstlisting}
+  \end{exampleblock}
+\end{frame}
+
+
+
+\begin{frame}[fragile]
+  \frametitle{Dynamic classes/functions at init-time}
+  \begin{exampleblock}{``Static'' nested scopes work}
+    \begin{lstlisting}
+def make_adder(N):
+    def add(x):
+        return x+N
+    return add
+
+add10 = make_adder(10)
+add20 = make_adder(20)
+
+def main():
+    print add10(32)
+    print add20(22)
+    \end{lstlisting}
+  \end{exampleblock}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{The Translation Toolchain}
+  \begin{itemize}
+  \item \textbf{CPython}: *.py -{}-{\textgreater} Python bytecode
+  \item \textbf{FlowObjSpace}: bytecode -{}-{\textgreater} flow graphs
+  \item \textbf{Annotator}: type inference on flow graphs
+    \begin{itemize}
+    \item High level Python types (\texttt{List(Integer)})
+    \end{itemize}
+  \item \textbf{RTyper}: high level types -{\textgreater} low level types
+    \begin{itemize}
+    \item lltype for C, ootype for CLI and JVM
+    \end{itemize}
+  \item \textbf{Backends}: code generation
+    \begin{itemize}
+    \item C, CLI (.NET), JVM
+    \end{itemize}
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Benchmarks}
+
+  \begin{itemize}
+  \item Classic Martin Richard's test
+  \item Available in Java, C{\#}, RPython
+
+    \begin{table}[ht]
+      \begin{tabular}{|l|r|r|}
+        \hline
+        \textbf{Language} & 
+        \textbf{Result} &
+        \textbf{Factor} \\
+        \hline
+        \multicolumn{3}{|c|}{Results on Microsoft CLR}\\
+        \hline
+        C\# & 
+        6.94 ms &
+        1.00x \\
+        
+        RPython &
+        7.25 ms &
+        1.04x \\
+
+        IronPython &
+        1675.00 ms &
+        241.35x \\
+        \hline
+
+        \multicolumn{3}{|c|}{Results on JVM}\\
+        \hline
+        Java & 
+        1.77 ms &
+        1.00x \\
+
+        RPython &
+        2.10 ms &
+        1.18x \\
+
+        Jython &
+        2918.90 ms &
+        1641.80x \\
+        \hline
+      \end{tabular}
+    \end{table}
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{What's good about RPython}
+  \begin{itemize}
+  \item Pythonic enough to be usable
+  \item Very fast
+  \item Testable under CPython
+  \end{itemize}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Things to improve}
+  \begin{itemize}
+  \item Originally an implementation detail
+  \item Not designed to be user-friendly; terse error messages
+  \item Lack of documentation/reference manual
+  \item Lack of separate compilation
+  \item Integration with the hosting platform
+    \begin{itemize}
+    \item Good for C/Posix
+    \item Proof of concept for .NET
+    \item Doesn't exist for JVM
+    \end{itemize}
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{About PyPy (1)}
+
+  \begin{alertblock}{Pyton in (R)Python}
+    \begin{itemize}
+    \item High level interpreter written in RPython
+    \item Easy to understand
+    \item Easy to extend
+    \end{itemize}
+  \end{alertblock}
+
+  \pause
+  \begin{alertblock}{Translation Toolchain}
+    \begin{itemize}
+    \item Written in full Python
+    \item Works as a general compiler
+    \item Especially for interpreters (e.g. Javascript, Prolog)
+    \end{itemize}
+  \end{alertblock}
+\end{frame}
+
+\begin{frame}
+  \frametitle{About PyPy (2)}
+
+  \begin{alertblock}{Low-level aspects inserted by the TT}
+    \begin{itemize}
+    \item Garbage collector
+    \item Threading model/Stackless
+    \item Additional language features
+    \item JIT compiler (only for the C backend so far)
+    \end{itemize}
+  \end{alertblock}
+
+  \pause
+  \begin{alertblock}{PyPy you can get}
+    \begin{itemize}
+    \item pypy-c (about 2x slower than CPython)
+    \item pypy-c-jit (up to 60x \textbf{faster} than CPython)
+    \item pypy.NET (about 6x slower than IronPython)
+    \item pypy-jvm (about 30\% \textbf{faster} than Jython)
+  \end{itemize}
+  \end{alertblock}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Acknowledgments}
+  \begin{itemize}
+  \item The whole PyPy Team
+    \begin{itemize}
+    \item RPython is \textbf{not} mine :-)
+    \end{itemize}
+
+  \item Davide Ancona
+  \item Massimo Ancona
+  \item Nicholas D. Matsakis
+  \end{itemize}
+\end{frame}
+
+\end{document}



More information about the Pypy-commit mailing list