Notxor tiene un blog: Niveles de configuración en emacs

Niveles de configuración en emacs

Una de las primeras cosas que se ve cuando uno se acerca a emacs es la pantalla de about-emacs y poco más. De primera vista lo único que destaca es el aspecto antiguo, algunos dirán: rancio, del diseño. A quien diga lo de rancio, no le falta razón. Emacs es un editor con mucho recorrido a la espalda y su diseño proviene de tiempos en los que la interface más habitual era la consola de texto y no estaban inventadas las teclas de cortar, copiar y pegar, ni tenían esos nombres, cuando este editor ya contemplaba esas acciones.

Quien decide profundizar en emacs, a pesar de su inicial apariencia de software desfasado, descubre un inmenso mundo de posibilidades que exceden el mero hecho de editar texto plano. El modo gráfico de emacs no es equivalente a usar gvim para un usuario de vim. El modo gráfico de emacs te permite visualizar pdf, leer epub, modificar svg, leer texto acompañado de sus gráficos y fotografías, navegar por páginas web o jugar al tetris. Todo ello gracias al lenguaje que viene con él y que permite hacer de todo; tanto, que hay un gestor de ventanas que básicamente es emacs distribuyendo sus frames en la pantalla.

Si estás leyendo este artículo, seguramente ya conocerás las maravillas de emacs y no voy a contarte nada nuevo. Si no las conoces tienes todo el blog para enterarte, porque creo que hablo de todas las cosas que hago con él. No voy a cansinar más con el tema y vamos al lío... ¿Cuál es el lío? La configuración, sin duda. Toda la potencia de emacs radica en una buena configuración. Configuración tan flexible y potente que a veces se atraganta a los nuevos usuarios, especialmente si desconocen Lisp en general y más concretamente emacs lisp. Si es tu caso, estás leyendo esto y no te aclaras muy buen con elisp, hace unos meses escribí una serie de artículos como introducción a la programación con elisp.

Jerarquía de configuraciones

¿Tan importante es elisp? La respuesta a esa pregunta podría ocupar todo un artículo del blog, pero voy a dejarlo en un escueto . Por supuesto, en elisp están escritos todos los paquetes que extienden funcionalidad de emacs y también el fichero de configuración. Así que sí, tienes que saber un poquito de ese lenguaje: lo suficiente como para asignar un valor a una variable si sólo lo vas a utilizar para configurar tu editor.

Configuración general

El fichero de configuración general se llama init.el y emacs lo busca en el subdirectorio .emacs.d de tu directorio de usuario. Al principio no necesitas escribir una línea de código para configurarlo. Si estás acostumbrado a utilizar herramientas gráficas encontrarás menús y botones en Options, para hacerlo. Pero con el tiempo, estoy seguro que terminarás utilizando la edición directa del código en lugar de trastear con menús y botones que andan por ahí escondidos en la configuración visual.

Como ya he explicado varias veces cómo configurar paquetes, e incluso he hablado alguna vez sobre mi init.el en este blog, no voy a hacer más extensa esta parte.

Configuración local

Por si no había suficiente flexibilidad en la configuración general también nos encontramos con la figura de la configuración local. Básicamente consiste en meter un fichero llamado .dir-locals.el en el directorio de trabajo. Eso afectará a la configuración de todos los ficheros que se encuentren en el directorio y los subdirectorios que cuelguen de él. ¿Para qué? Pues a veces ocurre que necesitas cambiar los parámetros básicos tal y como te gustan a ti, para un proyecto en particular.

Pongo dos ejemplos que me han ocurrido y donde la configuración local me ha venido a salvar los trastos. En el primer caso se trataba de un proyecto de programación y se acordó entre los participantes que el código debía utilizar tabuladores de ancho 4. Yo siempre utilizo espacios y resultaría muy cansino cambiar la configuración general de emacs cada vez que me ponía a programar. La solución fue meter en el directorio raíz del proyecto un fichero .dir-locals.el con el siguiente contenido:

((nil
  (fill-column . 80))
 (c-mode
  (indent-tabs-mode .t)
  (tab-stop . 4)))

Se puede apreciar que lo que contiene un fichero de configuración local viene a ser un listado de variaciones para cada modo mayor que se necesite. Cada uno de esos modos contiene una lista de nombres de variables y sus valores para el proyecto. También se puede especificar nil para el modo, lo que hará que se aplique en todos los modos activados en ese directorio.

En este caso el cambio en la configuración venía impuesta por el equipo de trabajo. Pero en el siguiente, la imposición venía de una herramienta.

Alguna vez he contado que para traducir textos utilizo una herramienta en Java que facilita la gestión de ese trabajo. El tema es que esa herramienta no reconoce la extensión .org como fichero que pueda trabajar y tuve que renombrar los todos los ficheros de un proyecto a la extensión .txt, pero así, cuando los abría con emacs los habría en modo Fundamental en lugar de org-mode. La solución como lo podéis imaginar fue crear un fichero en el directorio de fuentes. Al tener la extensión .el y estar oculto, OmegaT no lo reconoce para trabajarlo en la traducción, pero lo copiará al directorio de ficheros traducidos porque interpreta que es parte del proyecto.

;;; Directory Local Variables
;;; For more information see (info "(emacs) Directory Variables")

((org-mode
  (fill-column . 75)
  (eval . (org-show-all)))
 (text-mode
  (mode . org)))

Viendo el código podéis suponer que emacs tiene alguna manera de insertar las variables en ese fichero de forma más o menos automática sin tener que recordar la sintaxis de la lista de listas y lo hay: add-dir-local-variable. Preguntará por un modo, luego por una variable y al final por un valor. Por supuesto, también encontraréis su contrario delete-dir-local-variable.

Quiero destacar también la expresión (eval . (org-show-all)), porque como se puede ver, se puede ejecutar código también desde la configuración de variables locales. En este caso, lo que hace es que todos los ficheros que se abran en modo org se mostrarán en formato desplegado. Sin embargo, emacs considera que no es seguro hacer esto y preguntará al usuario si lo ejecuta o no, mostrando un diálogo y esperando hasta que contestemos antes de abrir un archivo en un modo en el que tenga que evaluar código.

Configuración de fichero

Y ¿qué ocurre si hay algún fichero que necesite algún tratamiento especial? Pues para ello existen las variables de fichero, que igual que las variables de directorio o locales sobrescriben las variables globales, las de fichero sobrescriben las locales.

Si llevas un tiempo utilizando emacs habrás visto en algunos ficheros una primera línea tal que por ejemplo:

# -*- mode: org-mode; coding: utf-8; -*-

Esa línea informa a emacs que el fichero que se ha abierto en el buffer tendrá que tratarlo como un fichero org y que debe utilizar la codificación utf-8.

En lugar de utilizar una lista como esa, empaquetada en una sola línea, que puede dificultar su lectura y comprensión, también podríamos hacerlo en forma de listado:

# Local Variables:
# mode: org-mode
# coding: utf-8
# End:

Hay que observar que la primera línea debe ser Local Variables: y hay que acabar el listado con End:. Podemos, como hemos visto en el punto anterior evaluar algo de código, por ejemplo:

# Local Variables:
# mode: org-mode
# eval: (org-show-all)
# End:

Hará que el fichero sea tratado como org y además ejecutará la función org-show-all. También, como he dicho en el apartado anterior, antes de hacer esa ejecución preguntará al usuario si es seguro realizarla o no. En el caso de este ejemplo el mismo efecto lo conseguiríamos utilizando las herramientas que nos proporciona org-mode para hacer lo mismo y la cosa la dejaríamos así:

# Local Variables:
# mode: org-mode
# End:

#+STARTUP: showall

Conclusiones

Como se puede ver la forma de configuración que nos permite emacs es mucho más precisa que simplemente establecer variables en un fichero general. La jerarquía de configuraciones hace que podamos establecer los modos hasta el nivel más bajo independientemente de las establecidas de forma general.

Esta potencia y flexibilidad también puede aportar algo de inseguridad pues abrir un fichero de texto puede implicar la ejecución de código que podría ser malicioso.

En la documentación que viene con emacs están todos estos temas mucho más detallados de lo que yo he descrito aquí, aunque quizá no organizados de esta forma.

-1:-- Niveles de configuración en emacs (Post )--L0--C0--October 09, 2019 12:00 AM

Maxxcan's Site: Trabajando con R en Emacs

Cómo trabajar con R en Emacs
-1:-- Trabajando con R en Emacs (Post )--L0--C0--October 09, 2019 12:00 AM

Notxor tiene un blog: El infierno del indentado

El infierno del indentado

Estos días he estado trabajando en un tema en Python. En otros lenguajes, el indentado del código es más una cuestión estética que funcional, pero ya sabéis que ese lenguaje utiliza, precisamente el indentado, para establecer los bloques de código. Es una forma elegante de obligar al programador a escribir código legible, quiera o no, pero viendo lo que suele ocurrir con ello, se convierte en el origen de muchas frustraciones. ¿Por qué? Pues básicamente porque a cada programador le gusta una forma de hacerlo y eso implica, también, que los editores de texto lo hagan por defecto a la manera que le guste a quien lo programó, que puede coincidir o no con el gusto del usuario, y/o con el gusto del programador del lenguaje, y/o con el de los que hicieran el estándar del mismo. Esto, básicamente, es lo que yo llamo el infierno del indentado.

En emacs el indentado sigue siendo un infierno, además, no define ninguna manera por defecto y se lo deja al usuario y al programador, haciendo habitual que sea cada modo mayor el encargado de velar por la correcta estructura del código que se esté trabajando. Esto tiene sus ventajas y sus desventajas. Entre las ventajas, claro está, la capacidad de que teniendo buffers abiertos con distintos lenguajes, cada uno de ellos utilice el indentado que corresponda sin interferir en los otros buffers. Y la principal entre las desventajas es que la mayoría de programadores vienen acostumbrados de otros editores a esperar un comportamiento uniforme en ese sentido y a tener que cambiarlo cada vez que cambias de lenguaje... y a cambiarlo a su gusto, naturalmente; encontrándose que después de haber gastado tiempo en configurar los espacios y tabuladores, resulta que abren un fichero de código y directamente pasan de sus configuraciones.

Hace tiempo que dejé de pegarme con el indentado en emacs, simplemente espero que funcione correctamente, porque me tiene acostumbrado a ello: pulsas enter cuando acabas una línea y el cursor va a la posición que corresponda según los usos y costumbres del lenguaje en el que estás programando y no me preocupo de más. Hasta aquí todo correcto y si eres el único programador del proyecto en el que estés y lo haces siempre con el mismo editor y no hay interferencias de otros editores, todo funciona perfectamente. Pero en un mundo ideal, si todo funcionara según las intenciones del que actúa y no según sus acciones, nos aburriríamos demasiado.

Descubriendo incongruencias en el indentado

Como decía, había estado trabajando un poco con Python y siendo ese lenguaje tan especial con el tema de los espacios al principio de línea, me encontré con el infierno del indentado de nuevo.

Por poner un ejemplo y que se entienda, vamos a analizar el siguiente código:

def con_argumento( arg="" ):
    if arg:
        print("El argumento es: ", arg)
    else:
        print("No hay argumento")

con_argumento("Hola")
con_argumento()

Mientras esperas que la salida sea algo como:

$ python3 prueba.py 
El argumento es: Hola
No hay argumento

Resulta que lo que lanza es algo como:

$ python3 prueba.py 
  File "prueba.py", line 3
    print("El argumento es: ", arg)
                                  ^
TabError: inconsistent use of tabs and spaces in indentation

¡Mierda! ¡Ya estamos! ... A ver; vamos por partes y os lo explico todo ─al menos lo poco que yo sé─.

Preferencias personales

Cuando uno tiene que lidiar con este tema, termina haciéndose una idea de cómo le gusta o no le gusta a él el indentado. En emacs, como en otros editores se pueden establecer esos gustos por defecto en el fichero init.el. Por poner mi ejemplo, yo tengo establecidos los siguientes parámetros en la lista de custom-set-variables:

'(indent-tabs-mode nil)
'(tab-width 4)

También se podría establecer fuera de dicha lista con:

(setq indent-tabs-mode nil)
(setq tab-width 4)

La primera variable estable que no se utilicen tabuladores para el indentado y que sean reemplazados por espacios y la segunda variable, establece que cada tabulador tenga un ancho de 4. El evitar que utilice tabuladores evita que al pasar de un editor a otro, o cuando ves el código en github, por ejemplo, todo el indentado se haya ido al garete.

Como ya he dicho, luego cada modo mayor establece sus parámetros al gusto del programador del modo, que suele coincidir con lo más habitual de cada lenguaje. Pero es interesante establecer los valores por defecto, para los casos en que los modos no tratan el indentado en su código.

¿Y qué ocurre si mis gustos personales no coinciden con los que tenga quien programó el modo de emacs? Pues tienes dos opciones, te acostumbras a lo que diga el modo o te creas un gancho, del estilo:

(add-hook 'python-mode-hook
          (function
           (lambda ()
             (setq indent-tabs-mode nil)
             (setq tab-width 4))))

Ese código se ejecutará después de establecerse el modo Python, por ejemplo, y ajustará los valores deseados a como tú los quieras. Pero es muy cansino hacerlo para todos y cada uno de los modos que puedes utilizar.

Visualizar los espacios en emacs

Todo esto, está muy bien: ya tenemos controlada ─un poco─ la fiera del indentado... ¿Qué pasa cuando nos llega código de otros, escrito con otros editores o con otros ajustes o gustos? Primero de todo es identificar dónde está el problema visualizándolo de manera directa. Si estás acostumbrado a programar en Python y a utilizar editores diseñados para la programación en dicho lenguaje, estarás más que harto de ver cómo el editor te muestra los saltos de tabulación y los espacios para delimitar los bloques de código. Eso también se puede visualizar de forma sencilla en emacs con el modo menor whitespace-mode.

En este caso, no hay que instalar nada, pues es uno de los modos que se incluyen en la base de emacs, sólo hay que activarlo llamando a whitespace-mode (o desactivarlo, con el mismo comando). Al activarse mostrará ws en la línea de estado.

Si lo activas y no lo has utilizado nunca, ni lo has configurado de otra manera, verás los espacios marcados por un carácter ·, los saltos de línea con $, los tabuladores con ». Todo eso se puede configurar, no sólo los colores que utilizará, sino también los caracteres por otros más a tu gusto o costumbre... En mi caso en su día utilicé el carácter | para el tabulador y el para el final de línea, pero quité los ajustes en una remodelación de mi init.el y ya me he acostumbrado a los valores por defecto.

Todo esto al final también es una cuestión de gustos, o más que gustos, de costumbre... pero que sepáis que poder se puede.

Cambiar el indentado sin morir en el intento

Hemos activado el modo y descubierto que nuestro código luce más o menos así:

def·con_argumento(·arg=""·):$
····if·arg:$
»   ····print("El·argumento·es:·",·arg)$
····else:$
········print("No·hay·argumento")····$
····$
con_argumento("Hola")$
con_argumento()$

Además lo marca con colores y vemos que tenemos algunas líneas que tienen al final espacios en blanco que sobran y que la tercera línea está mezclando caracteres » y ·, lo cual indica que los primeros cuatro espacios son un tabulador y los siguientes cuatro son espacios en blanco. ¿Cómo se quita? Muy fácil, con un sencillo par de pasos:

  1. Marcamos las líneas que queremos modificar.
  2. Llamamos al comando untabify, ─si queremos utilizar espacios en blanco─, o al comando tabify, ─si queremos utilizar tabuladores─, ya sabéis: va en gustos.

Cuando utilizamos tabify (o untabify) es posible que no veamos que emacs hace algo, porque el alineamiento puede estar mostrando por pantalla las cosas de manera normal: como hemos visto en el ejemplo, si el tabulador está fijado a 4 y el código está escrito para ajustarse a esos cuatro espacios, visualmente no se apreciará el cambio, a no ser que tengamos activado el modo whitespace. Algo más habitual de lo que se cree, porque los errores cuando no coinciden el ancho de tabuladores y los espacios, saltan a la vista; pero cuando coinciden y no se ven a simple vista, suele ser cuando más molestos de encontrar son.

Y ya está explicado todo lo que sé sobre el infierno del indentado y cómo enfrentarse a él desde emacs.

Conclusión

Es algo que hace que me rechinen los dientes cuando tropiezo en ello. Cada vez que me encuentro con un problema de estos me da vueltas el higadillo y la bilis lo salpica todo. Tengo que respirar hondo un par de veces y luego ya, activo whitespace-mode para visualizar los errores. Como ya habéis visto, es fácil corregirlos e inviertes sólo un rato, pero un rato que deberías estar dedicando a otra cosa importante: como comer, dormir, etc.

También quiero destacaros que no os dejéis llevar por las prisas y marquéis todo el buffer con C-x h y llaméis al comando (un)tabify para cambiar todo de golpe. A ver, poder se puede, pero esos comandos no distinguen si los espacios están o no al principio de las líneas y puedes estar modificando también espacios o tabuladores puestos para hacer una tabla en los comentarios u otros formateos de texto, como alinear las entradas de variables para visualizarlas mejor, etc. Dicho de otro modo: «Usadlo con cuidado».

-1:-- El infierno del indentado (Post )--L0--C0--October 08, 2019 12:00 AM

Maxxcan's Site: Cómo gestionar tus contraseñas con Emacs y Pass

Como gestionar las contraseñas con Emacs y Pass
-1:-- Cómo gestionar tus contraseñas con Emacs y Pass (Post )--L0--C0--September 30, 2019 12:00 AM

Maxxcan's Site: Racket con Emacs

Como trabajar con Racket en Emacs
-1:-- Racket con Emacs (Post )--L0--C0--September 29, 2019 12:00 AM

Maxxcan's Site: Introducción y qué es spacemacs

Qué es Spacemacs
-1:-- Introducción y qué es spacemacs (Post )--L0--C0--September 29, 2019 12:00 AM

Onda Hostil: Lo que he aprendido: manejar referencias bibliográficas en Emacs

Detesto instalar programas, aprender dónde están los botoncillos en un programa nuevo y que luego no me convenza y vuelta a empezar. Supongo que es uno de los motivos por los que me encanta Emacs: mismo programa, miles de tareas diferentes.

Últimamente he estado hurgando un poco en sus habilidades como gestor bibliográfico. Como ya os conté, yo suelo usar Jabref que es el programa que aprendí a usar en su momento y con el que me apaño bien para añadir referencias directamente desde la web, pero hay veces en las que manejar texto plano a pelo me parece más conveniente. ¡Y para eso no hay nada que iguale a Emacs! Os cuento un poco.

El modo BibTeX

La forma más básica para trabajar con bibliografías en Emacs es el modo BibTeX: se carga directamente al abrir un archivo con extensión .bib y nos permite organizar (M-x bibtex-sort-buffer) y adecentar (C-c C-c ) nuestras referencias.

Para insertar entradas tenemos el comando genérico C-c C-b tras el que podemos usar autocompletado, o el grupo de comandos que empiezan por C-c C-e. Por ejemplo, para crear una entrada de tipo artículo podemos hacer lo siguiente:

  • con C-c C-e C-a (o M-x bibtex-Article) creamos una plantilla para artículo;
  • rellenamos los datos necesarios, algunos comienzan por OPT porque son opcionales;
  • al acabar hacemos C-c C-c (o M-x bibtex-clean-entry) para quitar los campos opcionales que no hemos rellenado y que nos corrija el formato;
  • si no le hemos puesto una palabra clave nos sugerirá una y la entrada estará finiquitada y lista para ser citada.

Otro comando interesante es M-x bibtex-fill-entry (generalmente C-c C-q ) para alinear correctamente cada entrada bibliográfica. Y tampoco está mal establecer la variable bibtex-maintain-sorted-entries para tener las referencias en orden alfabético.

Como siempre, podemos recurrir a M-x describe-mode para que Emacs nos explique qué hace el modo. Es un modo chiquitico, pero muy útil para embellecer la lista de referencias ya que ayuda a cambiar de mayúsculas a minúsculas, quitar espacios innecesarios y míticas mierdas que, a las que somos maniáticas, nos ponen muy nerviosas.

Helm-bibtex

Mi modo favorito para gestionar las referencias bibliográficas en Emacs es Helm-bibtex. Lo descubrí intentando abrir los artículos que cito directamente desde Emacs y lo he introducido directamente en mi rutina de escritura científica (que algún día os contaré) junto con AUCTeX y RefTeX.

Es sencillito de usar: una vez instalado, lo llamamos con M-x helm-bibtex. Nos aparecerá entonces una lista de nuestras referencias bibliográficas en la que podremos elegir la entrada que queramos. Dándole a TAB vemos las acciones posibles, que se ejecutan todas en las teclas F1F12.

Como sugieren en su ayuda, he enlazado M-x helm-bibtex a la combinación Menú + b añadiendo esta línea al archivo de configuración:

(global-set-key (kbd " b") 'helm-bibtex)    

con la idea de configurar el resto de las historietas de Helm también en la tecla Menú y pulsar menos botoncicos.

Evidentemente, aunque sea muy listo este modo, tenemos que decirle dónde tenemos el archivo de bibliografía, los artículos en cuestión y las notas al respecto, si las estamos usando. Yo, como tengo un archivo y una carpeta con referencias para cada tema, establezco unas variables locales para el artículo que esté escribiendo

%%% Local Variables:
%%% eval:(setq bibtex-completion-bibliography '("refs.bib"))
%%% eval:(setq bibtex-completion-library-path  '("references/"))
%%% End:

pero si tuviera todas las referencias juntas, podría añadir ese par de líneas al archivo de configuración directamente con las rutas correspondientes.

Una cosa que me encanta de este modo es que, por medio de RefTeX, localiza la bibliografía local si se usa helm-bibtex-with-local-bibliography en lugar de helm-bibtex. Algo bastante útil sobre todo cuando estamos manejando bibliografías de otras personas.

De esta manera, cuando estoy escribiendo un artículo y quiero citar algo o a alguien, abro mis referencias, busco entre ellas lo que necesito y abro directamente el archivo en el propio Emacs[^windows] usando pdf-tools. En Windows (sorpresa) esto no me carrula, así que he añadido esto al archivo de configuración

(setq bibtex-completion-pdf-open-function
  (lambda (fpath)
    (call-process "acrobat" nil 0 nil fpath)))

para que me abra los pdfs con al Acrobat Reader. Si, por lo que sea, lo que busco no está entre mis referencias, el cacharro me busca en repositorios online. Me falta investigar cómo funcionan las notas, que hasta ahora no he tenido necesidad de ellas.

Org-ref

Si Helm-bibtex os ha gustado y sois fanáticos de Org como la que escribe, org-ref os va a enamorar. Sirve para gestionar las referencias bibliográficas y cruzadas en Org y nos permite añadir letreros ref, label y cite como los de LaTeX.

Lo que más me gusta de este modo es que su propia ayuda es un archivo Org en el que se usan las funcionalidades del modo. Se abre con M-x org-ref-help y nos cuenta todo lo necesario para jugar con él. Hace cosas molonas como permitir navegar por el documento siguiendo las referencias, mostrar el título y demás de los trabajos citados si ponemos el cursor encima o ser capaz de extraer la información bibliográfica de un pdf (como Jabref). Es muy chulo y lo mejor para entender cómo funciona es abrir el archivo de ayuda y hurgar.

En fin, una cosa más que puedo hacer con Emacs.

Referencias

Managing BibTeX Files with Emacs

BibTeX-Mode for GNU-Emacs

Research Literature Management with Emacs


Suena:

-1:-- Lo que he aprendido: manejar referencias bibliográficas en Emacs (Post Ondiz)--L0--C0--September 25, 2019 11:30 AM

Notxor tiene un blog: Plegando el código

Plegando el código

Cuando programo me gusta ver todo el código. A veces en ficheros largos los desplazamientos pueden ser largos, pero me apaño bien poniendo marcas donde saltar o utilizando M-g g (goto-line) para saltar a la línea deseada, o M-g c (goto-char) para ir a un carácter determinado --pero esto es más complicado de saber a priori--. Se puede uno mover de forma directa a otros sitios (al siguiente error, al error previo o a una posición determinada de la línea actual. Pero como ya digo, lo que más utilizo es la función goto-line.

¿Por qué estoy contando esto? Pues hace unos días un amigo ha hecho un cambio de trabajo. Hasta ahora programaba utilizando IDE's y herramientas muy concretas desde el «güindón del Bili Puertas» y ahora se encontraba en otro mundo. Puede utilizar el S.O. que prefiera con las herramientas que quiera para escribir el código. Él, habiéndome leído bastante lo pesadico que me pongo con el software libre en general y emacs en particular, ha decidido que probará a cambiar de herramientas y pasarse a la vía de los libres. Principalmente, porque eso le permite llevarse al trabajo un ordenador viejo en lugar del carísimo de la muerte y si se le escacharra en el tranvía pues tampoco pierde mucho. El caso es que hablando con él me dice que se ha repasado todos los artículos de mi blog sobre emacs y org-mode: se ha configurado la agenda, se ha configurado el correo electrónico, se ha pasado a i3wm como entorno de ventanas (awesomewm no le ha convencido), carga el editor con emacsclient, incluso ha configurado el powerline y el tree-mode, y se ha instalado orgzly en el móvil. Vamos, que va el tío y sigue todos mis consejos, personalizándose algunas cosas incluso metiendo algo de código en elisp que dice haber aprendido de mi minicurso. Y al final va y me hace una pregunta tonta: Oye, tú que sabes mucho de esto ¿Cómo se pliega el código?

Al principio no supe bien a qué se refería... ¿plegar código?.

─ Seguro que se puede. org-mode te lo muestra plegado por defecto si no le especificas otra cosa en el #+STARTUP ─me dijo.

─ ¡Oh! ¡Vaya! ¿¡Te refieres al outline!? ¡Vale! Escribo una minientrada en mi blog para explicarlo, pero la respuesta corta es: activa el outline-minor-mode y podrás plegarlo.

─ ¡Otro paquete que instalar!

─ No, no. outline viene de serie con emacs, no tienes que instalar nada. Lo único que tienes que hacer es configurar las teclas si quieres, pero eso ya te lo explico en el blog que es más largo.

Bueno, el caso es que estoy aquí para explicar básicamente eso y no mucho más. Como he dicho, es un modo que no suelo utilizar porque yo soy de los que les gusta tener todo el código a la vista, pero alguna vez lo he utilizado para plegar comentarios enormes que te hacen perder el hilo del código (es lo que tiene intentar hacer programación literaria escribiéndolo todo en el mismo fichero del código).

Y lo primero un aviso: no confundáis outline-minor-mode con outline-mode. Esto es un modo mayor y por tanto te cerrará el modo en el que estés trabajando para ponerse él. Lo normal, cuando programas es utilizar el minor, que te permite tener activado un modo mayor para Python, por ejemplo, y el plegado de código a la vez.

Comando Acción
M-x outline-minor-mode Establece el modo
C-c @ C-t oculta todo el buffer excepto cabeceras
C-c @ C-a muestra el texto completo del buffer
C-c @ C-q oculta todo menos las cabeceras principales
C-c @ TAB muestra todas las subcabeceras de la actual
C-c @ C-k muestra las subcabeceras pero no los cuerpos
M-x outline-previous-heading va a la cabecera anterior
M-x outline-next-heading va a la siguiente cabecera
C-c @ C-p va a la anterior cabecera visible
C-c @ C-n va a la siguiente cabecera visible
   

Como se puede ver la combinación C-c @ no es precisamente de las cómodas, pero en la documentación del paquete se propone o se sugiere, para quien utilice este modo con profusión otra configuración que puede facilitar el acceso un poco, copio el siguiente código de allí (no lo he probado, pero entiendo que estando en la ayuda del paquete del modo, debe ser correcto):

; Outline-minor-mode key map
(define-prefix-command 'cm-map nil "Outline-")
; HIDE
(define-key cm-map "q" 'hide-sublevels)    ; Hide everything but the top-level headings
(define-key cm-map "t" 'hide-body)         ; Hide everything but headings (all body lines)
(define-key cm-map "o" 'hide-other)        ; Hide other branches
(define-key cm-map "c" 'hide-entry)        ; Hide this entry's body
(define-key cm-map "l" 'hide-leaves)       ; Hide body lines in this entry and sub-entries
(define-key cm-map "d" 'hide-subtree)      ; Hide everything in this entry and sub-entries
; SHOW
(define-key cm-map "a" 'show-all)          ; Show (expand) everything
(define-key cm-map "e" 'show-entry)        ; Show this heading's body
(define-key cm-map "i" 'show-children)     ; Show this heading's immediate child sub-headings
(define-key cm-map "k" 'show-branches)     ; Show all sub-headings under this heading
(define-key cm-map "s" 'show-subtree)      ; Show (expand) everything in this heading & below
; MOVE
(define-key cm-map "u" 'outline-up-heading)                ; Up
(define-key cm-map "n" 'outline-next-visible-heading)      ; Next
(define-key cm-map "p" 'outline-previous-visible-heading)  ; Previous
(define-key cm-map "f" 'outline-forward-same-level)        ; Forward - same level
(define-key cm-map "b" 'outline-backward-same-level)       ; Backward - same level
(global-set-key "\M-o" cm-map)

De ese modo establece M-o como la combinación para el plegado y además añade configuración para todas las posibles acciones. Si os fijáis en la tabla anterior, había dos que la forma de acceder era con el comando completo desde el minibuffer. Es una combinación bastante apañá, porque no recuerdo ningún modo que mapee M-o para ninguna acción (así que tendrás pocas colisiones) y la o es fácil recordarlo por lo de outline.

Por último, si vas a utilizar este modo con bastante asiduidad como para configurar las teclas de acceso, lo mismo también quieres que se active cuando abras un archivo de código:

(add-hook 'prog-mode-hook 'outline-minor-mode)

Y esto es todo. Espero haber sido de ayuda.

-1:-- Plegando el código (Post )--L0--C0--September 20, 2019 12:00 AM

Blog uGeek: Emacs siempre a la última versión, betas, edge... gracias a Snap

Emacs siempre a la última versión, betas, edge... gracias a Snap

:DESCRIPTION:...

Sigue leyendo el post completo de Emacs siempre a la última versión, betas, edge... gracias a Snap

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Emacs siempre a la última versión, betas, edge... gracias a Snap (Post )--L0--C0--September 18, 2019 01:12 PM

La Pipa Plena: Entradas 33 y 34 del curso de emacs

Hemos añadido al curso de emacs dos nuevas entradas sobre las últimas cosas del curso de emacs que nos han aparecido en las amenas charlas que sobre el tema efectuamos: pass, highlight-changes-mode,  mouse-avoidance-mode, glasses-mode, list-color-display, nov, real-auto-save, transpose-frame, diff-mode, substitute-in-file-name, memento-mori, recenter-positions, pathify-directory y golden-ratio-adjust http://lapipaplena.duckdns.org/emacs/ Y tambien hemos actualizado el org correspondiente: http://lapipaplena.duckdns.org/emacs/curs_emacs.org   … Sigue leyendo Entradas 33 y 34 del curso de emacs
-1:-- Entradas 33 y 34 del curso de emacs (Post la pipa plena)--L0--C0--September 15, 2019 04:53 PM

Onda Hostil: Lo que he aprendido: Julia, Babel y Org

Ya sabéis que me gusta llevar la contraria. También que me gusta el minimalismo y usar el mínimo de herramientas posible. Así que cuando me ha dado por explorar la programación literaria y la investigación reproducible en Julia, en lugar de aprender a utilizar los cuadernos Jupyter como una persona normal, me he puesto a jugar con mi adorado modo Org y su funcionalidad para incluir bloques de código Babel1. Supongo que es lo que tiene ser la única de tu entorno (laboral) que hace estas cosas y no tener por tanto limitaciones en la elección de herramientas. Total, como en la academia no se colabora, no se va a dar el caso de que mi elección me limite. En fin, dejo la academia, que me caliento, y os explicito los motivos:

  • No instalo más software: ya estoy programando en Julia en Emacs así que no necesito mil programas y mi ordenador durará años y años.

  • Utilizo mis atajos de teclado y configuración: como sigo usando el mismo programa, no tengo que aprender dónde están otros botoncillos. Además, tengo definido cómo exportar a pdf desde Org pasando por LaTeX en mi archivo de configuración por lo que el documento final es exactamente como yo quiero.

  • Puedo cambiar de lenguaje de programación: el sistema funciona para una pila de lenguajes de programación. Puedo incluso mezclar código de diferentes lenguajes en un único documento2.

Visto esto, parece que elegir Org es una buena idea, así que paso a contaros en qué consiste la programación literaria, cómo se aplica en Org y qué tiene de especial el caso de Julia.

La idea: escribir para humanos

La idea de la programación literaria, como tantas otras buenas ideas, fue de Donald Knuth. Consiste en cambiar de lector objetivo al escribir un programa: en lugar de una secuencia de instrucciones para una máquina salpicada por algún comentario sobre la implementación, el programa se convierte en una descripción de la lógica detrás de la implementación salpicada por algún fragmento de código. De esta manera, no es necesario descifrar qué hace el programa leyendo el código porque las decisiones de diseño y la lógica se explicitan. Se puede pensar en el programa, entonces, como en una obra literaria.

Como me dedico a los métodos de cálculo, es decir, propongo una manera de calcular algo y luego demuestro mediante un ordenador que mi manera es mejor que la manera anterior, este enfoque me interesa por dos motivos:

  • Investigación reproducible: puedo escribir un artículo científico que incluya mis datos y mi código con lo que quien lo lea puede acompañarme en el proceso, obtener mis mismos resultados y verificar si que mis conclusiones son correctas.

  • Documentación útil: puedo explicar en el propio programa mi proceso mental para implementar numéricamente un cálculo que inicialmente era analítico, incluyendo matemáticas si es preciso.

Solo nos queda responder a una pregunta: ¿cómo demonios se lee esa mezcla de texto y código sin volverse una loca? Pues mediante los procesos de weaving, que deja solo lo humano, y tangling, que deja solo lo que entiende la máquina. ¡A ver si os habíais pensado que el señor Knuth no había pensado en esto! La cuestión aquí es que como tanto la documentación o explicación y el código salen de un mismo documento, ambos crecen juntos y limitamos la típica divergencia de según la documentación esta función tiene dos variables de entrada pero según el código tiene tres.

Programación literaria en Org

Ahora que sabemos qué es lo que queremos hacer, vamos a ver cómo lo hacemos en Org. No puede ser más fácil: cuando queramos meter un cacho de código escribimos

#+BEGIN_SRC lenguaje opciones_cabecera

Código

#+END_SRC

y ya está. Impresionante. Más os voy a decir: los bloques se pueden crear con las plantillas fáciles de Org situándonos en el principio de la línea y haciendo <s TAB.

Para poder ejecutar el trocito de código necesitamos primero decirle a Org que vamos a usar el lenguaje en cuestión y que ese lenguaje sea uno de los soportados. Tan sencillo como ir al archivo de configuración y añadir elementos a la lista de lenguajes:

(org-babel-do-load-languages
(quote org-babel-load-languages)
(quote (
(LENGUAJE1 . t)
(LENGUAJE2 . t)
)))

Ahora si hacemos C-c C-c sobre el trocito, lo ejecutaremos y nos saldrá el resultado debajo. Por seguridad, preguntará si queremos ejecutar y tendremos que contestarle, si somos vagos y nos gusta ver el mundo arder podemos decirle que ejecute todo el código sin preguntar con

(setq org-confirm-babel-evaluate nil)

¡Destrucción! ¡Sí!

Un detallico sobre los resultados: los trocitos de código se ejecutan por defecto como si fueran una función (opción de cabecera :results value) y solo nos devolverán el contenido si se lo pedimos explícitamente, con un return en el caso de Python, por ejemplo. Podemos cambiar la opción a :results output y, entonces, Org nos devolverá el contenido de STDOUT. Para lenguajes interpretados, podemos combinar esta opción con :session, que abre un intérprete y envía allí el código de todos los bloques que contengan dicha opción. Es un poco lío esto, pero jugando un poco con las opciones y leyendo la docu, se entiende.

También usamos las opciones de cabecera para decidir si al crear el documento exportamos el código (:exports code), los resultados (:exports results), el código y los resultados (:exports both) o nada (:exports none); para decirle a Org qué debe hacer con los resultados (:post); o para decir si queremos solo el archivo para la máquina (:tangle ARCHIVO_DESTINO), que por defecto no nos crea.

También podemos configurar cómo exporta el código al documento final. En mi caso, como el documento final es un pdf y eso pasa por LaTeX, quiero que use listingsUTF8 para los bloques de código. Se puede configurar para minted también, claro.

;; Exportar código como listings
(require 'ox-latex)
(setq org-latex-listings t)

;; Paquetes de LaTeX para código
(setq org-latex-default-packages-alist
'((""    "listingsutf8"  t)
("usenames,dvipsnames,svgnames,table"    "xcolor"    t))))

Las cuqueces y los colorinchis no se limitan al documento final, con

(setq org-src-fontify-natively t)

también tendremos colores en nuestro Org.

Ah, por cierto, el trocito de código lo podemos modificar en un buffer especial que se abre con C-c '.

El caso de Julia

Julia es uno de los lenguajes que no tiene soporte directamente en Babel porque su autor no le dio el copyright a la FSF. Por lo tanto, aparte de añadir Julia a la lista de lenguajes que puede usar Org, necesitamos los paquetes ESS y ob-julia.

Luego, hacen falta un par de líneas extra en el archivo de configuración para decirle a ob-julia dónde está el ejecutable de Julia (yo lo tengo en el PATH y por eso no le doy la ruta entera) y decirle a Emacs que use ob-julia:

;; Código Julia en Org
(setq inferior-julia-program-name "julia") ;; nombre o ruta de ejecutable
(require 'ob-julia)

(org-babel-do-load-languages
(quote org-babel-load-languages)
(quote (
(julia . t)
)))

Ale, ya puedo jugar a programar explicándome a mí misma lo que he hecho. Ahora solo me falta aplicar estas ideas al archivo de configuración de Emacs para no romperlo nunca.

Seguiremos informando.

Referencias

Documentación de Babel

Babel: active code in Org-mode

Working with source code en el manual de Org

Introduction to Literate Programming

Emacs para ciencias del dato

Julia with Emacs Org mode

Org-mode and julia: an introduction

Literate Programming Examples

Literate programming with Org-mode

Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks

Drops of Jupyter notebooks: how to keep notes in the information age


Os dejo con música:


  1. También hay un paquete específico para Julia, pero ¿me gusta a mí lo fácil? No. 
  2. Lo digo como su supiese programar en múltiples lenguajes, ¿habéis visto? 
-1:-- Lo que he aprendido: Julia, Babel y Org (Post Ondiz)--L0--C0--September 06, 2019 02:00 PM

Maxxcan's Site: Qué hacer después de instalar Emacs (2ª Parte)

Qué hacer después de instalar Emacs 2ª Parte
-1:-- Qué hacer después de instalar Emacs (2ª Parte) (Post )--L0--C0--September 03, 2019 12:00 AM

Notxor tiene un blog: Una plantilla para exportar documentos desde emacs

Una plantilla para exportar documentos desde emacs

Hace un tiempo, a raíz de presentar unos documentos, me preguntaron cómo me las apaño para que queden tan bien hechos. El secreto se llama LaTeX, como muchos sabéis, pero ayer mismo un amigo me preguntó por detalles más técnicos y la respuesta en ese momento se me quedó realmente corta. Aquí traigo una explicación más detallada de las cosas que tengo ya pre-paradas a la espera de la generación de documentos.

Los formatos que suelo trabajar para los documentos largos son PDF y epub. Utilizo PDF cuando necesito imprimir el documento en papel y utilizo epub cuando sólo requiere la lectura por pantalla. A veces, ni siquiera monto el epub y lo dejo en HTML, como por ejemplo, para las entradas de este blog.

Exportar a PDF

Como sabéis, y también lo dije antes, la exportación a PDF se hace a través de LaTeX. En mi caso venía ya de antes trabajando con esta herramienta para generar documentos y no necesité aprenderla aparte. Para abreviar, como esto va de plantillas, pongo la cabecera que tengo en un fichero en el directorio ~/Plantillas para iniciar los textos largos:

#+TITLE:         Título
#+SUBTITLE:      Subtítulo
#+DATE:          \today
#+AUTHOR:        Notxor
#+EMAIL:         notxor@nueva-actitud.org
#+LANGUAGE:      es
#+OPTIONS:       d:(not "LOGBOOK") date:t e:t email:nil f:t inline:t num:t
#+OPTIONS:       p:nil pri:nil prop:nil stat:t tags:t tasks:t tex:t
#+OPTIONS:       timestamp:t title:t toc:t todo:t |:t
#+LATEX_CLASS:   book
#+LATEX_CLASS_OPTIONS: [a4paper, 10pt, doubleside]

#+LATEX_HEADER: \usepackage[left=2.5cm,top=2.5cm,right=2.5cm,bottom=2.5cm]{geometry} 
#+LATEX_HEADER: \usepackage[spanish]{babel}

#+LATEX_HEADER: \usepackage{bbding}       %fuentes con iconos
# +LATEX_HEADER: \usepackage{enumitem}

# Personalizar las cabeceras
#+LATEX_HEADER: \usepackage[Bjornstrup]{fncychap}

# Las siguientes lineas para cambiar de fuente el pdf
# +LATEX_HEADER: \usepackage{mathpazo}    %fuente palatino
#+LATEX_HEADER: \usepackage{charter}      %fuente charter
#+LATEX_HEADER: \linespread{1.05}         %separa un poco las líneas para que no quede apelotonado

# Numerar las líneas de la página en los márgenes para referencias de corrección
#+LATEX_HEADER: \usepackage[switch,pagewise]{lineno}
#+LATEX: \linenumbers

En ese código hay algunos paquetes preparados pero no activados, por el simple hecho de añadir un espacio después del #. Quizá necesite explicar algunos paquetes menos habituales:

\usepackage{bbding}

Permite utilizar iconos mediante una fuente. En ocasiones le añado el paquete

\usepackage{enumitem}

Ese paquete hace que podamos modificar a nuestro gusto las etiquetas de nuestras listas, para conseguir un poco más de personalidad en nuestros listados:

\begin{itemize}[label=\HandRight]
    \item Prueba
    \item Prueba
\end{itemize}

o incluso

\begin{itemize}[label=\HandRight]
\item abc
\item[\PencilRight] def
\end{itemize}

Y con esos dos bloques de código se consigue la siguiente salida:

captura-latex-itemize.png

o también, ya que he importado la fuente en cuestión, se pueden hacer algunos separadores gráficos entre partes del documento y si tenemos que hacerlos tanto para epub como para PDF se puede utilizar algo como:

#+BEGIN_CENTER
#+HTML:  <p style="text-align:center">&#10054;  &#10052; &#10054;</p>
#+LATEX:   \SnowflakeChevron { } \SnowflakeChevronBold { } \SnowflakeChevron
#+END_CENTER

En muchas ocasiones lo que necesito impreso debe ser corregido antes de ser entregado. Para eso utilizo el siguiente código:

# Numerar las líneas de la página en los márgenes para referencias de corrección
#+LATEX_HEADER: \usepackage[switch,pagewise]{lineno}
#+LATEX: \linenumbers

Lo que hace el paquete lineno de LaTeX es escribir en los márgenes un número de referencia de cada línea. Las opciones switch y pasewise hace que se impriman en márgenes alternos para las páginas pares e impares y que reinicie el contador en cada página. Así encontrar los errores es más fácil, sobre todo si el corrector es otra persona. Con hacer referencia al número de página y de línea es suficiente.

Exportar a epub directamente

Un fichero epub no es más que un zip que contiene dentro ficheros html o xhtml, imágenes, css, etc. Básicamente es un sitio web encapsulado con la estructura de un libro. La forma más de andar por casa para realizar un epub es exportar a html desde emacs y luego importarlo a alguna de las herramientas como Sigil para hacer la edición electrónica.

Desde org-mode de emacs podemos generar directamente una exportación de contenido a un fichero epub. Para eso necesitamos dos sencillos pasos. El primero es instalar el paquete ox-epub por el procedimiento habitual.

M-x package-install RET ox-epub

Una vez instalado, cuando queremos generar un epub activamos la exportación con el comando org-epub-export-to-epub. Esto hace que en nuestro menú C-c C-e aparezca el correspondiente apartado, por lo que completando C-c C-e E e se genera un fichero epub.

Igual que podemos añadir opciones para LaTeX cuando queremos exportar a PDF, también podemos añadir opciones al html a lo largo de nuestro código. Incluso, si utilizamos un css personalizado, podemos cargarlo y el exportador lo meterá en el epub.

Conclusión

Generar documentos complejos con org-mode es sencillo. Por defecto, emacs realiza una exportación sencillo a PDF a través de LaTeX y a html. Sin embargo, el uso de lectores ebook y otras herramientas similares, hacen que el formato PDF sea incómodo y el html para ajustarse a pantalla necesita algo más de estructura. El formato epub vino a cubrir esas deficiencias y podemos hacer que emacs nos genere los contenidos de forma sencilla.

Cada uno tiene sus manías y es posible que los paquetes que utilizo para LaTeX no los utilices y prefieras tener otros, pero siempre es una buena idea tener nuestras cabeceras básicas guardadas en una plantilla para iniciar los documentos nuevos sin pensar demasiado, luego personalizar el resultado será más sencillo.

-1:-- Una plantilla para exportar documentos desde emacs (Post )--L0--C0--August 29, 2019 12:00 AM

Notxor tiene un blog: Prueba de concepto para crear un asistente de voz

Haciendo pruebas para crear uno de esos famosos asistentes de voz...leer más
-1:-- Prueba de concepto para crear un asistente de voz (Post )--L0--C0--August 22, 2019 12:00 AM

Blog uGeek: Corrector Ortagráfico para Emacs en Raspbian

Corrector Ortagráfico para Emacs en Raspbian

Tras adquirir mi nueva Raspberry 4 y la aparición de la nueva debian Buster, estoy utilizando Emacs remotamente...

Sigue leyendo el post completo de Corrector Ortagráfico para Emacs en Raspbian

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Corrector Ortagráfico para Emacs en Raspbian (Post )--L0--C0--August 16, 2019 02:50 PM

Onda Hostil: Lo que he aprendido: Julia en Emacs

He conseguido por fin poder programar en Julia usando Emacs. Eh, que no ha sido tan fácil: algo tan sencillo como instalar el julia-mode y el ess se convirtió en un infierno. Me pasó de todo.

Primero en GNU/Linux, como no estaba usando la versión más novedosa de elementary, el Emacs de los repositorios era demasiado antiguo y no compatible con los modos que me hacían falta. Me quedaban varias opciones: (i) actualizar el sistema (lo que finalmente hice); (ii) añadir un ppa con un Emacs más moderno (bien, pero prefiero tener los paquetes de mi distro que ya he organizado alguna petarda); o (iii) compilar Emacs desde fuente (ya lo hice alguna vez y no me apetecía repetir).

Luego en Windows, donde sí tenía un Emacs lo suficientemente moderno, parece ser que Julia tiene no sé que bug y se cuelga y hay que darle a C-g para que se reviva.

En fin, que actualicé el sistema operativo y en quince minutos ya tenía un entorno para programar en Julia. Bueno, eso en mi recién estrenado Juno, en Windows me conformo con Atom, ese editor que no es un editor. Qué dura es la vida a veces.

Después de contaros mis desventuras (para eso tengo un blog), paso a resumir qué hice la vez que funcionó todo.

Julia en GNU/Linux

Julia no está en los repos, nos dejan unos binarios genéricos para que descarguemos y ejecutemos sin más. Hay que elegir unos u otros según la arquitectura de nuestro procesador. Yo, como nunca sé qué tengo lo miro así:

ondiz@slimbook:~$ lscpu
Arquitectura:                        x86_64
modo(s) de operación de las CPUs:    32-bit, 64-bit

Descargados los binarios correspondientes, es útil crear un enlace simbólico a algún lugar donde ya estemos buscando ejecutables o añadir la carpeta donde los hemos descargado al PATH, a gusto del consumidor.

Yo he elegido la primera opción, así que he hecho:

sudo ln -s RUTA_A_EJECUTABLE /usr/local/bin/julia

Cuidadín que hay que poner la ruta absoluta al ejecutable bin/julia que si no no carrula.

Julia en Emacs

Pues lo que decía al principio: para tener un entorno chachi para programar en Julia solo hace falta instalar los modos julia-mode y ess. El primero es el modo oficial para editar Julia y el segundo es un paquete que ayuda a trabajar con lenguajes de programación para estadística (ESS viene de Emacs Speaks Statistics) como R, o en este caso, Julia. Se pueden hacer otras cosas, pero esta es la más simple en mi opinión.

Una vez instalados los modos, para activar una terminal juliana inferior solo hay que hacer M-x julia. Luego ya podemos abrir un archivo en la parte superior y jugar con opciones que nos da el modo ESS.

Llevo poco con el tema y solo he memorizado un par de combinaciones útiles (miento, no las he memorizado, las escribo aquí para mirarlas en el futuro):

  • C-c C-l: carga un archivo completo, lo que sería un include("archivo").

  • C-M-x: ejecuta (me encanta esta palabra) un trozo de código en el REPL.

  • C-c C-z: cambia del script al REPL o viceversa.

Hay también una pila de comandos para gestionar errores y para acceder a la documentación que algún día controlaré. O no. También me falta echarle un ojo a imenu anywhere para que me aparezcan opciones de autocompletado en cualquier lugar. Me lo dejo de deberes.

Curiosamente, lo que más trabajo me dio fue acostumbrarme a no darle a la flecha hacia arriba para repetir el último comando en el REPL. Aquí, como las combinaciones de GNU Readline están ya pilladas, hay que usar M-p y M-n (o C-↑ y C-↓) para moverse por la historia. Comint y cosas, ya sabéis, y si no, con hacer C-h b os enteráis.

Y hala, ya tengo un entorno para programar. Contadme qué usáis vosotros para que aprendamos todos, venga.

juliaEmacs

Referencias

Página oficial de Julia

Manual del modo ess

Julia en el modo ess

imenu anywhere en GitHub


Os dejo con un grupo cuyas canciones suelo berrear en los conciertos de las fiestas de los pueblos vecinos y que tiene el mérito de que no me quedase dormida encima del libro de física de primero de carrera. Era abrirlo y bostezar, oigan.

-1:-- Lo que he aprendido: Julia en Emacs (Post Ondiz)--L0--C0--August 08, 2019 12:54 PM

Blog uGeek: Exportando tu Notas de Google Keep a Org Mode o Markdown

Exportando tu Notas de Google Keep a Org Mode o Markdown

Hay quien no se acostumbra a utilizar Orgzly ni Emacs cuando toma notas con su movil, en cambio le gustaría el tener el backup de todas las notas de su cuenta Google Keep en un único archivo Org Mode. También hay quien le gustaría tenerlas en Markdown...

Sigue leyendo el post completo de Exportando tu Notas de Google Keep a Org Mode o Markdown

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Exportando tu Notas de Google Keep a Org Mode o Markdown (Post )--L0--C0--July 26, 2019 09:00 PM

Blog uGeek: Emacs 26.2 en Ubuntu

Emacs 26.2 en Ubuntu

A partir de la versión Org 9.2, ya no es posible utilizar el atajo que utilizábamos en versiones anteriores...

Sigue leyendo el post completo de Emacs 26.2 en Ubuntu

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Emacs 26.2 en Ubuntu (Post )--L0--C0--July 22, 2019 10:43 AM

Blog uGeek: Añadir cajetilla de código en orgmode como antes

Añadir cajetilla de código en orgmode como antes

A partir de la versión Org 9.2, ya no es posible utilizar el atajo que utilizábamos en versiones anteriores...

Sigue leyendo el post completo de Añadir cajetilla de código en orgmode como antes

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Añadir cajetilla de código en orgmode como antes (Post )--L0--C0--July 13, 2019 07:00 PM

Onda Hostil: Lo que he aprendido: el buffer de paquetes de Emacs

Años usando Emacs y no ha sido hasta hace unos meses que he descubierto que el buffer de los paquetes, ese al que entramos con M-x list-packages es mucho más fácil de usar de lo que yo pensaba.

Resulta que si te posicionas en la línea de un paquete sin instalar y le das a la i lo marcas para instalar, si vas a uno instalado y le das a la d lo marca para eliminar (delete) y si le das a la U así en general, marca los paquetes que hay que actualizar con una I (upgrade). ¿Y ahora cómo hacemos efectivas estas órdenes? Pues dándole a la x. Así todo lo que queramos borrar se borrará, lo que queramos instalar se instalará y lo que queramos actualizar se actualizará.

En la imagen se ve la I mágica de la que hablo en la columna de la izquierda del todo.

paquetes

En fin, aquí lo dejo, por si hay otro genio como yo por ahí al que le resulta útil. A cuidarse.

Referencias

48.1 The Package Menu Buffer en el manual de Emacs


Solo del punk no se vive, hoy suenan trompetas.

-1:-- Lo que he aprendido: el buffer de paquetes de Emacs (Post Ondiz)--L0--C0--April 15, 2019 11:00 AM

MGallego: Introduccion a Emacs Lisp: Seteando Variables

Existen dos formas de setear una variable en Lisp:

Usando set

Imaginemos que queremos setear una variable que contenga una lista de lenguajes de programación. Podemos hacerlo de la siguiente manera:

   (set 'lenguajes '(c python pascal php java erlang))

Esto setería una variable llamada lenguajes que contendría la lista '(c python pascal php java erlang)

Debemos fijarnos en un par de cosas, una de ellas ya la había explicado en el post anterior.

Si nos fijamos en la lista '(c python pascal php java erlang) podemos ver que la lista comienza con una comilla. Con esto lo que le estamos diciendo al intérprete es que la debe devolver tal y como está, sin evaluar nada.

Por otro lado vemos que hay una comilla simple delante del nombre de la variable. Esto es mas o menos lo mismo, no queremos que la evalúe, solo queremos pasar el elemento a la función set. Si no pusiésemos esa comilla el interprete devolvería un error al tratar de evaluarla.

De esta forma ya tenemos una variable lenguajes que al evaluarla fuera de paréntesis nos devolvería una lista de lenguajes de programación.

Usando setq

Setq es una forma un poco mas sencilla de crear una variable, aunque tampoco mucho mas, ya que lo que nos ayuda setq es en que no tenemos que poner la comilla en la variable que queremos crear. La creación de la variable anterior con setq sería de la siguiente manera:

   (setq lenguajes '(c python pascal php java erlang))

La q de setq es de quoted.

Creando un contador sencillo.

Si usamos set o setq de nuevo sobre una variable que ya tiene un valor asignado este se sobrescribe, así que podemos ver un sencillo ejemplo de esto viendo como podemos definir una variable contador en emacs.

     (setq counter 0) ; inicializador
     (setq counter (+ counter 1)) ; incrementador

     counter ; resultado

El "inicializador" lo que hace como su nombre indica es crear la variable y setearla a 0. Inicializarla. El incrementador incrementa el valor de la variable en 1, así que cada vez que ejecutemos la expresión del incrementador el valor de la variable counter se aumentará en 1.

-1:-- Introduccion a Emacs Lisp: Seteando Variables (Post )--L0--C0--April 14, 2019 03:37 PM

MGallego: Introduccion a Emacs Lisp: Listas

He comenazado a leerme el manual de introducción a Emacs Lisp, el cual es gratuito y se puede leer online aquí o descargar desde la misma dirección.

Así que voy a ir apuntando por aquí un breve resumen de lo que vaya aprendiendo, aunque no me gusta demasiado como está organizado el libro y voy a intentar solo anotar las cosas que realmente me resulten interesantes o crea que pueden llegar a aportar algo realmente

Listas

Lisp está basado en listas, un ejemplo de lista es el siguiente

     '(rose
       violet
       daisy
       buttercup)

Átomos

Cada uno de los elementos de las listas, separados por espacios en blanco se llama "atom", átomo. En el caso anterior rose, violet, daisy y buttercup serían átomos de la lista. Como buen átomo que se precie no se puede dividir en ningún elemento mas pequeño.

Pocas veces los programadores llaman átomo a los átomos, ya que se suelen referir a ellos por el tipo de átomo que es, por ejemplo string: '("texto entre comillas dobles") el texto entrecomillado con comillas dobles es un átomo de tipo string.

Listas vacías

Así que una lista en Lisp no es mas que una serie de átomos encerrados entre paréntesis. Aunque también podemos tener listas sin átomos, como por ejemplo (). Esto se llama "lista vacía"

Expresiones simbólicas

La representación de átomos o listas es llamada representación simbólica, Symbol Representation también denominada s-expression

Espacios en blanco

Los espacios en blanco no son tenidos en cuenta dentro de una lista, solo se usan como separados de átomos, pero independientemente del número de ellos. Los ejemplos siguientes representan la misma lista:

      '(atom1 atom2 atom3)

      '(atom1
        atom2
        atom3)

      '(atom1          atom2   atom3)

Ejecución de código

Cualquier lista en Lisp es un programa que se puede ejecutar. En la jerga de Lisp: evaluar.

Al evaluar una lista de lisp pueden ocurrir tres cosas:

  1. No hacer nada salvo devolver la propia lista
  2. Devolver un error
  3. Tratar el primer símbolo de la lista como un comando que realiza algo

En los ejemplos en los que hemos visto antes ponía una comilla simple delante de la lista, de está manera: '(lista de elementos) con esto se le dice al intérprete que debe devolver la lista tal cual. En el caso de no poder la comilla el interprete lo que intenta hacer es ejecutar el primer elemento de lista como una función. Como por ejemplo: (+ 2 2) que lo que haría sería sumar 2 + 2, ya que el primer símbolo + es la función de suma en Lisp.

Evaluando expresiones en Emacs

Para evaluar algo en emacs, lo mas sencillo es poner el cursor justo detrás de lo que queremos evaluar y pulsar la combinación de teclas C-x C-e. si por ejemplo tenemos dos listas una dentro de otra o queremos evaluar solamente un elemento de la lista podemos hacerlo colocando el cursor en el punto justo donde deseemos evaluar.

Por ejemplo con la siguiente lista: (+ 2 (+ 3 4)) si evaluamos después del último cierre de paréntesis el resultado devuelto será 9 pero si lo colocamos detrás del penúltimo cierre, el interprete nos devolverá 7 ya que estaremos evaluando solamente la expresión (+ 3 4). Es mas, si evaluamos justo después del 4 nos devolverá 4, ya que los números se devuelven a si mismo al evaluarse.

Generar mensajes de error

En el ejemplo anterior, si evaluásemos el símbolo + nos devolvería un error. Emacs abriría un nuevo buffer donde podríamos ver la descripción del error.

Variables

Para ver el contenido de una variable no debemos meterla dentro de una lista, se debe evaluar fuera de la lista, por ejemplo en el caso de la variable fill-column que viene ya definida en emacs, para ver el contenido deberíamos evaluarla así fill-column. En el caso de que la evaluemos de la siguiente manera: (fill-column) obtendríamos un error, ya que estaría intentando ejecutar fill-column como si se tratase de una función.

Un par de ejemplo de errores serían los siguientes:

Evaluar una variable como una función

    (fill-column)

Esto devolvería un error del tipo:

    ---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
(fill-column)
eval((fill-column) nil)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Se puede ver que dice algo así como que no es una función.

Evaluar una función como una variable

Este es justo el caso anterior, en el que intentamos evaluar una función fuera de una lista, como por ejemplo evaluar el símbolo +

    +
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
eval(+)
elisp--eval-last-sexp(nil)
eval-last-sexp(nil)
funcall-interactively(eval-last-sexp nil)
call-interactively(eval-last-sexp nil nil)
command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Sería mas o menos que se intenta ejecutar una variable que no lo es o que no está declarada como tal.

Argumentos

Como en muchos lenguajes de programación, a cada elemento que se le pasa a una función se le llama argumento. El numero de elementos puede ser variable y el tipo de elemento también.

Si pasamos un número de elementos erróneo para una función está devolverá un error. Lo mismo pasará cuando el tipo de argumento no sea el correcto. En el caso del tipado el error devolverá el tipo necesario seguido de "-p", esa p viene de predicate. Por ejemplo si requiere una lista dirá "lisp" si debe ser zero nos dirá "zerop"

La función message

Hay una función en emacs llamada message que sirve para pintar en el buffer de echo del editor. Un ejemplo de su uso sería (message "texto a mostrar")

Conclusión

He decidido no publicar mas en este post, no tiene ni todo el capitulo 1 del libro. Personalmente me resulta un tanto caótico, ya que salta de unas cosas a otras y te mete cosas como por ejemplo la función message cuando está hablando de variables, cosa que no comprendo. Así que lo mismo intento publicar posts un poco mas cortos pero mas centrados.

-1:-- Introduccion a Emacs Lisp: Listas (Post )--L0--C0--April 14, 2019 02:41 PM

La Pipa Plena: Tutorial emacs

Entre un montón de elementos linuxeros hemos realizado una traducción del tutorial de emacs de: https://www.computerhope.com/unix/uemacs.htm Seguramente tiene bastantes deficiencias pero ahí queda para quien lo quiera usar. Lo hemos colgado en el apartado emacs de la cabecera i está en: http://lapipaplena.duckdns.org/emacs/emacs_tut.html M-x felices-orgasmos
-1:-- Tutorial emacs (Post la pipa plena)--L0--C0--March 24, 2019 05:15 PM

Podcast uGeek: Notas y Documentos en la nube para compartir, trabajar en equipo,...

Notas y Documentos en la nube para compartir, trabajar en equipo,...

Simplenote, es una aplicación de notas muy conocida de Software Libre, totalmente multiplataforma y gratuita...

Sigue leyendo el post completo de Notas y Documentos en la nube para compartir, trabajar en equipo,...

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Notas y Documentos en la nube para compartir, trabajar en equipo,... (Post )--L0--C0--March 11, 2019 04:45 AM

Bad Daemons: Gomic y primeras impresiones sobre Go

Go, también llamado golang, es un lenguaje de programación diseñado por Google. Es de tipado estático, compilado y similar a C. Algunas diferencias con este son que tiene protección de memoria, recolector de basura y concurrencia nativa. Este articulo tiene dos fines, enseñar lo bonico que me ha quedado un programa que he hecho en go y plasmar mis impresiones sobre mi primera incursión en este lenguaje.

Empecemos por el principio. Hace un tiempo decidí que quería hacer un programa que descargase imágenes y las mostrase como una galería en un servidor web tonto. No iban a ser unas imágenes cualquiera, en un principio quería que fuesen los cómics que hace Julia Evans (recomiendo muy fuerte echarle un ojo a su blog). Mediante cómics explica conceptos y herramientas tecnológicas con un estilo muy interesante. Quería poder ver uno de ellos de forma aleatoria, visitando una página web. Me parecía interesante por que hay veces que en el trabajo tengo cinco minutos muertos mientras espero que se ejecute alguna CI, y me parece que aprender cosas que no se suelen buscar es una forma útil de usar ese tiempo.

Tenia pensado hacerlo en python, por que ya he tocado alguna cosilla en flask. El proceso lo tenia claro. Hacia falta un fichero con la lista de las imágenes a descargar. Una vez descargadas, habría que lanzar un servidor web que mediante templates de html, renderizaria una página con las imágenes. Teniendo tan claro lo que habia que hacer, decidí hacerlo en algún otro lenguaje for the lulz.

Go es un lenguaje por el que siento curiosidad desde hace un tiempo. Muchas de las tecnologías que he estado usando el último año están hechas en go, como por ejemplo docker, kubernetes, terraform o prometheus. Y alguna vez me he encontrado algún funcionamiento fuera de lo normal y no he sabido determinar si era un bug o cosa mia, y si hubiese sabido algo de go me habría venido bien.

Como el fin de semana pasado estaba malo y no podía hacer mucho, decidí darle al tema. Y salió gomic.daemons.it.

No entraré en detalles de como se hace nada, porqué el código del programa está muy comentado. De lo que hablaré es de las cosas de este lenguaje que me han llamado la atención (sobretodo en comparación con python) y las cosas que me han gustado del proyecto.

Disclaimer: Mis conocimientos de programación son limitados, por lo que es probable que suelte alguna burrada.

  • Lenguaje compilado: Esto lo ves nada más empezar a leer sobre go. Lo que no ves de primeras es que no es necesario compilar. Es recomendable y deberías crear binarios, pero para desarrollar puedes usar go run . y se ejecuta del tirón. Incluso se pueden hacer scripts en go. Hay formas de hacerlo, más o menos estándar, aquí hablan más del tema. Pero si a este script se le da permisos de ejecución y se ejecuta con ./script.go, funciona sin más:
//usr/bin/go run $0; exit
package main
import "fmt"
func main () {fmt.Println("Holi")}
  • Declarar tipo de variable VS asignar valor a una variable: No se si es así en otros lenguajes de tipado estático, pero en go se puede hacer de ambas formas:
var variable "holi"
variable := "holi"
  • El módulo de logueo: Como se ve aquí, se usa del tirón. Esto es algo que en python siempre me ha molestado mucho, para loguear tienes que hacer movidas muy raras. En go puedes usar log.Println para loguear a nivel info y log.Fatal para errores. Hasta se encarga de parar el programa al haber detectado un error fatal.

  • Docker friendly: Una cosa muy interesante que tiene go, a diferencia de java por ejemplo, es que puedes compilar binarios dinámicos o estáticos. La diferencia básica es que el primero solo funcionará en un SO con las mismas características que en el que se ha compilado (es decir, mismas librerías), y el segundo en cualquiera. Mola por que si lo compilas estáticamente, no hace falta nada más. Y cuando digo nada más es literalmente nada más, se puede usar la imagen scratch para crear la imagen. Por comparar, veamos el tamaño de la imagen de drone-xmpp (python) comparado con la de gomic:

r.daemons.it/gomic                   9.24MB
r.daemons.it/drone-xmpp              139MB

Es normal la diferencia. La imagen de gomic solo tiene un binario y un par de htmls, css y js. En cambio la de drone-xmpp tiene alpine, que aún siendo un SO muy pequeño, sigue siendo mucho más que nada.

  • Linter chulo: Emacs tiene un paquete de linters llamado flycheck. He intentado sacar como funciona por debajo para dar una visión más general para quien no use emacs, pero no he sido capaz. Si alguien lo sabe, que comente. El motivo por el que me ha gustado tanto es que es capaz de decirte que no puedes asignar la variable a de tipo string al valor 1 por que este un integer. Parece algo como muy tonto, pero me sorprende mucho tener un análisis estático del código en tiempo real y que no consume recursos de forma aparente.

  • Control de error obligatorio (casi): Según he visto en muchas de las funciones que he usado suelen obligan a controlar el error. Por ejemplo:

file, err := os.Create(filePath)
if err != nil {
	log.Print("error creating " + filePath)
	log.Print(err)
}

Por que digo que es obligatorio (o casi)? os.Create devuelve la descripción del fichero (file descriptor, creo que se traduce así) y un objeto de error (vacío si no existe). Al devolverlo la función, hay que asignar a ambos valores una variable. Si una variable no es usada en go, el programa no compila. Y ale, de esta forma tan tonta te obligan a tener que hacer algo con esta variable, lo normal seria usarla para comprobar que no hay ningún error. Hay formas de usar la variable para saltarse el bloqueo sin que sea útil, pero la excusa de hacer eso es más bien pequeña.

  • repl: Gore es un repl, puedes hacer pruebas rápidas con ello.

  • Paquetes nativos muy potentes: Como se puede ver si se lee el código, no he tenido que usar ningún paquete externo para el programa. En un principio usé grab para descargar ficheros, pero realmente no me aportaba demasiado. Además, no dejaba escoger que nombre le ponía al fichero, lo cual es un problema. Pero seguramente lo que llama más la atención es que el servidor http nativo sea tan potente. O igual no es tan sorprendente, si tenemos en cuenta que go se usa mucho para la generación de apis.

  • Tipos de datos: Esto fue de lo que más me costó entender, aunque no tengo claro haberlo entendido del todo. Al ser tipado estático, tienes que saber exactamente el tipo de todas las variables, por ejemplo al hacer un return de una función. Me encontré con que no podía convertir estructuras (struct, que se llama) a tipos simples, como es un string o un integer. En realidad no sabia por que no podía, el tema de las estructuras lo descubrí después de muchas horas. Concretamente, lo que estaba haciendo era intentar convertir el tipo os.FileInfo a string. Y claro, no encontraba por internet la forma de hacerlo, por que, salvando las distancias, es como si intentase convertir una clase de python en un string. Sentido cero. Al final era mucho más simple, como solo me interesaba el atributo Nombre, solo habia que acceder al atributo de una forma intuitiva, con os.FileInfo.Name().

  • Muy buena documentación: La documentación está muy bien escrita y muchas veces tiene incluso ejemplos.

  • Bulma: Esto no tiene que ver con go directamente, pero lo cuento igual por que mola. Cuando hice la primera iteración del programa, la interfaz era esta.

Se lo enseñe a Ameba y como cualquier persona con ojos, se sintió muy ofendida por el “diseño”. Por ello, hizo una primera implementación de bulma, un framework CSS como lo es bootstrap. Viendo que se habia tomado la molestia, por sentido de la vergüenza y por que en realidad soy consciente de que la UX es importante, decidí terminar de implementarlo (con mucha ayuda) y aprender bastante de conceptos básicos de html, css y js, que siempre voy muy pez. Y ha quedado algo más cuqui, como se puede ver en la primera imagen.

Poco más que añadir. Go me parece un lenguaje interesante y probablemente siga aprendiendo porque hace ya tiempo que quiero tener algún otro lenguaje a parte de python. Es improbable que Gomic reciba muchas más actualizaciones más allá de añadir más orígenes, pero cualquier sugerencia siempre será bienvenida.

-1:-- Gomic y primeras impresiones sobre Go (Post )--L0--C0--February 24, 2019 04:00 PM

Onda Hostil: Lo que he aprendido: AUCTeX

Me he hartado de usar más de un programa y he decidido que las pocas veces que escriba en LaTeX a pelo lo haré también en Emacs. Así soy, cada día más simple. Para ello estoy usando AUCTeX, un modo hiperpotente que tiene una manual de solo 130 páginas y que se autodefine como un sofisticado entorno TeX para Emacs.

Lo curioso del tema es que instalé AUCTeX hace más de un año porque fue la única manera de hacer funcionar CDLaTeX, el modo menor que ayuda a crear entornos y movidas matemáticas y que uso con Org. En todo este año no he configurado AUCTeX y he seguido usando Texmaker y Kile por pura inercia. Ahora que lo he puesto a mi gusto y que llevo usándolo una semana, he desinstalado el resto de editores de LaTeX y no creo que vuelva atrás, ¡me encanta!

Unas órdenes básicas

Como siempre, para usar AUCTeX hay que instalarlo y activarlo, a mí se me activa solo al abrir un archivo con extensión .tex, pero si no fuera el caso, M-x LaTeX-mode y adelante. Cuidado con confundirlo con latex-mode, el modo para LaTeX que viene con Emacs. Sí, lo hacemos aposta para liar.

Usar AUCTeX es bastante sencillo, hay un par de atajos de teclado que valen para casi todo y que os listo aquí. La palabreja que pongo en cursiva es con lo que yo relaciono la combinación de teclas para acordarme (que puede o no ser la  idea del autor original).

  • C-c C-c (compile) ejecuta una orden, dando a TAB podemos ver las opciones, hay opciones molonas como Clean all y Clean que eliminan respectivamente todo lo creado por la compilación y solo los archivos auxiliares.
  • C-c C-v (view) muestra el resultado.
  • C-c C-e (environment) introduce un entorno y te va pidiendo los datos que necesite.
  • Si tenemos el activado el parser automático, con C-c C-a (all) deduce qué tiene que usar y compila las veces que haga falta. No viene activado por defecto porque tarda un poco. Esta historieta nos fabrica una carpeta `auto` con cosas dentro, no os asustéis como hice yo. En el archivo de configuración que he puesto más abajo podéis ver cómo se activa.

Como hereje del Emacs que soy os voy a decir algo: no hace falta aprenderse todo esto. Utilizad la GUI y los menús desplegables sin pudor alguno (yo lo hago, un botón tiene un leoncito muy cuqui).

Embellecedores

AUCTeX tiene herramientas interesantes para que nos resulte más sencillo escribir y entender lo que hemos escrito. Lo que yo llamo embellecedores son sus capacidades de sustituir las letras griegas y otros símbolos con su equivalente Unicode (prettify) y de escribir la letra que está entre etiquetas de formato con el formato en sí (fontify).

Así, cuando escribimos \omega nos pone una ω, si escribimos \emph{cosa en cursiva}, nos escribe el texto en cursiva y demás. Creo que la parte de cambiar la fuente viene activada por defecto pero para los símbolos hay que llamar al modo prettify-symbols-mode.

Tiene además un montón de opciones para previsualizar trocitos de documento, aunque yo no las uso porque estoy muy acostumbrada a escribir en LaTeX y generalmente no la organizo estoy acostumbrada a compilar y mirar los errores en el log por otros editores que he utilizado.

Doblado

Otra cosa que nos ayuda a la hora de leer lo que hemos escrito es el doblado (folding) que consiste en ocultar etiquetas como \section o \emph dejando solamente el texto con el formato.

Si activamos el modo de doblado con M-x TeX-fold-mode y hacemos C-c C-o C-b nos quita el barullo y nos deja un documento mucho más sencillo de leer. Haciendo click o entrando sobre el ítem doblado con el puntero vuelve a mostrarse como LaTeX.

Como esta herramienta me encanta, hago que Emacs me la active siempre cuando uso AUCTeX, más abajo en el archivo de configuración pone cómo lo he hecho.

Autocompletado

Esto ha sido sin duda lo más difícil de configurar, probablemente porque soy una novata del Emacs1 y pego cosas sin sentido en el archivo de configuración. Después de hurgar en diferentes modos y destruir, me he quedado con la variante para AUCTeX de Company mode que se llama contra todo pronóstico Company AUCTeX.

Para que me funcione tengo que activar  company-mode y luego evaluar (company-auctex-init) así que he puesto eso en el archivo de configuración, probablemente haya maneras mejores.

En fin, dejando a un lado la configuración, esto sirve para que según vayas escribiendo las órdenes Emacs te de sugerencias.

Buffer de Emacs con funcionamiento de company-auctex: al escribir \app predice appendix, approx y approxeq

En la imagen se ven además las variables locales que me ha escrito AUCTeX. Ese TeX-master: t significa que este archivo es el archivo maestro, algo muy útil cuando estamos usando subdocumentos, ya que podemos mandar la orden de compilar desde cualquiera de ellos y AUCTeX sabrá cuál es el maestro. Esto me aparece ahí porque le digo en el archivo de configuración que me pregunte la primera vez que compilo cuál es el archivo maestro con (setq-default TeX-master nil).

Otras magias

Este modo hace muchas más cosas, por ejemplo, M-RET al final de línea en un entorno predice lo que necesitamos en la línea siguiente, probadlo en las tablas, vais a ver.

He instalado además el paquete latex-extra para poder abrir y cerrar los títulos como hago en Org.

RefTeX

Estoy usando además RefTeX en combinación con AUCTeX para manejar las referencias y las citas. Este modo lo escribió el creador de Org y es utilísimo para las académicas como yo.

Os pongo un par de atajos que se aprenden rápido por la lógica que se usa generalmente al referenciar en el mundillo (referencias a algo del propio documento entre paréntesis y a la bibliografía entre corchetes):

  • C-c = crea un índice que nos permite navegar rápidamente por el documento.
  • C-c ( crea una etiqueta (\label)
  • C-c ) inserta una referencia (`\ref`) a una etiqueta previamente definida
  • C-c [ hace una referencia a una referencia bibliográfica (`\cite`). Dando a la combinación de teclas y escribiendo el nombre de un autor o autora busca en el archivo de bibliografía definido en `\bibliography` y muestra diferentes opciones. A mí al principio me funcionó raro y solo me dejaba buscar la palabra anterior a donde tecleaba la combinación.

Tiene muchas más opciones pero yo tengo un tiempo de vida limitado.

 

Archivo de configuración

Añadiendo todas las cosas que he comentado, la parte de AUCTeX del archivo de configuración me queda así:

;; Activar CDLaTeX
(add-hook 'LaTeX-mode-hook 'turn-on-cdlatex)
;; Activar prettify
(add-hook 'LaTeX-mode-hook 'prettify-symbols-mode)

;; Autocompletar
(add-hook 'LaTeX-mode-hook (lambda ()(company-mode 1)))
(company-auctex-init)

;; Pide archivo maestro, para documentos con subdocumentos
(setq-default TeX-master nil)

;; Parser automático
(setq TeX-parse-self t) ; activar el parser al cargar
(setq TeX-auto-save t) ; activar el parser al guardar

;; Fold por defecto
(add-hook 'LaTeX-mode-hook (lambda ()(TeX-fold-mode 1)))

;; Activar RefTeX
(add-hook 'LaTeX-mode-hook 'turn-on-reftex)
(setq reftex-plug-into-AUCTeX t)

;; LaTeX extra para tener doblado de secciones como Org
(add-hook 'LaTeX-mode-hook #'latex-extra-mode)

Estoy muy contenta. hay que saber de LaTeX para sacarle partido, pero es maravilloso. Hasta he grabado un minivídeo para que se viesen algunas de las cosas de las que hablo2:

Lo único raro que me ocurre es que no me cierra los paréntesis. Los corchetes, las llaves y los dólares sí, el problema solo es con los paréntesis.

Si fuera perfecto no sería divertido.

Referencias

Manual de AUCTeX

Chuleta de AUCTeX (pdf)

What is your favorite Emacs and/or AUCTeX command/trick? en TeXExchange

Manual de RefTeX

How can I make AUCTeX use the spelling dictionary in the same language as babel is loaded with? en TeXExchange

Useful shortcuts or key bindings or predefined commands for emacs+AUCTeX en TeXExchange

Company AUCTeX

Company mode

Actualización (21/03/2019)

En Vim se puede hacer más o menos lo mismo, tenéis un ejemplo en el flujo de trabajo de este chico para coger apuntes


Sonando este homenaje a Cantona, un futbolista que tiene los nada desdeñables méritos de salir en una película de Ken Loach, decirle a la peña que sacase su dinero del banco para hacer caer el sistema y darle una patada voladora en la boca a un racista.


  1. Me estoy leyendo los artículos de Notxor sobre Elisp y pronto sabré lo que hago ¡JA! ↩
  2. Y esta en Archive, que te den Google↩
-1:-- Lo que he aprendido: AUCTeX (Post Ondiz)--L0--C0--February 07, 2019 12:00 PM

Bad Daemons: Doom: un framework para configurar emacs

Emacs es seguramente la tecnología a la que más tiempo de estudio le he dedicado (y dedico) desde que empezó mi interés por los ordenadores. Y si algo he sacado en claro es que, dado mis otros intereses, nunca le dedicaré el tiempo a mi configuración personal que se merece. Lo he hecho durante mucho tiempo y lo seguiré haciendo, pero he decidido que no lo haré “a pelo”, sino que usaré ciertas facilidades que da doom.

Qué es doom? En realidad es la configuración de emacs de hlissner. Este humano quería usar emacs con los atajos de vim y quería que emacs se pareciese a un IDE moderno. Además, decidió que quería que la gestión de este fuese mediante la terminal.

Las características principales que tiene son:

  • Un Makefile para gestionar la instalación de paquetes, actualización y otros
  • Gestión de paquetes declarativa mediante def-package, un wrapper para use-package y quelpa
  • Un gestor de popups mediante shackle
  • Atajos de teclado de vim con evil-mode
  • Completado de código mediante company-mode
  • Gestión de proyectos mediante projectile
  • Workspaces mediante persp-mode
  • Es bonito
  • Arranca rápido (a día de hoy tengo 300 paquetes y ha tardado 4 segundos en arrancar)

Quien ya use estos programas, puede que piense que es una tontería, que no aporta nada. Pero la principal característica, que no mencionan en la página del proyecto es que alrededor de todos estos paquetes mencionados, hay wrappers que hacen que se integren entre ellos. Veremos más adelante a que me refiero.

La característica que más me gusto fue la de workspaces. Ahora solo tengo que ejecutar projectile-switch-project y el proyecto que abra, se abrirá en un workspace nuevo, sin que los buffers que abra se mezclen con los que ya tengo abiertos. Un video vale más que mil palabras.

En este video se puede ver que en el primer workspace, abro el proyecto de mi página web. En el segundo, en cambio, abro uno gestión de infraestructura con ansible. Y ambos están separados, cuando en cada uno de ellos ejecuto find-file, me muestra solo los ficheros de ese proyecto

Para probarlo rápidamente, se puede ejecutar lo siguiente:

git clone https://github.com/hlissner/doom-emacs ~/.emacs.d
cd ~/.emacs.d
cp init.example.el init.el
make install
emacs

En adelante mi configuración estará en este repositorio. Dado que hay muchos cambios respecto a como lo tenia antes, prefiero crear un repositorio nuevo y mantener el antiguo como referencia.

-1:-- Doom: un framework para configurar emacs (Post )--L0--C0--February 04, 2019 09:11 PM

Podcast uGeek: GNU-Linux, Emacs,.. ¿porqué?

GNU-Linux, Emacs,.. ¿porqué?

GNU-Linux, Emacs,.. ¿porqué?...

Sigue leyendo el post completo de GNU-Linux, Emacs,.. ¿porqué?

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- GNU-Linux, Emacs,.. ¿porqué? (Post )--L0--C0--November 21, 2018 08:53 PM

uGeek: Kde Connect en Emacs

Por culpa del Podcast de atareao.es, he estado probando Kde Connect y la verdad es que ha pasado a ser una aplicación imprescindible en mi día a día. Tal como explica en su Podcast, existe la posibilidad de utilizarla con Emacs y como podéis imaginar, no me he podido resistir a probarla. Os explico como utilizarla:

Teniendo los repositorios de Melpa:

  1. Instalación: M-x package-install RET kdeconnect
  2. Listamos los dispositivos de nuestra red local: M-x kdeconnect-list-devices
  3. Buscamos los búfer anteriores para copiar los id de nuestros dispositivos (C-x Izquierda)
  4. Introducimos el id de nuestro dispositivo: M-x kdeconnect-select-active-device RET id
  5. Hacemos un ping para comprobar que se ha conectado correctamente: M-x kdeconnect-ping

YA ESTA!!!

Ahora si copiamos un texto en el portapapeles de nuestro Emacs, podremos pegarlo en el otro dispositivo gracias a Kde Connect.

Vamos a enviar un texto desde Emacs al otro dispositivo M-x kdeconnect-ping-msg RET Texto

Os dejo el resto de funciones para que juguéis y el repositorio donde está toda la información:

Resto de Funciones disponibles

Función Descripción
kdeconnect-get-active-device Mostrar el dispositivo activo
kdeconnect-list-devices Muestra todos los dispositivos visibles, incluso los no disponibles.
kdeconnect-ping Enviar una notificación al dispositivo activo.
kdeconnect-ping-msg Envía una notificación con un mensaje personalizado al dispositivo activo
kdeconnect-refresh Escanee la red y actualice las conexiones disponibles
kdeconnect-ring Hacer que suene el dispositivo activo (útil para encontrarlo)
kdeconnect-select-active-device Seleccione el dispositivo activo de kdeconnect-devices
kdeconnect-enviar-archivo Enviar el archivo seleccionado al dispositivo activo
kdeconnect-enviar-sms Enviar un SMS al destino especificado

Repositorio de GitHub

Publicado por Angel


Suscribete al Blog

Suscribete al Podcast

Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

YouTube

Escucha más Podcast en el Reproductor de la web ►Play

Tags: , blog , emacs , kdeconnect ,

<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
-1:-- Kde Connect en Emacs (Post )--L0--C0--November 02, 2018 12:00 AM

uGeek: Convertir de Markdown a Org Mode gracias a Pandoc

Vamos a convertir nuestros archivos Markdown a Org Mode gracias a Pandoc. Para ello, primero necesitamos instalar Pandoc en nuestro Ubuntu:

sudo apt install pandoc

Ahora tenemos 2 posibilidades, transformar únicamente un archivo .md a .org, o aprovechando la magnífica gestión de los archivos Org Mode, convertir todos los archivos Markdown de una carpeta a un único archivo Org Mode.

1) Markdown a Org Mode. Ejecutamos este comando en la terminal.

pandoc -f markdown -t org -o nuevo_archivo.org archivo_a_convertir.md

2) Muchos archivos Markdown a un único Org Mode.

Vamos a la carpeta donde están todos los Markdown que queremos convertir y Llamamos a find vía Pandoc:

find . -name \*.md -type f -exec pandoc  -f markdown -t org -o {}.org {} \;

Recordar verificar que la conversión se ha hecho correctamente.

Publicado por Angel


Suscribete al Blog

Suscribete al Podcast

Canal en Telegram

Grupo en Telegram

uGeekPodcast en Twitter

YouTube

Escucha más Podcast en el Reproductor de la web ►Play

Tags: , blog , emacs , markdown , orgmode , pandoc ,

<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
-1:-- Convertir de Markdown a Org Mode gracias a Pandoc (Post )--L0--C0--November 01, 2018 12:00 AM

Podcast uGeek: Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3

Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3

Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3...

Sigue leyendo el post completo de Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3 (Post )--L0--C0--October 29, 2018 07:06 PM

La Pipa Plena: Curso emacs 32. Actualizaciones, maps, suggest y envios

Como ya hemos vistos anteriormente, desde la versión 24 de Emacs se puede instalar paquetes de forma tan simple a como se hace en cualquier distribución GNU/Linux (M-x package-install RET paquete) y naturalmente también disponemos de lo que en las distros derivadas de Debian tenemos como upgrade. Para programar la actualización de todas las funciones … Sigue leyendo Curso emacs 32. Actualizaciones, maps, suggest y envios
-1:-- Curso emacs 32. Actualizaciones, maps, suggest y envios (Post la pipa plena)--L0--C0--October 22, 2018 01:45 PM

nba - GNU's Rock: temax

sucede que haciendo una prueba con el vps conectado via ssh queria dejar corriendo un comando

> youtube-dl -f best -ciw -v 'https://www.youtube.com/channel/UCbGYYbuGLFC6wIsyKXXW4cQ'

y salir de la sesion, dejando al vps a su bola, p-e-r-o, p-e-r-o, p-e-r-o si sales de la sesion ssh, tu comando tambien se corta

y esto no se soluciona poniendo un & al final del comando, por que este (supongo y sin idea) “proceso” es un “hijo” de tu shell que es un hijo de tu sesion y si la sesion se muere, el padre mata a todo mundo. Ja, ja, ja, ha

Como solucionar esto? pues teniendo un shell que sea “hijo de un demonio😈” que ande a su bola, e invocarlo cuando nos venga en gana

y todo esto que suena tan complicado y misterioso, es mas facil de lo que parece (creo). Encima podemos hacerlo con emacs, aunque igual, segun la situacion podriamos recurrir a otros dos programitos habitualmente disponibles en cualquier distribucion

emacs

emacs tiene un modo demonio que sirve para dos cosas:

  • cargar emacs una vez y luego lanzar instancias que comparten la misma sesion pero se manifiestan a la velocidad del rayo

  • volver independiente tu sesion de una shell, fuera esta en ssh o en modo texto o grafico

primero, para activar el modo demonio lanzamos el siguiente comando

> emacs --daemon

esto no lanzara ningun emacs, simplemente colocara bajo las sombras una sesion con la que podremos contactar. Para hacer esto necesitamos un comando particular llamado emacsclient. Como la mayoria de las cosas, no es tan sencillo. Si lo lanzamos tal cual

> emacsclient
emacsclient: file name or argument required
Try 'emacsclient --help' for more information

nos dira que intentemos ver la ayuda. Si bien, esta ayuda es basta, podriamos simplificarla a dos opciones utiles

> emacsclient -c

que nos lanza emacs en el buffer scratch.

dejemos una marca en dicho buffer para identificar nuestros pasos. Colocando por ejemplo, la frase "hola soy emacsclient uno"

bien, terminemos emacs como se haria habitualmente C-x C-c e invoquemos de nuevo a nuestro emacs-demonio emacsclient -c -nw

hala, nuestro mensaje sigue hay!

ahora en nuestra terminal (tilix) dividida, lanzamos de nuevo emacsclient -c -nw

de nuevo lo mismo

y si cerramos uno o todos los emacsclient da igual, lo que en ellos hagamos permanecera mientras no se apague el sistema o cerremos el modo demonio

la otra forma en la que podemos lanzar emacsclient, consiste en indicar que ficheros abrir

> emacsclient fichero1 fichero2 ...

y ahora con esto, podriamos resolver el problema inicial. Abrimos una shell, ponemos el comando a ejecutar, salimos (C-x C-c), cerramos el ssh y regresamos cuando lo creamos conveniente. El demonio de emacs con todos sus buffers y demas cosas, seguira realizando su labor!

y ahora? pues para terminar con el modo demonio, desde un emacsclient

M-x server-mode

nos dira que actualmente hay un servidor con clientes, que si lo queremos terminar de todas maneras, a lo que diremos que si.

cosas

emacs es un entorno centrado en el texto, que puede dividirse, expandirse y adaptarse de formas inimaginables, sin embargo, una terminal pura donde ejecutar programas visuales e interactivos escritos cada uno en su lenguaje, con sus propias librerias y forma de entender sus combinaciones de teclado, igual y queda en otra liga mas alla de los fines de emacs

tambien, aunque emacs posee su propia terminal (tonta) eshell, lo mejor es lanzar programas no interactivos. Ademas eshell, sola hay una y solo una, Emacs no es multiproceso, o hace una cosa o hace otra, pero no dos al mismo tiempo. Si lo que necesitamos son varias shell reales, lo mas conveniente seria recurrir a otras herramientas

GNU Screen

esto es un multiplexor de terminal, que segun la wikipedia:

es una aplicación de software que puede utilizarse para varias sesiones de inicio de sesión independientes basadas en seudoterminales dentro de una única pantalla de terminal, una ventana de emulador de terminal, una consola de sistema de PC/puesto de trabajo o una sesión de inicio de sesión remota, o para separar y volver a adjuntar sesiones de un terminal. Es útil para tratar con múltiples programas desde una interfaz de línea de comandos, y para separar programas de la sesión de la shell de Unix que inició el programa, particularmente para que un proceso remoto continúe ejecutándose incluso cuando el usuario está desconectado.

pero que en resumidas palabras, podria resumirse en un “emacs” para las terminales o como “un entorno de escritorio para las terminales”

y que podemos hacer con esto? tras instalar gnu screen (buscarlo como screen en su distribucion) y lanzarlo por primera vez

> screen

nos resivira con un bonito mensaje

tras presionar espacio, aparecera el prompt de nuestra shell de siempre, donde lanzar los comandos de siempre

bien no? pues si… a-u-n-q-u-e, cuando salimos de la terminal, no salimos de la terminal, saldremos de la terminal en screen

[screen is terminating]

volvamos a lanzarla de nuevo y veamos como demonios (ja, ja, que cachondo) utilizar este invento

primero, screen tiene algunas influencias emacseras, y como este, tiene un prefijo para hacer cosas, que por defecto es C-a (Control y a al mismo tiempo) seguido por una (o mas) combinaciones que serian el comando en si, por ejemplo, si presionamos C-a d saldremos de screen pero sin cerrar screen, que seguira en “segundo plano” a su rollo, rollo al que podemos regresar

como hacer esto? no es tan sencillo, primero deberemos averiguar el nombre de nuestra “sesion” y re-enlazar a ella

mientras haciamos el C-a d nos lanzaba la siguiente salida

[detached from 6469.pts-3.tachikoma]

un dato similar podemos obtenerlo con el siguiente comando

> screen -ls
There is a screen on:
	6469.pts-3.tachikoma	(Detached)
1 Socket in /run/screens/S-nasciiboy.

donde el dato importante es ese que va luego del punto del numero, hasta el primer espacio, es decir (y en este caso particular) pts-3.tachikoma. Dicho valor nos servira para recuperar la sesion

> screen -x pts-3.tachikoma

bonito no? ehhhh, mas o menos. Salgamos sin cerrar e iniciemos una nueva sesion con un nombre mas sencillo

> screen -S mi-sesion

de nuevo, tendriamos otra terminal…

repitiendo el listado de sesiones

> screen -ls
There are screens on:
	7832.mi-sesion	(Detached)
	6469.pts-3.tachikoma	(Detached)
2 Sockets in /run/screens/S-nasciiboy.

guaaa, que emocionante…

para contactar a esta nueva sesion

> screen -x mi-sesion

y? pues ahora un par de cosas medio chulas, primero podemos dividir la pantalla ¡en dos! presionando C-a S

luego puedes saltar a esta nueva division con C-a TAB. Ver el cursor en esta nueva seccion, apretar los botones a lo loco y ver que no pasa nada

hasta que invoques una shell en este espacio con el comando magico C-a c

dividir nuevamente la ventana (ahora en vertical) C-a |, saltar a esta C-a TAB, nueva shell C-a c y sonreir locamente

ahora como cerrar este conjunto, si salimos de la shell (C-d o con exit) la seccion no desaparecera, seguira hay hasta que presionemos C-a X

si por alguna razor quisieramos cambiar el prefijo C-a por otro distinto, por ejemplo C-b, tenemos dos opciones crear un fichero .screenrc en nuestro home con el contenido

escape ^Bb

con lo que el comando prefijo quedaria fijado a C-b por siempre jamas, o bien, lanzar screen de la siguiente manera

> screen -e^bB

y pocas cosas mas puedo comentar sobre screen y sus fabulosas cualidades. Para mas informacion dentro de la misma sesion presionar c-a ? invoca a la ayuda. tambien podriamos ver la pagina del manual

tmux

y… tmux es mas o menos como screen, tambien va a su rollo y puede sobrevivir al cuelgue de una sesion ssh, tiene combinaciones “tipo emacs” y sirve de “entorno de escritorio para las terminales”, p-e-r-o, p-e-r-o, p-e-r-o, por defecto es algo mas amigable y 🌈moderno🌈 (1987 vs 2007) aunque ambos estan escritos en c

y cual escogeria screen o tmux? pues, tmux! aunque si hay necesidad, se usar los dos!

y ahora, como usarlo

> tmux

como vemos, a diferencia de screen, tmux se nos comera una fila al final de la pantalla, muy a lo emacs. Otra diferencia particular, empieza por el prefijo, que en lugar de ser C-a pasa a ser C-b (y encuentro mas comodo). Ademas de eso al dividir la pantalla en sus diferentes formas

  • C-b " division horizontal
  • C-b % division vertical

aparecera una shell sin hacer nada mas

podemos deambular por las “divisiones” con

  • C-b o saltar a la siguiente
  • C-b ← saltar a la derecha
  • C-b ↑ saltar arriba
  • C-b → saltar a la derecha
  • C-b ↓ saltar abajo
  • C-b C-← redimencionar hacia la derecha
  • C-b C-↑ redimencionar hacia arriba
  • C-b C-→ redimencionar hacia la derecha
  • C-b C-↓ redimencionar hacia abajo

tambien centrar la atension en la shell actual sin romper la distribucion de las ventanas con C-b z (zoom) y luego restaurar con otro C-b z

o incluso y mas locochon, hacer que las shells cambien de sitio con C-b C-o

o hacer aparecer un reloc ascii gigante con C-b t

u otras cosas mas chulas como agregar “nuevos escritorios” con C-b c

e ir y venir entre escritorios con

  • C-b n siguiente
  • C-b p anterior
  • C-b 0, C-b 1 C-b …, escritorio 0, escritorio 1, …

o C-b w, que nos permite elegir visualmente

salir de esta secion sin cerrarla con C-b d y recuperarla con tmux attach

tambien, podriamos no salir de dicha sesion e ingresar en ella desde otra terminal, repitiendo tmux attach

que hace una cosa muy chula; adaptarse y limitar lo que se ve en la sesion con las dimenciones de la mas pequeña. Ademas, como en screen podemos darle un nombre a una sesion y vincularnos a ella

> tmux new-session -s mi-sesion # lanzar
> tmux attach -t mi-sesion      # conectar
> tmux list-sessions            # listar sesiones

esto y muchas cosas mas que pueden o no ser de interes, empiezan consultando la ayuda incluida C-b ?, su pagina man o si se desea un librillo con comentarios

https://leanpub.com/the-tao-of-tmux/read

aunque creo que el nombre “the tao of” le viene grande, pues no enseñan un flujo o estrategia de trabajo. Solo comandos con imagenes, que puedes descubrir por tu cuenta, como el obscuro proceso para congelar la pantalla, seleccionar texto y pegarlo en donde se nos ocurra aun sin sesion grafica!

en fin, yo estoy utilizando tmux para dejar corriendo en el servidor comandos de prolongado tiempo y tambien para ejecutar weechat “acumulando logs” por dias y dias en salas de irc… mera investigacion de la fauna…

happy hacking!

-1:-- temax (Post )--L0--C0--September 20, 2018 07:03 PM

MGallego: Ejecutando Test de PHPUnit en Emacs

phpunit logo

Hace un tiempo que dejé de usar php+-mode, mas que nada porque parece que lo han sacado de Melpa y me gusta tenerlo todo actualizado, así que decidí volver a php-mode, un modo que no usaba ya que php+-mode me parecía mas completo.

En php+ tenías proyectos donde podías configurar muchas cosas, como por ejemplo los tests, cosa que con php-mode no se puede, el tema es que para lo de los proyectos hace mucho que uso projectile, un modo imprescindible para programar, pero me faltaba la integración de phpunit. Por suerte tenemos phpunit.el una libreía con la cual podremos ejecutar nuestros tests.

Yo he tenido que añadir alguna cosa en mi configuración que no viene en la documentación oficial, como por ejemplo que coja el ejecutable de phpunit de una ruta de mi carpeta, si vosotros lo tenéis en el path del sistema no creo que tengáis problemas.

Pues bien, esta es toda la configuración que he tenido que añadir a mi fichero de configuración:

  (use-package phpunit
    :ensure t
    :config
    (add-hook 'php-mode-hook (lambda ()
                             (setq phpunit-default-program (concat (projectile-project-root) "bin/phpunit"))
                             ))
    )

Esto es lo que hace la configuración:

  • Hace que use-package se descargue el modo y lo instale. Si no usáis use-package deberíais echarle un ojo porque es bastante útil.
  • Añade un hook para que cuando entremos en modo php saque la ruta del ejecutable de phpunit usando la ruta del proyecto en el que nos encontramos.

Esto último me dio algunos problemas, ya que no se me había ocurrido ejecutarlo en el hook y se ejecutaba en la propia configuración, que al estar versionada con git pues también la tengo como proyecto.

Con esto ya podremos usar las funciones del modo phpunit, que podréis encontrar en su documentación. Lo suyo es que os las asignéis a alguna combinación de teclas, yo tengo que F2 me ejecute el test en el que me encuentro posicionado y F3 me ejecuta todos los tests de la clase.

  (global-set-key[f2] 'phpunit-current-test)
  (global-set-key[f3] 'phpunit-current-class)

Los tengo globales, porque es como los usaba en php+-mode, es algo que aún tengo pendiente de cambiar, en esos refactors infinitos que hacemos durante toda nuestra vida en la configuración de emacs.

Recursos

-1:-- Ejecutando Test de PHPUnit en Emacs (Post )--L0--C0--September 14, 2018 03:30 PM

MGallego: Usando Emacs Como Cliente De Correo

Una de las cosas que siempre he tenido ganas pero me ha dado mucha pereza ponerme a hacer ha sido configurar el correo para gestionarlo a través de emacs. Hace un par de días decidí dar el paso, hoy lo he estado probando y ha merecido la pena el esfuerzo

Aquí están todos los pasos que he tenido que dar para configurar una cuenta de Gmail en Emacs y en Debian.

Offlineimap

Lo primero que necesitamos es un cliente de imap. Este cliente será el que se encargue de actualizar nuestra cuenta de gmail, sincronizando los cambios entre nuestro local y el servidor de Google. Para eso he instalado offlineimap

sudo apt-get install offlineimap

Después de descargar el programa debemos configurarlo de la siguiente manera, comenzaremos creando un fichero de configuración en: ~/.offlineimaprc

El contenido del fichero es el siguiente. Esta es la configuración básica que he encontrado en los ejemplos, de aquí deberemos cambiar el usuario del email, en el ejemplo está como usuario@gmail.com. Importante fijarse que está en dos lineas.

También podremos cambiar la carpeta donde queramos que se descargue el correo. El password como podéis ver no está añadido, ese es el siguiente paso.

[general]
accounts = Gmail
maxsyncaccounts = 1
pythonfile = ~/.offlineimap.py

[Account Gmail]
localrepository = Local
remoterepository = Remote

[Repository Local]
type = Maildir
localfolders = ~/Maildir

[Repository Remote]
type = Gmail
remoteuser = usuario@gmail.com
remotepasseval = get_password_emacs("imap.gmail.com", "usuario@gmail.com", "993")
realdelete = no

folderfilter = lambda foldername: foldername not in ['[Gmail]/Spam', '[Gmail]/All Mail', '[Gmail]/Starred', '[Gmail]/Important']

holdconnectionopen = true
keepalive = 60
sslcacertfile = /etc/ssl/certs/ca-certificates.crt

Para no tener que guardar el password en texto plano en nuestra configuración de offlineimap debemos crear un par de ficheros mas y hacer alguna cosilla. Empezaremos por crear un fichero ~/.offlineimap.py con el siguiente contenido dentro:

#!/usr/bin/python
import re, os

def get_password_emacs(machine, login, port):
    s = "machine %s login %s port %s password ([^ ]*)\n" % (machine, login, port)
    p = re.compile(s)
    authinfo = os.popen("gpg -q --no-tty -d ~/.authinfo.gpg").read()
    return p.search(authinfo).group(1)

Del fichero .py no hay que tocar nada, simplemente se encarga de leer un fichero que crearemos ahora donde se encontrará la contraseña.

El siguiente paso es crear el fichero ~/.authinfo, en este fichero deberemos introducir lo siguiente, cambiando usuario@gmail.com por nuestro usuario y aquivaelpassword por nuestra contraseña.

machine imap.gmail.com login usuario@gmail.com port 993 password aquivaelpassword
machine smtp.gmail.com login usuario@gmail.com port 587 password aquivaelpassword

Y ahora viene el encriptado del fichero, ya que si lo dejamos así estaría en texto plano.

El cifrado lo realizaremos desde emacs, ejecutando el siguiente comando y seleccionado el fichero .authinfo que acabamos de crear.

M-x epa-encrypt-file

Esto nos generará un fichero ~/.authinfo.gpg, una vez creado debemos eliminar el original.

Y con esto ya tenemos configurado nuestro imap lo siguiente sería sincronizar con el siguiente comando y tomarnos algo mientras tanto, porque tardará bastante.

$ offlineimap

¿Qué pasa si tengo doble factor de autenticación en mi correo?

Posiblemente tendréis habilitado un segundo factor de autenticación en vuestra cuenta, en ese caso no podréis usar vuestra contraseña, para solucionar eso tenemos dos opciones:

  • Crear una aplicación Oauth en Google y usarla con offlineimap. Esta opción no la he probado, así que no se como se haría, si que he visto algún post comentando como se hace.
  • Crear un pasword de aplicación para el correo electrónico desde vuestra cuenta de google y usarlo como password. Aquí teneis como se realiza.

He visto quien desaconseja esta última opción ya que sería como quitar el doble factor de autenticación y recomiendan usar el token de Oauth. Mi impresión es que estaríamos en las mismas, ya que el password de aplicación tiene también la opción de cancelarlo y así invalidar esa aplicación.

Posible error con gpg

Al ejecutar todo el proceso en otra máquina me encontré con el siguiente error a la hora de ejecutar offlinimap: gpg: Sorry, no terminal at all requested - can't get input

La solución mas sencilla que he encontrado ha sido cambiar en el script de Python gpg por gpg2. Quizás antes tengais que instalarlo, en Debian sería con apt-get install gnupg2 y habría que dejar el script ~/.offlineimap.py de la siguiente manera:

#!/usr/bin/python
import re, os

def get_password_emacs(machine, login, port):
    s = "machine %s login %s port %s password ([^ ]*)\n" % (machine, login, port)
    p = re.compile(s)
    authinfo = os.popen("gpg2 -q --no-tty -d ~/.authinfo.gpg").read()
    return p.search(authinfo).group(1)

Creando el indice

Una vez ya ha terminado offlineimap de sincronizar debemos indexar, para ello nos hará falta mu, como también nos hará falta mu4e lo instalamos e indexamos.

sudo apt-get install mu4e

mu index --maildir=~/Maildir

Cron

Lo siguiente que he hecho y que mas me ha costado encontrar es como hacer estas tareas cada X tiempo, no por que sea complejo si no porque no he visto nada relacionado. Yo he decidido crear un cron que lo ejecute cada 5 minutos.

crontab -e

Y como contenido:

*/5 * * * * offlineimap -u quiet && mu index --maildir=~/Maildir

Envío de correos

Para envíar los correos desde emacs hace falta instalar lo siguiente en Ubuntu/Debian

sudo apt-get install gnutls-bin

Configurando Emacs

Aún no he tocado demasiado, estoy aún aprendiendo el modo mu4e, así que esta configuración es opcional. Dejo aquí la mía como ejemplo.

Imap

       (require 'mu4e)

       ;; default
       (setq mu4e-maildir (expand-file-name "~/Maildir"))

       (setq mu4e-drafts-folder "/[Gmail].Borradores")
       (setq mu4e-sent-folder   "/[Gmail].Enviados")
       (setq mu4e-trash-folder  "/[Gmail].Papelera")

       ;; don't save message to Sent Messages, GMail/IMAP will take care of this
       (setq mu4e-sent-messages-behavior 'delete)

       ;; setup some handy shortcuts
       (setq mu4e-maildir-shortcuts
             '(("/INBOX"             . ?i)
               ("/[Gmail].Enviados" . ?s)
               ("/[Gmail].Papelera"     . ?t)))

       ;; allow for updating mail using 'U' in the main view:
       (setq mu4e-get-mail-command "offlineimap")

       (setq
        user-mail-address "usuario@gmail"
        user-full-name  "Nombre Apellido"
       )

SMTP (envío)

    (require 'smtpmail)

    (setq message-send-mail-function 'smtpmail-send-it
          starttls-use-gnutls t
          smtpmail-starttls-credentials
          '(("smtp.gmail.com" 587 nil nil))
          smtpmail-auth-credentials
          (expand-file-name "~/.authinfo.gpg")
          smtpmail-default-smtp-server "smtp.gmail.com"
          smtpmail-smtp-server "smtp.gmail.com"
          smtpmail-smtp-service 587
          smtpmail-debug-info t)

Alertas

Nos pintará en nuestra barra un sobrecito con el número de correos sin leer, lo ejecutará cada minuto y además mostrará alertas del sistema.

  (use-package mu4e-alert
    :ensure t
    :after mu4e
    :init
    (setq mu4e-alert-interesting-mail-query
      (concat
       "flag:unread AND maildir:/INBOX AND NOT flag:trashed "
       ))
    (mu4e-alert-enable-mode-line-display)
    (defun gjstein-refresh-mu4e-alert-mode-line ()
      (interactive)
      (mu4e~proc-kill)
      (mu4e-alert-enable-mode-line-display)
      )
    (run-with-timer 0 60 'gjstein-refresh-mu4e-alert-mode-line)
    )

Como podéis ver este código por ahora es prácticamente copiado y pegado de las fuentes, como he dicho aún no he tenido tiempo de tocarlo demasiado y quizá tampoco me haga falta.

mu4e

Pues poco puedo contar de este modo, aún tengo que aprender a manejarlo bien. Si ejecutáis en emacs M-x mu4e os mostrará un pequeño dashboard donde podréis comenzar a usarlo, con documentación incluida.

Conclusión

Solo llevo un día de uso y me ha resultado muy útil, sobre todo para hacer limpieza de correos. Me costó un poco configurarlo todo, pero una vez conseguido ha merecido mucho la pena.

Una recomendación que me gustaría daros es que no uséis gmail, en este caso lo hice porque es el correo del trabajo, podéis usar cualquier correo que acepte IMAP y SMTP y seguramente con algún protocolo mas también. Os dejo con un listado de servicios y herramientas que si tienen en cuenta la privacidad del usuario, ahí podréis encontrar buenos servicios de email.

Cualquier duda puedes preguntarme por gnusocial.net.

Fuentes

-1:-- Usando Emacs Como Cliente De Correo (Post )--L0--C0--September 07, 2018 06:44 PM

La Pipa Plena: Curso emacs 31. Recordatorio de cositas varias, zone, dissociated-press, spook

Si queremos ver un listado de extensiones instaladas: C-h v package-activated-list Si queremos un buffer scratch persistente (que se guarde y restaure con una nueva sesión) colocar en el archivo de configuración .emacs: (persistent-scratch-autosave-mode 1) Si precisamos de un calculo simple que se muestra en el minibuffer y cuyo resultado se guarda y puede pegarse … Sigue leyendo Curso emacs 31. Recordatorio de cositas varias, zone, dissociated-press, spook
-1:-- Curso emacs 31. Recordatorio de cositas varias, zone, dissociated-press, spook (Post la pipa plena)--L0--C0--August 26, 2018 08:58 AM

nba - GNU's Rock: elipo

Recuerda, “No tiene que gustarte Emacs para que te guste”––Emacs puede tener diferentes colores, diferentes comandos y diferentes atajos que el Emacs por defecto. {AItPiEL}

An Introduction to Programming in Emacs Lisp

git clone https://gitlab.com/nasciiboy/elipo.git
# o
git clone https://notabug.org/nasciiboy/elipo.git

para descarga en formato zip, tar, o bien visionar directamente en version web en ingles y español

“Una introducción a la programación en Emacs Lisp” es una guia turistica por los conceptos basicos de la programacion, recorriendo las entrañas mas emblematicas en “las fuentes” de GNU Emacs, el “editor extensible”.

El documento es un primer acercamiento gentil, mas o menos claro y muy reiterativo a Emacs Lisp, que a un iniciado en la programacion deseoso por utilizar el verdadero potencial de emacs le vendra de maravilla. Menciono que a un iniciado, por que asi es mi caso, y me costaria recomendarlo como primer libro de programacion. Aun asi, utiliza buenas analogias e introduce los conceptos base de forma tan gradual como para no descartarlo (por completo) como libro novel.

A lo largo del material, aprenderemos ademas de los fundamentos de la programacion (variables, bucles, recursividad, funciones, …, listas), a crear atajos personalizados para las funciones de Emacs, como tambien a definir las nuestras propias, a manipular y construir listas lisp, visitar buffers, mover el punto, utilizar la region, crear funciones interactivas, a conocer el anillo de la muerte y en ultima instancia a enterarnos con certeza de lo que hacemos con nuestro init.el

…bueno, el texto esta un poco anticuado fue escrito con la version 22 (2007-2008) en mente, pero en la practica (practicamente) todo el codigo aun es aplicable, exeptuando algunas pocas funciones y configuraciones relacionadas con X Window

Antes ya habia realizado otros acercamientos a lisp como “The land of Lisp” (traduciendolo “informalmente” como hasta un 2X%) y tambien con ANSI Common Lisp, pero este ha sido el primer libro que termino y donde (mas o menos) llego a comprender las bases de Lisp… sin masterizarlo a profundidad, pues el libro no abarca conceptos como la metaprogramacion, macros y el potencial de las funciones lambda (quien sabe que signifique todo eso…)

De momento Lisp me continua pareciendo un lenguaje curioso, con algo de elegancia (no demaciada), medianamente “retro” y un poco tosco en lo que a adquirir documentacion y uso de librerias se refiere

Muchos aspectos son forzados a encajar en el molde de las listas y en otros tantos, como las “formas especiales”, simplemente se ignoran en pro de la practicidad

Mi calificacion?

  • No es una perdida de tiempo

  • Necesario si quieres profundizar en emacs o descubrir la superficie de lisp

  • Sin ser una lectura ipnotizante, tampoco es soporifera. En ocaciones cuesta seguir las ideas del autor, pero es apreciable que sin ser un escritor de profesion o vocacion (supongo) se esforza por plasmar su conocimento lo mas claro que le fue posible

porg

No recuerdo si fue en alguna busqueda de Emacs-material, en irc o directamente el la pagina de David Arroyo donde con alegria incontrolable descubri la existencia de una traduccion al español (en apariencia terminada) de este titulo, que ademas de tener una version en PDF y texinfo, contaba con el material impreso.

Con la mayor alegria que puede albelgar un aprendis del silicio y en particular usuario de Emacs que poco entiende del lenguaje ingles, procedi a descargar el PDF para recorrerlo con deseo. Sin embargo, al poco de leer, fue evidente que la version tenia defectos apresiables aun para un completo perdido del engrish.

Incredulo, supuse que la version digital y la impresa tenian algun (compresible) desfase comercial y fui directamente al repositorio donde se albergaba la fuente. Para descubrir que el material era tal cual el del repositorio

No negare que un fuerte sentimiento de desilucion aparecio al ver que habria que hecharle esfuerzo para tener un material compresible. Aunque viendolo desde otro angulo, ya habia personas que habian invertido tiempo y energia preparando el material. Que menos que unirse a la causa para sumar al material, o tan siquiera dejarlo en un punto que fuera util a mis egoistas fines

Segun el repo, la primer contribucion que hice fue el 30-05-16, pero aunque intente mantenerme constante, encontre que traducir mediante un fichero .po que ademas esta documentado en texinfo es bastante engorroso. Sumado a esto, las taras ortograficas y traductorias que cargo que son bastas (e incorregibles…), como resistirme a colocar acentos o a pasar un corrector ortografico y ademas tener en esas fechas algunos experimentos bizarros para un lenguaje de marcas ligero que cumpliera todas mis ridiculas exigencias, condujeron a que hiciera un “fork” del proyecto

“fork” etre comillas, porque no cargue con el material original. Fue una adaptacian express al lenguaje experimental de aquel tiempo (aun sin exportador, ni nada) y tras “corregir” cerca del 30% perdi la motivacion….

el asunto se fue aparcando, el formato de marcado ligero cambiando y poco interes tenia por actualizar

hasta que por diciembre del 2017 lo retome esporadicamente y luego de bastantes seciones, pues lo doy por “usable” y digno de ser compartido bajo unos pobres estandares.

Eso si, no sera ningun logro literario, pero no negare que visualmente tanto las versiones web y en morg, tienen un acabado de puta madre. Ha quedado bien chido y “profecional”

Sin embargo, la parte de la traduccion que no se como inicio, pero creo fue obra del traductor de google (y en un inico continue con la tradicion hasta que aparecio deepl) (por mi parte) consistio apenas en darle sentido a los parrafos

En muchas (por no decir que en todas) las seciones, terminaba por entrar en una face cercana al sueño y dejando presionada una tecla indefinidamente. Iniciaba una alerta de regresar a la consciencia, y… volvia a controlar la somnolencia, unos minutos mas antes de desistir.

Otro de los bellos detalles que inclui, fueron palabras con sus caracteres en posiciones alteradas de sitio. Asi como palabras repetidas y poca atencion al formato

Hay varios sitios donde es necesario hacer mas digerible la transmicion de ideas y otros donde por la falta de conocimiento del engrish solo intuia el sentido e inventaba el resto

Algunas traducciones no son consistentes, otras dificiles de transladar y unas mas se asume que ya se entienden, por ejemplo las funciones y conceptos narrow y widen, que deje como reducir y extender

Donde decia “computer” al principio substitui con computador, pero termino como ordenador, y asi otros tantos detalles

Por el lado del codigo, el proyecto de traduccion original (de libre-manuals) planeaba adaptar el codigo a una version reciente. Por parte mia, y ya que segun la wikipedia el autor de esta obra (y otras mas) Robert J. Chassel murio en 2017, he preferido dejarlo (casi en su mayoria) tal cual. (Alguna cosa cambie pero no recuerdo que exactamente.)

Otra cosa importante, es que todas las regiones de texto en el original dentro de un bloque texinfo ignore, las extripe de las versiones a “morg”. Considere que eran comentarios y ya que estaban inconclusos los quite.

Asocia la tecla ‘Bloq Mayus’ a ‘Control’ (Una interfaz de usuario tan rota, sugiere que los fabricantes de teclados piensan que las computadoras son máquinas de escribir de 1885.) {AItPiEL}

Y luego del momento de monolo, el producto central esta en los siguientes repos

git clone https://gitlab.com/nasciiboy/elipo.git
git clone https://notabug.org/nasciiboy/elipo.git

tambien hay uno en github, pero los repos hay presentes (todos inconclusos) los he congelado y/o estan en proceso de migracion hacia gitlab

Para quien desee intervenir el material, recomendaria primero leer acerca del (cambiante y experimental) lenguaje de marcas ligeras morg y si se quiere profundizar mas, seguir la etiqueta morg en este blog.

El fichero donde deben realizarce las modificaciones tanto en español, como en ingles es emacs-lisp-intro_es.porg

Para facilitar la labor, utilizo org-mode para algunas funcionalidades, como escribir listas y tener outline-mode. Algunas de las configuraciones que se pueden agregar a init.el para ayudar un poco, son:

(add-to-list 'auto-mode-alist '("\\.morg\\'" . org-mode))
(add-to-list 'auto-mode-alist '("\\.porg\\'" . org-mode))

;;; resaltado primitivo y no siempre certero de la sintaxis
(add-hook 'org-mode-hook
          (lambda ()
            (highlight-regexp "@[^[<({]+[[<({][^]>})]+[]>})]" 'hi-green-b)
            (highlight-regexp "@[[<({][^]>})]+[]>})]" 'hi-red-b)
            (highlight-regexp "@[^[<({]+[[<({][]>})]" 'hi-red-b)
            (highlight-regexp "[[:space:]]@[[:space:]]" 'hi-yellow)
            (highlight-regexp "@[a-zA-Z]+[[:space:]]" 'hi-yellow)
            (highlight-regexp "^ *@ +.*" 'hi-pink)
            )
          )

me parece que el programa que esta en los repositorios y el que utilizo en mi sistema para realizar la exportacion, difieren un poco… estaba en proceso de refactorizacion e inesperadamante cai en un bucle de poscastinacion y falta de ideas.

En los planes esta que las versiones finales de ficheros (en|es|..|xx|).morg puedan mesclarze, traducirse automaticamente, compararse, reformatearse y demas. Pero ante mi ineficacia, para este material recurri a simples trucos para generar la versiones finales apartir del fichero .porg

para producir la traduccion en español, solo tienen que borrarse todas las lineas que inicien con #. Para generar la version en ingles, mantener todas las lineas vacias y que inicien con #, y luego eliminar el # inicial mas un caracter en blanco (si lo hubiera)

he colocado unas cripticas instrucciones en el .porg, para generar ambas versiones.

De .porg a en.morg y ademas exportacion a html, seria:

awk 'length == 0 || /^#/' emacs-lisp-intro_es.porg | sed -e 's/^# \?//' | sed '8,11d' > emacs-lisp-intro.morg && morg toHtml emacs-lisp-intro.morg

y de .porg a es.morg con exportacion a html:

morg unPorg emacs-lisp-intro_es.porg && morg toHtml emacs-lisp-intro_es.morg

Si se desea verificar que los enlaces en las exportaciones html apuntan a algun lado, se puede utilizar linkchecker (presente en los repositorios de debian)

linkchecker emacs-lisp-intro_es.html --check-extern

algunas convenciones

cuando despues de un atajo se incluye el nombre de la funcion que invoca “entre parentesis”, utilizo la sintaxis @%c(nombre-de-funcion)

cuando despues de un palabro en español o ingles se coloca su equivalente en el otro idioma, utilizo la sintaxis @%i(traduccion/original)

En el documento origital varias “piezas de codigo” se colocaban entre comillas simples. Cuando lo considere pertinente y que ofrecia un mejor resaltado utilice @'c(pieza-de-codigo)

Por falta de mejora en el exportador, y sombretodo, como un apaño, dentro de los bloques de codigo, deben respetarse los espacios en blanco. Si un bloque de codigo en el original tiene una linea de espacio en blanco, debe intercaralse forzosamente el codigo en ingles, colocando la traduccion al español y que ambos bloques compartan la linea en blanco

En el original, habia condiciones para que al exportar el fuente los enlaces externos a los manuales de Emacs y Emacs Lisp estubieran accesibles desde info y en caso de exportar en un formato diferente, desde la ruta web.

un proposito futuro, es replicar este comportamiento (una vez adaptadas esas dos obras a morg), pero eso puede tardar mucho o nunca suceder. Para mantener la funcionalidad, en principio substitui toda referencia a dichos recursos con la ruta web al manual mono-pagina. Pero para evitar peticiones de varios megas a gnu.org, con la lentinud que ello conlleba, termine por colocar en el repositorio verciones locales de estos en formato web mono-pagina

En el original creo que las citas con comillas dobles y sencillas y ---, se aplicaban mediante sintaxis texinfo. Para mejorar la legibilidad en el fuente, se modificaron a “cosas”, ‘cosas’y ––. El formato morg, tiene comandos para aplicar los mismos efectos: @"(cosas), @'(cosas) y @-(cosas). Sin embargo el ultimo no esta adaptado para casos “especiales” si las cosas tienen llave de apertura pero no de cierre. Aun considero cambiar todas las apariciones “legibles a simple vista” por su version en comando, pero no lo termino de decidir

Disfrut! Bienvenidas las peleas, asesorias programacionales a morg, los exportadores de texinfo a morg, los tenedores, monitores 2K y sobre todo, el sucio dinero!

-1:-- elipo (Post )--L0--C0--July 29, 2018 05:19 PM

La Pipa Plena: Curso emacs 30. url-copy, más sobre el tiempo y menús con hydra

Para descargar el presente curso de emacs, por llamarlo de alguna manera, y, naturalmente en formato org como hariamos desde cualquier consola de linux con wget pero desde un buffer ielm (M-x ielm): (url-copy-file “http://lapipaplena.zzzz.io/emacs/curs_emacs.org”  (expand-file-name “~/curs_emacs.org”) 1) t,  correcta la descarga y ya lo tendremos en nuestro directorio personal. nil si hubiese fallado que … Sigue leyendo Curso emacs 30. url-copy, más sobre el tiempo y menús con hydra
-1:-- Curso emacs 30. url-copy, más sobre el tiempo y menús con hydra (Post la pipa plena)--L0--C0--May 13, 2018 08:07 AM

nba - GNU's Rock: pwds

Por lo habitual, mi uso de Emacs va emparejado con una terminal y auxiliado por el navegador de ficheros (y firefox). Asi que lo mas conveniente seria poder sincronizar las rutas de trabajo entre Emacs, Tilix (terminal) y Nautilus (navegador grafico de ficheros) sin tener que escribir cada vez la ruta entera, o andar pinchando con el raton en botones visuales

la solucion (quitando el glamour de la frace “sincronizar las rutas de trabajo de …“) consiste simplemente en copiar la ruta actual de cada programa al portapapeles

tilix

la eleccion de este emulador de terminal (ademas de por su gnomero estilo y su personalizacion de atajos profunda) se encuentra fundamentada en incorporar marcadores de fabrica. Sin embargo, optener la ruta actual y copiarla directamente al portapapeles no es una de sus caracteristicas… y por ello la solucion puede aplicarse a cualquier emulador de terminal.

para saldar la limitacion usaremos el programa xclip (buscar en el repositorio de su distribucion), en conjuncion con pwd y tr (para eliminar el salto de linea producido por pwd)

pwd | tr -d '\n' | xclip -sel clip

el comando se explica por si mismo…

otro comando que tambien suelo utilizar habitualmente para “ajustar” las fechas en los post de este blog:

date --iso-8601=seconds | tr -d '\n' | xclip -sel clip

si bien, el recordar estos comandos a primera vista parece (y lo es) una meta imposible, ya que utilizo fish como interprete y como este se encuentra en modo historial permanentemente, solo tengo que ingresar o pwd o data y el solito se encarga de completar el comando. De esa forma evito crear un script especifico para copiar cosas entre el terminal y el resto del entorno grafico

nautilus

pues nada, aunque tiene sus marcadores, si se presiona la combinacion C-l nos muestra y selecciona la ruta actual… Copiar, modificar o pegar!

Emacs

los marcadores en emacs, ademas de diferenciarlo del resto de la “competencia” lo convierten en un asistente muy potente. La cuestion es como comunicar las rutas de trabajo con el portapapeles del entorno

La solucion mas sencilla es entrar en modo dired para seleccionar y matar la ruta actual, y como la ultima entrada en el anillo de la muerte tiene comunicacion directa con el cortapapeles, tendriamos resuelto el problema… pero, ya que emacs se puede adaptar a nuestras necesidades, extendamos su funcionalidad para que copie directamente en el clipboard tanto la ruta de trabajo, como la ruta del buffer actual

(defun pwd-to-kill-ring ()
  "Agrega la ruta actual al kill-ring."
  (interactive)
  (kill-new default-directory))

(defun buffer-path-to-kill-ring ()
  "Agrega la ruta del buffer actual al kill-ring."
  (interactive)
  (if (buffer-file-name)
      (kill-new (buffer-file-name))
    (message "El buffer actual no esta ligado a un fichero")))

(global-set-key "\C-cp" 'pwd-to-kill-ring)
(global-set-key "\C-cf" 'buffer-path-to-kill-ring)

listo! con unas modificaciones minusculas tenemos nuevas funcionalidades y atajos vinculados a estas. C-c p para optener el pwd y C-c f (si el buffer actual esta vinculado a un fichero) para optener la ruta absoluta a la fuente del buffer, o en su defecto un amigable mensaje “El buffer actual no esta ligado a un fichero”

(mencionar que emacs posee el comando cd con el que podemos modificar manualmente el pwd al que apunta, como tambien un comando nativo pwd. Este pwd cambia automagicamente segun el buffer en el que estemos)

ido-mode

como el shell fish tiene un sistema de autocompletado de rutas automagico (fusionado con el historial), emacs no podia ser menos y deberia proveernos ayuda con el autocompletado de las rutas.

el modo ido nos proporciona autocompletado con “busqueda difusa” de patrones y esta disponible para la busqueda de ficheros, directorios y buffers

de inicio, es un poco lioso y si presionas tap sin antes ver que es lo que hace ido puedes verte creando ficheros en rutas inesperadas. Uno llega a cogerle el truco, pero en ultima instancia es posible desactivar sus “ayudas”

ido forma parte de la distribucion estandar, asi que no tenemos que instalar nada, solo configurarlo un poco

(require 'ido)                    ; invocar a ido
(setq ido-enable-flex-matching t) ; activar busqueda difusa
(ido-mode t)                      ; activar ido

con esto (hasta donde he podido percatarme) ido usurpara el lugar de los comandos vinculados a C-x C-f, C-x d, C-x C-d, C-x i, C-x C-w y C-x b.

Para utilizarlo basta con escribir tap para completar automagicamente y usar las flechas derecha e izquierda para navegar entre las opciones.

No hara falta escribir el nombre preciso del siguiente elemento en la ruta, con escribir algunos caracteres, por ejemplo la extencion de lo que buscamos, seguramente sea suficente.

en caso de que queramos desactivar ido y regresar temporalmente al comando que este suplantando, basta con presionar C-f. Si con esto no es suficiente y se desea apagar ido pues M-x ido-mode, o siendo mas radical, (mientras nos habituamos) podemos vincular su activacion/desactivacion a un atajo

(global-set-key (kbd "C-c .") 'ido-mode)

compile

la mayoria de los programas que realizan algun tipo de inspeccion en un fichero, como pueden ser compiladores, exportadores de formatos o programas de busqueda de patrones, suelen lanzar resultados con el formato

ruta-de-fichero:linea: "cosas"

o

ruta-de-fichero:linea:columna: "cosas"

el comando compile de emacs, se aprovecha de esta convencion para permitirnos navegar entre los ficheros que indique nuestro programa, de una forma mas comoda de lo que seria buscar directamente a mano el fichero, su linea y columna.

cuando se invoca al comando compile (M-x compile) nos pedira un comando (del sistema) a ejecutar, este podria ser por ejemplo gcc mis-cosas.c, make o por que no, grep!

Para buscar todas las coincidencias en una ruta!

M-x compile RET grep -Rn patron [ruta-opcional]

(M-x compile RET grep -Rn package ~/nconf/emacsRocks/)

sorprendente!

para navegar, entre las coincidencias podemos cambiar entre ventanas (C-x o) y dar enters en las lineas resaltadas, o, presionar C-h m y averiguar que combinaciones trae por defecto compile.

ja, ja, ja, aunque la utilidad del comando es evidente, a los peresosos emacsers les da mas por laborar una vez y descanzar eternamente. Por ello tenemos dos modos disponibles para hacer busquedas “a lo grep”.

El primero viene incorporado y se llama occur, vinculado a M-s o. El inconveniente es que las busquedas se limitan al buffer actual.

El segundo, basa su funcionalidad en un (nuevo) comando del sistema llamado ag (The Silver Searcher) que es algo asi como un grep super rapido, configurado para actuar recursivamente por defecto

hay un modo para unir en armonia tanto a compile como a ag para ello (como recomiendan en su repositorio) tendriamos que clonar el fuente y agregar lo siguiente a nuestro init:

;; source: git clone https://github.com/philsnow/ag.el
(add-to-list 'load-path "~/ruta/a/carpeta/ag.el")
(require 'ag)
(setq ag-highlight-search t)

para utilizar el comando: M-x ag RET patron RET ruta

… y eso es todo, happy hacking!

-1:-- pwds (Post )--L0--C0--April 26, 2018 09:07 PM

Bad Daemons: Charla: Emacs no necesita esteroides

Este miércoles 25 de abril, a las 20:00, daré una charla sobre emacs en la Brecha Digital. Veremos, a grandes rasgos, qué es exactamente emacs, sus orígenes, comparación con vim para darle emoción, que posibilidades de uso tiene y cómo empezar a usarlo. El nivel de la charla será introductorio, pero si ya conoces emacs siempre puedes aprovechar la ocasión para ver la Brecha Digital, un grupo que se reúne en La Brecha, un centro social alquilado, en el que nos untamos habitualmente para dar charlas y aprender tecnologías molonas en común. Más información de La Brecha Digital aquí, echadle un ojo para ver como llegar a La Brecha.

-1:-- Charla: Emacs no necesita esteroides (Post )--L0--C0--April 21, 2018 08:42 PM

MGallego: Lanzando Hook al Guardar Buffer en Un Modo en Particular de Emacs

Para programar en PHP me gusta usar el modo mayor php+-mode y uno de los modos menores que uso es ac-php para usar company-mode y realizar el autocompletado. Este modo menor es bastante útil, sobre todo porque crea una tabla de tags muy buena, pero no he encontrado una forma automática de crearla, cada cierto tiempo ejecutaba el comando de generación de tags para autocompletar.

Tenía previsto desde hace mucho tiempo hacer que se regenere cuando guardo un buffer en modo php+ pero por pereza lo he ido dejando, incluso asigné una tecla al comando de tags, pero al final me decidí a hacer las cosas bien.

Actualizando tags de PHP cuando guardo un fichero en modo PHP

Este es el código que finalmente he añadido a mi configuración, a continuación os lo explico.

   (defun remake-ac-php-tags ()
   "Remake php tags from current buffer"
   (when (eq major-mode 'php+-mode)
      (ac-php-remake-tags))
    )

   (add-hook 'after-save-hook #'remake-ac-php-tags)
   

Como veis lo primero que hago es crear una función que será la que lanzaremos con el hook, podría decirle al hook que lanzase directamente la de generación de tags, pero la que he creado también filtra por el modo en el que nos encontramos.

(when (eq major-mode 'php+-mode) (ac-php-remake-tags))) Aquí está lo interesante, la condicion que dice que el modo mayor debe ser php+-mode y dentro la ejecución del comando que deseamos.

(add-hook 'after-save-hook #'remake-ac-php-tags) El siguiente paso ya es simplemente añadir la función al hook que se lanzará siempre que se guarde un fichero.

Al final el código es sencillo a mas no poder, es mas la pereza de buscar el cómo se hace, que el hacerlo. Espero que os sirva de ayuda a la hora de lanzar vuestras acciones al guardar un fichero.

Debería mejorarlo para que en realidad mirase si está el modo menor ac-php activo, pero la verdad es que aún no se como hacerlo.

-1:-- Lanzando Hook al Guardar Buffer en Un Modo en Particular de Emacs (Post )--L0--C0--April 18, 2018 08:26 PM

nba - GNU's Rock: Keep Regexp

es muy vergonZoSo sentirse capaz y al enfrentar un reto quedarse congelado al borde del fracaso

El asunto es el siguiente, tenemos un fichero con correos (muchos correos, 79 exactamente). El fichero ademas de los correos incluye nombres y comas y la meta es obtener unicamene los correos.

Empece el reto substituyendo comas por saltos de linea, luego probe una complicada regexp para buscar los correos, pero tras muchos fallidos intentos, abandone la idea… ademas, que esperaba encontrando la regexp? no es como si la coincidencia colocara la region en la coincidencia y luego se pudiera “cortar” y “pegar”

Lo siguiente, fue utilizar el comando flush-lines para borrar las lineas que no coincidieran con el patron [^@], “obviamente” no funciono, auque en mi ignorancia culpe al patron… (risa histerica) y bueno, sucede que no te aclaras y hasta se te olvida utilizar la ayuda del emacs

un par de intentos mas tarde, termine por utilizar una poco elegante macro, que cumplia el objetivo chapuceramente

luego, tras ver la primer solucion, mas simple, conpacta, no del todo “segura”, pero para el caso efectiva

cat lista_correos.txt | tr " " '\n' | grep @ | xargs

e inmediatamente despues un vi-liever solucionaba el asunto con

:%s/  */^M/g
:v/@/d
:%join

como podia evitar la inminente culpa y herida en el orgullo klingon-emacsero?

intetentando superar la frustracion, dio inicio un aprendizage formal y profundo de las regexes en emacs y alguno que otro comando mas. Pero antes de pasar a ello, fue nesesario aminorar el trauma implementando una solucion en awk y otra en C….

# esto a un fichero, por ejemplo a.awk
1 {
    for( i=1; i<=NF; i++ )
        if( $i ~ /@/ ){
            printf( "%s\n", $i)
        }
}

# y luego ejecutar con:
# $ awk -f a.awk lista_correos.txt

aca la solucion con C. Compilar con gcc a.c regexp4.c y ejecutar con $ a.out lista_correos.txt

Un dia despues, con la agonia mental aun fresca, llego la solucion en emacs

M-<
M-x replace-regexp RET " +\|," RET C-o RET
M-<
M-x keep-lines RET "@" RET

(no conocia keep-lines si tu tampoco, te la presento. Ignorar las comillas son para delimitar la cadena de entrada)

ciertamente mas extensa que vi, pero consideremos que emacs no tiene una simbiosis con el comando sed, ni tampoco una implementacion de sus comandos de tal forma que puedan ejecutarse “en bloques”. No esta tan mal, supongo.

aqui es donde se podria iniciar una “guerra santa”. Pero bueno, la naturaleza extensible e ilimitada de emacs para un tema concreto puede ser menos eficiente, es cierto… aunque, nada impide que se implemente un comando interprete tipo sed e incluso otro para aplicar acciones por lineas y de manera global (sin recurrir a macros)

Supongo que los usuarios del modo maligno, han hecho algo asi, mas profanar emacs con tales paganismos, ni utilizar “modos” que fuerzan a presionar ESC de forma inconciente, son algo a contemplar por mi parte, las cosas “modales” son un dolor, ya es suficientemente modal tener que usar el firefox, o el navegador de ficheros y andar presionando ahi teclas de otros “modos”

o, por aca un semi-equivalente en elisp de la solucion

(defun emailtor ()
  "Separa los correos en lista_correos.txt"
  (interactive)
  (goto-char (point-min))
  (while (re-search-forward " +\\|," nil t)
    (replace-match "\n" nil nil))
  (goto-char (point-min))
  (delete-non-matching-lines "@"))

ha, no es lo mas fino, pero para el caso cumple

regexp

  • Conjunto []. Conjunto inverso [^]. Dentro de los conjuntos (con la syntaxis completa [[:clase:]]) se permiten las clases

    • [:alnum:] caracter alfanumerico
    • [:alpha:] una letra, incluidos caracteres unicode
    • [:blank:] espacio y tabulacion
    • [:cntrl:] caracteres ASCII de control
    • [:digit:] numeros ascii del 0 al 9
    • [:graph:] cualquier caracter visible, exepto espacios en blanco
    • [:print:] cualquier caracter visible, incluidos espacios en blanco
    • [:lower:] caracteres en minusculas
    • [:upper:] caracteres en mayusculas
    • [:punct:] signos de puntuacion
    • [:space:] espacios en blanco
    • [:word:]caracteres que formen parte de las palabras
    • [:xdigit:] caracteres hexadecimales (0-9, a-f y A-F)
    • [:ascii:] caracter ASCII
    • [:nonascii:] cualquier caracter no ASCII
    • [:multibyte:] caracteres unicode multibyte
    • [:unibyte:] caracteres codificados en un solo byte (basicamente todo ASCII)
  • punto .

  • metacaracter \

  • agrupacion y captura \(\)

  • coincidencia con la anterior captura \d. (Substituir d por el numero de captura)

  • agrupacion sin captura \(?:\)

  • alternativa \|

  • cuantificadores

    • ? cero o uno
    • * cero o mas
    • + uno o mas
    • \{n\} exactamente n
    • \{n,\} n o mas
    • \{n,m\} entre n y m
  • modificadores

    • $ coincidencia al fin de linea
    • ^ coincidencia al inicio de linea
    • \= coincidencia en la posicion del punto
    • \' coincidencia al final del buffer
    • \` coincidencia al inicio del buffer
  • fin o inicio de palabra \b

  • (deacuerdo al modo) un caracter que forme palabras \w o \sW

  • (deacuerdo al modo) un carac,ter que no forme palabras \W o \Sw

  • espacios \s- o \s (”\s”)

  • symbolos \s_

  • delimitador de apertura \s(

  • delimitador de cierre \s)

  • caracteres de puntuacion \s.

comandos de utilidad

  • (search-forward) busqueda de texto hacia adelante
  • (search-backward) busqueda de texto hacia atras

  • C-s (isearch-forward) busqueda de texto de forma interactiva hacia adelante

  • C-r (isearch-backward) busqueda de texto de forma interactiva hacia atras

  • (search-forward-regexp) busqueda de regexp hacia adelante

  • (search-backward-regexp) busqueda de regexp hacia atras

  • C-M-s (isearch-forward-regexp) busqueda de regexp de forma interactiva hacia adelante

  • C-M-r (isearch-backward-regexp) busqueda de regexp de forma interactiva hacia atras

  • M-s o (occur) listado interactivo de lineas que coinciden con la regexp

  • (replace-string) substitucion de texto

  • (replace-regexp) substitucion de regexp

  • M-% (query-replace) substitucion interactiva de texto

  • C-M-% (query-replace-regexp) substitucion interactiva de regexp

  • (highlight-lines-matching-regexp) resaltar cualquier linea que coincida con una regexp

  • (highlight-regexp) resaltar una regexp

  • (unhighlight-regexp) des-resaltar regexp

  • (flush-lines) eliminar lineas que coincidan con la regexp. (el patron ^$ eliminara todas las lineas en blanco)

  • (keep-lines) se eliminan las lineas que no coincidan con la regexp

  • (align-regexp) alinea (verticalmente la parte en varias lineas que coincida con la regexp

re-builder, isearch, isearch+

De entre las muchas cosas relacionadas con regexes, el modo re-builder es uno muy interesante, pues nos permite escribir y editar una regexp con suma facilidad y luego copiar el resultado.

Supongo que este modo, es una facilidad para los programadores de emacs, basandome en que la expresion esta entrecomillada y al copiar la regexp con el comando reb-copy (C-c C-w) incluye las comillas y ademas el formato de escape de caracteres esta dispuesto a la forma que requiere el codigo fuente en elisp.

Dicho escape de caracteres y metacaracteres, se debe a la naturaleza de las cadenas en C de hay que las cosas suelan requerir escapes para los escapes. Por defecto re-builder viene en modo de syntaxis read que es de la que hablo, pero tambien podemos cambiar a sintaxis string (la que utiliza isearch), bien presionando la combinacion C-c TAB y escribiendo string o directamente colocando lo siguiente en nuestra configuracion

;; re-builder
(setq reb-re-syntax 'string)

pese a la facilidad de edicion y creacion de regexes, me pregunto la razon de no vincular este modo con isearch. Mas adelante (o no) una posible razon y un par de soluciones.

los comandos basicos de utilidad

  • C-c C-w copiar regexp (comillas incluidas)
  • C-c C-q salir del modo
  • C-c TAP cambiar syntaxis de entrada
  • C-c C-r ir a coincidencia previa
  • C-c C-s ir a coincidencia siguiente

isearch en sus modalidades mas conocidas isearch-forward-regexp (C-M-s) e isearch-backward-regexp nos permiten buscar expresiones regulares hacia adelante y hacia atras del punto interactivamente, mas no dejeis que os engañen las funciones basicas de estos comandos, pues no son simples comandos, son modos por si mismos, podemos averiguar sus muchas posibilidades (ya dentro de isearch) presionando C-h m o con la documentacion de la funcion C-h f isearch-forward-regexp

quiza el comando mas conocido de las busquedas interactivas sea C-w que toma la entrada sobre y delante del punto como texto de entrada (dividida por palabras). Pero ademas de esa combinacion tenemos otras muy interesantes

  • M-s e para editar “con papeles” la regexp, aunque no interactivamente
  • C-M-y ingresar a la regexp el caracter del buffer sobre el que esta el punto
  • C-M-w borrar el ultimo caracter de la regexp
  • M-s C-e ingresar a la regexp el resto de la linea apartir de la posicion del punto
  • C-y traer ultima cadena del anillo de la muerte
  • M-y iterar sobre el contenido del anillo de la muerte
  • M-c cambiar la sensivilidad a las mayusculas-minusculas
  • C-s siguiente coincidencia
  • C-r anterior coincidencia

y muchas otras cosas misticas y confusas mas trae el modo. La cuestion problematica tiene que ver con la forma en que isearch incorpora el contenido del anillo de la muerte a la busqueda, pues si por ejemplo matamos la cadena \(group\)[set] al hacer el yank (C-y) en lugan de ingresar \(group\)[set] escapara los caracteres significativos en la regexp, dejando \\(group\\)\[set] lo que obligaria a editar de forma penosa la expresion

preguntando en reddit, el unico lugar donde aparecen respuestas prontas y en ociones con feliz resultado, oantolin proporcionaba el siguiente comando alternativo para hacer el yank con su contenido tal cual dentro de la expresion

(defun isearch-yank-kill-literally ()
  "Pull string from kill ring into search string literally."
  (interactive)
  (setq isearch-yank-flag t)
  (let ((string (current-kill 0)))
    (isearch-process-search-string
     string
     (mapconcat 'isearch-text-char-description string ""))))

(define-key isearch-mode-map (kbd "C-S-y") #'isearch-yank-kill-literally)

como puede verse, se sugiere la vinculacion al atajo Control-Super-y, pero en mi caso me es incompatible con otro comando… lo que sirvio fue suplantar directamente el comando yank de isearch dejando como nombre de la nueva definicion solamente isearch-yank-kill

cabe aclarar, que la copia tal cual del contenido del anillo de la muerte, no es una caracteristica considerada de inicio en isearch, por lo que al hacer un M-y, el demas contenido del anillo seguira siendo modificado con escapes. De hay que otro colega, 00-11, suguiriera el uso del modo isearch+, que si considero esta necesidad en su base

isearch+ (supongo) es una capa sobre el modo isearch que ademas de agregar la posivilidad de hacer yanks sin modificar el contenido, nos colorear la busqueda en secciones y proporciona varios comandos de utilidad extra. Todo esto manteniendo los atajos de isearch (casi) intactos

isearch+, no viene en el repositorio melpa, para instalarlo deberemos copiar directamente su codigo desde emacswiki a un fichero, y luego cargarlo “a mano”.

https://www.emacswiki.org/emacs/download/isearch%2b.el

En el mismo fichero proponen cargar el modo con el comando

(eval-after-load "isearch" '(require 'isearch+))

pero he preferido agregar lo siguiente en mi init

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PACKAGE*: isearch+            ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; source: https://www.emacswiki.org/emacs/download/isearch%2b.el
(load-file "~/.emacs.d/plugins/isearch+.el")

vamos con la justificacion de utilizar isearch+, que era poder hacer yanks.

En la linea 2547, tenemos la variable customizable isearchp-regexp-quote-yank-flag que si la ponemos a nil, asi

    (defcustom isearchp-regexp-quote-yank-flag nil

nos dara el resultado que buscamos.

Si, se puede hacer el cambio de la varible en el init, pero ya que tenemos y vamos a cargar el codigo directamente, mejor dejarse de historias y hacer el cambio in-situ

(nota: al cargar isearch+ substituye automaticamente a isearch. He probado el modo con emacs 25 sin ninguna extencion y funciona sin problemas)

ahora si, despues de tener isearch+ configurado, podemos escribir nuestra funcion en re-builder (modo de syntaxis string) y copiar la regexp (manualmente) ignorando los parentesis, para luego “pegarlo” directamente en isearch(+) con un yank

Enlaces, fuentes y otras cosas

-1:-- Keep Regexp (Post )--L0--C0--April 08, 2018 04:50 PM

nba - GNU's Rock: The Holy War

Post original (04/12/2001) -> https://www.linux.com/news/emacs-vs-vi-endless-geek-holy-war

Author: JT Smith

Ahí van de nuevo. El presidente de nuestro grupo local de usuarios de Linux envió el mensaje de que el tutorial de la semana sería cancelado. El hecho de que el tutorial fuera sobre el uso del editor de texto vi fue suficiente para iniciar una nueva ronda de tiros de última hora.

Greg Menke disparó la primera salva. Usar vi? ¿Qué tan difícil puede ser? Envió por correo electrónico sus propios pasos para usar vi. Fueron estos:

  1. Adquirir un pecado, de cualquier tipo, longitud > 30 cm

  2. Congelarlo durante la noche

  3. Siéntese frente a la PC, ejecute vi

  4. Sosteniendo el pez por la cola, golpéelo repetidamente contra su frente hasta que decida darle una oportunidad a EMACS porque las escamas de pescado están volando alrededor de su cabeza y comienza a doler.

Menke, por supuesto, insinuaba que no sólo vi era insensatamente obstinado sino que los usuarios de vi también lo eran por negarse a admitir cómo se estaban infligiendo a sí mismos brutales golpes en la cabeza con un pescado congelado.

No tardó mucho para que los amantes de vi devolvieran el fuego. Uno sugirió a Menke que agregara esta línea a sus instrucciones: Escriba 'emacs' antes del paso 1, para que cuando el paso 4 esté hecho, finalmente haya terminado de cargarse.

¿Intentaba decir que EMACS es lento?

Al igual que los batallones fatigados por la lucha llegan a una tregua temporal pero se niegan a abandonar la guerra, los usuarios de vi y EMACS mantienen un intranquilo punto muerto en GNU/Linux, SAGE y muchas comunidades virtuales relacionadas con computadoras. Es el tipo de empate que puede permanecer inactivo durante meses, pero sólo se necesita una pizca de vaguedad de un lado para que una vez más las llamas se propaguen por los grupos de noticias y las listas de correo. Porque justo por debajo de su conducta civilizada, cada bando siente que el editor que usa es el mejor de todos los editores posibles y aquellos que usan cualquier otro editor, particularmente ese otro editor, son tontos que se daran cuenta de su erronea forma de pensar aunque sólo sea posible a base de muchas burlas.

Ahora, una escision sobre cual editor de texto en Unix es una construccion del mismisimo Dios puede no parecer significativa dados todos los problemas del mundo, un empate de Coca-Cola vs. Pepsi sin consecuencias, sin motivaciones más allá de la simple unión grupal (¡Vamos Equipo!).

Pero, ¿por qué esta diferencia de puntos de vista ha seguido siendo un divisor de la cultura de los programadores durante más de dos décadas? ¿Por qué ha permanecido intacta en el PC, luego de que las interfaces gráficas de usuario, el ratón, Internet y el código abierto han alteraron el panorama computacional?

Desde que tengo uso de razon, la población de hackers se ha dividido 50/50 [entre] EMACS [y] vi, escribe en un email Eric Raymond, quien tiene varios roles en las comunidades de software de código abierto y hackers como antropólogo observador y participante desde hace mucho tiempo. Pico, Joe, MicroEmacs, y otros editores han estado básicamente abajo en el ruido estadístico durante todo el período. Raymond puede datar personalmente la división vi/EMACS en 1985 y estipula que, con toda probabilidad, fue mucho antes de eso.

Ya en 1991, Raymond registro la guerra santa vi vs. EMACS en el Jargon File, quizás la colección definitiva de la terminología hacker.

Cuando se presiona, la mayoría de la gente familiarizada con ambos editores dirá que la diferencia entre los dos es de velocidad vs. flexibilidad, con los usuarios de vi señalando lo rápido que pueden moverse y los amantes de EMACS pregonando su inmenso número de opciones. Los usuarios de vi se burlan de EMACS por ser innecesariamente ostentosos; los usuarios de EMACS se burlan de vi por ser difícil de aprender y tener un alcance limitado.

Así que el gran debate del editor de textos de nuestro tiempo se reduce al equivalente técnico del gustos menos/o-mas relleno. Bueno, sí, más o menos. Pero como en todos los asuntos relacionados con la religion ––o la guerra––, cuanto más se profundiza, más oscuros se vuelven los temas.

Pero aqui hay algo significativo. Estos editores son la tabula rasa sobre la que se ha construido gran parte del ciberespacio. El hecho de que estas herramientas, cada una diseñada para ser transparente para el usuario final, estén sujetas a lealtades tan feroces y competitivas, revela algo acerca de algunas suposiciones primordiales que la gente tiene acerca de las mejores maneras de hacer las cosas.

Vi: ¿El editor que el tiempo olvidó?

A primera vista, los forasteros podrían ver a vi como el editor que el tiempo olvidó. No es sólo que tienes que abrir una ventana de terminal sólo para usar la cosa. Esa también es la mejor manera de conseguir EMACS. Pero incluso con VIM, la versión actualizada que la mayoría de los usuarios de vi emplean hoy en día, uno no puede evitar maravillarse (o frustrarse) por la falta de intuición sobre su funcionamiento.

Incluso el webmaster de la página de inicio de los Amantes de VI admite que la curva de aprendizaje es empinada. Vi no es mas veloz antes de conocer 25 comandos más o menos, escribe Thomer Gil, oriundo de Ámsterdam, que actualmente trabaja en un doctorado en ciencias de la computación en el Instituto Tecnológico de Massachusetts.

Gil ha sido comparado por sus compañeros de oficina con un cavernícola que blandía un hacha y un garrote por su uso de VIM.

De todas las deficiencias percibidas en vi, tal vez la más notable sea la necesidad de ingresar la tecla de inserción sólo para escribir cualquier cosa en la pantalla. Vi tiene dos modos: Uno es el modo insertar en el que se puede introducir texto. Se accede a este modo pulsando la tecla insertar del teclado. Pero también existe el modo de comando en el que no se puede introducir texto, sino comandos relevantes. Desde el modo de inserción puede llegar a este ultimo pulsando la tecla de escape.

Así que imagínese al usuario desprevenido escribiendo por primera vez y que accidentalmente presiona la tecla de escape, sólo para descubrir que no sólo no puede ingresar más texto, sino que sus pulsaciones envian extrañas instrucciones al programa .

El Jargon File observa secamente que esta característica de vi tiende a frustrar infinitamente a los nuevos usuarios, ya que no toma comandos mientras espera texto de entrada ni viceversa, y la configuración predeterminada no proporciona ninguna indicación del modo en el que se encuentra el editor.

Los múltiples modos asustan a la gente, admite Gil.

Vi fue escrito por Bill Joy en 1976, quien lo forjó a partir de dos herramientas de edición aún más primitivas, ed y ex. Vi significaba interfaz visual, que en 1976 estaba en la vanguardia de la informática, según una entrevista a Joy en la Linux Magazine.

Intentaba hacerlo utilizable con un módem de 300 baudios. Esa también es la razón por la que tienes todos estos comandos divertidos. Apenas funcionaba usar un editor de pantalla sobre un módem, dijo Joy, Así que el editor estaba optimizado para que pudieras editar y sentirte productivo cuando pintaba más lento de lo que pensabas.

En esa entrevista, Joy contrastó el entorno de desarrollo de vi con el de EMACS, dijo que fue escrito para sistemas con enlaces de canales de fibra y un monstruo PDP-10.

Así que podrían tener comandos divertidos con la pantalla brillando y todo eso, y mientras tanto, estoy sentado en casa en una especie de vivienda excedente de la Segunda Guerra Mundial en Berkeley con un módem y un terminal que apenas puede sacar el cursor de la línea de fondo, dijo Joy, tal vez sonando un poco envidioso. La gente no sabe que vi fue escrito para un mundo que ya no existe.

Sin embargo, aunque vi debería haber desaparecido a principios de los años 80 a medida que aumentaba la velocidad de la red y del procesador, ha florecido. Las VI Pages listan cerca de 30 clones vi desde elvis y VIM hasta obscuridades tales como WinVi y vigor.

Tim O'Reilly, autor intelectual de la editorial O'Reilly & Associates, señaló en la columna Ask Tim de su empresa, que su empresa vende el doble de libros de vi que de EMACS. Además, O'Reilly apoya un juego de pintura de vi vs. EMACS en alguna convención, invariablemente el doble de voluntarios se inscriben para defender el honor de vi sobre EMACS.

Entonces, ¿cuál es el atractivo? Esto se describe mejor en el Culto de VI, en el que John Arundel escribe: Al ver a un gurú de vi haciendo una edición intensa en un archivo, mientras sus dedos sobrevuelan las teclas y las transformaciones textuales barren la pantalla, uno podría creer que está en presencia de poderes sobrenaturales.

Gil publica algunos ejemplos de esta magia en su sitio web. Un concepto clave en vi es combinar una determinada acción (borrar, copiar a búfer, escribir en mayúsculas, etc. con un movimiento (ir a la línea 25, ir al final del documento, ir a la siguiente coincidencia de 'foo', ir a la segunda coincidencia del carácter 'x' en esta línea, etc.)).

¿Eh? Le envié un correo electrónico.

Gil devuelve un ejemplo: Si, por ejemplo, un documento contiene las líneas: 'a b c d e f g h' y el cursor está situado en 'b', luego puedo escribir d/f.

La primer d significa borrar, la / es una función de búsqueda, así que lo que hará este comando es borrar de b a f.

No se requieren circunstancias especiales para usar esto... Borrar palabras, oraciones. Vuelve a donde estaba antes. Oh, no, salta de nuevo. Deshacer lo que hice, rehacerlo, escribe Gil.

Gil estipula que también puedes hacer trucos como este en EMACS. Sin embargo, se requiere memorizar combinaciones de teclas apestosas Ctrl-X Ctrl-c Alt-F4 para su ejecución.

Otro truco que Gil revela es cómo VI permite a los usuarios moverse dentro de los ficheros. La manera estúpida es usar las teclas de flecha; hay muchas otras maneras más avanzadas de moverse, escribe Gil. Entre las formas avanzadas de movimiento que ofrece vi se encuentra la opción de saltar a los últimos saltos del cursor, o a la siguiente ocurrencia de una palabra en particular, o a la siguiente oración o párrafo.

Incluso la característica de modo dual se vuelve transparente para los usuarios. Hace un año entrevisté a Jon Lasser para escribir sobre su entonces reciente libro Think Unix, (cuyo manuscrito, me dijo, fue compuesto enteramente en vi). La conversación finalmente llegó a vi, y me quejé de los dos modos.

Lasser explicó que no veía ninguna diferencia entre trabajar en vi y en procesadores de texto como StarOffice o Microsoft Word. En Word, cuando mueve el puntero fuera del área de pantalla, no puede escribir texto. De hecho, pasar del modo de inserción al modo de comando. Es lo mismo, explica.

Como O'Reilly escribió sobre vi: Como muchas cosas sobre UNIX, sólo parece difícil.

Más es más con EMACS?

Cuando el lealista de vi O'Reilly escribió en Ask Tim que primero cambió de EMACS a vi sólo después de que su perfil personalizado de EMACS fue destrozado, fue uno de esos jabs sutiles que a los usuarios de vi les gusta usar en contra de EMACS.

EMACS contrasta con la prístina limitación de comandos de vi, con su personalización casi infinita. Sin embargo, dado que la naturaleza humana es lo que es, tal poder en manos de los usuarios puede no ser siempre lo mejor.

Como dice el Emacs-Beginner-HOWTO, EMACS puede ser un editor de texto, un cliente de correo, un lector de noticias, un procesador de texto, un editor de scripts y un entorno de desarrollo integrado para lenguajes de programación.

La clave para esto son los múltiples modos, cada uno con un conjunto de comandos único, que EMACS ofrece. ¿Quieres comprobar el correo electrónico? Sólo tienes que pasar al modo de correo electrónico. ¿Quieres escribir un programa en C++? Utiliza el modo C++. ¿Necesita crear algunas páginas Web? Salta dentro del modo html-helper.

Y además de todo esto, también puedes personalizar EMACS e incluso añadir nuevas funciones, normalmente modificando su código en Lisp.

Es por todo esto que muchos usuarios de vi lo ven como terriblemente presuntuoso para lo que se supone que es un simple editor de texto, sin mencionar que distrae al usuario. La broma en curso sobre EMACS es que es un sistema operativo con un editor de texto adjunto.

EMACS como tal comenzó como un proyecto de estándares, escribe Guy Steele, uno de los creadores de EMACS, junto con Richard Stallman, quien más tarde fundó la Free Software Foundation.

Tal y como recuerda Steele, Stallman mantuvo un primer editor para el PDP-10 llamado TECO, que significaba Text Editor and COrrector. A pesar de que ciertas pulsaciones de teclas realizaban comandos de edicion, Stallman creo una tabla programable por el usuario, de manera que cada pulsación de tecla realizaba una búsqueda en la tabla que describía qué hacer para esa pulsación, según dice Steele. Una opción era ejecutar una macro TECO especificada por el usuario.

Usando esta funcionalidad de macros, los usuarios estaban programando conjuntos personalizados de macros para ser vinculados a varias pulsaciones de teclas, pero esto se volvió problemático cuando los programadores comenzaron a colaborar en programas y descubrieron que tenían pocas pulsaciones de teclas comunes entre ellos.

La comunidad de usuarios se había fragmentado con respecto a las habilidades de edición de textos (y programas), escribe Steele. Así que Steele, junto con David Moon y Stallman, asumió el proyecto de integrar todas las ideas en un conjunto de comandos unificado.

Inventé una matriz en papel y corrí mucho de un lado a otro entre los implementadores y usuarios de los distintos paquetes de macros, dice Steele en un correo electrónico.

Recuerdo esto muy bien, recuerda Dan Weinreb, quien fue uno de los primeros alfa testers de EMACS. El tipo tenía un portapapeles con un pedazo de papel que mostraba todas los atajos, y recogió cuidadosa y diplomáticamente los comentarios de todo el mundo para unificarlos, en atajos estándar.

Después de unos meses, Steele, ocupado tratando de terminar su tesis de maestría, entregó la obra a Stallman. Y el resto es historia.

El hecho de que la flexibilidad se horneara desde el inicio le da a EMACS su ventaja, dicen los usuarios hardcore.

Pienso en EMACS como la navaja suiza de los editores, menciona en un correo electrónico a Debra Cameron, coautora de Learning GNU Emacs y presidenta de Cameron Consulting. Es un ambiente de trabajo completo, un microcosmos. Si piensas en algo que desearías que hiciera, probablemente descubrirás (después de mirar a tu alrededor) que ya lo hace. Si no lo hace, puedes extenderlo y hacer que haga lo que quieras que haga.

¿No podemos llevarnos todos bien?

Entonces, ¿cómo difiere EMACS de vi?

He visto a usuarios de vi muy hábiles hacer algunos trucos bastante ingeniosos, pero sigo pensando que vi es (sólo) un editor, incluso si para algunos es un gran editor, menciona Cameron. Siempre, siempre funciona de la misma manera. En este sentido, vi es como McDonald's; no importa a donde vayas, es exactamente lo mismo.

¿Quieres un editor que se adapte a tus necesidades y peculiaridades y que haga muchas, muchas cosas o simplemente quieres ser capaz de editar archivos rápidamente en cualquier máquina? pregunta ella. Para la gente que tiene que moverse de un ordenador a otro constantemente, esta consistencia puede ser una ventaja real.

En otras palabras, EMACS = flexibilidad, mientras que vi = uniformidad?

Aquí es donde las cosas se ponen turbias.

EMACS es ciertamente más complejo que vi, pero no creo que sea más poderoso de ninguna manera útil, porque vi fue diseñado para ser parte de un sistema UNIX e interactuar con esas herramientas, replica Jon Lasser.

Tenga en cuenta que, para Lasser, útil significa la forma en que vi le permite leer documentos directamente desde una tubería UNIX desde otro proceso, como lo haría en cualquier otra aplicación UNIX, explica. Así, la cadena arcana de pulsaciones de teclas <esc> :r !ls<enter> introducidas en vi (en modo comando, recuerde) lee en el búfer la salida del programa ls, o una lista de archivos del directorio actual. Y una tubería de cualquier otro programa UNIX también funcionaría.

En cuanto a la edición automática de un gran número de archivos en vi, Lasser dice que es por eso que tenemos sed, awk, y todas las demás herramientas de procesamiento de texto UNIX.

El procesamiento de texto es para lo que UNIX fue diseñado, y vi fue diseñado para ser parte de ese sistema, escribe Lasser.

Tal vez el problema subyacente entre EMACS y vi no es el de la uniformidad frente a la flexibilidad en absoluto. Después de todo, ambos editores ofrecen flexibilidad, es sólo que con vi, lo hace a través del propio UNIX, mientras que EMACS lo logra construyendo sobre el sistema.

Y, para el caso, el único punto de la flexibilidad es hacer que el trabajo vaya más rápido. Si desea un procesamiento de texto sencillo y sin complicaciones, puede optar por Pico, que ofrece sólo una pantalla en blanco y ninguna de las características de vi o EMACS que confunden a los novatos. Lo que ambos editores ofrecen son formas avanzadas de reducir la distancia entre la velocidad de los dedos en el teclado y la velocidad del cerebro del programador.

En otras palabras, ¿podría ser que estos editores ofrezcan lo mismo, pero exijan diferentes maneras de pensar a sus usuarios? Vi requiere la paciencia para aprender sus extravagantes formas, aunque una vez que las dominas, eres libre de llevar tu acto a cualquier sistema UNIX. EMACS te da la libertad de personalizar tu configuración como mejor te parezca, aunque si no eres cuidadoso, te convertirás en prisionero de tu propia configuración.

En algún momento durante la gran caminata de mejora de la auto-eficiencia que todos los buenos programadores toman, los usuarios de vi y EMACS se cruzan, cada uno viniendo de una dirección diferente. Y cuando se encuentran, normalmente se tiran piedras unos a otros.

Pero todo está bien.

No creo que haya una gran diferencia en la funcionalidad. Ambos editores hacen un buen trabajo y todo se reduce a lo que la gente aprende primero, escribe Gil. Ya que la mayoría de las personas conocen EMACS, les enseñarán a otros EMACS. Por lo tanto, la mayoría de la gente usa EMACS, etc.

Y así la disputa continuará...

(Nota: Las mayúsculas de EMACS, UNIX y vi pueden haber sido cambiadas en comillas a sus formas originales, excepto en los títulos directos de libros y páginas Web).

-1:-- The Holy War (Post )--L0--C0--April 08, 2018 03:35 PM

Bad Daemons: Modificar la salida de una función de emacs lisp sin redefinirla

Casi es más largo el título que la definición o solución del problema.

Por mostrar un caso real explicaré el problema que tenia. Uso el paquete Projectile, que sirve para gestionar proyectos en emacs, recomiendo fuertemente que le echéis un ojo. Cuando se han abierto unos cuantos proyectos puede usarse la función projectile-switch-project, que permite cambiar el proyecto. El tema es que muchos directorios de mi home son en realidad enlaces simbólicos a otros sistemas de ficheros. Esto hace que los proyectos se me muestren con las rutas reales, no las rutas de los enlaces simbólicos. Por ejemplo, un proyecto en /home/drymer/Documentos/Ansible/roles/upgrade-all se me muestra como /media/.secret/Casa/Documentos/Ansible/roles/upgrade-all, lo cual es horroroso.

Lo que yo necesito es hacer que los proyectos en /media/.secret/Casa/ se muestren como /home/drymer/. Investigando, vi que lo que me hacia falta era usar una función de asesoramiento. No tengo claro si se traduce así, en inglés son Advising Functions. El tema es que estas funciones permiten, entre otras cosas, modificar la salida de una función elisp sin tener que redefinirla.

Por lo tanto, hay que averiguar que función es la que hay que modificar. En este caso, la función que da el nombre a los proyectos es projectile-project-root. Ahora crearemos una función simple que ejecute un replace-regexp-in-string en la salida:

(defun daemons/projectile-project-root (arg)
(replace-regexp-in-string "\\(/media/.secret/Casa\\)" (getenv "HOME") arg))

Un ejemplo de la ejecución de esta función:

(daemons/projectile-project-root "/media/.secret/Casa/Proyectos/nikola.el")

Solo nos queda añadir el filtro:

(advice-add 'projectile-project-root :filter-return #'daemons/projectile-project-root-filter)

Desgranemos el código:

  • advice-add: Añade función de asesoramiento.
  • projectile-project-root: La función que modificaremos.
  • filter-return: De que modo modificamos la función.
  • daemons/projectile-project-root-filter: Función con la que modificaremos el comportamiento de la primera.

La parte más interesante es la de filter-return, ya que este no es el único parámetro que se puede definir. Si quisiésemos, podríamos sustituir la función entera de muchas formas distintas. De hecho, si quisiésemos redefinir una función ya definida en alguna parte, las buenas prácticas dicen que hay que usar las funciones de asesoramiento. Recomiendo leer su sección del manual.

-1:-- Modificar la salida de una función de emacs lisp sin redefinirla (Post )--L0--C0--February 06, 2018 10:10 PM

Bad Daemons: Múltiples cursores en emacs

Este es un paquete al que cuesta cogerle el punto. Pisa un poco las funcionalidades de las macros, es un poco especialito y hay que tener un poco de imaginación al usarlo, pero una vez le pillas el truco es muy útil.

El paquete que muestra el siguiente gif es de multiple-cursors, y hace exactamente esto, abrir múltiples cursores en emacs. Lo he estado usando últimamente que he tenido que he estado usando Terraform en el trabajo, y se presta al uso de este paquete. Veamos un ejemplo:

La primera función es mc/mark-next-like-this, que crea un cursor en el siguiente elemento que es igual al que se está seleccionando. Tiene su equivalente mc/mark-previous-like-this para lo mismo pero para atrás. La siguiente función es mc/mark-next-lines que marca la siguiente linea sin más. Igual que la anterior, tiene su equivalente inverso, mc/mark-previous-lines. Y por último, el más útil, como todos los dwim, Do What I Mean. Se comporta de forma distinta según desde dónde se ejecute. Si se selecciona una región, introduces una cadena de carácteres y inserta cursores en esas regiones. En otra región hará otra cosa.

En la fabulosa página de Emacs Rocks hay un screencast sobre este paquete. Son solo tres minutos y muestra otro ejemplo de como usar este modo.

-1:-- Múltiples cursores en emacs (Post )--L0--C0--December 11, 2017 07:30 AM