Que es LaTeX

Es un lenguaje de marcado y de preparación de textos. Creado por Donal Knuth, el lenguaje TeX, fue después extendido, es decir se la añadieron un conjunto de macros, para hacer el TeX, mas fácil de usar para el usuario común. Estas fueron introducidas por Leslie Lamport y de ahí que ahora el lenguaje Tex extendido con las macros se llama .

LaTex es un lenguaje ampliamente usado en la comunidad científica, sobre todo para preparar documentos donde hay muchas formulas matemáticas. sin embargo aun cuando queramos hacer un escrito donde no haya matemáticas LaTeX es una muy buena opción pues podemos beneficiarnos de su gran calidad en el formato y en la facilidad con la que se pueden hacer documentos académicos, por ejemplo con un montón de citas bibliográficas.

Latex en GNU/Linux

Primero pretendía escribir una guía de como instalar y configurar correctamente LaTeX en Ubuntu. Pero me encontré que ya hay una excelente referencia en este blog, así que mejor pongo la cita. Y algunos tips

• Es ampliamente recomendable usar codificación utf-8, para todos tus documentos en LaTeX.
• En conjunto con el utf-8, e uso del paquete inputec y del paquete babel, para hacer los documentos en español de manera mas simple.
• En Linux no hay nada mejor que usar Kile (conste que lo digo yo, que no me gusta KDE), y ahora es muy fácil configurarlo para usarlo con GNOME.
• Nada mejor que tener correctamente configurado el KIle, es decir, sustituir los programas de KDE de visualización por sus respectivos en GNOME y el corrector ortográfico.
• Ampliamente recomendado instalar los extras, para que tengamos beamer.

Cosas extras

Una cosa bastante interesante es instalar el plugin para poder escribir LateX en wordpress, como comenté en un post pasado.
Nada mejor que poder instalar el plugin de LaTeX para Pidgin y así poder escribir y chatear a gusto con tus compas con un montón de matemáticas. (vaya que se oyo geek).
la instalación me fue mas o menos sencilla, make , sudo make install, ojo que debemos de tener instalado, tanto el Latex, como el Image Magick. Después de la instalación tuve problemas pues al parecer mi Image Magick se reusaba a convertir un .dvi en un .png, pero lo pude seleccionar agregando una linea al archivo de confguración de image magic como dice este post.

Bibliografía recomendada

Yo aprendí con este libro, pero honestamente creo que ya esta un poco pasado de moda, Laura me recomendó éste otro libro excelente, y además recuerden que la documentación oficial de LaTeX así como excelentes manuales-tutoriales, viene en los repositorios en los paquetes texlive-doc-base y texlive-doc-es. Así que no hay excusa además hay un montón de documentación en la red.

Aunque la clase pinta ser bastante interesante, por que ha tomado un poco el tinte de cátedra, no pude evitar mi decepción cuando nos dijeron que el curso giraría en torno al desarrollo en Java.

El primer profesor es la Dra. Amparo Lopez, su clase ha sido un poco aburrida para mi, por que ella misma admitió que seria un curso introductorio y que los que ya supiéramos programar en Java podríamos saltarnos su parte de la cátedra, (vía un proyecto en Java).

Como he decidido quedarme, y se que para las demás partes de la cátedra sera importante tener un entorno de desarrollo completo en Java he decidido escribir este post.

Este post debería de servirle a cualquier estudiante que quiera (o tenga) que aprender java

¿Que es lo que entiendo por entorno de desarrollo Java?

Queremos tener un compilado Java, para esto usar el JDK de sun, es decir no queremos la alternativa libre.

Queremos tener un IDE muy eficiente. Para esto usaremos eclipse, por ser software libre y por ser a mi juicio y el de muchas personas que conozco, el mejor IDE para desarrollar en Java (propietarios incluidos).

Queremos un servidor/contenedor de servlets y JSP’s, para esto utilizaremos uno de los mejores: apache tomcat por aquello de que también es software libre.

En resumen:

• JDK de sun (vía repositorios).
• Eclipse EE para desarrollo en Java (descargado del web).
• Servidor Web Tomcat (descargado del web).

De donde partimos

Hago las siguientes suposiciones:

Que tienes ya instalado Ubuntu (Yo estoy probando en 8.04, pero pienso que puedes adaptar estos pasos a tus necesidades fácilmente).

Que vamos a levantar Tomcat no como servicio, si no dentro de Eclipse, y por el puerto 8080, esto con el fin de que si ya tenemos otro servidor web (por ejemplo un LAMP) no tengan conflictos. Y además si es un entorno de desarrollo, probablemente tengas un servidor dedicado en algún otro lado.

Asumimos que no tenemos instalado el Eclipse de los repositorios. Por que al instalarlo también instala el java libre y lo usara en vez de usar el de sun.

Advertencia: Considero que eclipse es el mejor IDE de Java, pero eso no quiere decir que sea ligero, no recomiendo instalarlo en maquinas de menos de 512MB de RAM y al menos otro tanto de swap

Instalando Java JDK de Sun

Este es el único paquete que nos traeremos de los repositorios, por su sencillez y que no esta tan atrasado respecto a las versiones disponibles del web. Además así nos evitamos setear un montón de variables de entorno manualmente. Así que instalamos ya sea vía apt o synaptic los siguientes paquetes:

• sun-java6-bin
• sun-java6-demo
• sun-java6-jdk
• sun-java6-jre
• sun-java6-doc

El paquete sun-java6-doc es opcional si queremos tener la documentación. Desgraciadamente este es un metapaquete que no contiene la documentación. Así que si deseamos instalarlo, tendremos que ir a la pagina de sun, descargar la documentación de java, una archivo llamado jdk-6-doc.zip, luego cambiarle de dueño a root, y moverlo a /tmp. Después decirle a synaptic o apt que instalen el paquete.

Asumiendo que estamos parados en donde esta el archivo descargado:

sudo chown root:root jdk-6-doc.zip
mv jdk-6-doc.zip /tmp
sudo apt-get install sun-java6-doc

Instalamos Eclipse

Lo descargamos del sitio oficial, queremos la versión que dice: Eclipse IDE for Java EE Developers por que es el mas completo para nuestros propósitos.

Podríamos usar cualquier otro y después instalarle los paquetes adicionales que nos hagan falta, pero ¿Para que molestarnos? Si podemos descargar uno que ya viene listo para usarse con Java.

Una vez que lo descarguemos, solo hace falta descomprimirlo en algún lado, lo mas recomendable es ponerlo en alguna carpeta usada comúnmente para guardar programas, yo ocupe /opt pero también podría funcionar /usr/local por aquello de la buena educación.

Supongamos que estamos parados donde se hizo la descarga:

tar -xzvf eclipse-jee-ganymede-linux-gtk.tar.gz
sudo mv eclipse/ /opt

Ahora sólo nos hace falta crear un lanzador para usar Eclipse, asumiedo que usamos Gnome, vamos a Sistema -> Preferencias -> Menú Principal. Se abrira alacarte seleccionamos un el menú donde queremos crear el lanzador, un buen lugar es Programación, y de ahi le damos Elemento nuevo.

Llenamos los datos que nos piden: el tipo es Aplicación, el nombre Eclipse, en comando le damos examinar y buscamos el ejecutable se llama eclipse, y esta dentro de la carpeta eclipse.. El eclipse EE para java al parecer viene sin icono, puedes buscar alguno en la web, aqui pongo uno por si te sirve.

Un pantallazo de la de como le hize yo:

Instalando Apache Tomcat

Primero vamos al sitio de Apache tomcat, y de ahí descargamos la ultima versión, cuando escribí esto era la rama 6.x la versión 6.0.18 y de ahí descargamos la distribución .tar.gz. (en realidad cualquiera hubiera servido, pues son multiplataforma, pero por costumbre en Linux el usamos la que viene compresa .gz).

Ahora descomprimimos tomcat y lo movemos a algún directorio apropiado, de nuevo yo uso /opt.

tar -xzvf apache-tomcat-6.0.18.tar.gz
sudo mv apache-tomcat-6.0.18 /opt/apache-tomcat

Liiisto esa es la instalación de tomcat, si queremos probarlo, podemos ejecutar el archivo start.sh para arrancar Tomcat y shutdown.sh para detenerlo. Ambos viven en el directorio bin, dentro del directorio de Tomcat.

/opt/apache-tomcat/bin/startup.sh
/opt/apache-tomcat/bin/shutdown.sh

Para probar podemos arrancar Tomcat y abrir nuestro navegador en el sitio http://localhost:8080, donde nos debe contestar Tomcat dándonos la bienvenida. Si quieres ver que hace, puedes navegar a Miscellaneous y de ahí ejecutar alguno de los JSP o de los Servlets que trae de ejemplo. También recomendaría editar el archivo $CATALINA_HOME/conf/tomcat-users.xml y añadir a un usuario con privilegios de administración para usar el manager.

Aquí hay un ejemplo de como hacer una edición básica del archivo: tomcat-users.xml

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="jorge" password="secreto" roles="admin,manager"/>
</tomcat-users>

Poniendo todo junto

Ahora viene lo divertido, hay que decirle a Eclipse, donde esta Tomcat, esto tiene la enorme ventaja que así él podrá arrancarlo cuando lo use y pararlo cuando no. Es decir prácticamente administra él.

Primero ejecutamos eclipse, al lanzarlo por primera vez se ve una pantalla de bienvenida: En esta pantalla podemos leer la documentación y ver algunos tutoriales de eclipse, es muy recomendable leerlos en algún momento. Por ahora vamos directamente al workbench.

En la parte superior del workbench el primer icono que encontramos de izquierda a derecha es el de New, lo presionamos y abre un submenu, ahí le damos la ultima opción la que dice Other.

Se abre una ventana pidiéndote que selecciones el asistente, buscamos en la carpeta de Servers, aquel que dice Server y le damos Next

Una aclaración: eclipse solo puede tener un servidor de cada tipo y versión corriendo a la vez, así que si ya definiste algún servidor Tomcat 6.0 antes, no te dejará hacerlo de nuevo hasta que lo borres y lo vuelvas a crear (o cambies de workspace)

En la siguiente pantalla te pide que digas que tipo de Servidor seleccionas la carpeta de Apache y el servidor tipo Tomcat v6.0 Server, es importante también que le digas que el nombre del host es localhost. Y en el nombre del servidor le puedes poner lo que quieras el default esta bien.

En donde dice Server Runtime enviroment le damos Add y se abre otro cuadro de dialogo, aquí lo importante es que le digamos donde esta instalado el Tomcat como se ve en la pantalla.

Si todo esta bien le puedes dar Finish y se “crea” el Server dentro de eclipse.

Probando la instalación

Cada que quieras hacer un nuevo proyecto con JSP’s o Servlets, creas un nuevo proyecto de tipo Web y luego Dinamic Web Project y te fijas que el Target Runtime Enviroment sea el servidor que recién creamos.

Para efectos de prueba, puedes descargarte este proyecto de prueba, e intentar ejecutarlo. Desde el menú File, Import, General, Existing Proyect into Workspace, Select Archive File y seleccionar el zip recién descargado.

Una vez importado desde la pestaña de servers arrancas el Servidor Tomcat, luego navegas dentro del proyecto recién importando y le pides que te muestre el JSP de prueba debes ver algo parecido a esto:

Mas información

Este post fue escrito basándome un poco en el libro de Orelly, un poco en la documentación del mismo eclipse y bastante en este sitio.

Un cierto genero de juegos que me gustaba mucho era el denominado Bet ‘em Up, tambien llamado hack and slash. Básicamente son los juegos de pelea de uno contra muchos. Un juego que era de mi particular agrado es el de alien v.s. predator.

Cuando era un usuario del lado obscuro de la fuerza, conocí un proyecto libre llamado MAME, que por cierto es desarrollado en C. MAME es un emulador de maquinitas es decir que nos permite usar nuestra computadora como si de una de estas se tratara.

Dentro de la filosofía de MAME se debe de emular el hardware independientemente del juego en cuestión. Los juegos de las arcades eran chips es decir también hardware. De ahí que para jugar un juego de arcade en nuestra computadora debemos tener dos cosas un el juego o rom y un emulador. MAME es solamente el emulador.

Instalando MAME en Ubuntu

Lo primero que tenemos que hacer es instalar MAME, para esto instalamos los siguientes dos paquetes ya sea vía sinaptic, o aptitude. No recomiendo usar la utilería de quitar y añadir programas.

• xmame-common
• xmame-sdl

¿Que por que estos? Bueno el paquete xmame-common contiene las utilerías necesarias para usar MAME y el paquete xmame-sdl contiene los binarios de MAME. Los binarios de SDL no son los únicos binarios, también hay binarios de svga (xmame-svga) y de x11 (xmame-x). Cualquiera de ellos hace lo mismo y solo necesitamos tener uno, mi recomendación personal son los de SDL que en mi maquina fueron los únicos que funcionaron.

Bajamos un rom para jugar.

Hay muchos lugares en la red donde conseguir ROMS, a mi en lo personal me gustan mucho dos sitios: planet emu y rom world. ahora que si de veras queremos tener un montón de juegos podemos ver esta otra opción :p

Bajemos el juego de Alien vs Predator de romworld, al buscarlo podemos ver que hay muchos roms que parecen ser el mismo juego.

Generalmente un juego que salio en muchos países haya cambiado un poco de un país a otro, por eso hay as de un ROM, sin embargo casi siempre hay un ROM maestro con el juego y los demás solo contienen los cambios.

Para jugar necesitamos al menos el rom maestro, si queremos además alguna versión en especial también la bajamos. No hay manera segura de saber cual es el maestro, aunque casi siempre es el que mide mas, así que para seguir con el ejemplo anterior bajamos el de Europa. También notamos que nos avisan que este juego necesita de los ROMS de Neo Geo para poder jugarlo, algunos fabricantes como NEO GEO le cargaban un bios a las maquinas, estos bios eran necesarios para jugar juegos de esa compañía) así que los bajamos también.

Instalamos los ROMS.

Si estamos siguiendo el ejemplo debemos haber descargado al menos dos archivos: avsp.zip y neogeo.zip. Los ROM solo funcionan estando comprimidos así que no se les vaya a ocurrir descomprimirlos. La manera como le decimos a xmame que tenemos nuevos ROMS es moviéndolos a la carpeta donde el busca ROMS al arrancar, si estamos haciendo la instalación de default de Ubuntu eso es en /usr/share/games/xmame/rom que usualmente es una carpeta protegida de escritura así que para mover los ROMS podemos hacer lo siguiente:

sudo mv avsp.zip neogeo.zip /usr/share/games/xmame/rom/

Probando que funcione el juego

Para jugar un juego simplemente corremos el MAME desde la linea de comandos así:

xmame NOMBREROM
Si queremos ser mas específicos le podemos decir el binario que queremos que ocupe (solo si tenemos mas de uno instalado), en el caso de mi ejemplo seria algo así:
xmame.SDL avsp.zip

No importa en donde estemos parados ya que xmame buscara el ROM en la carpeta de ROMS.

Ahora es posible que tengamos una bronca es decir que veamos que el juego corre en una ventanita chiquita que no podemos maximizar ni darle resize.

Creando un archivo de configuración

Xmame por default busca la configuración en un archivo de sistema, luego la busca en otro archivo dentro de nuestro home, así que para decirle que corre en pantalla completa vamos a usar ese archivo de configuración.

Primero necesitamos crearlo, para no tener problemas de sintaxis, lo podemos hacer todo en un paso con el siguiente comando:

xmame --showconfig > ~/.xmame/xmamerc

Que manda la configuración actual al archivo xmamerc dentro de un directorio oculto de nuestro home. Luego nos ponemos a editar el archivo

gedit ~/.xmame/xmamerc

Y buscamos la linea:

fullscreen              0

Donde cambiamos el 0 por un 1, salvamos y listo podemos volver a correr el juego para ver el resultado.

Poniendo un front end gráfico

Alternativamente podemos usar un frontend, para usar mame. Hay algunos en los repositorios, a mi en lo personal no me gusto ninguno de ellos, así que mi humilde recomendación es usar uno que no viene en el repositorio gxmame.

Entramos a al sitio de gxmame y bajamos la versión 0.35beta2, es importante señalar dos cosas. Uno, que la versión que ofrecen directamente de la pagina no es la que queremos, para bajar la 0.35beta2 tenemos que irnos a la pagina de proyecto en surceforge, de ahí a donde dice download y de ahí buscar la ultima que es la 0.35beta2, es importante por que la 0.34 tiene un bug que le impide encontrar los ROMS. Dos, bajemos la gxmame_0.35beta2-1_i386.deb por que es un binario que funciona en Debian/Ubuntu y nos hará mas sencilla la instalación. Luego simplemente instalamos el deb, como acostumbremos, una manera es:

sudo dpkg -i gxmame_0.35beta2-1_i386.deb

Y listo ahora vamos al menú Juegos y vemos que ya tenemos el gxmame, al ejecutarlo vemos una pantalla como esta:

Antes de que vemos los juegos debemos hacer dos cosas, ir al menú Archivo y darle Audit all games. Con esto checa la integridad de nuestros roms para ver que sean compatibles y que esten completos. Cuando termine, debemos ir al menú Opciones y le damos reconstruir lista de juegos, cuando termine, podemos navegar con la barra lateral a donde dice Disponibles, y ahora si debemos de ver nuestro juego listo para usarse, simplemente lo seleccionamos y le damos Play Game.

Algunos tips

Una ves corriendo el juego, lo minimo que necesitan saber es los siguiente:

• Con el botón de Tab, pueden ver la opciones, Y en Input this game, pueden configurar los botones a usar.
• Con el botón de Esc salen del juego.

• Suponemos que la instalación se va a realizar en Ubuntu, esto significa que el servidor va a vivir en Ubuntu.
• Que queremos que los repositorios sean visibles vía web, que el servidor web sea Apache de la rama 2.x (Subversión tiene su propio servidor, nosotros mejor ocuparemos Apache).
• Que el protocolo para comunicarse sea SSL, la información viaje encriptada (es decir que el URL sea https://algo).
• Que se podría hospedar mas de un repositorio.
• Que para conectarse un usuario tenga que proporcionar un password.
• Que tengamos políticas de acceso, es decir que no todos los usuarios puedan ver todas las carpetas, habrá algunos que puedan ver, otros que puedan escribir, y a cada carpeta le podemos poner diferentes atributos (permisos).

Cuando aprendimos a hacer esta instalación leímos el tutorial de Viktor Zigo, que esta libre bajo una licencia Creative Commons, sin embargo me decido a aumentar algunas cosas como la política de acceso, además dado que no hay mucha documentación en español sobre este tema, me imagino que este documento le ayudara a alguien.

Paquetes necesarios

Hay que instalar, o verificar que estén instalados los siguientes paquetes:

• subversion
• libapache2-svn
• libapache-mod-dav
• apache2

En ubuntu 7.10 el paquete libapache-mod-dav, no existe simplemente continuamos sin el pues mod-dav ya esta incluido en apache2

Habilitar el modulo de SSL en apache

Para hacer este paso primero hay que habilitar el modulo de apache que deja comunicarse via SSL, luego hay que editar un archivo de configuración de apache para decirle que escuche por el puerto 443, que es el default de SSL

Habilitar el modulo de apache2 de SVN

sudo a2enmod ssl

Editar el archivo de configuración /etc/apache2/ports.conf del apache.

Agregando al final la linea: “Listen 443”. Es decir deben haber dos lineas, la del 80 y la del 443

Nota me acabo de dar cuenta de que en Ubuntu 7.10, no es necesaria la edición del archivo, pues el comando anterior a2enmod, ya edita el archivo por nosotros, lo que se debe de hacer es fijarnos en este archivo y que escuche el 443.

Generar un certificado

Para hacer un certificado hay que ocupar una herramienta, desde Ubuntu Festy en adelante esta herramienta es: make-ssl-cert, antes de eso la herramienta era: apache2-ssl-certificate.

Sea cual sea el caso, hay que hacer un certificado, el certificado es un archivo .pes y una llave, que es un archivo con números raros de nombre.

Para hacer el certificado la herramienta nos hace algunas preguntas, como quienes somos, donde se ubica el servidor físicamente, a que organización pertenecemos, etc.

Es importante usar el nombre real de nuestro servidor, cuando lo pida, por que de lo contrario cada vez que un usuario quiera acceder al repositorio, su cliente le marcara un warning diciendo que el servidor y el emisor del certificado no corresponden.

Si el servidor va a ser accesible por un dominio, el dominio es el nombre del servidor, si va a ser accedido por una IP fija, la IP es el nombre del servidor, si va a ser accedido dentro de una red interna el nombre en la red de la maquina es el nombre del servidor.

La herramienta debe generar ambos archivos el apache.pem y el de la llave, lo mas recomendable es que estos se encuentren en la carpeta ssl, dentro de la carpeta de apache. Puede que sea necesario que nosotros tengamos que mover los archivos manualmente.

La herramienta antes de Festy 7.04 se usaba asi:

sudo apache2-ssl-certificate

Desde Festy en adelante se usa así:

sudo /usr/sbin/make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem

En donde el primer argumento es el comando a invocar en este caso make-ssl-cert, el segundo es una plantilla de certificado en este caso se ubica en /usr/share/ssl-cert/ssleay.cnf, y el tercero el lugar donde se pone el certificado /etc/apache2/ssl/apache.pem. Es decir que lo único que podría cambiar es el tercer argumento aunque no se recomienda. Es importante que antes se cree la carpeta donde va a vivir el certificado

Crear un host virtual

En apache2 hay posibilidad de que un solo servidor maneje muchos sitios, lo mas recomendable es hacer un sitio aparte para nuestros repositorios de SVN.

Copiamos el sitio de default, para ocuparlo de plantilla

sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/$NOMBRESITIO

En donde $NOMBRESITIO, es el nombre que queremos que tenga nuestro sitio que maneja los repositorios. por ejemplo podemos ponerle repos.

Editamos configuración del sitio

Abrimos con nuestro editor de textos plano favorito el recién creado archivo de configuración del sitio y lo editamos:

Cambiamos la parte que dice:

NameVirtualHost *
<VirtualHost *>

Por:

NameVirtualHost *:443
<VirtualHost *:443>

Y añadimos las siguientes lineas:


SSLEngine on
SSLCertificateFile /etc/apache2/ssl/apache.pem
SSLProtocol all
SSLCipherSuite HIGH:MEDIUM

Dentro de las etiquetas VirtualHost, pero fuera de cualquier etiqueta Directory

Habilitamos el nuevo host virtual

Primero le decimos a apache que ya hay un nuevo sitio

sudo a2ensite $NOMBRESITIO

Y reiniciamos apache

sudo /etc/init.d/apache2 restart

Si hubo errores al editar el archivo, ahora se quejara, corregimos hasta que apache arranque, si hay un warning de que no puede determinar el nombre de dominio calificado, es normal.

Y se puede arreglar añadiendo ServerName $NOMBREDELSERVIDOR al archivo de configuración principal de apache: /etc/apache2/apache2.conf (el nombre del servidor es el nombre de la maquina que lo hospeda)

Creando los repositorios:

Suponemos que queremos tener varios repositorios, creamos una carpeta donde ponerlos todos, un buen lugar para hacerlo es en: /var/svn, luego hacemos los repositorios y le cambiamos los permisos a los repositorios para que el usuario de apache (www-data), tenga total control sobre ellos.

Por ejemplo:

sudo mkdir /var/svn
sudo svnadmin create /var/svn/$REPOS
sudo chown -R www-data:www-data /var/svn/$REPOS
sudo chmod -R g+ws /var/svn/$REPOS

Donde $REPOS, es el nombre del repositorio a crear, se pueden hacer varios repositorios. Que deberían vivir bajo la mima carpeta, en este caso /var/svn.

Agregar usuarios al repositorio

Para que un usuario pueda consultar el repositorio, debe de tener un password, el encargado de hacer la validación sera Apache, y la manera como lo hará sera verificando que el usuario y el password, estén en un archivo de texto plano.

Creando el archivo de password

Hay que ocupar la herramienta htpasswd, en versiones de Ubuntu anteriores a 7.04, la herramienta se llama htpasswd2, ambas son la misma herramienta, solo le quitaron el 2, en el nombre, así que es cuestión de usar el que nos corresponda.

Ejemplo:

sudo htpasswd -c -m /etc/apache2/svn-auth-file $NOMBREUSUARIO

En este momento nos preguntara cual va a ser el password del para el usuario $NOMBREDEUSUARIO y se crea el archivo de nombre svn-auth-file. El nombre del archivo puede ser cualquiera pero se sugiere algo que nos recuerde que son los passwords del svn, y puede vivir en cualquier lado, pero se recomienda que viva donde el apache lo hace.

El modificador -c, es para que cree el archivo de passwords y el modificador -m para que encripte el password.

Importante: Si queremos agregar un nuevo usuario usamos el comando sin el modificador -c y lo apuntamos al archivo que ya creamos, de esta manera los passwords de ambos usuarios están guardados en el mismo archivo. En nuestro ejemplo seria:

sudo htpasswd -m /etc/apache2/svn-auth-file $NOMBRENUEVOUSUARIO

Agregando políticas de acceso

Vamos a hacer una archivo de control de acceso, lo mas simple es usar como plantilla alguno de los que viene en cualquier repositorio. Por ejemplo podemos ir al repositorio que acabamos de hacer y dentro de su directorio conf, hay un archivo de ejemplo: authz

Podemos tomar este archivo de ejemplo como plantilla. Y copiarlo al directorio de apache, cambiarle por los permisos adecuados y después editarlo con nuestras preferencias. Podemos ponerle cualquier nombre yo aquí lo llamo svn-authz-file.

sudo cp /var/svn/$REPOS/conf/authz /etc/apache2/svn-authz-file
sudo chmod 644 /etc/apache2/svn-authz-file
sudo gedit /etc/apache2/svn-authz-file

Editar el archivo no es difícil y podemos ver que la plantilla ya trae un ejemplo con la sintaxis. Yo por ejemplo solo le agrego algo como esto:

[$REPOS:/]
$NOMBREUSUARIO = rw
$NOMBRENUEVOUSUARIO = r
En donde $NOMBREUSUARIO puede leer y escribir el repositorio $REPOS y $NOMBRENUEVOUSUARIO solo puede leerlo.

Poniendo todas las opciones de configuración a nuestro repositorio

Ahora solo resta decirle a apache que sirva de interfaz a nuestro repositorio con todas las opciones que le acabamos de dar.

Para hacer esto editamos el archivo dav_svn_conf que se encuentra dentro de la carpeta mods-available del directorio de apache.

sudo gedit /etec/apache2/mods-available/dav_svn_conf

Este archivo tiene de nuevo un ejemplo de llenado, cada repositorio tiene sus opciones dentro de las etiquetas location. Podemos repetir la que ya tiene por defecto y agregarle nuestras opciones.

<Location /$REPOS>
DAV svn
# our access control policy
AuthzSVNAccessFile /etc/apache2/svn-authz-file
SVNPath "/var/svn/$REPOS"
AuthType Basic
AuthName "Subversion repository"
AuthUserFile /etc/apache2/svn-auth-file
Require valid-user
SSLRequireSSL
</Location>

De estas opciones debemos modificar dentro de la etiqueta de apertura de location el nombre de nuestro repositorio. En donde dice SVPath ponemos el lugar donde esta el repositorio. En la opción de AuthzSVNAccessFile el archivo que creamos de políticas de control de acceso. Y en la opción de AuthUserFile el archivo donde están las contraseñas de los usuarios. No olvidemos añadir tambien la linea SSLRequireSSL

Reiniciamos apache

Por ultimo para que todos los cambios surtan efecto:

sudo /etc/init.d/apache2 restart

Si algún archivo no quedo bien editado ahora se quejara, de no ser así podemos proceder a probarlo:

Abrimos nuestro navegador web favorito y visitamos las dirección http://localhost/$REPOS y debe de contestarnos algo así como 403: Forbiden. Ahora visitamos el sitio https://localhost/$REPOS y debe pedirnos usuario y contraseña, en caso de que la contraseña sea incorrecta o que el usuario que introducimos no tenga permiso de lectura sobre $REPOS volverá a contestarnos 403: Forbiden.

Si el usuario se autentifica correctamente y tiene los permisos necesarios, debe mostrarnos el repositorio si aun no hemos hecho ningún import o commit, debe ser un repositorio vacío en la revisión 0.

He probado que estos pasos funcionan en Ubuntu 6.10, 7.04 y 7.10

Mas conocimientos

Recuerden que el mejor lugar para aprender mas de subversion es el libro oficial, que ademas es libre y existe una traducción al español.

Instalar Geany, no debe de dar mayor problema, pues se encuentra en los repositorios oficiales de Ubuntu, lo podemos hacer via apt-get, o synaptic, o incluso se encuentra disponible en agregar o quitar programas bajo la categoría de desarrollo, si su sistema esta en español (el Ubuntu), geany también vendrá en español.

Bueno, por que querría yo usar un editor de texto aparte de gedit? Pues por que geany me da ciertas ventajas que no me da por ejemplo gedit, al escribir código, estoy hablando a que nos da mas ventajas que el simple sintax highlight

Pues aquí viene lo bonito del asunto, si queremos usar Geany para escribir código de OpenGL y glut en Ubuntu, y ya sabemos hacer nuestros propios makefiles, como lo explique en el post anterior.

Ahora podemos usar todo esto a nuestro favor para tener un entorno de desarrollo muy amigable, para empezar guardemos todos nuestros archivos fuentes y makefile en una sola carpeta luego iniciamos geany.

Ahora suponemos que en nuestro makefile, define cierto nombre para el ejecutable por ejemplo “Modelo3D”, y que definimos un make all, de defualt, y que también pusimos un “make destroy”, que elimina los objetos y el ejecutable.

Pues abrimos Geany, de ahí abrimos todos nuestros archivos fuentes, Archivo -> abrir y luego nos vamos al menú que dice: construir

En la ultima opción se encuentra Selecciona Inclusiones y Argumentos, al entrar a esta opción vemos una ventana como esta:

Ahora vemos que Geany ya ha dado valores de default, pues sabe que estamos escribiendo código en C, por que abrimos un archivo .c, sin embargo como nosotros ya hicimos nuestro propio makefile, la vamos a cambiar esas opciones, para que llame a nuestro make.

Lo que tenga escrito en la primer caja de de compilar es lo que se va a ejecutar, cuando apretemos el botón de compilar, ahora nosotros queremos que antes de compilar elimine todos los objetos y el ejecutable, y luego intente compilar todo, es decir queremos que ejecute “make destroy” y luego “make all”, y como esta instrucción se va a mandar al shell tal como la escribimos podemos escribir:
make destroy; make
Ahora lo que escribamos en argumentso para el programa, es lo que ejecuta cuando presionamos el boton de ejecutar, así que podemos poner ahi ./nombre_de_ejecutable o para nuestro ejemplo:
./modelo3D

Y listo, ahora podemos programar cómodamente en Geany, usando glut y OpenGL, cada que queramos compilar, solo presionamos el botón de compilar y al ejecutar el botón de ejecutar.

Algunas observaciones

• Geany es muy ligero y tiene la enorme ventaja que no hace archivos de proyecto, o de configuración, esto es una ventaja para programas pequeños.
• La ventaja de tener total control de los argumentos con nuestro propio makefile.
• También se puede importar código muy fácil, ya que geany, nos da lo mínimo, para poder escribir entre Windows y GNU/Linux, es decir nos deja cambiar el carácter de terminación de linea de los archivos fuentes y la codificación de caracteres, la codificación de GNU/Linux y en particular de Ubuntu es UTF8, la codificación en Windows es depende del idioma en que lo tengamos, pero seguro aparece en el menú de geany. La terminación de linea en Windows es CRLF y en GNU/Linux es LF.
• Tenemos las opciones que mas comúnmente se usan al programar en un Editor muy ligero y que no para instalar no necesitamos traer montones de librerías como en los casos de editores mas poderosos.

El makefile es un archivo de texto plano, que usa la herramienta make, dicho archivo debe ser escrito por el desarrollador y dice como se compila el programa que escribió. Usualmente los makefiles son complejos y contienen un montón de reglas, sin embargo nosotros nos vamos a limitar a tres: una para compilar, una para limpiar y otra para reconstruir.

Así que abrimos nuestro editor de texto plano favoritos y construimos un archivo que tenga por nombre makefile (el nombre es muy importante).

Si nuestro programa solo va tener un archivo fuente esta sera nuestra plantilla:

1
2
3
4
5
6
7
8
9
10

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = -Wall
LIBRARIES = -lglut -lGL -lGLU -lm
ejecutable: fuente.c
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
destroy:
	rm -f *.o ejecutable
clean:
	rm -f *.o

En donde ejecutable es el nombre que queremos que tenga nuestro archivo ejecutable y fuente es el nombre de nuestro único archivo fuente.

Analizando un poco vemos que el makefile define unas variables en las primeras lineas, y luego define unas reglas, las reglas siempre son de la forma:

[objetivo]: [dependencia]
[comandos]

Donde objetivo es el nombre de la operación que queremos hacer, dependencia es todo lo que necesitamos para llevarla a acabo y comandos es lo que debemos hacer para llevar a cabo la operación.

Las reglas que defino son ejecutable que sirve para hacer el ejecutable, clean que sirve para borrar todos los los archivos intermedios que hace el compilador (por ejemplo los .o) y destroy que borra todo lo que hace el compilador y nos deja listos para intentar compilar de nuevo (por ejemplo en nuestro periodo de ensayo error).

Se observa que uso gcc como compilador, por que el lenguaje C es usualmente nuestro default, si piensan programar en c++, cambien gcc por g++. Tambien fijense que entra las librerías mando a GL a GLU y a glut, que es por que queremos hacer un programa de OpenGL con glut, pero además mando un misterioso -lm, estas son as demás librerías de default de C, por ejemplo si en nuestro programa queremos usar funciones definidas en math.h.

Si queremos hacer un programa con mas de un código fuente esta es otra plantilla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

LIBDIR = -L/usr/X11R6/lib
CC = gcc
CFLAGS = $(COMPILERFLAGS)
LIBRARIES = -lglut -lGL -lGLU -lm
OBJ = fuente1.o fuente2.o fuente3.o fuente4.o
BIN = ejecutable
 
all: $(BIN)
$(BIN) : $(OBJ)
	$(CC) $(CFLAGS) -o $@ $(LIBDIR) $? $(LIBRARIES)
 
fuente1.o: fuente1.c
	$(CC) -c fuente1.c -o fuente1.o $(CFLAGS)
 
fuente2.o: fuente2.c
	$(CC) -c fuente2.c -o fuente2.o $(CFLAGS)
 
fuente3.o: fuente3.c
	$(CC) -c fuente3.c -o fuente3.o $(CFLAGS)
 
fuente4.o: fuente4.c
	$(CC) -c fuente4.c -o fuente4.o $(CFLAGS)
 
destroy:
	rm -f $(OBJ) $(BIN)
clean:
	rm -f $(OBJ)

En donde fuente1, … fuentei, son todos los archivos fuentes que componen el programa y ejecutable es el nombre del ejecutable.

Ahora lo importante:

Es ampliamente recomendado tener una carpeta donde guardar todo lo referente a nuestro programa y solo eso, es decir mi fuente y mi makefile deben estar en una carpeta para ellos solos (esto para facilitar su transporte) y que no se vayan a volar algo sin querer al escribir una regla mal del make XD
Para compilar nuestro programa simplemente escribimos en la linea de comandos “make”: (obviamente debemos estar parados en el directorio donde esta todo):

$make

Si nuestro programa compilo correctamente genero el archio ejecutable, pero si tuvimos errores, veremos los errores y warnings en la shell y debemos de hacer los siguiente:
ejecutar make destroy, para limpiar toda al basura generada por la compilación fallida, corregir nuestro fuente y luego volver a intentar compilar.

$make destroy 

Algunas observaciones:

• Estos makefiles son solo recomendaciones y de hecho no siguen las reglas GNU de los makefiles, para aprender mas de eso pueden visitar: http://www.gnu.org/software/make/
• Para escribir este post me base en la guia publicada por el area de linux de la fesa, quizas si le dan un ojo les quede mas claro http://www.acatlan.unam.mx/linux/graficacion/compilalinux.html
• Si nuestro fuente tiene cabeceras por ejemplo cabecera.h, estas no necesitan ser compiladas y por lo tanto no se ponen en el make, basta que en el fuente sean usadas #include, Siempre que la cabecera no tenga código en C, si no mas bien declaraciones de estructuras y variables globales (que es como debe ser).

Paso 1

Instalar el compilador de C.

Una de las cosas que mas me sorprendió es que Ubuntu, no viene con el compilador de C, en su instalación de default (hasta ahora es el único Gnu/Linux donde me ha pasado esto), así que tienes que instalarlo desde los repositorios.

En Ubuntu solo es cuestión de instalarte los paquetes ya sea vía apt-get o via synaptic lo que te acomode mejor, al caso debes de instalar los siguientes paquetes:

• build-essential
• g++
• g77
• gcc
• make

Estos paquetes no vienen solos, es decir probablemente necesites descargar muchos paquetes mas para satisfacer las dependencias de estos, sin embargo dado que tanto synaptic como apt-get, pueden satisfacer sus dependencia de manera automática solo debemos indicarle estos paquetes. tanto de gcc, como de g++ y g77, hay varias versiones de los paquetes, sin embargo el paquete sin números siempre es un paquete con la versión mas actual.

En resumen lo único que un usuario novato debe de teclear es:

 	$sudo apt-get install build-essential g++ g77 gcc make

Paso 1.5 Probamos la instalación del compilador de C

En nuestro editor de textos plano favorito tecleamos un programa de C, básico por ejemplo un clásico hola mundo: hello.c Lo guardamos por ejemplo con el nombre de hello.c y vamos a compilarlo.

Con la siguiente instrucción:

$gcc hello.c -o hello

Podemos observa que la sintaxis para compilar un programa en C, es la siguiente:

$gcc [archivo fuente.c] -o [nombre de mi ejeculable]

En realidad el gcc es mucho mas completo, un tutorial de como compilar programas con C lo puedes encontrar aqui.

2 Instalamos las librerias necesarias para OpenGL

Ahora necesitaremos instalar los siguientes paquetes:

freeglut3 freeglut3-dbg freeglut3-dev ftgl-dev gle-doc glut-doc glutg3 glutg3-dev libglu1-mesa libglu1-mesa-dev libgl1-mesa libgl1-mesa-dev libgl1-mesa-dri libglut3 libglut3-dev mesa-common-dev mesa-demos mesa-swrast-source mesa-utils

No se cuales sean los esenciales, yo siempre he instalado con todos, pero se que así funciona, muchos de ellos son dependencias, así que no igual lo único que debes de tener en cuenta es tratar de instalar freeglut-dev.

Importante: Si piensas tener tu computadora con Aceleración Gráfica (por ejemplo para tener Beryl), es decir instalar los drivers propietarios de ATI o de nVidia, debes hacerlo antes de hacer esta instalación, se pueden tener ambas funcionando pero poner el driver gráfico debe ser anterior a la instalación de OpenGL. De la contrario nuestros programas de OpenGL no tendrán aceleración

Para saber si nuestra computadora tiene o no aceleración Gráfica puedes ejecutar el comando glxinfo y ver la salida, en el renglón donde dice direct rendering: un “Yes”, significa que tenemos Aceleración gráfica. Una forma de filtrarlo es:

 	 $glxinfo | grep rendering

Por supuesto que tener o no Aceleración Gráfica es totalmente dependiente de tu hardware. Por lo que no se puede escribir una guía general, sin embargo hay muchísima información en la red sobre esto, mi experiencia es que si tu computadora tiene tarjeta de vídeo Intel o nVidia, no debes tener ningún problema, las ATI, en cambio debes de investigar un poco antes de hacerlas funcionar.

2.5Probar la instalación de OpenGL y glut

Nos tecleamos un programa sencillo de glut y OpenGL, por ejemplo este: ventana.c

Y ahora vamos intentar la compilación:

$gcc ventana.c -o ventana -lglut

Y debemos ver una ventana negra.
Si en al linea de comandos ven un warning que dice algo así como:

libGL warning: 3D driver claims to not support visual 0x5b

Pero la ejecución de el programa continua, no deben de preocuparse, este warning solo significa que no esta correctamente configurado su driver de la tarjeta de vídeo, pero es algo que no debe de afectar sus programas escritos en OpenGL, mas que en el performance, y no es un problema de su programa si no del driver de la computadora.

Obviamente el caso ideal es tener tanto el OpenGL como la aceleración gráfica funcionando al mismo tiempo, si ya tenían la aceleración gráfica y siguen este método no deben de tener ningún problema y ni siquiera les debe marcar ese molesto warning.

Usuarios de Red Hat y similares la receta es la misma, solo que deberán de tratar de instalar el freeglut-devel***.rpm, donde *** usualmente son la distribución, la arquitectura y versión del paquete, se recomienda que instalen el paquete que viene en sus discos, usualmente este paquete tiene muchas dependencias, así que la ayuda de un gestor de paquetes como yump o synaptic sin duda les ayudara.

En un post posterior hablare de como tener un IDE funcional que nos de mas ayuda a compilar programas de OpenGL en Linux, en particular en Ubuntu la idea es que el final de mi serie de post del tema se pueda tener un entorno de programación cómodo y funcional en Ubuntu, como para que puedan con ayuda de algún libro como el libro rojo autoaprender a programar con OpenGL