\section{Introducción al entorno}
	\subsection{Instalación}
		\subsubsection{Debian y Ubuntu}
			\begin{itemize}
				\item Mono 1.1.13 y muchos paquetes relacionados están disponibles tanto en debian testing y unstable como en Ubuntu dapper, así como en la mayoría de las distribuciones importantes
			\end{itemize}
		\subsubsection{Instalador genérico}
			\begin{itemize}
				\item Para todas las plataformas existe un instalador genérico
				\begin{itemize}
					\item Esto incluye a GNU/Linux, con un instalador que funciona en toda distribución
				\end{itemize}
				\item Está muy bien para cacharrear con Mono:
				\begin{itemize}
					\item Fácil de instalar (instalador \texttt{GTK})
					\item Instalación limpia (desinstalación limpia)
					\item Viene con la última versión de Mono
					\item Independiente de dependencias etc. (da lo mismo si usas sid, testing, suse o lo que sea)
				\end{itemize}
				\item Por otra parte, también tiene sus desventajas:
				\begin{itemize}
					\item Es fácil para hacer poca cosa. Para hacer que \texttt{xsp} se ejecute como usuario www-data, tienes que configurarlo tú mismo (hacer lo que los mantenedores de los paquetes ya han hecho por tí)
					\item Dificil de mantener: tienes que estar pendiente de actualizaciones
					\item Las dependencias no lo detectan. Algunos programas exigen otras dependencias.
				\end{itemize}
				\item La configuración de \texttt{xsp} se tratará más adelante
			\end{itemize}
			\newpage
			\begin{center}
				\includegraphics{figuras/instalador-generico-1.png}
				\includegraphics{figuras/instalador-generico-2.png}
				\includegraphics{figuras/instalador-generico-3.png}
				\includegraphics{figuras/instalador-generico-4.png}
				\includegraphics{figuras/instalador-generico-5.png}
				\includegraphics{figuras/instalador-generico-6.png}
				\includegraphics[scale=0.385]{figuras/instalador-generico-7.png}
			\end{center}
		\newpage
		\subsubsection{Windows}
			\begin{itemize}
				\item Está el instalador de Mono
				\begin{itemize}
					\item Viene con Mono, GTK\#, el servidor XSP\ldots
				\end{itemize}
				\item Hay un instalador para utilizar GTK\# desde el VS.NET
			\end{itemize}

		\subsubsection{Otros}
			\begin{itemize}
				\item Para probar Mono sin instalarlo, hay una Live on CD llamada \href{http://www.mono-live.com/}{Mono Live}, que viene con:
				\begin{itemize}
					\item versiones muy recientes de Mono
					\item aplicaciones vistosas de Mono
					\begin{itemize}
						\item Beagle
						\item F-spot
						\item Muine
						\item MonoDevelop
						\item \ldots
					\end{itemize}
				\end{itemize}
			\end{itemize}
	\subsection{Herramientas básicas}
		\subsubsection{mono}
			\begin{itemize}
				\item Programa que ejecuta un ensamblado ejecutable
				\begin{itemize}
					\item Hay dos paquetes que contienen este comando:
					\begin{itemize}
						\item \texttt{mono-jit}: compilador jit (y aot)
						\item \texttt{mono-mint}: intérprete
					\end{itemize}
					\item Nosotros utilizaremos y aquí hablamos del \texttt{mono-jit}
				\end{itemize}
				\item Algunas opciones:
				\begin{itemize}
					\item \verb+--+\texttt{aot}: Genera un \texttt{.so} con las funciones compiladas
					\begin{itemize}
						\item Unida a \verb+-+\texttt{O=all} (todas las optimizaciones), puede ser útil para optimizar un programa.
					\end{itemize}
					\item \verb+-+\texttt{v}: Verboso. \verb+-v -v -v -v+. \emph{Muy} verboso					
				\end{itemize}
				\item Variables de entorno:
				\begin{itemize}
					\item \texttt{MONO\_PATH}: donde busca los ensamblados a importar (\texttt{.dll}s)
					\item \texttt{PKG\_CONFIG\_PATH}: donde busca los paquetes
				\end{itemize}
			\end{itemize}
		\newpage
		\subsubsection{Diferenciando JIT de AOT}
			\begin{itemize}
				\item Dado un código en CIL, ejecutamos:
				\begin{verbatim}
					mono programa.exe
				\end{verbatim}
				\item Estará utilizando el compilador JIT:
				\begin{enumerate}
					\item Empieza a ejecutar
					\item Llega a una función no compilada
					\item La compila a nativo
					\item La ejecuta
					\item Cada vez que la vuelva a encontrar, la ejecutará (sin necesidad de compilarla)
				\end{enumerate}
				\item Si utilizamos el flag \verb+-+\texttt{O=all}
				\begin{itemize}
					\item Cuando llega a una función no compilada, compila la función de una manera más óptima (tarda más en compilarlo)
					\item El código compilado es más óptimo (tarda menos en ejecutarlo)
				\end{itemize}
				\item Si utilizamos el flag \verb+--+\texttt{aot}, estaremos utilizando el compilador AOT:
				\begin{itemize}
					\item Compilamos de una pasada todas las funciones, y dejamos el código generado en un fichero \texttt{.so}
					\item El fichero es dependiente de la plataforma
				\end{itemize}
				\item Al ejecutar el programa de nuevo:
				\begin{itemize}
					\item Al llegar a una función, ya estará compilada, por lo que se salta el paso de compilar las funciones del JIT
					\item Sin embargo, no habrá diferencia respecto al compilador JIT cuando estemos utilizando funciones ya compiladas (funciones que ya se han ejecutado)
					\item Pero, si al hacer el \verb+--+\texttt{aot}, le pasamos también \verb+-+\texttt{O=all}, además de evitar que las funciones no compiladas se tengan que compilar, el código ejecutado está más optimizado:
					\begin{itemize}
						\item No habrá fase de compilación en tiempo de ejecución
						\item El código ejecutado será más óptimo
					\end{itemize}
				\end{itemize}
				\item "Demostración" de lo que hace el compilador AOT:
				\begin{itemize}
					\item \emph{Código en interaccionLenguajes/aot/programa.cs}
					\item Compilamos \texttt{programa.cs}:
					\begin{verbatim}
						nctrun@ord3p:~/aot$ mcs programa.cs
						nctrun@ord3p:~/aot$
					\end{verbatim}
					\item Ejecutamos el programa:
					\begin{verbatim}
						nctrun@ord3p:~/aot$ mono programa.exe
						15
						nctrun@ord3p:~/aot$
					\end{verbatim}
					\item Ejecutamos \texttt{programa.exe} con el flag \verb+--+\texttt{aot}:
					\begin{verbatim}
						nctrun@ord3p:~/aot$ mono --aot programa.exe
						Mono Ahead of Time compiler - compiling assembly
						 /home/nctrun/aot/programa.exe
						GOT SIZE: 8
						Executing the native assembler: as /tmp/mono_aot_e3Ujqu
						 -o /tmp/mono_aot_e3Ujqu.o
						Executing the native linker: ld -shared -o
						 /home/nctrun/aot/programa.exe.so /tmp/mono_aot_e3Ujqu.o
						Compiled 2 out of 2 methods (100%)
						0 methods contain absolute addresses (0%)
						0 methods contain wrapper references (0%)
						0 methods contain lmf pointers (0%)
						0 methods have other problems (0%)
						AOT RESULT 0
					\end{verbatim}
					\item Vemos que tenemos un archivo llamado \texttt{programa.exe.so}
					\item Vemos su interior con \texttt{objdump}:
					\begin{verbatim}
						nctrun@ord3p:~/aot$ objdump -D programa.exe.so|less

						programa.exe.so:     formato del fichero elf32-i386
						
						Desensamblado de la sección .hash:
						
						00000094 <.hash>:
						94:   11 00                   adc    %eax,(%eax)
						96:   00 00                   add    %al,(%eax)
						98:   1c 00                   sbb    $0x0,%al
						9a:   00 00                   add    %al,(%eax)
						(...)
						456:   be 05 00 00 00          mov    $0x5,%esi
						45b:   8b de                   mov    %esi,%ebx
						45d:   83 c3 0a                add    $0xa,%ebx
						460:   53                      push   %ebx
						(...)
						000015c4 <.got>:
						15c4:       54                      push   %esp
						15c5:       15 00 00 00 00          adc    $0x0,%eax
						15ca:       00 00                   add    %al,(%eax)
						15cc:       00 00                   add    %al,(%eax)
							...
					\end{verbatim}
					\item Ejecutamos el programa de nuevo:
					\begin{verbatim}
						nctrun@ord3p:~/aot$ mono programa.exe
						15
						nctrun@ord3p:~/aot$
					\end{verbatim}
					\item Suponemos que esta vez el programa ha utilizado el \texttt{.so}. Para evitar suposiciones:
					\begin{enumerate}
						\item Abrimos el \texttt{.so} con el biew:
						\begin{verbatim}
							nctrun@ord3p:~/aot$ biew programa.exe.so
						\end{verbatim}
						~\\
						\item F2 -\verb+>+ Dissasembler
						\item F5 -\verb+>+ 456 (estaremos viendo las líneas de antes):
						~\\
						\begin{verbatim}
							456:   be 05 00 00 00          mov    $0x5,%esi
							45b:   8b de                   mov    %esi,%ebx
							45d:   83 c3 0a                add    $0xa,%ebx
						\end{verbatim}
						~\\
						\item Dado que está en la sección \texttt{.methods}, y suma 10 a 5, tiene pinta de ser la suma de nuestro programa. Vamos a cambiar el 5 por 10, por ejemplo:
						\item F4 -\verb+>+ Cambiamos \texttt{BE 05 00 00 00} por \texttt{BE 0A 00 00 00}. F2.
						\item Salimos. F10 (o escape un par de veces)
						\item Ejecutamos el programa otra vez:
						~\\
						\begin{verbatim}
							nctrun@ord3p:~/aot$ mono programa.exe
							20
							nctrun@ord3p:~/aot$ 
						\end{verbatim}
						~\\
						\item Desensamblamos el CIL:
						~\\
						\begin{verbatim}
							nctrun@ord3p:~/aot$ monodis programa.exe|less
							(...)
							IL_0000:  ldc.i4.5
							IL_0001:  stloc.0
							IL_0002:  ldloc.0
							IL_0003:  ldc.i4.s 0x0a
							IL_0005:  add
							(...)
						\end{verbatim}
						~\\
						\item Como vemos, no está haciendo caso al CIL (que dice que cojamos 5 y le sumemos 10) porque ha encontrado que el método ya está compilado (y dice una cosa diferente, que cojamos 10 y le sumemos 10), y por tanto ni compila el código CIL
					\end{enumerate}
					\item Sin embargo, como hemos dicho, una vez se ha ejecutado el método, si se le llaman varias veces, no va a haber diferencia entre \texttt{AOT} y \texttt{JIT}, salvo que al generar el \texttt{.so} hayamos utilizado optimizaciones.
					\item Generamos el \texttt{.so} otra vez, con optimizaciones:
					\begin{verbatim}
						nctrun@ord3p:~/aot$ mono -O=all --aot programa.exe
					\end{verbatim}
					\item Suponemos que el código generado es más óptimo que el anterior. Para evitar suposiciones:
					\begin{enumerate}
						\item Volvemos a ver el código del \texttt{.so}:
						~\\
						\begin{verbatim}
							nctrun@ord3p:~/aot$ objdump -D programa.exe.so
							(...)
							450:   6a 0f                   push   $0xf
							(...)
						\end{verbatim}
						\item Como vemos, aproximadamente por la misma zona, aparece un \texttt{0xf}, que es la suma de 10 + 5, por lo que se ahorra la suma en tiempo de ejecución.
						\item Para comprobar que realmente es lo que parece, podemos volver a modificar el \texttt{.so}
						\item Al igual que antes, una vez ejecutado un método, las siguientes veces no habrá diferencia respecto a ejecutar con:
						\begin{verbatim}
							mono -O=all programa.exe
						\end{verbatim}
					\end{enumerate}
				\end{itemize}
			\end{itemize}
		\newpage
		\subsubsection{Compiladores}
			\begin{itemize}
				\item Mono viene con compilador de C\# y VB.NET
				\begin{itemize}
					\item \texttt{mcs} es el compilador de C\#
					\item \texttt{mbas} es el compilador de VB.NET
				\end{itemize}
				\item Algunas opciones a destacar de estos compiladores son:
				\begin{itemize}
					\item \verb+-+\texttt{r} para importar un ensamblado (\texttt{.dll}s)
					\item \verb+-+\texttt{pkg} para utilizar un paquete
				\end{itemize}
				\item Además, hay compiladores de otros lenguajes
				\begin{itemize}
					\item \texttt{ikvmc} para Java (comentado más adelante)
					\item \texttt{booc} para \href{http://boo.codehaus.org}{Boo} (comentado más adelante)
				\end{itemize}
				\item Y para obtener el código en \texttt{CIL} de un ensamblado:
				\begin{itemize}
					\item \texttt{monodis}
				\end{itemize}
			\end{itemize}
		\newpage
		\subsubsection{Documentación}
			\begin{itemize}
				\item \texttt{monodoc}
				\begin{itemize}
					\item herramienta para editar y explorar documentación
					\item Dado un ejecutable, permite editar y añadir su documentación, además de verla
				\end{itemize}
				\item \texttt{monop}
				\begin{itemize}
					\item Permite obtener información acerca de ensamblados o de las librerías instaladas
					\begin{verbatim}
						nctrun@ord3p:~$ monop System.Byte
						[Serializable]
						public struct Byte : IComparable, IConvertible,
						 IFormattable {
						
						    public static byte Parse (string s,
						     IFormatProvider provider);
						    (...)
						    public const byte MinValue = 0;
						    public const byte MaxValue = 255;
						}

					\end{verbatim}
				\end{itemize}
			\end{itemize}
		\newpage
		\subsubsection{gacutil}
			\begin{itemize}
				\item Herramienta para manipular el \href{http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconglobalassemblycache.asp}{\texttt{GAC}} (\texttt{Global Assembly Cache})
				\begin{verbatim}
					nctrun@ord3p:~$ gacutil -l|grep gecko
					gecko-sharp, Version=1.0.0.0, Culture=neutral,
					 PublicKeyToken=ccf7d78a55e9f021
					gecko-sharp, Version=2.0.0.0, Culture=neutral,
					 PublicKeyToken=ccf7d78a55e9f021
				\end{verbatim}
				\item Opciones de \href{http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cptools/html/cpgrfGlobalAssemblyCacheUtilityGacutilexe.asp}{\texttt{gacutil}}
			\end{itemize}
		\newpage
		\subsubsection{Entorno de Desarrollo Integrado}
			\begin{itemize}
				\item Para Windows, está el \href{http://www.icsharpcode.net/OpenSource/SD/}{SharpDevelop}
				\begin{itemize}
					\item es \href{http://www.gnu.org/copyleft/gpl.html}{GNU GPL}
					\item para funcionar necesita Microsoft .NET
					\begin{itemize}
						\item pero puedes compilar, ejecutar y demás con Mono
					\end{itemize}
				\end{itemize}
				\item Bajo GNU/Linux, el IDE de Mono más popular es el \href{http://www.monodevelop.com/}{MonoDevelop}
				\begin{itemize}
					\item Escrito en Mono, es un port del SharpDevelop
					\item En estos momentos no funciona en Windows (sí como mínimo en GNU/Linux y Mac OS X)
				\end{itemize}
				\item También hay un \href{http://www.gotmono.com/docs/ide/eclipse.html}{plugin} para \href{http://www.eclipse.org}{Eclipse}
				\item Y por supuesto está \href{http://www.vim.org}{vim}, \href{http://www.gnu.org/software/emacs/emacs.html}{Emacs}, \href{http://www.xemacs.org}{XEmacs}, \href{http://kate.kde.org/}{kate}\ldots
			\end{itemize}
	\subsection{Interacción entre lenguajes}
		\subsubsection{C\#}
			\begin{itemize}
				\item Compilando y ejecutando el "holamundo":
				\begin{verbatim}
					nctrun@ord3p:~/holamundo$ mcs holamundo.cs
					holamundo.cs(26) warning CS0219: The variable 'dato3' is
					 assigned but its value is never used
					Compilation succeeded - 1 warning(s)
					nctrun@ord3p:~/holamundo$ mono holamundo.exe
					Hola mundo
					nctrun@ord3p:~/holamundo$
				\end{verbatim}
				\item Viendo el código en CIL:
				\begin{verbatim}
					nctrun@ord3p:~/holamundo$ monodis holamundo.exe
					.assembly extern mscorlib
					{
					  .ver 1:0:5000:0
					  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
					}
					.assembly 'holamundo'
					{
					  .hash algorithm 0x00008004
					  .ver  0:0:0:0
					}
					.module holamundo.exe // GUID =
					 {1220A931-5542-4364-8B81-293C8D4C5584}


					(...)

					        IL_0000:  ldstr "Hola mundo"
					        IL_0005:  call void class
					 [mscorlib]System.Console::WriteLine(string)
					        IL_000a:  ldsfld  int32 Principal::dato2
					        IL_000f:  ldc.i4.5
					        IL_0010:  add
					        IL_0011:  stloc.0
					        IL_0012:  ret
					    } // end of method Principal::default void Main (string[]
					 args)
					
					  } // end of class Principal
				\end{verbatim}
				\item Creando un \texttt{.dll}:
				\begin{verbatim}
					nctrun@ord3p:~/librerias$ mcs -t:library
					 holamundo.cs
					holamundo.cs(26) warning CS0219: The variable 'dato3' is
					 assigned but its value is never used
					Compilation succeeded - 1 warning(s)
					nctrun@ord3p:~/librerias$
				\end{verbatim}
				\item Utilizando el \texttt{.dll}:
				\begin{verbatim}
					nctrun@ord3p:~/utilizando$ mcs DesdeCS.cs -r:holamundo.dll
					nctrun@ord3p:~/utilizando$ mono DesdeCS.exe
					8 5
				\end{verbatim}
				\item Utilizando paquetes:
				\begin{verbatim}
					nctrun@ord3p:~/utilizando$ mcs UtilizandoPaquetes.cs
					 -pkg:gtk-sharp
					nctrun@ord3p:~/utilizando$ mono UtilizandoPaquetes.exe
					nctrun@ord3p:~/utilizando$
				\end{verbatim}
			\end{itemize}
		\newpage
		\subsubsection{Java}
			\begin{itemize}
				\item Para utilizar Java desde Mono hay una herramienta llamada \href{http://www.ikvm.net/}{IKVM}
				\item IKVM permite:
				\begin{itemize}
					\item utilizar desde Mono bytecode de Java
					\item utilizar ensamblados de Mono desde Java (ejecutado bajo Mono con IKVM)
				\end{itemize}
				\item De la API de Java utiliza la implementación del proyecto \href{http://www.gnu.org/software/classpath/}{GNU Classpath}
				\item Es útil para utilizar librerías o incluso aplicaciones de Java:
				\begin{itemize}
					\item \href{http://www.jython.org/}{Jython}
					\item Incluso \href{http://www.eclipse.org/}{Eclipse} ha sido ejecutado sobre Mono a través de IKVM:\\
					~ \\
					\begin{center}
						\includegraphics[scale=0.45]{figuras/eclipse-mono.png}
						~\\
						\small \href{http://primates.ximian.com/~miguel/images/eclipse-mono.png}{Web original de la imagen}
					\end{center}
				\end{itemize}
				\newpage
				\item Utilizando Java desde Mono con IKVM:
				\begin{itemize}
					\item Creando una librería en Java:
					\begin{verbatim}
						nctrun@ord3p:~/ikvm$ javac MiClase.java
						nctrun@ord3p:~/ikvm$ ikvmc -out:MiClase.dll MiClase.class Note:
						automatically adding reference to
						"/home/nctrun/usr/local/lib/ikvm/IKVM.GNU.Classpath.dll"
					\end{verbatim}
					\item Utilizando la librería desde C\#:
					\begin{verbatim}
						nctrun@ord3p:~/ikvm$ export
						MONO_PATH=$MONO_PATH:/home/nctrun/usr/local/lib/ikvm/
						nctrun@ord3p:~/ikvm$ mcs DesdeCS.cs -r:MiClase.dll
						nctrun@ord3p:~/ikvm$ mono DesdeCS.exe
						hola mundo
						llamando al método
						nctrun@ord3p:~/ikvm$
					\end{verbatim}
				\end{itemize}
				\item Utilizando Mono desde Java sobre Mono con IKVM:
				\begin{itemize}
					\item Creamos unos \texttt{.jar} para hacerlos accesibles desde Java:
					\begin{verbatim}
						nctrun@ord3p:~/ikvm$ ikvmstub
						 /home/nctrun/usr/local/lib/mono/gtk-sharp/gtk-sharp.dll
						Warning: Assembly loaded from
						 /home/nctrun/usr/local/lib/mono/gac/gtk-sharp/1.0.0.0__
						35e10195dab3c99f/gtk-sharp.dll instead
						nctrun@ord3p:~/interaccionLenguajes/ikvm$ ikvmstub
						 /home/nctrun/usr/local/lib/mono/1.0/mscorlib.dll
						Warning: Assembly loaded from
						 /home/nctrun/usr/local/lib/mono/1.0/mscorlib.dll
						 instead
						nctrun@ord3p:~/interaccionLenguajes/ikvm$ ikvmstub
						 /home/nctrun/usr/local/lib/mono/gtk-sharp/atk-sharp.dll
						Warning: Assembly loaded from
						 /home/nctrun/usr/local/lib/mono/gac/atk-sharp/1.0.0.0__
						35e10195dab3c99f/atk-sharp.dll instead
						nctrun@ord3p:~/interaccionLenguajes/ikvm$ ikvmstub
						 /home/nctrun/usr/local/lib/mono/gtk-sharp/
						glib-sharp.dll
						Warning: Assembly loaded from 
						/home/nctrun/usr/local/lib/mono/gac/glib-sharp/1.0.0.0__
						35e10195dab3c99f/glib-sharp.dll instead
					\end{verbatim}
					\item Estos \texttt{.jar} sólo son ejecutables desde IKVM. No sirven para utilizar Mono desde Java.
					\begin{itemize}
						\item Para ello existe otro proyecto llamado \href{http://dev.mainsoft.com/}{Grasshoper}, desarrollado por \href{http://www.mainsoft.com}{Mainsoft}
					\end{itemize}
					\item Una vez tenemos los \texttt{.jar}, sí podemos compilar un programa en Java, tal que:
					\begin{verbatim}
						nctrun@ord3p:~/ikvm$ javac -classpath
						 .:mscorlib.jar:gtk-sharp.jar:glib-sharp.jar:
						atk-sharp.jar Demo.java
						nctrun@ord3p:~/ikvm$
					\end{verbatim}
					\item Y ejecutamos desde IKVM el programa en Java:
					\begin{verbatim}
						nctrun@ord3p:~/ikvm$ ikvm -cp glib-sharp.jar:
						 gtk-sharp.jar:atk-sharp.jar:mscorlib.jar:. Demo
						nctrun@ord3p:~/interaccionLenguajes/ikvm$
					\end{verbatim}
					\item O bien lo compilamos a CLI para ejecutarlo con Mono diréctamente:
					\begin{verbatim}
						nctrun@ord3p:~/interaccionLenguajes/ikvm$ ikvmc
						 -out:Demo.exe Demo.class gtk-sharp.jar
						Note: found main method in class "Demo"
						Note: automatically adding reference to
						 "/home/nctrun/usr/local/lib/ikvm/IKVM.GNU.Classpath.dll"
						nctrun@ord3p:~/interaccionLenguajes/ikvm$ mono Demo.exe 
						nctrun@ord3p:~/interaccionLenguajes/ikvm$
					\end{verbatim}
				\end{itemize}
				\item Interoperabilidad
				\begin{itemize}
					\item Java no tiene ni delegados, ni atributos, ni propiedades, ni paso de parámetros por referencia, ni otras características del CIL
					\item Para utilizar estas características, hay que utilizar ciertas "formas":
					\begin{itemize}
						\item Para utilizar propiedades, un código como:
						\begin{verbatim}
							public int Dato{
							    get{
							        return dato;
							    }
							}
						\end{verbatim}
						sería invocado tal que:
						\begin{verbatim}
							int dato = instancia.get_Dato();
						\end{verbatim}
						\item Para llamar a un delegado como:
						\begin{verbatim}
							public delegate void EventHandler (object sender, EventArgs e);
						\end{verbatim}
						sería utilizado tal que:
						\begin{verbatim}
							class A implements cli.System.EventHandler.Method{
							    public void Invoke (Object sender,
							     cli.System.EventArgs e) {
							       System.out.println("hola");
							    }
							}
						\end{verbatim}
					\end{itemize}
				\end{itemize}
			\end{itemize}
		\newpage
		\subsubsection{IronPython}
			\begin{itemize}
				\item \href{http://workspaces.gotdotnet.com/ironpython}{IronPython} es una implementación de Python para .NET
				\item 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 licencia \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}
				\item Por el momento sólo sirve para acceder a CIL desde Python, no al revés
			\end{itemize}
		\newpage
		\subsubsection{Limitaciones}
			\begin{itemize}
				\item Realmente los lenguajes que más fácilmente se integran bien en .NET son aquellos que son realmente una abstracción del CIL, como C\# o VB.NET
				\item Asímismo, las partes de otros lenguajes que sean subconjunto del CIL, también se pueden usar con facilidad
				\item Sin embargo:
				\begin{itemize}
					\item La inversa (utilizar desde un lenguaje que es casi en su totalidad un subconjunto del CIL algo escrito en CIL) es más dificil, y hay que utilizar una serie de \textit{work around}s que pueden hacer incómodo el uso de ese lenguaje
					\item Si es incómodo utilizar librerías del CIL desde esos lenguajes, no tiene sentido hacer componentes en esos lenguajes (sólo cuando los lenguajes permitan acceder a APIs hechas en el propio lenguaje)
				\end{itemize}
				\item De la misma forma, las características de otros lenguajes que no estén en el CIL serán difíciles de acceder: incómodo utilizar componentes en otros lenguajes
			\end{itemize}
		\newpage
		\subsubsection{Boo}
			\begin{itemize}
				\item \href{http://boo.codehaus.org}{Boo} es una adaptación de \href{http://www.python.org}{Python} a .NET:
				\begin{itemize}
					\item Inspirado en Python
					\item Pero tiene tipado estático, delegados, propiedades\ldots
				\end{itemize}
				\item Ejemplo de código:
				\begin{verbatim}
					import System
					import Gtk from "gtk-sharp"
					
					Application.Init()
					
					window = Window("Button Tester",
					         DefaultWidth:  200,
					         DefaultHeight: 150,
					         DeleteEvent: Application.Quit)
					
					window.Add(Button("Click Me!",
					         Clicked: { print("button clicked!") }))
					window.ShowAll()
					
					Application.Run()
				\end{verbatim}
				\item Últimamente ha crecido en popularidad en la comunidad de Mono, especialmente desde que IronPython no es Open Source.
			\end{itemize}
		\newpage
		\subsubsection{Utilizando código nativo}
			\begin{itemize}
				\item Para acceder a código nativo de la plataforma se utiliza \texttt{P/Invoke} de la siguiente manera:
				\begin{verbatim}
					[DllImport("libreria")]
					tipo_acceso extern static tipo_retorno nombre_funcion(parametros);
				\end{verbatim}
				\begin{itemize}
					\item Por ejemplo, podemos ver algo de código del binding para OpenGL de Mono \href{http://svn.myrealbox.com/viewcvs/trunk/glgen/glut/glut.cs?view=markup}{aquí}:
					\begin{verbatim}
						[DllImport("glut")]
						static extern void glutInitWindowPosition(int x, int y);
						public static void InitWindowPosition(int x, int y)
						{
						    glutInitWindowPosition(x, y);
						}
						
						[DllImport("glut")]
						static extern void glutInitWindowSize(int width, int height);
						public static void InitWindowSize(int width, int height)
						{
						    glutInitWindowSize(width, height);
						}
						
						[DllImport("glut")]
						static extern void glutMainLoop();
						public static void MainLoop()
						{
						    glutMainLoop();
						}
					\end{verbatim}
					\item (Concretamente el binding de OpenGL ha sido generado por glgen)
				\end{itemize}
				\item \href{http://www.dotgnu.org}{DotGNU} tiene además un compilador de C a CIL
				\item Ejemplos
				\begin{itemize}
					\item Simple en \emph{/interaccionLenguajes/accesoNativo/}
					\item Utilizando OpenGL en \emph{/interaccionLenguajes/accesoNativo/ogl/}. El código es un ejemplo del cursillo de \href{http://www.bardok.net}{Bardok} de OpenGL, de \href{http://www.e-ghost.deusto.es/cursillosjulio/ficheros2004/OpenGL/}{aquí}
					\begin{center}
						\includegraphics{figuras/ogl.png}
					\end{center}
					\item Utilizando Mono.Posix para acceder a estructuras de más bajo nivel, en \emph{/interaccionLenguajes/accesoNativo/eso/}
				\end{itemize}
			\end{itemize}