Planet Emacses

-1:-- Archivar tareas de tu OrgMode en Emacs (Post )--L0--C0--February 12, 2020 01:37 PM

Notxor tiene un blog: Utilización de registros en Emacs

-1:-- Utilización de registros en Emacs (Post )--L0--C0--February 11, 2020 12:00 AM

Blog uGeek: Marca de tiempo con Emacs

Edito con Emacs en diferentes dispositivos. Eso implica entre otras cosas, sincronizar estos archivos tanto con Rclone como Syncthing....

Sigue leyendo el post completo de Marca de tiempo con Emacs

-1:-- Marca de tiempo con Emacs (Post )--L0--C0--February 05, 2020 06:02 PM

Blog uGeek: Integración total de todotxt en Emacs

Utilizar org-mode con Emacs, no quiere decir que sea incompatible con el todo.txt....

Sigue leyendo el post completo de Integración total de todotxt en Emacs

-1:-- Integración total de todotxt en Emacs (Post )--L0--C0--January 29, 2020 04:56 PM

Blog uGeek: Copiando una página web o parte de ella a OrgMode

Vamos a utilizar un paquete que nos va a permitir copiar el contenido de una página web o parte de él, con enlaces, etc... a orgmode...

Sigue leyendo el post completo de Copiando una página web o parte de ella a OrgMode

-1:-- Copiando una página web o parte de ella a OrgMode (Post )--L0--C0--January 17, 2020 07:50 PM

Blog uGeek: Emacs en Android

Podemos utilizar Emacs en Android gracias a Termux a través de la Terminal. La novedad es que desde hace mas o menos un mes, hay un nuevo paquete x11 para...

Sigue leyendo el post completo de Emacs en Android

Managing BibTeX Files with Emacs

-1:-- Emacs en Android (Post )--L0--C0--January 16, 2020 05:45 PM

Notxor tiene un blog: Listas de tareas

-1:-- Listas de tareas (Post )--L0--C0--January 12, 2020 12:00 AM

Notxor tiene un blog: Escribir un correo electrónico

-1:-- Escribir un correo electrónico (Post )--L0--C0--January 03, 2020 12:00 AM

Notxor tiene un blog: Agenda, fechas y configuración de teclas

-1:-- Agenda, fechas y configuración de teclas (Post )--L0--C0--December 20, 2019 12:00 AM

Notxor tiene un blog: Herramientas para el sistema

-1:-- Herramientas para el sistema (Post )--L0--C0--December 05, 2019 12:00 AM

Maxxcan's Site: Proyecto Twice3D -- Impresora Recicladora

Presentación del proyecto Twice3D -- Impresora Recicladora

-1:-- Proyecto Twice3D -- Impresora Recicladora (Post )--L0--C0--November 06, 2019 12:00 AM

Maxxcan's Site: Introducción a la programación literaria

Introducción a la programación literaria

-1:-- Introducción a la programación literaria (Post )--L0--C0--October 23, 2019 12:00 AM

Onda Hostil: Mi entorno de trabajo

Me han preguntado bastantes veces cómo me organizo y, aunque hace un tiempo hablé un poco sobre mi entorno de trabajo en Emacs, desde entonces he introducido algunas mejoras así que voy a hablar de mi entorno de trabajo en general. Aprovecho para enlazar otras entradas del blog en las que hablé en concreto de las herramientas que cito para que se note que las uso de verdad y no es (solo) postureo.

La base: acta en Org

La base de mi metodología es un archivo de Org que utilizo como acta y lista de tareas. Org tiene la ventaja de que me permite añadir imágenes, código y enlaces a diferentes documentos y, además, puedo exportar la parte del acta en diferentes formatos según las manías del receptor.

Este archivo se abre directamente cuando abro Emacs por las mañanas para que pueda ver qué me queda por hacer y acceder directamente a los documentos o al código en los que estoy trabajando desde él, que se abrirán o no en el propio Emacs según su formato. Para que esto ocurra he añadido la siguiente líneas a mi archivos de configuración:

; Abrir archivos con programa que corresponda
; Lo privativo!
(add-hook 'org-mode-hook
           '(lambda ()
          (add-to-list 'org-file-apps
               '("\\.m\\'" . default)    ;; Matlab
               '("\\.fig\\'" . default)  ;; Matlab
               '("\\.xlsx\\'" . default) ;; Excel
               )))

; Abrir acta al iniciar Emacs
(find-file (expand-file-name "acta/acta.org" default-directory))

Como toda mi labor investigadora se basa en este archivo tengo, evidentemente, una copia de seguridad.

El soporte auxiliar: diario de Emacs

Aparte de tener apuntadas mis tareas por temática, llevo un diario en el que apunto qué he hecho cada día. Esto tiene una doble función: por una parte, cuando me desmoralizo y creo que no avanzo, tengo evidencia empírica de que no es así; por otra, me sirve para seguir mi proceso mental y recordar qué estaba haciendo antes de irme de vacaciones, por ejemplo. Esto me resulta crucial porque me permite tanto desconectar en cuanto levanto el culo de la silla del trabajo como tener mis ideas hiladas en un lugar que no es mi (variable) cabeza.

Para ello uso el diario de Emacs de manera poco ortodoxa, que es como me gusta a mí usar las cosas. Tengo una copia de seguridad también del diario, claro.

El producto: texto plano y control de versiones

El tercer pilar de mi organización es que todo lo que produzco (los documentos, la bibliografía, las imágenes, el código …) es texto plano. Aparte de que de esta manera podré seguir accediendo a mi información dentro de treinta años¹, así puedo tener todo bajo control de versiones. Para el control de versiones uso Magit en Emacs y git en la terminal por la vieja costumbre.

Os detallo un poco más cómo funciono:

Documentos: escribo en Org o en LaTeX tanto los artículos como los informes y las presentaciones para clase. Para LaTeX uso el modo AUCTeX con RefTeX para las referencias bibliográficas, CDLaTeX para las ecuaciones y Company para el autocompletado.
Bibliografía: la manejo con Jabref y, últimamente, con Helm-bibtex desde el propio Emacs. En este último caso, uso las variables locales para seleccionar el archivo de bibliografía correspondiente a cada documento así como la carpeta donde viven los pdfs.

%%% Local Variables:
%%% eval:(setq bibtex-completion-bibliography '("ruta_a_bib"))
%%% eval:(setq bibtex-completion-library-path '("ruta_a_pdf"))
%%% End:

Imágenes: trabajo generalmente con svg en Inkscape, o exporto a eps o svg desde el resto de programas. El motivo es que ambos son formatos vectoriales y eps el favorito de las revistas científicas. Para las gráficas científicas, tengo el código para producir la imagen bajo control de versiones y una función que le da un estilo uniforme a todas las imágenes que exporto.
Código: programo en Matlab por obligación y en Julia y últimamente algo en Python por vicio. Con Matlab hago más que suficiente con no caer en las malas prácticas que fomenta. Para programar en los otros dos uso los modos específicos de Emacs y también Org para programación literaria.

Un día en mi vida

Dicho esto, uno de mis días laborales suele tener esta estructura:

Abro Emacs.
Leo en la lista de tareas qué me queda por hacer y en el diario qué hice el día anterior.
Decido qué voy a hacer. Si hay un archivo relacionado, estará enlazado en la propia lista de tareas y se me abrirá en Emacs o en el programa externo correspondiente.
Trabajo. Escribo, programo, busco papers … abro ramas y envío actualizaciones al repo según corresponda con Magit o desde la terminal.
Actualizo la lista de tareas y el diario con lo que vaya terminando y las conclusiones sacadas.
Cierro Emacs.

Esta rutina laboral se irá modificando según vaya aprendiendo cosas nuevas, cuando eso ya os contaré. ¡De momento contadme vosotros qué hacéis!

Dudo que vaya a querer, pero podré.

-1:-- Mi entorno de trabajo (Post Ondiz)--L0--C0--October 16, 2019 03:00 PM

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

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

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 F1–F12.

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 "<apps> 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.

ACTUALIZACIÓN (16/10/2019) Por algún motivo que desconozco (Windows), la ruta relativa dejó de funcionar de un día para otro y tuve que poner la ruta absoluta.

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 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

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

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

-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 Babel¹. 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 documento².

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:

También hay un paquete específico para Julia, pero ¿me gusta a mí lo fácil? No. ↩
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

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

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:

No hacer nada salvo devolver la propia lista
Devolver un error
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,...

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,...

-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

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é?...

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