Archivo de la etiqueta: programación

Lo que he aprendido: compilar Emacs desde fuente

¡Saludos damas y caballeros! Vuelvo después de mis merecidas vacaciones con el frikismo recargado. Digo esto porque estuve de visita en casa de un amigo que compiló Emacs 25 desde fuente delante de mí y ha provocado que tenga envidia y quiera compilar yo también. Y eso os vengo a contar, mi experiencia creando Emacs desde sus piezas más elementales desde mi punto de vista de ignorante de la informática.

¿Compilar?

No es mi primera vez compilando, es concretamente la segunda. La primera fue con pdfpc que compilé tanto en Windows como en GNU/Linux invocando a cmake para que crease las instrucciones, luego a make para que compilase y finalmente a make install para que me instalase el programa en las carpetas correctas.

Compilar Emacs es similar solo que en lugar de llamar a cmake usamos el script configure, un script estándar para los programas de GNU que verifica que el sistema cumple las condiciones para compilar el programa en cuestión y crea las instrucciones para make.

Que los programas de GNU se compilen siempre de la misma manera es debido al conjunto de herramientas GNU Build System o Autotools, que ayudan a crear paquetes de código portables para que los programadores se centren en la funcionalidad de sus programas y que los usuarios solo tengan que aprender el método para compilar una única vez.

He resumido lo que he entendido de este proceso en un dibujillo, para que luego sepamos más o menos dónde estamos:

¡A compilar Emacs!

Después de esta pequeña introducción vamos a ensuciarnos las manoplas. Los pasos que seguiremos son:

  1. Descargaremos el código fuente
  2. Si hemos clonado de un repo ejecutaremos autogen.sh para obtener el script configure
  3. Ejecutaremos configure con las opciones que queramos
  4. Llamaremos a make que nos fabricará Emacs
  5. Si queremos instalar Emacs en las carpetas de instalación haremos make install

Veamos cuál ha sido mi experiencia con sus problemas y soluciones.

Descargar el código fuente

Evidentemente, lo primero que necesitamos para compilar desde fuente es el código fuente. Para conseguirlo tenemos dos opciones:

  • Descargar la release desde la web a mano, con wget o como nos parezca. En este caso empezamos directamente con el script configure, siguiendo las instrucciones del archivo INSTALL.
  • Clonar desde el repositorio de GitHub o Savannah. Obedeceremos a INSTALL.REPO que nos manda ejecutar autogen.sh para que aparezca el famoso configure.

El script autogen.sh

Como yo siempre sigo el camino más difícil, cloné el repo de GitHub y por lo tanto tuve que invocar primero a autogen.sh. Para ello necesité primero instalar Autoconf, una de las herramientas que conforman el GNU Build System y que se encarga de crear el script configure a partir del archivo configure.ac. Como suele ser habitual, hice:

sudo apt-get install autoconf

En el caso de que descarguemos la release no tenemos que fabricar el script configure sino que ya viene incluido.

El script configure

Ahora nos toca ejecutar configure para que nos verifique si tenemos todas las librerías necesarias instaladas y genere finalmente el Makefile si es así. También podemos pasarle diferentes opciones para controlar el proceso, con --help vemos cuáles hay.

Por ejemplo, yo utilicé --prefix para elegir el destino en el que quería que se instalase Emacs. No quería que lo instalase en el directorio por defecto /usr/local/ porque solo estaba haciendo unas pruebas:

ondiz@slimbook:~/Testing/emacs$ ./configure --prefix=/home/ondiz/Testing/

Nos irá diciendo qué dependencias tenemos que resolver y la opciones que debemos darle si no queremos usarlas con un mensaje de este estilo:

configure: error: The following required libraries were not found:
libXpm libjpeg libgif/libungif libtiff gnutls
Maybe some development libraries/packages are missing?
If you don't want to link with them give
--with-xpm=no --with-jpeg=no --with-gif=no --with-tiff=no --with-gnutls=no
as options to configure

Sigue leyendo

Anuncios

Lo que he aprendido: registro de cambios en un documento LaTeX con git

Estoy echando una mano a mi hermano con una documentación to guapa para un tema que mejor os cuenta él y me preguntó cómo incluir un registro de cambios en el documento. Un registro de cambios no puede ser muy complejo de hacer si estamos usando git, pensé, así que me puse a investigar las diferentes alternativas, empezando por la opción evidente: git log.

Jugando con git log

Empecemos por los inicios, como todos los que usáis git sabéis mejor que yo, git log nos permite dar un formato al historial de commits con las opciones --pretty y --format. Por ejemplo, podemos mostrar la fecha y la descripción del commit haciendo:

git log --pretty=format:"%ad%x09%s" --date=short > cambios.log

Seguir leyendo →

Lo que he aprendido: programar tareas desde cmd en Windows

Siguiendo en mi cruzada de hacer que el ordenador trabaje mientras yo leo movidas en el interneto, he aprendido a “retrasar” una tarea en Windows sin usar el Programador de tareas: usar el comando timeout. Lo que hace es esperar un determinado tiempo antes de ejecutar el próximo comando. Es megaguay porque pone una cuenta atrás y parece que el ordenador va a explotar o algo. Es especialmente interesante para usarlo en un ordenador comunitario y no avisar a los demás de lo que andas tramando. Sí, soy malvada y me encanta.

Es tan fácil de usar como hacer:

timeout <T>

Donde <T> es el tiempo que tiene que esperar en segundos. Tenemos la opción de añadir /nobreak para que si alguien pulsa una tecla no se nos active la tarea.

De propinilla vamos a aprender cómo escribir comentarios en la línea de comandos de Windows:

  • Comentar línea completa: usamos ::
  • Comentario dentro de la línea: usamos & :: ya que el & es el comando separador de líneas, es decir, permite poner varios comandos en una única línea.

Lo he usado para programar un cálculo de Abaqus y aprovechar el ordenador por la noche. Para ello he creado un archivo cmd y he escrito lo siguiente en él:

:: Wait 10'
timeout 600 /nobreak 
abaqus job=<JOBNAME> interactive
pause & :: wait until keystroke

El pause del final es para que no se me cierre la ventanita al acabar y poder ver cómo ha ido el tema la mañana siguiente.

Nada más por hoy, estamos un poco más cerca de este señor 😛

Fuentes

Man de timeout

How to comment in Windows command line? en StackOverflow

10 Keys to Command Shell Scripting

Difference Between CMD and BAT

Lo que he aprendido: código en un documento con pandoc

Siguiendo con nuestro plan de dominación mundial hoy vamos a poner código con sintaxis resaltada con su pie de código y su referencia usando Markdown, pandoc y pandoc-crossref. Veamos cómo.

Resulta que cuando metemos código entre las míticas ``` podemos poner como opciones el lenguaje y un pie de código:

```{.python caption="Code block"}
print 'Hello!'
```

Si además usamos el filtro pandoc-crossref podemos ponerle una etiqueta para referenciarlo en el texto, estas etiquetas tienen la estructura #lst:nombre_etiqueta:

```{#lst:codeBlock .python caption="Code block"}
print 'Hello!'
```

Seguir leyendo →

Lo que he aprendido: trucar paquetes de Latex

Os contaba hace tiempo cómo hacer una lista de símbolos en Latex sin enloquecer. Hoy os traigo la versión mejorada de esa lista porque como estoy ida de la cabeza he modificado el paquete para que cumpla con mis manías. Antes de nada he de decir que yo no tengo ni idea de programar cosas en Latex y es la primera vez que toco un paquete pero os quiero demostrar que estas cosas no son tan difíciles como parecen 😀

En nuestro caso vamos a modificar el paquete listofsymbols para que separe los símbolos de las letras griegas y los acrónimos. Para ello cogeremos el archivo sty, lo leeremos a ver si comprendemos lo que hace y lo trucaremos a nuestro gusto.

Echando un vistazo al código podemos ver que los símbolos se definen y se escriben en un archivo auxiliar sym:

\newcommand{\opensymdef}{\newwrite\@sym \immediate\openout\@sym=\jobname.sym}

\newcommand{\closesymdef}{\immediate\closeout\@sym}

Seguir leyendo →

Lo que he aprendido: programar el ordenador para que se apague solo

El otro día me pasó una cosa curiosa, le dije así sin darme cuenta a mi jefe que había programado el ordenador para que se apagara solo porque estaba calculando una historia y quería que terminase. La cuestión es que el pavo tiene envidia ahora y quiere que su ordenador también se apague solo. Luego se meten conmigo por friki pero no se dan cuenta de que la frikez es megaútil.

Os voy a contar a vosotros también cómo va la movida porsiaca. Recordemos que esto ocurrió en mi currelo así que estamos en Windows (así es la vida hermanos, te obligan a usar Windows en los trabajos). Lo que tenemos que hacer es una chorrada supina para nosotros los usuarios del terminal.

Vamos al cmd y escribimos:

shutdown /s /t TIEMPO_HASTA_APAGADO_EN_SEGUNDOS

Por ejemplo para apagarlo dentro de un minuto:

shutdown /s /t 60

Eso es la parte number one pero nosotros como vagancias que somos no queremos escribir eso una y otra vez. ¿La solución? El infrautilizado e infravalorado Programador de tareas. Vamos a él (Panel de control, Herramientas administrativas) y creamos una tarea nueva. En la pestaña de Desencadenadores le damos la fecha y hora en la que queremos que se apague el ordenata y en Acciones ponemos:

unnamed

Guardamos la tarea y tal lógicamente y la próxima vez que queramos usarla con editarla cambiando la hora ya lo tenemos.

Pues nada más señoras y señores, ¡enseñadles esto a vuestros jefes y hagamos que la frikez domine el mundo!

Lo que he aprendido: generar números primos en Haskell

Os conté hace tiempo que me había dado por aprender Haskell para entretenerme. Hoy os voy a contar un efecto colateral: he descubierto una nueva manera de hallar números primos.


Hasta ahora para filtrar los números primos de entre los naturales, hacía lo que se conoce como división por tentativa, es decir, ir probando si cada número era divisible por los números primos menores que él.

Implementado en Haskell quedaría algo así:

Así, si queremos saber cuáles son los números primos por debajo de 25, haríamos:

> primos 25
> [2,3,5,7,11,13,17,19,23]

Como podéis ver, esto no es muy eficiente que se diga. Aquí es donde nos viene al rescate la Antigua Grecia y lo que se conoce como la Criba de Eratóstenes. Consiste en lo siguiente:

  1. Escribimos una lista de los números naturales empezando en 2
  2. Marcamos el primer valor de la lista p como número primo
  3. Eliminamos los múltiplos de p de la lista
  4. Volvemos al paso 2

En la imagen se puede ver el algoritmo en acción, es un trucazo de lo más inteligente:

Bien, vamos a implementarlo en Haskell:

Ahora si llamamos a la función primos nos dará una lista infinita de números primos. Pero, ¿y si queremos solo unos pocos? Pues utilizamos una de las características más elegantes de Haskell: la evaluación perezosa. Unos ejemplos serían:

De esta manera podríamos aplicar las condiciones que queramos a nuestra lista gigante de primos y solo se evaluará lo que sea necesario.


Nada más por hoy. ¡Ánimo con las comidas navideñas y empezad bien el año todos! 😀

Fuentes

Código de la división trivial: Programming in Haskell de Graham Hutton

Fuente de la imagen de la criba

Código de la implementación de la criba

Más

Why functional programming matters?