\documentclass{beamer}

\usepackage{beamerthemeprogressbar}
\usepackage[spanish]{babel}
\usepackage{fix-cm}
\usepackage{color}
\include{pythonlisting}

% the following is for unicode
\usepackage{fontspec}
\setmainfont[Mapping=tex-text]{DejaVu Sans}
\usepackage{xunicode}
\usepackage{xltxtra}

\usepackage{fancyvrb}

\definecolor{verdeoscuro}{rgb}{.2,.4,.2}
\definecolor{casinegro}{rgb}{.1,.2,.1}
\newcommand{\vpy}[1] {\texttt{\textbf{\color{verdeoscuro}#1}}}

\setbeamersize{text margin left=20pt }
\setbeamersize{text margin right=20pt }
\setbeamertemplate{itemize item}[triangle]
\setbeamertemplate{itemize subitem}[triangle]

\title{Python 3000}
\author{Facundo Batista}
\date{\today}

\begin{document}
\frame[plain]
{
\fontsize{52}{0}\selectfont

\begin{picture}(0,0)
  \put(96,-75){\includegraphics[scale=.23]{images/futuro.jpg}}
  \put(0,-5){\textbf{\textit{\color{blue}Python}}}
  \put(52,-55){\textit{\textbf{\color{red}3000}}}

  \fontsize{22}{0}\selectfont
  \put(5,-110){Facundo Batista}

  \fontsize{10}{0}\selectfont
  \put(192,-130){\includegraphics[scale=.3]{images/logo-pyar.png}}

  \fontsize{8}{0}\selectfont
  \put(10,-145){\color{casinegro}Gracias especiales a \textbf{nessita} por su indispensable ayuda con \LaTeX para esta presentación}

\end{picture}
}

\frame
{
\fontsize{38}{0}\selectfont

\begin{picture}(0,0)
  \put(35,-135){\includegraphics[scale=.3]{images/duda.png}}
  \put(20,55){¿Python}
  \put(150,30){queloqué?}
\end{picture}
}

\frame
{
\frametitle{Evolución normal}

    \begin{itemize}
    \setlength{\itemsep}{5pt}
    \setlength{\parskip}{5pt}
    \item Versiones: Python x.y.z
        \begin{itemize}
        \setlength{\itemsep}{2pt}
        \item x: mayor
        \item y: menor
        \item z: bugfix
        \end{itemize}
    
    \item Normalmente no rompemos (casi) nada
        \begin{itemize}
        \setlength{\itemsep}{2pt}
        \item warnings
        \item from future
        \end{itemize}

    \item Se barajaba una versión disruptiva desde hace años

    \item El futuro ya llegó
    \end{itemize}
}

\frame
{
  \frametitle{¿Por qué? ¿Para qué?}

    \begin{itemize}
    \setlength{\parskip}{3pt}
    \setlength{\itemsep}{3pt}
    \item Corregir errores de diseño, viejos principalmente
        \begin{itemize}
        \item clases clásicas
        \item división de enteros
        \item print como declaración
        \end{itemize}
    \item Los tiempos cambian: compromiso espacio/velocidad
        \begin{itemize}
        \item str / unicode
        \item int / long
        \end{itemize}
    \item Nuevos paradigmas
        \begin{itemize}
        \item views de los diccionarios
        \item anotaciones en los argumentos
        \end{itemize}
    \end{itemize}
}

\frame
{
\begin{picture}(0,0)
  \put(-5,-180){\includegraphics[scale=.4]{images/new.jpg}}
\end{picture}

\fontsize{40}{50}\selectfont
\vspace{1cm}
\begin{flushright}
Nuevas \\ funcionalidades \\ y mejoras
\end{flushright}
}

\frame
{
\frametitle{Textos, textos, textos!}

\begin{itemize}
    \setlength{\parskip}{6pt}
    \setlength{\itemsep}{6pt}
    \item En Py2: cadenas normales y unicode
    \begin{itemize}
        \item no estaban bien separados los conceptos
        \item confundía, sorprendía
    \end{itemize}
    \item En Py3 tenemos bytes y texto
    \begin{itemize}
        \item texto: nos abstraemos de la codificación
        \item bytes: una secuencia de valores de 8 bits
        \item son dos tipos de datos totalmente separados
    \end{itemize}
\end{itemize}
}

\begin{frame}[fragile]
\frametitle{Textos en Python 3}

\begin{itemize}
    \setlength{\parskip}{4pt}
    \setlength{\itemsep}{2pt}
    \item Distinguimos ambos literales
    \begin{itemize}
        \item b'...': bytes
        \item '...': cadenas de caracteres (unicode)
        \item u'...': también caracteres, por compatibilidad
    \end{itemize}
    \item No hay conversiones implícitas
    \begin{itemize}
        \item menos confusión, menos sorpresas
        \item más fácil de seguir la Regla de Oro de Unicode
    \end{itemize}
    \item Las fuentes tiene un default: UTF-8
    \begin{itemize}
        \item menos confusión, menos sorpresas
        \item no necesitamos más el \vpy{ -*- coding:... -*-}
    \end{itemize}
    \item \vpy{open()} tiene 'encoding' opcional!
    \begin{itemize}
        \item como \vpy{codecs.open()}
    \end{itemize}
    \item Unicode en los nombres
    \begin{itemize}
        \item \vpy{>>> año = 3000}
    \end{itemize}

\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Avistando diccionarios}
\vspace{5mm}
\begin{itemize}
\setlength{\itemsep}{6pt}
\item \vpy{dict.keys()}, \vpy{.values()}, \vpy{.items()}, ahora devuelven una \textit{vista}

\item Se actualizan cuando el diccionario cambia
  \begin{python}
  >>> d = dict(a=3, b=4)
  >>> v = d.values()
  >>> v
  dict_values([3, 4])
  >>> list(v)
  [3, 4]
  >>> d["c"] = 8
  >>> list(v)
  [3, 8, 4]
  \end{python}

\item Son re-iterables, no se \textit{gastan} como el viejo \vpy{.iteritem()}
  \begin{python}
  >>> list(v)
  [3, 8, 4]
  >>> list(v)
  [3, 8, 4]
  \end{python}

\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Asterisquémonos}
\vspace{5mm}
\begin{itemize}
\setlength{\itemsep}{2pt}
\item Podemos tener argumentos sólo nombrados
  \begin{python}
  >>> def foo(*args, bar=None):
  ...     print(args, bar)
  >>> foo(1)
  (1,) None
  >>> foo(1, 2)
  (1, 2) None
  >>> foo(1, bar=7)
  (1,) 7
  \end{python}

\item Asignación múltiple de largo variable
  \begin{python}
  >>> a, b, *c = range(5)
  >>> a, b, c
  (0, 1, [2, 3, 4])
  >>> a, *b, c = range(5)
  >>> a, b, c
  (0, [1, 2, 3], 4)
  \end{python}
  
\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{La función format()}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item Integrada, formatea un sólo valor
  \begin{python}
  >>> format(1.2321, "8.2f")
  '    1.23'
  \end{python}

\item Cómo método de las cadenas
  \begin{python}
  >>> "Son {0}: {val:.2f}".format("pesos", val=4)
  'Son pesos: 4.00'
  \end{python}

\item Más poder, más flexibilidad
    \begin{itemize}
    \item trabaja bien con los códigos de formateo conocidos
    \item se puede definir el comportamiento del formato: \vpy{\_\_format\_\_}
    \end{itemize}
    \begin{python}
    >>> "{:,.2f}".format(Decimal(3123.5))
    '3,123.50'
    \end{python}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Abstract Base Classes (ABC)}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item Nos permite definir clases abstractas con las cuales cumplir

\item  El módulo \vpy{collections} define estrictamente comportamientos
\begin{python}
>>> dir(collections)
[..., 'Callable', 'Container', 'Hashable',
                    'Iterable', 'Sequence', ...]
\end{python}

\item El chequeo rígido de interfaces es nuevo a Python
    \begin{itemize}
    \item quizás dispare nuevas metodologías
    \item con suerte no hará que aparezcan miles de controles \vpy{isinstance()}
    \item el tiempo dirá si ayudan o lastiman al \textit{duck typing}
    \end{itemize}

\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Más y mejores números I}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Literales binarios y la función \vpy{bin()}
\begin{python}
>>> 0b1001
9
>>> bin(34)
'0b100010'
\end{python}

\item ¿Cuantos bits usa para un número?
\begin{python}
>>> (27).bit_length()
5
\end{python}

\item Fracciones!
\begin{python}
>>> Fraction(1, 3)
Fraction(1, 3)
>>> print(Fraction(1, 3))
1/3
>>> print(Fraction(1, 3) * 3)
1
\end{python}

\end{itemize}
\end{frame}



\begin{frame}[fragile]
\frametitle{Más y mejores números II}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Nueva forma de buscar la representación más exacta de un \vpy{float}
    \begin{itemize}
    \item \vpy{1.1} es \vpy{1.100000000000000088817841970012523233890533447265625}
    \item antes se tomaban 17 decimales y ya: \vpy{'1.1000000000000001'}
    \item ahora se busca el número más corto que siga siendo igual a lo almacenado: \vpy{'1.1'}
    \item igual, lo subyacente no cambia
\begin{python}
>>> 1.1 + 2.2 == 3.3
False
\end{python}
    \end{itemize}

\item Mejoras en Decimal
    \begin{itemize}
    \item Conversión exacta desde \vpy{float}
\begin{python}
>>> Decimal.from_float(1.1) 
Decimal('1.100000000000000088878...0533447265625')
\end{python}
    \item Está codeada (también) en C: de 12 a 120 veces más rápida
    \end{itemize}

\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Interactuando con el sistema}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item La E/S no depende más de \verb|<stdio.h>| de C
    \begin{itemize}
    \item independiente de la plataforma
    \item unicode bien integrada en el stack subyacente
    \item reescrito en C en 3.1, en 3.0 estaba en Python y era lento
    \item nuevo flag 'x' para abrir un archivo: exclusivamente un archivo nuevo
    \end{itemize}

\item \vpy{os.sendfile()} provee 'zero-copy' entre archivos o sockets

\item Todas las excepciones contra el sistema son \vpy{OSError}
    \begin{itemize}
    \item Deprecamos \vpy{IOError}, \vpy{EnvironmentError}, \vpy{WindowsError}, \vpy{mmap.error}, etc...
    \item No hace falta revisar el \vpy{errno} para saber qué pasó, hay excepciones puntuales como \vpy{FileNotFoundError}, \vpy{NotADirectoryError}, \vpy{PermissionError}, \vpy{TimeoutError}, etc...
    \end{itemize}

\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Ejecuciones simultáneas}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item Nuevo paquete \vpy{futures} para ejecutar código 'en paralelo'
\begin{python}

PRIMES = [ lista de nros ]

def is_prime(n):
    (código para averiguar si n es primo)

with concurrent.futures.ProcessPoolExecutor() as executor:
    all_calls = executor.map(is_prime, PRIMES)
    for number, prime in zip(PRIMES, all_calls):
        print('%d is prime: %s' % (number, prime))
\end{python}

\item Procesos (sensible cantidad default) o hilos

\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Mejoras en la sintaxis I}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Decoradores de clase
    \begin{itemize}
    \item Fácil de aprender
    \item Mucho más sencillo que metaclases
    \end{itemize}

\begin{python}
>>> def f(cls):
...     cls.log = lambda self, *a, **k: print(a, k)
...     return cls
...
>>> @f
... class C():
...     pass
...
>>> c = C()
>>> c.log(2)
(2,) {}
\end{python}

\item Atrapando excepciones con menos riesgo
    \begin{itemize}
    \item \vpy{except KeyError, err: → except KeyError as err:}
    \item menos confuso: \vpy{except KeyError, AttributeError:}
    \end{itemize}

\end{itemize}
\end{frame}



\begin{frame}[fragile]
\frametitle{Mejoras en la sintaxis II}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Declaración nonlocal
\begin{python}
>>> b = 5
>>> def f():
...     b = 3
...     def g():
...         nonlocal b
...         b = 1
...     g()
...     print(b)
...
>>> f()
1
>>> print(b)
5
\end{python}

\item Anotación de funciones
    \begin{itemize}
    \item \vpy{def promedios(valores: list) -> float:}
    \item se permite cualquier expresión
    \item el intérprete no le da significado o propósito
    \end{itemize}


\end{itemize}
\end{frame}



\begin{frame}[fragile]
\frametitle{Mejoras en la sintaxis III}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Literales para set, y \textit{set comprehensions}
\begin{python}
>>> {1, 2, 2, 3}
{1, 2, 3}
>>> {x**2 for x in (-1, 0, 1)}
{0, 1}
\end{python}

\item También \textit{dict comprehensions}!
\begin{python}
>>> {y:x for x,y in d.items()}
{0: 'a', 1: 'b', 2: 'c'}
\end{python}

\item Abriendo muchos archivos con \vpy{with}
\begin{python}
>>> with open('mylog') as inp_f, open('out', 'w') as out_f:
...     for line in inp_f:
...         if '<critical>' in line:
...             out_f.write(line)
\end{python}

\end{itemize}
\end{frame}



\begin{frame}[fragile]
\frametitle{Más y mejores módulos}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Diccionarios ordenados
    \begin{itemize}
    \item \vpy{collections.OrderedDict()}
    \item Buenísimo para representar configuración
    \end{itemize}

\item Cache automático para funciones: 
    \begin{itemize}
    \item \vpy{@functools.lru\_cache(maxsize=300)}
    \item para pagar el costo una vez en funciones caras
    \end{itemize}

\item Acumulador
    \begin{itemize}
    \begin{python}
>>> list(itertools.accumulate([8, 2, 50]))
[8, 10, 60]
    \end{python}
    \item muy usado al integrar, o trabajando con probabilidady y estadística
    \end{itemize}

\item Y muchos más
    \begin{itemize}
    \item \vpy{argparse}, para interpretar lineas de comandos, más completo y fácil
    \item \vpy{faulthandler}, para crashes como un \verb|Segmentation Fault|
    \item \vpy{lzma}, soporte para \verb|.xz| y \verb|.lzma| en la biblioteca estándar!
    \item Entornos virtuales, como \verb|virtualenv|
    \end{itemize}

\end{itemize}
\end{frame}



\begin{frame}[fragile]
\frametitle{Otras mejoras que no lastiman a nadie I}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Bytes mutables: \vpy{bytearray}
\begin{python}
>>> bytearray(5)
bytearray(b'\x00\x00\x00\x00\x00')
>>> b = bytearray(range(5))
>>> b
bytearray(b'\x00\x01\x02\x03\x04')
>>> b[3] = 255
>>> b
bytearray(b'\x00\x01\x02\xff\x04')
\end{python}


\item Entregando desde otro lado
\begin{python}
>>> def g(x):
        for i in range(x):
            yield i
>>> def f(x):
        yield from range(x)
>>> list(g(5)), list(f(5))
[0, 1, 2, 3, 4], [0, 1, 2, 3, 4]
\end{python}

\end{itemize}
\end{frame}



\begin{frame}[fragile]
\frametitle{Otras mejoras que no lastiman a nadie II}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}

\item Nombres completos para clases y funciones
\begin{python}
>>> class C:
...     class D:
...         def meth(self):
...             pass
...
>>> C.D.__name__
'D'
>>> C.D.__qualname__
'C.D'
>>> C.D.meth.__name__
'meth'
>>> C.D.meth.__qualname__
'C.D.meth'
\end{python}

\item No necesitamos argumentos para \vpy{super()}

\end{itemize}
\end{frame}



\frame
{
\fontsize{35}{40}\selectfont
\begin{picture}(0,0)
  \put(180,-195){\includegraphics[scale=.4]{images/burro.jpg}}
\end{picture}
\begin{flushleft}
Muchas mejoras \\ no son \\ compatibles
\end{flushleft}
\vspace{15cm}
}

\begin{frame}[fragile]
\frametitle{\vpy{print} es ahora una función}

\begin{itemize}
    \setlength{\parskip}{6pt}
    \setlength{\itemsep}{6pt}
    \item El cambio es sencillo
    \begin{itemize}
        \item \vpy{print 'pyar'  →  print('pyar')}
    \end{itemize}
    \item Flexibilidad
    \begin{itemize}
        \item fácil de reemplazar por tu propia función
        \item más opciones, mejor legibilidad
        \item \vpy{print(m, file=stderr)}
        \item \color{verdeoscuro}\verb|print('\r' % avance, end='', flush=True)|
    \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Iteradores/generadores FTW!}
\begin{itemize}
\setlength{\itemsep}{3pt}
\setlength{\parskip}{3pt}
\item La idea es tratar de usar siempre iteradores o generadores
\item Es mucho más eficiente en velocidad y memoria
\item Sólo es molesto en el intérprete interactivo
\item Muchos cambios para ir hacia esto
    \begin{itemize}
    \item \vpy{range()} ahora se comporta como \vpy{xrange()} (que no está más)
    \item \vpy{map()} y \vpy{filter()}
    \item \vpy{dict.items()}, \vpy{.keys()}, \vpy{.values()}
    \item no están más \vpy{dict.iteritems()}, \vpy{dict.iterkeys()}, etc.
    \item muchos son tipos de datos específicos, no realmente \textit{iteradores}
    \end{itemize}
\item Tenemos un \vpy{next(it)} integrado
    \begin{itemize}
    \item \vpy{.next() → .\_\_next\_\_()}
    \end{itemize}

\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Ordenando ideas}
\begin{itemize}
\setlength{\itemsep}{5pt}
\setlength{\parskip}{5pt}

\item Chau al orden universal
    \begin{itemize}
    \item no hay más comparaciones arbitrarias
    \item \vpy{[2, 'w'].sort() → TypeError}
    \end{itemize}
\item \vpy{sorted()} y \vpy{list.sort()} no tienen más \textit{cmp}
    \begin{itemize}
    \item usar \textit{key}
    \item más limpio, más fácil
    \item acordarse que el sort es estable!
    \begin{python}
>>> seq = [('b', 2), ('a', 2), ('b', 1), ('c', 1)]
>>> seq.sort(key=itemgetter(1))
>>> seq.sort(key=itemgetter(0))
>>> seq
[('a', 2), ('b', 1), ('b', 2), ('c', 1)]
    \end{python}
    \end{itemize}
\item tampoco tenemos al \textit{cmp} integrado

\end{itemize}
\end{frame}

\begin{frame}[fragile]
\frametitle{Pasamos la escoba}
\begin{itemize}
\setlength{\itemsep}{1pt}
\setlength{\parskip}{1pt}
\item Eliminamos \vpy{<>}
    \begin{itemize}
    \item Usar \vpy{!=}
    \end{itemize}
\item Eliminamos \vpy{d.has\_key(x)}
    \begin{itemize}
    \item Usar \vpy{x in d}
    \end{itemize}
\item Eliminamos \vpy{reload()}
    \begin{itemize}
    \item Usar \vpy{imp.reload()}
    \end{itemize}
\item Eliminamos \vpy{reduce()}
    \begin{itemize}
    \item Usar \vpy{functools.reduce()}
    \end{itemize}
\item Eliminamos \vpy{apply()}
    \begin{itemize}
    \item Usar \vpy{f(*args)}
    \end{itemize}
\item Eliminamos \vpy{basestring}
    \begin{itemize}
    \item No tenemos más bytes y caracteres mezclados!
    \end{itemize}
\item Eliminamos los \vpy{``}
    \begin{itemize}
    \item Usar \vpy{repr()}
    \end{itemize}

\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Excepciones también como nuevas}
\begin{itemize}
\setlength{\itemsep}{6pt}
\setlength{\parskip}{6pt}
\item \vpy{raise 'foo'  →  TypeError}
\item La sintaxis del \vpy{raise} es
    \begin{itemize}
    \item \vpy{raise Exception(args)}
    \item \vpy{raise Exception(args) from traceback}
    \end{itemize}
\item La sintaxis del \vpy{except} es
    \begin{itemize}
    \item \vpy{except Exception:}
    \item \vpy{except Exception1, Exception2:}
    \item \vpy{except Exception as var:}
    \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Seguimos cambiando I}
\begin{itemize}
\setlength{\itemsep}{2pt}
\setlength{\parskip}{2pt}
\item No más clases clásicas
    \begin{itemize}
    \item Todas son \textit{nuevas}
    \item Cambió la sintáxis para indicar metaclases
    \begin{python}
    >>> class C(metaclass=...):
    \end{python}
    \end{itemize}
\item Enteros y no tanto
    \begin{itemize}
    \item Los int y long ahora son el mismo objeto
    \item División verdadera: \vpy{1/2} devuelve \vpy{0.5}
    \item Nuevos literales para otras bases
    \begin{python}
    >>> 0x101
    257
    >>> 0o101
    65
    >>> 0b101
    5
    \end{python}
    \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Seguimos cambiando II}
\begin{itemize}
\setlength{\itemsep}{3pt}
\setlength{\parskip}{3pt}
\item Una biblioteca con menos polvo
    \begin{itemize}
    \item Se eliminaron módulos viejos no mantenidos
    \item Se armó un nivel más, es más intuitiva
    \end{itemize}
\item El import relativo ahora es explícito
    \begin{itemize}
    \item \vpy{import foo} no es más dentro del paquete
    \item \vpy{from .foo import bar}
    \end{itemize}
\item \vpy{None}, \vpy{True} y \vpy{False} ahora son palabras reservadas
    \begin{itemize}
    \item \vpy{True = 0  →  SyntaxError}
    \end{itemize}
\item No tenemos más el desempaquetado de tuplas en los parámetros
    \begin{itemize}
    \item \vpy{def f(a, (b, c)):  →  SyntaxError}
    \end{itemize}
\item \vpy{.\_\_nonzero\_\_() → .\_\_bool\_\_()}
\item \vpy{raw\_input() → input()}

\end{itemize}
\end{frame}


\frame
{
\fontsize{40}{55}\selectfont
\begin{picture}(0,0)
  \put(0,-200){\includegraphics[scale=.4]{images/paracaidas.jpg}}
\end{picture}
\begin{flushright}
Saltando \\ a Python \\ 3000
\end{flushright}
}

\begin{frame}[fragile]
\frametitle{¿Ya ya ya ahorita?}
\begin{itemize}
\setlength{\itemsep}{6pt}
\setlength{\parskip}{6pt}
\item Python 2 está soportado, pero hay que ir pensando el cambio
    \begin{itemize}
    \item 2.7 ya tiene un par de años, \textbf{y es el último}
    \item algunos OSs ya no traen Python 2 por default
    \end{itemize}
\item Hay que migrar cuando ambas condiciones sean verdad:
    \begin{itemize}
    \item que ya estés listo
    \item que todas tus dependencias hayan sido portadas
    \end{itemize}
\item Aunque no migren ahora, vayan preparándose
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{La herramienta 2to3}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item Es un traductor de código fuente, no mantiene contexto
\item Maneja muy bien lo que es sintaxis
    \begin{itemize}
    \item \vpy{print};  \vpy{<>};  \vpy{except E, v}:
    \end{itemize}
\item Maneja bastante bien a las funciones y los tipos integrados
    \begin{itemize}
    \item \vpy{d.keys()}, \vpy{xrange()}, \vpy{apply()}
    \end{itemize}
\item No hace inferencia de tipos
\item No sigue variables en el código
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Preparandonos para Python 3000}
\begin{itemize}
\setlength{\itemsep}{5pt}
\setlength{\parskip}{5pt}
\item Migrar a Python 2.7, que es la versión de transición
    \begin{itemize}
    \item muchos features de Py3 fueron incluídos aquí
    \item tiene un flag \vpy{-3} que se queja de todo lo que se romperá luego
    \end{itemize}
\item Empezar a escribir código que sirva a futuro
    \begin{itemize}
    \item no preocuparse por trivialidades que 2to3 soporta
    \item como \vpy{callable()},  \vpy{<>},  etc.
    \end{itemize}
\item Focalizarse en lo que 2to3 no puede hacer
    \begin{itemize}
    \item dejar de usar módulos obsoletos
    \item comenzar a usar iteradores y generadores
    \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Escribiendo código a futuro en 2.7}
\begin{itemize}
\setlength{\itemsep}{3pt}
\setlength{\parskip}{3pt}
\item Heredar las clases de \vpy{object()}
\item Usar \vpy{dict.iterkeys()}, \vpy{.iteritems()}, etc.
\item Usar \vpy{xrange()}, \vpy{sorted()} sin el \textit{cmp}, \vpy{zip()}, etc
\item Importar la división del futuro y usar \vpy{//} donde corresponda
\item Heredar las excepciones de \vpy{BaseException}
\item Usar \vpy{\_\_lt\_\_} y \vpy{\_\_eq\_\_} en lugar de \vpy{\_\_cmp\_\_}
    \begin{itemize}
    \item si realmente necesitan la semántica de \textit{cmp}: \vpy{(a > b) - (a < b)}
    \end{itemize}
\item Manejar texto de la mejor forma posible
    \begin{itemize}
    \item aislar el uso de texto codificado
    \item usar \vpy{b''} (en 2.7 sólo un alias) para todo lo explícitamente bytes
    \item usar Unicode para todo lo que corresponda
    \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Como recorrer el camino}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item Plan de migración detallado
    \begin{itemize}
    \item migrar a 2.7
    \item comenzar a usar en 2.7 todo lo que se pueda de 3.3
    \item ejecutar con \vpy{-3}, para descubrir qué podemos ir cambiando
    \item convertir el código con 2-to-3
    \item ejecutar todas las pruebas unitarias
    \end{itemize}
\item Cuando tengamos código Py3 válido
    \begin{itemize}
    \item si se puede, pegar el salto!
    \item si no: mantener dos versiones
    \item o derivar código de Py3 desde Py2
    \end{itemize}
\end{itemize}
\end{frame}


\begin{frame}[fragile]
\frametitle{Ejemplo de código de transición}
\begin{itemize}
\setlength{\itemsep}{4pt}
\setlength{\parskip}{4pt}
\item Teníamos en Py2 viejo:
\linebreak\verb|                |\texttt{\textbf{\color{blue}print '2 ==', 11 / 5}}
\item Vamos a Py2.7:     
\linebreak\verb|                |\texttt{\textbf{\color{blue}igualito}}
\item Usamos el flag -3:  
\linebreak\verb|                |\texttt{\textbf{\color{blue}warning: floor division 11/5}}
\item Corregimos 2.7:     
\linebreak\verb|                |\texttt{\textbf{\color{blue}print u'2 ==', 11 // 5}}
\item 2to3 nos deja:    
\linebreak\verb|                |\texttt{\textbf{\color{blue}print('2 ==', 11 // 5)}}
\end{itemize}
\end{frame}

\frame
{
\fontsize{45}{40}\selectfont
\begin{center}
Conclusión
\end{center}
\fontsize{25}{40}\selectfont
\begin{center}
¿... entonces ...?
\end{center}
}


\begin{frame}[fragile]
\frametitle{Conclusión}
\begin{itemize}
\setlength{\itemsep}{6pt}
\setlength{\parskip}{6pt}
\item Py3 es más limpio y liviano
\item Hay menos trampas
    \begin{itemize}
    \item Menos sorpresas
    \item Menos casos particulares
    \item Es más \textit{cuadradito}
    \end{itemize}
\item No le tengas miedo a Python 3000
    \begin{itemize}
    \item Divertite con las nuevas características
    \item Pegar el salto no es trivial pero tampoco imposible
    \end{itemize}
\end{itemize}
\end{frame}


\frame
{
\fontsize{35}{40}\selectfont
\begin{flushleft}
Sigue siendo
\end{flushleft}
\fontsize{55}{40}\selectfont
\begin{flushleft}
Python
\end{flushleft}
\fontsize{20}{40}\selectfont
\begin{center}
(con todo lo que eso implica)
\end{center}
\begin{picture}(0,0)
  \put(230,80){\includegraphics[scale=.20]{images/viborita.png}}
\end{picture}
}



\frame
{
\begin{picture}(0,0)
  \fontsize{30}{0}\selectfont
  \put(60,50){¡Muchas gracias!}
  \fontsize{16}{0}\selectfont
  \put(90,9){\color{blue}¿Preguntas?}
  \put(150,-15){\color{blue}¿Sugerencias?}

  \fontsize{20}{0}\selectfont
  \put(100,-55){\color{green}Facundo Batista}
  \fontsize{9}{0}\selectfont
  \put(112,-70){\color{blue}facundo@taniquetil.com.ar}
  \put(106,-83){\color{blue}http://www.taniquetil.com.ar}
  \put(132,-96){\color{green}@facundobatista}

  \put(65,-137){\includegraphics[scale=.6]{images/cc-byncsa.png}}
  \fontsize{5}{0}\selectfont
  \put(125,-122){\textbf{Licencia}: Creative Commons }
  \put(125,-129){Atribución-NoComercial-CompartirDerivadasIgual 2.5 Argentina}
  \put(125,-136){http://creativecommons.org/licenses/by-nc-sa/2.5/deed.es\_AR}
\end{picture}
}

\end{document}
