\section{Python: lenguaje de scripting para JRE y CLI}

\subsection{Introducción}
	\subsubsection{Python lenguaje de scripting para JRE y CLI?}
		\begin{itemize}
			\item Sí: existen proyectos que buscan permitir programar con la sintaxis de Python, y las librerías existentes para Java o Mono/.NET
			\item Permiten tener las ventajas del JRE o CLI (librerías,intérprete optimizado,Garbage Collector) y las de Python (sintaxis que permite programación rápida)
			\item Ideal para:
			\begin{itemize}
				\item Prototipado
				\begin{itemize}
					\item Puedes hacer rápidamente un paquete / ensamblado en Python, que utilice Java  CLI, y utilizar este paquete desde Java  CLI
					\item Ese código será sustituido por otro lenguaje más tarde en caso de ser necesario
				\end{itemize}
				\item Creación rápida de tests
				\item Realizar pruebas rápidamente:
				\begin{enumerate}
					\item ...cómo devolverá exáctamente java.net.URLConnection su content-type?
					\item En un vistazo rápido a \href{http://java.sun.com/j2se/1.5.0/docs/api/java/net/URLConnection.html#getContentType()}{la documentación de URLConnection} no lo veo demasiado claro... a ver a ver...\\
					\begin{verbatim}
						nctrun@ord3p:~$ jython
						Jython 2.1 on java1.5.0_02 (JIT: null)
						Type "copyright", "credits" or "license" for more information.
						>>> from java.net import *
						>>> URL('http://localhost/').openConnection().getContentType()
						'text/html; charset=iso-8859-1'
						>>>
					\end{verbatim}
					\item Vale, está claro
				\end{enumerate}
			\end{itemize}
		\end{itemize}
	\subsubsection{Limitaciones}
		\begin{itemize}
			\item Para conseguir integración absoluta entre las diferentes plataformas, hace falta pequeños \emph{arreglos} en muchos casos, algunos de los cuales pueden hacer imposible determinadas sintaxis
			\begin{itemize}
				\item Los parámetros por defecto de Python es extremadamente dificil de hacer accesibles desde el JRE o el CLI.
				\begin{itemize}
					\item En el caso de \href{http://www.jython.org/}{Jython}, por ejemplo, diréctamente capan esa opción: una función que se quiere dejar que Java vea, no tiene esa sintaxis
				\end{itemize}
			\end{itemize}
			\item Tu aplicación, que antes dependía de Java / otro lenguaje, pasa a depender, además, de:
			\begin{itemize}
				\item Python (si cambia algo en la sintaxis de Python, tendrá que cambiar en la de sus implementaciones)
				\item La implementación de Python que estés utilizando
			\end{itemize}
		\end{itemize}

\newpage

\subsection{Python en Java: Jython}
	\subsubsection{Qué es}
		\begin{itemize}
			\item \href{http://www.jython.org}{Jython} es una implementación de Python escrita 100\% en \href{http://java.sun.com/}{Java}
			\item Puede descargarse tanto de su web oficial (\href{http://www.jython.org}{www.jython.org}) como empaquetada para distribuciones de GNU/Linux
			\item Implementa la sintaxis de Python y parte de su librería estándar
			\begin{itemize}
				\item La versión estable más reciente es la 2.1: implementa la sintaxis de Python 2.1
				\subitem Recordemos que por ejemplo \texttt{True} y \texttt{False} no existían en Python 2.1
				\item Implementa \textbf{parte} de su librería estándar
				\subitem Como podemos imaginar, implementar \verb+Tkinter+ en Java sería un esfuerzo demasiado grande para lo que aportaría
			\end{itemize}
			\item Permite, utilizando la sintaxis de Python:
			\begin{itemize}
				\item Hacer todo lo que se pueda hacer en Java:
				\begin{itemize}
					\item Puedes ejecutarlo allá donde puedas ejecutar algo hecho en Java
					\item Puedes acceder a toda librería que puedas acceder desde Java
					\subitem Puedes desarrollar aplicaciones con SWING con la síntaxis de Python
					\item Puedes hacer tus Applets en Jython
				\end{itemize}
				\item Empotrar código Jython en código Java
			\end{itemize}
		\end{itemize}
	\subsubsection{Modos}
		\begin{itemize}
			\item Interactivo:
			\begin{verbatim}
				nctrun@ord3p:~$ jython
				Jython 2.1 on java1.5.0_02 (JIT: null)
				Type "copyright", "credits" or "license" for more information.
				>>> import java.net
				>>>
			\end{verbatim}
			\item Normal:
			\begin{verbatim}
				nctrun@ord3p:~/dev/jython$ jython holamundo.py
				hola mundo
				nctrun@ord3p:~/dev/jython$
			\end{verbatim}
			\item Compilado (no hace falta tener jython para ejectuarlo):
			\begin{verbatim}
				nctrun@ord3p:~/dev/jython/holamundo$ jythonc -c -d -j
					holamundo.jar holamundo.py processing holamundo
				
				Required packages:
				
				Creating adapters:
				
				Creating .java files:
				holamundo module
				
				Compiling .java to .class...
				Compiling with args: ['/usr/bin/javac', '-classpath',
					'/usr/share/java/jython.jar:/usr/local/lib/jmf/lib/jmf.jar:
				/usr/local/lib/jmf/lib/sound.jar:.::/usr/share/java/
				libreadline-java.jar:./jpywork::/usr/share/jython/Tools/
				jythonc:/home/nctrun/dev/jython/holamundo/.:
				/usr/share/jython/Lib:/usr/lib/python2.1
				:/usr/lib/python2.1/site-packages:/usr/lib/site-python',
					'./jpywork/holamundo.java']
				0
				Building archive: holamundo.jar
				Tracking java dependencies:
				nctrun@ord3p:~/dev/jython/holamundo$ java -jar holamundo.jar
				hola mundo
				nctrun@ord3p:~/dev/jython/holamundo$ ls -lh holamundo.jar
				-rw-r--r--  1 nctrun nctrun 302K 2005-07-10 13:23
					holamundo.jar
			\end{verbatim}
		\end{itemize}
	\subsubsection{Ejemplos simples}
		\begin{itemize}
			\item Ejemplo: leyendo una línea del teclado
			\begin{itemize}
				\item En Java (para ser justos en número de líneas, lo hacemos en una línea):
				\begin{verbatim}
					import java.io.*; public class Simple{ public static void
					 main(String [] args) throws Throwable{System.out.println(new
					 BufferedReader(new InputStreamReader(System.in)).readLine());
					 } }
				\end{verbatim}
				\item En Java (para ser justos en claridad, lo hacemos más claro):
				\begin{verbatim}
					import java.io.*;
					public class Simple{
					    public static void main(String [] args) throws Throwable{
					        BufferedReader br = new BufferedReader(new
					         InputStreamReader(System.in));
					        System.out.println(br.readLine());
					    }
					}
				\end{verbatim}
				\item En Jython:
				\begin{verbatim}
					print raw_input()
				\end{verbatim}
			\end{itemize}
			\item Ejemplo: hola mundo en Swing
			\begin{itemize}
				\item En Java:
				\begin{verbatim}
					import javax.swing.*;
					
					public class SimpleSwing{
					    public static void main(String [] args){
					        JFrame a = new JFrame("titulo");
					        JLabel b = new JLabel("hola");
					        a.add(b);
					        a.pack();
					        a.setVisible(true);
					    }
					}
				\end{verbatim}
				\item En Jython:
				\begin{verbatim}
					from javax.swing import *
					a = JFrame("titulo")
					b = JLabel("hola")
					a.add(b)
					a.pack()
					a.setVisible(1)
				\end{verbatim}
			\end{itemize}
		\end{itemize}
	\subsubsection{Truquillos para andar por Jython}
		\begin{itemize}
			\item Hacer que ambos lenguajes puedan hablar entre sí lleva a que deba haber algunos mecanismos de integración
			\begin{itemize}
				\item Por defecto, \verb+java.lang+ no está importado. Si se quiere utilizar \verb+System+ o \verb+String+, debe importarse.
				\item Ni las listas ni las tuplas de Python son completamente equivalentes a los arrays de Java: \verb+jarray+
				\begin{itemize}
					\item Para convertir una lista en un array:
					\begin{verbatim}
						>>> a = [5,6,7]
						>>> import jarray
						>>> b = jarray.array(a,'i')
						>>> b
						array([5, 6, 7], int)
						>>>
					\end{verbatim}
					\item Para crear un array vacío:
					\begin{verbatim}
						>>> import jarray
						>>> a = jarray.zeros(5,'b')
						>>> a
						array([0, 0, 0, 0, 0], byte)
						>>>
					\end{verbatim}
				\end{itemize}
				\item Hay varias diferencias más, sobre todo con conceptos de herencia entre clases Jython y clases Java, o de exportar Jython para hacerlo visible desde Java, o de uso de \texttt{synchronized}
				\begin{itemize}
					\item Para ello consultar las referencias sobre Jython
					\item La documentación de Jython en la página oficial
					\item IBM tiene varios artículos sobre Jython
					\item O'Reilly tiene un libro muy bueno sobre Jython
				\end{itemize}
			\end{itemize}
		\end{itemize}
\newpage

\subsection{Python en Mono/.NET}
	\subsubsection{Introducción}
		\begin{itemize}
			\item Dado que el \href{http://en.wikipedia.org/wiki/Common_Language_Infrastructure}{CLI} es \emph{language agnostic}, es más fácil que surjan proyectos que compilen código Python a \href{http://en.wikipedia.org/wiki/Common_Intermediate_Language}{CIL}
			\item Aquí nombramos los principales, pero ninguno tiene todavía la madurez o funcionalidad de Jython
		\end{itemize}
	\subsubsection{IronPython}
		\begin{itemize}
			\item \href{http://ironpython.com}{IronPython} está escrito por \href{http://hugunin.net}{Jim Hugunin}
			\begin{itemize}
				\item desarrollador de \href{http://www.jython.org}{Jython} y \href{http://hugunin.net/projects.html}{otros proyectos}
				\item trabaja en Microsoft desde Agosto 2004 (poco después de publicar IronPython 0.6)
			\end{itemize}
			\item Licencias:
			\begin{itemize}
				\item Hasta la versión 0.6, el proyecto estaba publicado bajo la licencia \href{http://www.eclipse.org/legal/cpl-v10.html}{Common Public License 1.0}, que cumple los requisitos para ser \href{http://opensource.org}{Open Source}.
				\item Sin embargo, las versiones posteriores (0.7.x), \href{http://workspaces.gotdotnet.com/ironpython}{están alojadas} en \href{http://www.gotdotnet.com/}{got dot net}, bajo la \href{http://www.gotdotnet.com/workspaces/License.aspx?id=ad7acff7-ab1e-4bcb-99c0-57ac5a3a9742}{Shared Source for IronPython}
			\end{itemize}
			\item La implementación más madura de Python sobre Mono y .NET
			\begin{itemize}
				\item Las versiones 0.7.x exigen .NET 2.0
				\item Por tanto exigen versiones beta tanto de .NET como de Mono
			\end{itemize}
		\end{itemize}
	\subsubsection{Python for .NET}
		\begin{itemize}
			\item \href{http://www.zope.org/Members/Brian/PythonNet}{Python for .NET} está escrito por \href{http://brianlloyd.blogspot.com/}{Brian Lloyd},  \href{http://zope.com/about_us/management_team.html}{miembro de} \href{http://www.zope.org}{ZOPE}
			\item Objetivos similares a IronPython
			\begin{itemize}
				\item menos madurez y apoyo
			\end{itemize}
			\item \href{http://www.opensource.org}{Open Source}
		\end{itemize}
	\subsubsection{Boo}
		\begin{itemize}
			\item \href{http://boo.codehaus.org/}{Boo} \textbf{no} es una implementación de Python:
			\begin{itemize}
				\item Es un lenguaje para Mono/.NET
				\begin{itemize}
					\item Sintaxis similar a la de Python
					\item Adaptado a las características de Mono/.NET
				\end{itemize}
				\item Si tienes código hecho en Python, olvídate de usarlo ;-)
			\end{itemize}
			\item Muy rico, está convirtiéndose en un lenguaje de interés en la comunidad de \href{http://www.mono-project.com}{Mono}
			\item Ejemplo:
			\begin{verbatim}
				import System
				name = Console.ReadLine()
				print "Hello, $\{name\}"

				class Person:
					def constructor(name):
						self.name = name

					public name as string
						
				print(Person("homer").name)
			\end{verbatim}
		\end{itemize}
\newpage