Emacs. El editor universal

Como es posible que emacs, un editor de macros creado en 1975 por Richard Stallman , todavía continué utilizándose? Tal vez analizando la siguiente cita extraida de su manual de referencia oficial lleguemos a entenderlo.

"Emacs is the extensible, customizable, self-documenting real-time display editor."

Extensible gracias a integra un interprete emacs lisp con la que el propio usuario puede extender las funcionalidades del editor. Elisp incorpora sentencias que permiten usar el editor como interfaz entre el usuario y los comandos del sistema. De ahí el que se atribuyan usos tales como editor universal, entorno de desarrollo integrado, escritorio remoto o cómicamente el de sistema operativo.

Es personalizable por usuario ya que es posible adaptar cualquier aspecto de uso a nuestras propias necesidades. Visualización, apariencia, teclas rápidas, comandos y un interminable etc.

Auto documentado ya que además de poder consultar los man o info del sistema, toda la documentasen referente al editor o elisp viene de serie.

Aquí una de mis capturas de panatalla



La mejor manera ser productivos con una aplicaron interactiva es aprender los atajos de teclado de las funciones mas usadas. Emacs esta pensado para esto dedicando dos teclas a modo de comodín para una interacción eficiente con el sistema. Estas teclas son Control(Tecla ctrl) simbolizado por la letra C- y Meta(Tecla alt) por M- de tal forma que por ejemplo para salir del editor hemos de pulsar C-x C-c (dejamos presionado "ctrl" y a continuación pulsamos "x" y luego "c¨)

Hay que resaltar que emacs tiene una de las mayores comunidades de usuarios y desarrolladores que contribuyen a que el editor innove e importe maneras útiles para manipular todo tipo de información. Gracias a esto, la aplicacion se mantiene actualizada y adaptada a las nuevas necesidades. Se acabó el tener que aprender y configurar un nuevo editor con cada tipo de documento o lenguaje de programación!

En este enlace pueden hojear algunas de las mejores funcionalidades del editor mediante mas capturas de pantalla.

Si te animas te recomiendo que visites la sección hispana del wiki de la comunidad internacional de emacs

Compilación de módulos bajo Linux

Desde que entré en el mundo de Linux me ha llamado la atención el núcleo y todo lo que represente meter mano por ahí. Lo malo de eso es que resulta engorroso, confuso y complicado empezar (al menos a mi me pasa), después de ganar cierta experiencia moviendome en sistemas UNIX (o sea Linux para que nos vamos a engañar...) me he dado cuenta de que la parte más fructífera para el informatico de a pié son los módulos.

¿Qué es un módulo? Mucha gente cree que un módulo en Linux es un driver, un programa para manejar un cacharro. En principio yo también lo pensé, es más, surgieron precisamente para ese motivo, pero un módulo es más que eso. Un módulo se puede ver a grosso modo como un cacho más del núcleo, un pedazo de código que hace algo, puede ser manejar un dispositivo o puede ser ordenar un vector, que se yo, cualquier cosa. La característica más resaltable de los módulos como todos saben es la posibilidad de la carga y descarga de ese cacho de código mientras el núcleo está funcionando. Para desarrolladores hay otra característica igual de importante que es el hecho de que no hay que recompilar el núcleo para crear el módulo (gracias a dios!).

Lo que voy a poner a continuación después de esta comida de bola es algunas notitas para mi mismo y para quién las necesite sobre como compilar un módulo.

1. Necesitamos los fuentes de un núcleo. OJO! si queremos que el módulo funcione para el núcleo que corre actualmente hacen falta los fuentes de ese núcleo obviamente, pero podemos generar módulos para otras versiones de núcleo diferentes a la que está corriendo... lógicamente no podremos cargarlos por la incompatibilidad de versiones (aunque creo que se puede desactivar cuando se compila el núcleo) así que lo normal es trabajar con un núcleo X.Y.Z corriendo y tener los fuentes del núcleo X.Y.Z para generar módulos para un núcleo X.Y.Z.
2. Necesitaremos compilar el núcleo, esto es debido a que hace falta generar el árbol de dependencias para luego poder compilar módulos. Al compilarlo una vez ya se crea este árbol, no hace falta recompilar el núcleo cada vez que queremos compilar un módulo.
3. Crear un makefile con una sintaxis especial, luego veremos ejemplos.
4. Compilar el módulo, debe ser compilado dentro del contexto del árbol de dependencias del núcleo, así que no vale ejecutar make y ya está, luego veremos como se hace.
5. Cargar el módulo con insmod o modprobe. El segundo es más inteligente que el primero, deberiamos acostumbrarnos a usarlo.
6. Abrir una cervecita, beber y decir "joder! que de puta madre!" si todo funciona else decir "esto es una mierda, el puto ole no sabe explicarse!", abrir una cervecita, beber y descubrir que está pasando.
7. Si todo funcionó empezar a usar el módulo para darte cuenta de que no funciona el programa en si y que tienes que buscar fallos. Documentación de debugging de módulos hay en el tema 4 del libro "Linux Device Drivers" de Jonathan Corbet, Alexandro Rubini y en la tercera edición también Greg Kroah-Hartman. MUY ENCARECIDAMENTE SE LOS RECOMIENDO EN INGLÉS Y NO EN ESPAÑOL! He mirado la segunda edición en inglés y la tercera en español... no hay color, la traducción es muy mala. Desde aquí se lo dedico Pedro J. Gómez Corriente.

Ejemplitos de código estúpido y compilación sarna (el típico, hola mundo):

---------------------------------------------------------------------------------------
#define EL_MUNDO_APESTA 0

int algo()
{
printk(KERN_ALERT "HOLA MUNDO!!!\n"); //OJO al \n que muchas recompilaciones se hacen por ellos
return EL_MUNDO_APESTA;
}

int blablabla()
{
printk(KERN_WARNING "descargando modulo\n");
return 0;
}

module_init(blablabla);
module_exit(algo);
---------------------------------------------------------------------------------------

El ejemplo lo he picado con la misma sin mirar nada así que es altamente probable que no funcione. Seguramente faltarán bibliotecas, creo que para el tema de módulos hay que añadir siempre una tal linux/modules.h pero no sé. Cuando el make pete miran lo que dice resuelven y tan amiiiiiigos noooooo?!

Makefile para un módulo que es generado por UN ÚNICO fichero objeto.
-----------------------------------------------------------------------------------------
obj-m := nombre_que_queremos_para_el_modulo.o
-----------------------------------------------------------------------------------------

Makefile para un módulo que es generado por VARIOS ficheros objeto.
-----------------------------------------------------------------------------------------
obj-m := nombre_que_queremos_para_el_modulo.o
module-objs := fichero1.o fichero2.o .....
-----------------------------------------------------------------------------------------

Orden make para compilar:

make -C directorio_de_los_fuentes_del_núcleo M=direccion_donde_quiero_estar_despues_de_compilar modules

Red multicast con qemu

En ciertas ocasiones, programación en red por ejemplo, nos interesa poder simular una red de computadoras con sóla maquina de manera segura y sin tener que modificar nuestro sistema operativo. Aquí les comento como hacerlo usando un emulador libre llamado qemu que interconectara tres terminales linux mediante una red multicast.

Como se pueden imaginar, en una red multicast si una estación envía un paquete este es recibido por todos por todas las demás al igual que ocurre en una topología de bus.

Primero vamos a descargar qemu para windows
A continuación replicaremos la imagen de linux.img que viene de serie en el directorio y las renombramos como linux1.img linux2.img y linux3.img
Seguidamente crearemos tres archivos .bat en el mismo directorio de la siguiente manera:

archivo uno.bat
qemu.exe -L . -m 128 -hda linux1.img -localtime -M isapc -net nic,macaddr=52:54:00:12:34:56 -net socket,mcast=224.0.0.1:1234

archivo dos.bat
qemu.exe -L . -m 128 -hda linux1.img -localtime -M isapc -net nic,macaddr=52:54:00:12:34:57 -net socket,mcast=224.0.0.1:1234

archivo tres.bat
qemu.exe -L . -m 128 -hda linux1.img -localtime -M isapc -net nic,macaddr=52:54:00:12:34:58 -net socket,mcast=224.0.0.1:1234

Resaltar que hemos cambiado el numero de direccion fisica de cada una de las tres interfaces que usaran los sistemas.

Tras arrancar los tres sistemas mediante la ejecución los .bat. Asignaremos una dirección ip a cada sistema de la siguiente forma:

sistema 1
ifconfig 192.168.0.1 netmask 255.255.255.0

sistema 2
ifconfig 192.168.0.2 netmask 255.255.255.0

sistema 3
ifconfig 192.168.0.3 netmask 255.255.255.0

Finalmente para comprobar que todo funciona probaremos a hacer ping entre cualquiera de los sistemas. Por ejemplo, desde el primero hacia el tercero mediante la orden:
ping -c 2 192.168.0.3

El procedimiento similar con otros sistemas operativos tanto el del host como de las maquinas virtuales a interconectar.

Automatizar tareas repetitivas con Firefox

Sabes que es una macro? A mi juicio no es mas que una secuencia de tareas asociadas en una única acción. Por ejemplo: Imagina que quieres personalizar un titulo de pagina con un determinado tipo de fuente, tamaño, alineación y color. En lugar de realizar esa secuencia de operaciones cada vez que necesites insertar un titulo, podrías crear una macro llamada "Mititulo" que se encargue de ello. Me sigues?

El caso es que por casualidad encontré una extensión para el Firefox llamada iMacros que te permite automatizar tareas de negación web.
La extensión simula a una persona que interactúa con el navegador pudiendo rellenar estomáticamente formularios, hacer cliks, cerrar ventanas publicitarias, descargar archivos, etc..
Vamos! Que ahora todas las tareas repetitivas solo las tendrás que realizar tu una sola vez para grabar la macro. Y a partir de ahí, puedes repetirlas cómodamente con un simple golpe de ratón.