Notxor tiene un blog: nyxt 2.0

Creo que ya mencioné alguna vez nyxt en este blog o quizá estoy equivocado y sólo pensé hacerlo. En mi incansable búsqueda de un web browser gráfico que llevarme a mis navegaciones por la Internet, cada vez más, me van faltando alternativas. Parece que hay que quieren obligarme a morir al palo de chrome y así llegué a encontrar éste navegador, completamente escrito en Lisp. Hice varias pruebas con él en su versión 1.1 y lo encontré muy prometedor pero algo inestable e incompleto. Hace poco que me enteré que salió la versión 2.01 y vuelvo al ataque, a ver si ha mejorado y efectivamente: lo ha hecho. ¿Es mi navegador por defecto? Actualmente no, pero promete mucho y su modo Emacs me facilita mucho las cosas.

Inconveniente: no me compila

A pesar de mis esfuerzos por compilarlo desde el código fuente no he conseguido hacerlo. Mi hipótesis es que compila dependiendo de manera bastante cerrada de cómo están situadas las librerías en la distribución GNU/Linux y no encuentra dónde las sitúa OpenSuse. Porque el error que me lanza es sobre una librería que tengo instalada en una versión adecuada junto con el paquete devel con las cabeceras. El resto de dependencias, especialmente las de Lisp se manejan automáticamente por el compilador sbcl ─el mismo que usa el programador del sistema─ y no parece que haya problemas por ese lado.

No debo ser el único, porque una de las formas de distribución de nyxt es con todo el paquete conteniendo las dependencias y librerías metido todo en uno. Una solución que funciona, pero que ocupa un güevo y la yema del otro.

Ese fue el motivo de descartarlo después de las pruebas iniciales que hice la primera vez... pero acabándose las alternativas, a estas alturas no me parece que sea tan descabellado instalarlo de ese modo. No es el ideal y me gustaría haber podido compilarlo, pero al menos funciona y puedo ir haciendo pruebas hasta que encuentre cómo arreglar el problema de compilación.

Cómo funciona

Captura-pantalla_nyxt-pagina-nyxt.png

La ventana del navegador tiene una apariencia pulcra y cuidada. ¿Te recuerda a tu editor favorito? A mí sí.

En la barra de estado podemos ver los habituales botones (de izquierda a derecha) que nos permiten navegar a la página anterior, a la posterior o recargar la página. El siguiente nos permite ejecutar uno de los comandos del navegador y el último es la lista de buffers abiertos. Al lado de la botonera está la dirección de la página que tienes abierta. Más a la derecha una lista con los buffers que están abiertos, y por último, el espacio más a la derecha, nos dice los modos activados (por ejemplo, emacs, noscript, etc.). Debajo de la línea de estado, hay un buffer de texto que nos mostrará opciones según los comandos, muy parecido a como funciona Emacs aunque más ordenado y formateado en tablas.

Acabo de pasar por el asunto de los comandos muy rápido pero lleva un completo intérprete de Lisp cargado en él.

Captura-pantalla_lisp-repl.png

No lo he explorado aún a fondo, pero promete mucho, mucho. Para rematar, no sé si os sonará, puedes meter cualquier parámetro de inicio en el fichero ~/.config/nyxt/init.lisp. Concretamente tengo apenas dos ajustes para él:

;; Desactivar el javascript, por defencto al abrir un buffer
(define-configuration buffer
  ((default-modes (append '(noscript-mode) %slot-default%))))

;; Configurar las teclas de comando en modo Emacs
(define-configuration buffer
  ((default-modes (append '(emacs-mode) %slot-default%))))

Es posible también que no quieras modificar todas las teclas y sólo quieras una o dos. Puedes, por ejemplo, modificar la combinación de teclas para ejecutar un comando, sin cargar el emacs-mode, tal que:

(define-configuration buffer
  ((override-map (let ((map (make-keymap "override-map")))
                   (define-key map
                     "M-x" 'execute-command)))))

Y esto me lleva al siguiente punto.

Modos de teclas

Otra de las cosas que me encanta del navegador es que cuenta con modos de funcionamiento. Para resumirlo de manera rápida, nyxt puede funcionar en tres modos, o conjuntos de definición de teclas, CUA (por defecto), emacs y vi (este tiene dos modos, vi-insert y vi-normal2).

Por ejemplo, dos capturas para ver cómo cambian las cosas según el modo empleado:

Captura-pantalla_follow-hint-CUA.png
Captura-pantalla_follow-hint-emacs.png

En la primera captura se puede apreciar la configuración por defecto de teclas. Sin embargo, en la siguiente, vemos la misma captura de comando, pero con el emacs-mode activado. Por ejemplo, la combinación de teclas para activar execute-command en el modo por defecto es C-Espacio, mientras que en emacs-mode es M-x.

Edición

También cuenta con un editor de código interno:

Captura-pantalla_editor-buffer.png

Aún le queda mucho recorrido para alcanzar otras herramientas de desarrollo html, apenas es un buffer donde poder cargar un fichero html o css o js y modificar un poco su código, sin coloreado de sintaxis siquiera.

Navegación sin ratón

Navegar con ratón es como lo hacen el resto de los navegadores web. El problema de otros navegadores es que sin ratón, navegar es la muerte a pellizcos. Por el contrario, nyxt permite hacerlo sin ese periférico sin morir en el intento.

Para navegar por las páginas web podemos encontrar dos maneras distintas, que no falten alternativas. Una que tiene que ver con la lógica de la página utilizando el comando jump-to-heading, que nos mostrará una lista de las cabeceras definidas en la web cargada. Por ejemplo:

Captura-pantalla_navegacion-por-titulos.png

Si las páginas web sólo nos permitieran saltar a esos titulares no serían demasiado flexibles, quizá sería mejor leer un libro. La potencia de la web es precisamente que podemos encontrar un montón de enlaces en las páginas abiertas y formar la famosa red, abriendo todo un inmenso mundo de posibilidades a la navegación. La mayoría de los browsers gráficos permiten pinchar en cualquier enlace con el ratón, pero, como he dicho antes, si por algún motivo no tienes ratón o ganas de usarlo, navegar con cualquiera de ellos consiste en descargar desesperadamente nuestra frustración sobre el tabulador hasta alcanzar el elemento que deseamos para pulsar enter.

nyxt establece un comando que nos permite, mostrando una lista de los enlaces encontrados en la página, seleccionar cuál queremos utilizar y permitirnos saltar:

Captura-pantalla_navegacion-sin-raton.png

El principio es sencillo, se añade una etiqueta, combinación de letras a cada enlace y una lista que muestra el texto del enlace y la URL asociada. Basta movernos por esa lista o teclear el hint y nos moveremos como con el ratón.

Conclusión

Es pronto para sacar conclusiones, me quedan aún muchas cosas para investigar. En su uso, encuentro que es un navegador ligero, responde bien y rápido a los comandos, pero aún me encuentro torpe en su uso y desconozco muchas de las posibilidades que puede ofrecer.

El que funcione mediante comandos, da la sensación, que permitirá el poder generar scripts que no sólo configuren su funcionamiento, sino que completen las cosas que puede hacer. Me da la sensación de que puede convertirse en todo un nicho de desarrollo de aplicaciones, como lo es Emacs y como otros navegadores intentas emular con un lenguaje, javascript, menos agraciado que Lisp.

Ya volveré sobre el tema si consigo algo más interesante que contar.

Footnotes:

1

El día 20 del mes pasado.

2

Dos escrituras a elegir, vi, vi, vi, vi, viiiii... ya me disculparéis la coña.

-1:-- nyxt 2.0 (Post )--L0--C0--June 10, 2021 06:58 AM

Blog uGeek: Wallabag en Emacs

Wallabag en Emacs

Hay publicado un nuevo paquete de wallabag para Emacs en GitHub. De momento no está disponible en Melpa u otros repositorios, así que si quieres hacer uso, tienes que clonar...

Sigue leyendo el post completo de Wallabag en Emacs

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Wallabag en Emacs (Post )--L0--C0--April 15, 2021 05:50 PM

Notxor tiene un blog: Emacs y lsp-mode

Hoy vengo con un modo que hace poco que empecé a utilizar: lsp-mode. La verdad es que no lo utilizo demasiado, la mayor parte de mi trabajo la hago en org-mode y lo que menos hago es programar, que es para lo que es más útil lsp, aunque también podría usarlo para LaTeX. Language Server Protocol se está convirtiendo en un estándar para todos los editores de código e incluso los editores viejunos como Emacs y vim lo soportan. Este artículo hablará de cómo configurarlo mínimamente en Emacs y sobre un par de pruebas que he hecho para ver su funcionamiento.

Como decía, mi trabajo habitual, como corresponde a un psicólogo, no es programar sino escribir mucha documentación, informes, registros de visitas, planes de prevención, cursos de formación, blog... en fin, la mayor parte de lo que hago es escribir con org-mode o con LaTeX y para ello no necesito utilizar lsp-mode. En realidad, tampoco lo necesito utilizar cuando programo, algo que últimamente hago en elixir y para el que utilizo el paquete alchemist de Emacs, que cubre todas mis necesidades de sobra.

Descubrí lsp-mode cuando hice la aproximación o intento de aprender Rust. Lenguaje, que como ya dije en este blog, abandoné por desconfianza en los miembros de la fundación que se ha hecho cargo de su desarrollo. Cuando empecé a trastear con ese lenguaje, el modo de Emacs pedía insistentemente el lsp-mode y al final cedí y lo instalé. La experiencia fue breve pero pensé que debía probar un poco más ese paquete. La verdad es que lsp convierte cualquier editor en un IDE completo y proporciona funcionalidad de completado de sintaxis, ayuda contextual, navegación por el código, etc. Todo lo que puedas esperar de un buen editor. Para muchas de esas cosas Emacs tiene suficientes herramientas para trabajar y no necesita, en principio, servidores externos. Recuerdo que alguien me preguntó una vez qué editor actual usaría, que no sean mis dos preferidos Emacs y vim. Quizá la respuesta esperada estaría entre los famosos sublime, atom y similare... sin embargo, creo que mi respuesta ahora, conociendo lsp sería Kate: tiene todo lo que tienen los mencionados (y más), y kate traga menos recursos además de tener el soporte de lsp, que lo convierte en una magnífica alternativa.

Para entender cómo funciona lsp hay que comenzar diciendo que es el acrónimo de Protocolo de Servidor de Lenguaje. Es decir, hay un servidor con el que se comunica el editor para dotarle de todas esas características. Cada lenguaje tiene su servidor independiente, lo que obliga a que tendremos que tener un servidor de esos por lenguaje. No voy a entrar más allá en cómo funciona pero hay que dejar claro que la funcionalidad la proporciona un elemento externo al editor.

Instalación de lsp-mode

Tenemos la habitual instrucción de package-install. Como tampoco voy a ser muy exhaustivo, si estáis pensando en utilizarlo, es que os leáis su web:

M-x package-install <RET> lsp-mode <RET>

El paquete ya estará instalado en nuestro editor aunque de una manera muy básica. Lo que hace lsp-mode es intentar integrar el funcionamiento de lsp con los habituales paquetes de Emacs company, flycheck o flymake, projectile son los básicos, pero también utiliza otros como dired, treemacs, iedit... Por tanto hay que tener en cuenta que debemos tener instalados todos esos paquetes en nuestro Emacs para tener toda la funcionalidad. Al menos para lo básico:

  • company: es un paquete para el autocompletado de código. Hay paquetes para multitud de lenguajes específicos.
  • flymake: viene instalado con Emacs en sus últimas versiones y sirve para evaluar errores y warnings del código sobre la marcha.
  • projectile: es un paquete para la gestión de proyectos.

También es muy recomendable instalar junto con lsp-mode el paquete lsp-ui porque éste nos facilita también la navegación visual por el código, desplegables de documentación, selector de acciones de código, etc. Otro paquete que puede ser interesante es dap-mode para integrar el debugger. Aunque según qué lenguaje, sobre todo si podemos utilizar gdb, también podemos utilizar el modo de depuración propio de Emacs. Y por último, también es recomendable que si usas ivy o helm es recomendable que instales el paquete lsp-ivy o lsp-helm.

Configuración

La configuración que tengo activada para las pruebas incluye tan solo dos lenguajes. Uno es C++, para el que no he tenido que hacer nada especial durante su configuración. Parece que lsp-mode ya lo trae preparado todo. Fue abrir un fichero con en ese lenguaje y todo funcionó sin problemas. El segundo lenguaje es Python, que necesité instalar el servidor del lenguaje. Lo que me viene bien para mostrar las dos alternativas.

No voy a entrar en la configuración de todos los otros paquetes auxiliares, porque sería extenderme innecesariamente. La configuración que tengo en mi init.el es muy sencilla:

;;; Establecer prefijo para lsp-mode
(setq lsp-keymap-prefix "C-l")

;;; Configuración de lsp-mode
(require 'lsp-mode)
(add-hook 'python-mode-hook #'lsp)
(add-hook 'c++-mode-hook #'lsp)

La primera línea no necesita mucha explicación: establece como prefijo para los comandos de lsp la combinación C-l. Las dos últimas líneas indican que cuando se entre en los modos para programar en Python o c++ se lance el modo lsp. Como sabéis #' es un atajo para función en elisp. Lo que hace esa función es levantar el servidor y entrar en lsp-mode. Arrancar el servidor, puede llevar unos segundos. Además hay que añadir que al entrar en lsp-mode este configura de forma automática tanto lsp-ui como company-mode. Si se quiere retrasar el lanzamiento del servidor hasta que sea visible el contenido del buffer, se puede utilizar lsp-deferred en lugar de lsp.

Utilizando flymake, en su día, también definí un par de combinaciones para navegar por los errores y que vienen bien mientras programas con flymake activado:

(global-set-key (kbd "C-c f n") 'flymake-goto-next-error)
(global-set-key (kbd "C-c f p") 'flymake-goto-prev-error)

Como digo, en mi caso ya tenía algunas de estas herramientas configuradas y preparadas para trabajar. Pero para profundizar un poco haciendo pruebas y poder escribir este artículo he utilizado el lsp-mode con los dos lenguajes que dije antes. Aunque programo más en otros lenguajes y no uso para ellos esta herramienta.

Para más precisión en la configuración, es recomendable, que antes te leas detenidamente todas las opciones que hay en su web para ajustar todos los aspectos y comportamientos.

Captura-pantalla_lsp-cplusplus.png

En ambos lenguajes parece funcionar correctamente:

Captura-pantalla_lsp-python.png

Al menos todo lo bien en las pruebas que he hecho, que aunque no han sido exhaustivas ni durante demasiado tiempo, puedo asegurar que en ambos casos me ha funcionado el modo con soltura. Sin embargo, para usar lsp-mode con Python he tenido que instalar el paquete del servidor de lenguaje.

Instalando servidores de lenguaje

Como dije antes, para trabajar con C++ no necesité ningún paso intermedio, simplemente, instalé el modo y lo configuré como hemos visto antes. Automáticamente funcionó con ese lenguaje. No fue así con Python: abría un fichero .py, intentaba activar el modo lsp-mode y lanzaba un error. El problema lo pude resumir en que no encontraba el Language Server y tuve que instalarlo.

La instalación fue tan sencilla como abrir una consola y teclear:

pip install pyls

A partir de ese momento comenzó a funcionar lsp-mode. Estuve barajando también el instalar jedi-language-server, en lugar de pyls, pero implicaba que también había que instalar lsp~jedi en Emacs para funcionar y me pareció que ya eran demasiados paquetes sólo para hacer pruebas. La alternativa parece también válida e interesante, pero no quería liarlo más.

En todo esto de instalar o no servidores ls supongo que influye también el haber utilizado con ese lenguaje algún editor que ya soportaba de antes lsp y de tener instalado precisamente el que necesitas. De todas formas, también podemos encontrar que el mismo modo lsp puede instalar una serie de servidores con el comando lsp-install-server.

Es también conveniente echar un vistazo a todos los servidores soportados por lsp-mode y seguir las instrucciones para instalar el que nos convenga.

Funciones principales de lsp-mode

Las funciones principales, o que más se utilizan, vienen definidas a partir del atajo de teclado que hayamos establecido en la configuración. En mi caso utilizo como combinación base para lsp-mode el atajo C-l:

lsp-format-buffer
C-l = =, unifica el formato del buffer para unificar el aspecto y hacer el código más legible.
lsp-format-region
C-l = r. Da formato a la región seleccionada.
lsp-find-declaration
C-l g d, nos lleva a la declaración de una función, constante o variable.
lsp-find-definition
C-l g g, nos lleva donde esté definida la función, constante o variable.
lsp-find-references
C-l g r, nos muestra una lista de todas las apariciones y referencias de una función, constante o variable dentro del proyecto permitiéndonos saltar a ellas.
lsp-rename
C-l r r, renombra un identificador en todas sus apariciones.
lsp-workspace-shutdown
C-l s q, sale del espacio de trabajo cerrando el servidor y saliendo del modo.
lsp-workspace-restart
C-l s r, reinicia el espacio de trabajo.
lsp
C-l s s, lanza el espacio de trabajo levantando el servidor y entrando en el modo.

Hay más funciones que explorar pero esta es la lista de las que más he usado y que más útiles puede resultar.

Conclusión

El modo lsp-mode es bastante completo, pero al final se integra con otros modos y paquetes que ya puedes utilizar directamente en Emacs sin necesitarlo: como dired (para la gestión de directorios) o iedit (para escribir a la vez en varias zonas de un buffer), etc.

¿Qué aporta entonces lsp-mode a Emacs? Pues básicamente uniformidad entre lenguajes... Poco más que reseñar. Por ejemplo, toda la funcionalidad que proporciona lsp lo proporciona, por ejemplo, alchemist, el modo de programación para elixir, pero con sus atajos de teclas y sus idiosincrasias. Quizá también aporte que algunos programadores decidan pasarse a editores viejunos, pero potentes, que les proporcionen las mismas funcionalidades que los modernos pero sin tantos quebraderos de cabeza como las configuraciones: configuras mínimamente el editor, configuras lsp y todo funciona como esperas de un IDE.

-1:-- Emacs y lsp-mode (Post )--L0--C0--March 11, 2021 08:20 AM

Maxxcan's Site: Introducción a org-static-blog

Introducción

Org-static-blog es un generador de blog estático. Está enfocado en la simplicidad. Todos los ficheros son simples ficheros org-mode en un directorio. El único requerimiento es que esos ficheros tengan un #+TITLE y un #+DATE, y opcionalmente, #+FILETAGS.

Instalación

Para instalarlo es tan sencillo como hacerlo desde el gestor de paquetes de Emacs o con el comando package-install, siempre claro que tengamos en nuestra configuración añadido los repositorios marmalade y/o melpa-stable.

Como recordatorio para añadir el repositorio melpa-stable solo hay que añadir lo siguiente a nuestro fichero de configuración principal de Emacs.

(require 'package)
(setq package-archives (append package-archives
                               '(("melpa" . "http://melpa.org/packages/"))))
(package-initialize)

Configuración

Explicación

Para org-static-blog, un blog consiste en 6 partes:

  1. Los post en sí. Todo fichero org en el directorio org-static-blog-posts es un post en el blog. Cada post es renderizado como su propia página HTML.
  2. La página índice que contiene los últimos post en una sola página. El número de entradas en el índice puede ser modificada usando org-static-blog-index-length.
  3. Opcionalmente muestra una previsualización de un párrafo en vez del post entero en el índice usando org-static-blog-use-preview.
  4. Una página de archivo que lista las fechas y las cabeceras de todos los post publicados.
  5. El fichero XML RSS para los agregadores de noticias.
  6. Cada post del blog puede tener etiquetas, y cada etiqueta enlace a las páginas que tienen las mismas etiquetas. Además de una página con todas las etiquetas es creada con una lista de las fechas de publicación y la cabecera de todos los post. Esta característica solo será habilitada si habilitamos la opción org-static-blog-enable-tags.

Cada página HTML se puede personalizar con las siguientes opciones.

  1. Con la variable org-static-blog-page-header insertamos el código que queramos en la sección <head> de cada página. Esto incluye el CSS y el Javascript de nuestro blog.
  2. El contenido de org-static-blog-page-preamble es insertado justo antes del contenido de cada página. Es un buen sitio para poner las cabeceras o menús del blog.
  3. El contenido de org-static-blog-postamble es insertado después del contenido de cada página generada. Aquí es donde se suele incluir el copyright u otra información relevante del blog.

También podemos personalizar el fichero RSS configurando org-static-blog-rss-extra. Su contenido será localizado a la derecha antes de la secuencia de posts. Por ejemplo podemos añadir el icono del RSS o decir que el blog está creado con org-static-blog, por ejemplo.

Algunos textos como "Other posts", "Tags", etc que org-static-blog incluye por defecto. Estos están en inglés, pero para cambiar el lenguaje podemos cambiar el valor de org-static-blog-langcode.

Configuración de ejemplo

Si todo lo anterior te ha parecido muy largo lo más seguro es que con este ejemplo lo entiendas rápidamente:

  (setq org-static-blog-publish-title "Titulo del blog")
  (setq org-static-blog-publish-url "https://direccion-del-blog")
  (setq org-static-blog-publish-directory "~/proyectos/blog/publish/")
  (setq org-static-blog-posts-directory "~/proyectos/blog/posts/")
  (setq org-static-blog-drafts-directory "~/proyectos/blog/drafts/")
  (setq org-static-blog-enable-tags t)
  (setq org-export-with-toc nil)
  (setq org-export-with-section-numbers nil)
  ;; Esta cabecera es insertada en la sección <head> de cada página web:
  ;; (crearemos una hoja de estilos en ~/proyectos/blog/static/style.css
  ;; y el favicon en ~/proyectos/blog/static/favicon.ico)
  (setq org-static-blog-page-header
          "<meta name=\"author\" content=\"Tu nombre\">
          <meta name=\"referrer\" content=\"no-referrer\">
          <link href= \"static/style.css\" rel=\"stylesheet\" type=\"text/css\" />
          <link rel=\"icon\" href=\"static/favicon.ico\">")
  ;; Esto se inserta al principio de la sección <body> de toda página:
  ;; Esto en particular crea un <div> con un simple enlace a la cabecera
  (setq org-static-blog-page-preamble
        "<div class=\"header\">
            <a href=\"https://maxxcan.com\">Mi Blog</a>
          </div>")
  ;; Esta sección es insertada al final del <body> de cada página:
  ;; Esto en particular crea un <div> con un enlace a la página de los archivos y a la licencia
(setq org-static-blog-page-postamble
"<div id=\"archive\">
<a href=\"https://www.maxxcan.com/archive.html\"> Otros Posts</a>
</div>
<center><a rel=\"license\" href=\"https://creativecommons.org/licenses/by-sa/3.0/\"><img alt=\"Creative Commons License\" 
style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/3.0/88x31.png\" /></a><br />
<span xmlns:dct=\"https://purl.org/dc/terms/\" href=\"https://purl.org/dc/dcmitype/Text\" 
property=\"dct:title\" rel=\"dct:type\">Maxxcan.com</span> by 
<a xmlns:cc=\"https://creativecommons.org/ns#\" href=\"https://www.maxxcan.com\" 
property=\"cc:attributionName\" rel=\"cc:attributionURL\">
Maxxcan Fox</a> is licensed under a <a rel=\"license\"
 href=\"https://creativecommons.org/licenses/by-sa/3.0/\">Creative Commons Attribution-ShareAlike 3.0 Unported License</a>.
</center>")
  ;; Este código HTML es insertado en la página del índice entre el preámbulo y los posts del blog 
  (setq org-static-blog-index-front-matter
          "<h1> Bienvenido a mi blog </h1>\n")

Otras configuraciones

En la página del autor podemos encontrar más configuraciones, aunque sabiendo un poco Javascript toda configuración es posible. Por ejemplo siqueremos añadir comentarios con disqus podemos añadir el siguiente código al configurar el org-static-blog-postamble:

(setq org-static-blog-page-postamble  
   "<div id=\"archive\">  
   <a href=\"https://maxxcan.com/archive.html\">Otros posts</a>  
   </div>  
   <center><button id=\"disqus_button\" onclick=\"load_disqus()\">Load Disqus Comments</button></center>  
   <div id=\"disqus_thread\"></div>  
   <script type=\"text/javascript\">  
   function load_disqus() {  
   var dsq = document.createElement('script');  
   dsq.type = 'text/javascript';  
   dsq.async = true;  
   dsq.src = 'https://bastibe.disqus.com/embed.js';  
   (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);  
   document.getElementById('disqus_button').style.visibility = 'hidden';  
   };  
   </script>  
   <center><a rel=\"license\" href=\"https://creativecommons.org/licenses/by-sa/3.0/\"><img alt=\"Creative Commons  
   License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/3.0/88x31.png\" /></a><br /><span  
   xmlns:dct=\"https://purl.org/dc/terms/\" href=\"https://purl.org/dc/dcmitype/Text\" property=\"dct:title\"  
   rel=\"dct:type\">bastibe.de</span> by <a xmlns:cc=\"https://creativecommons.org/ns#\" href=\"https://bastibe.de\"  
   property=\"cc:attributionName\" rel=\"cc:attributionURL\">Maxxcan</a> is licensed under a <a rel=\"license\"  
   href=\"https://creativecommons.org/licenses/by-sa/3.0/\">Creative Commons Attribution-ShareAlike 3.0 Unported  
   License</a>.</center>")  

Añadiendo la licencia y la posibilidad de usar Disqus como sistema de comentarios. También podríamos añadir nuestro propio sistema si conocemos el Javascript necesario.

Mi configuración

Además de lo visto por si puede ser de ayuda dejo aquí mi propia configuración:

(setq org-static-blog-publish-title "Mi Blog Personal sobre Cosas que discurren")
(setq org-static-blog-publish-url "https://www.maxxcan.com/")
(setq org-static-blog-publish-directory "~/Documentos/blog/publish")
(setq org-static-blog-posts-directory "~/Documentos/blog/posts/")
(setq org-static-blog-drafts-directory "~/Documentos/blog/drafts/")
(setq org-static-blog-enable-tags t)
(setq org-export-with-toc nil)
(setq org-export-with-section-numbers nil)
(setq org-static-blog-langcode "es")
(setq org-static-blog-use-preview t)
(setq org-static-blog-preview-link-p t)
(setq org-static-blog-preview-convert-titles t)
(setq org-static-blog-preview-ellipsis "Sigue leyendo... / Continue reading...")

;; This header is inserted into the <head> section of every page:
;;   (you will need to create the style sheet at
;;    ~/projects/blog/static/style.css
;;    and the favicon at
;;    ~/projects/blog/static/favicon.ico)
(setq org-static-blog-page-header
      "<meta name=\"author\" content=\"Maxxcan Fox\">
<meta name=\"referrer\" content=\"no-referrer\">
<link href= \"static/style.css\" rel=\"stylesheet\" type=\"text/css\" />
<link href= \"static/code.css\" rel=\"stylesheet\" type=\"text/css\" />
<link rel=\"icon\" href=\"static/favicon.ico\">")

;; This preamble is inserted at the beginning of the <body> of every page:
;;   This particular HTML creates a <div> with a simple linked headline
(setq org-static-blog-page-preamble
      "<div class=\"header\">
  <a href=\"https://www.maxxcan.com\">Blog Personal de Maxxcan Fox</a>
</div>")

;; This postamble is inserted at the end of the <body> of every page:
;;   This particular HTML creates a <div> with a link to the archive page
;;   and a licensing stub.
(setq org-static-blog-page-postamble
      "<div id=\"archive\">
<a href=\"https://www.maxxcan.com/rss.html\">RSS</a></div>
<center><a rel=\"license\" href=\"https://creativecommons.org/licenses/by-sa/3.0/\"><img alt=\"Creative Commons License\" 
style=\"border-width:0\" 
src=\"https://i.creativecommons.org/l/by-sa/3.0/88x31.png\" /></a><br />
<span xmlns:dct=\"https://purl.org/dc/terms/\" href=\"https://purl.org/dc/dcmitype/Text\" 
property=\"dct:title\" rel=\"dct:type\">Maxxcan.com</span> by 
<a xmlns:cc=\"https://creativecommons.org/ns#\"href=\"mailto:maxxcan@disroot.org\" 
property=\"cc:attributionName\" 
rel=\"cc:attributionURL\">Maxxcan Fox</a> is licensed under a <a rel=\"license\" 
href=\"https://creativecommons.org/licenses/by-sa/3.0/\">
Creative Commons Attribution-ShareAlike 3.0 Unported License</a>.<br />
Si quieres contactar  conmigo puedes hacerlo a través de mi correo 
<a href=\"mailto:maxxcan@disroot.com\">maxxcan@disroot.org</a>
</center>")

Uso

Esta es la parte más divertida y más fácil. Ahora una vez configurado ahora solo hay que llamar a la función org-static-blog-posts-create-new-post, escribir el contenido y renderizarlo con org-static-blog-posts-publish. Cada post será un fichero org con lo siguiente:

#+TITLE: El titulo de nuestro post
#+DATE: <2021-03-02 mar>
#+FILETAGS: emacs blog editor 

Resumiendo solo hay que hacer 4 pasos:

  1. package-install org-static-blog
  2. Ejecutar Alt-x: org-static-blog-create-new-post y escribir el contenido
  3. Ejecutar Alt-x: org-static-blog-publish
  4. Subir el contenido de la carpeta ~/proyectos/blog/publish/ al servidor.

Nota Importante

En ocasiones cuando ejecutamos org-static-blog-publish éste no funciona y nos saca del buffer. Si esto ocurriera podemos también probar con la función org-static-blog-publish-file que exportará el org a html y entonces ejecutamos org-static-blog-publish para crear todo el blog.

Conclusiones

El sistema de org-static-blog es sencillo, fácil de gestionar ya que solo tienes que gestionar un directorio y sus directorios, y puedes gestionarlos con cualquier control de versiones, cifrarlos con pgp, etc. Además no tiene requerimientos externos ni hace falta tener nada más instalado a parte de Emacs.

Para más información pasad por la información de su autor donde hay incluso ejemplos de blogs que lo usan.

También podéis visitar el post de Notxor donde tiene un artículo que habla sobre ello.

-1:-- Introducción a org-static-blog (Post )--L0--C0--March 04, 2021 09:00 AM

Maxxcan's Site: Presentación del Blog

Introducción

Que valga este post como reinicio del blog personal que llevo desde hace un tiempo pero que por mi falta de constancia desde hace un tiempo que no actualizo. Por mi falta de constancia y por no encontrar un sistema que realmente me convenciera para llevar la gestión de él. Sistema que he encontrado en algo sencillo y minimalista como org-static-blog y del que hablaré sobre él en el siguiente post.

Volvemos a la carga

Como ya he dicho volvemos de nuevo tras muchos meses de parada, y es que desde hace tiempo que sufro de un profundo problema a la hora de retomar un proyecto ya empezado, requiero de mucha fuerza de voluntad y tener que volver a recordar cosas que ya había aprendido. Esto lo estoy superando gracias al Método Zettelkasten, del que hablaré en muchos post ya que una de las cosas que me ha hecho retomar el blog es profundizar en este método y cómo combinarlo con otras técnicas para mejorar nuestra productividad. Si ya tienes curiosidad puedes tener más información en esta página web.

Más variedad al Blog

Aunque mi blog iba enfocado inicialmente solo a artículos sobre el mejor Editor/programa/SO del mundo como es Emacs, la idea no es quedarme ahí, aunque Emacs da para muchos blogs y publicaciones, sino hablar de más cosas relacionadas con lo que me gusta y/o investigo. Esto es: computación, programación, biología, biotecnología, electrónica, productividad y diseño 2D y 3D, también cine, libros y cultura en general, así como pensamientos varios sobre la vida, el mundo y lo que viene siendo las cosas que transcurren en nuestro loco loco mundo.

Buscando una marca personal

Todo esto para buscar y encontrar una marca personal que me defina si es que eso es posible. Desde hace mucho me gusta la idea de ir buscando nuevas experiencias, aprender cosas constantemente y no terminar definiéndome a ningún estricto sistema de identificación de mi trabajo. Eso me tuvo un poco contrariado por un tiempo hasta que leí que a las personas como yo se les llama Exploradores, es un arquetipo desde hace mucho definido por la psicología y hay más. Éste y otros pueden ayudar no tanto a definirte, ya he dicho que estoy en contra de esas cosas, pero sí a definir tu trabajo y lo más importante a presentarte frente al mundo. Esto lo explican muy bien en este artículo llamado como crear tu marca personal basándote en los arquetipos de Jung y sobre esto y otras cosas relacionadas también hablaré.

Agradecimientos

Me gustaría agradecer de antemano toda aquella persona que gaste su tiempo en leer el blog y en aportar comentarios o recomendaciones sobre él o mi trabajo. Muchas gracias. El que quiera puede libremente usar mi correo electrónico para cualquier duda, comentario y/o aportación. Como digo se agradecerá mucho.

-1:-- Presentación del Blog (Post )--L0--C0--March 04, 2021 09:00 AM

Notxor tiene un blog: Publicar con org-mode II

Este es un artículo de esos incoherentes en los que me dedico a contestar preguntas y peticiones de aclaración. Ya en este blog hablé de cómo publicar en html con org-mode, fue un artículo casi a vuela pluma y rápido sin detenerme en detalles y eso ha propiciado varias dudas. Además, algunos me habéis preguntado por más detalles sobre la publicación y los distintos formatos en los que podemos publicar. Además de detalles que hay que tener en cuenta. El principal foco de atención han sido las plantillas, y particularmente qué opciones de exportación son más aconsejables. También cómo montar un servidor local para visualizar los cambios y hacer pruebas, en el caso de que sea un proyecto para html: bien sea un blog o simplemente documentación. Y también cómo gestionar si se desea que la salida se produzca en varios formatos, por ejemplo, html y pdf. Y también si es mejor utilizar etiquetas include o enlazar los archivos. Algunas de estas preguntas tienen respuestas sencillas de procedimiento, pero a otras sólo puedo contestar: depende. Ahora bien, ese depende es lo que explico en adelante.

El depende principal es el de la salida que queremos obtener y en función de esa salida debemos trabajar. Cuando el proyecto sólo se publicará en un formato, no hay ningún problema: configuramos ese formato y no hará falta más. Cuando hacemos cambios generamos la salida y todo funcionará perfectamente. El problema viene cuando queremos generar documentos de diverso tipo con sus diferentes idiosincrasias. No hace falta rebuscar mucho, por ejemplo, si nos fijamos en la manera en que html y TeX numeran sus cabeceras, veremos que son significativamente distintas y que, por tanto, necesito tener configuradas opciones distintas según el formato de salida. ¿Eso complica las cosas? Pues un poco: necesitamos cabeceras de exportación con opciones distintas, e incluso quizá diferentes opciones de publicación. Ten en cuenta que exportación y publicación, aunque lo pueda parecer de primeras, no son sinónimos para mí.

Efectivamente, podemos separar lo que significa convertir nuestro documento org en otro formato, ─eso es exportación─, de lo que significa facilitar el acceso al contenido, ─que es la publicación─. Si te has perdido un poco, espero que lo entiendas con el ejemplo.

Vamos a imaginar que queremos generar una documentación de algún proyecto es una especie de wiki donde las distintas páginas estarán enlazadas mediante enlaces, valga la rebuznancia, entre ficheros org. Exportar esta wiki a formato html es sencillo: sólo hay que seguir los pasos del artículo donde explicaba como publicar html desde org-mode. Como todo ya está explicado en ese artículo no voy a dar muchos detalles: se ponen enlaces entre los archivos org y recordamos activar :recursive t en las opciones de publicación del proyecto, ya está todo listo... Pero, opciones de publicación... opciones de exportación... ¡uff! ¿de qué va todo esto?

Opciones de exportación

Algunos me dicen que copian las cabeceras de sus documentos org1 y no entienden por qué unas veces les muestra bien los subíndices, como en H2O ─por poner un ejemplo─, y otras veces muestra algo como H_2O o incluso H2O, sin ninguna explicación aparente. La respuesta a ese gran enigma es que estás copiando las opciones sin saber qué significan y qué comportamientos controlan. Revisa la documentación de org-mode, ahí está todo explicado. Pero si te da pereza sigue leyendo un poco.

La manera más rápida de generar una plantilla de exportación es copiar una ya hecha. Sin embargo, algunas veces nos encontramos con líneas como la siguiente:

#+options:  H:3 num:nil toc:nil \n:nil ::nil |:t ^:{} -:nil f:t *:t <:t

Nos puede parecer algo esotérico y casi mágico, que casi da miedo tocar para no cagarla, pero tenemos que ser conscientes que cada elemento de esa lista tiene efectos sobre el documento generado. Además esos elementos se circunscriben al fichero en cuestión y sólo afectan a la exportación del mismo. Utilizar otras opciones, para otros contenidos es lo que hace que la utilidad de las plantillas sea increíble. Por ejemplo, en la exportación a html podemos no necesitar tener el índice de los apartados, ─especialmente si lo vamos a tratar como páginas web enlazadas─, pero al generar la salida para pdf con los mismos archivos, nos puede parecer imprescindible. Lo más rápido será tener plantillas para generar html y para generar pdf... además, al generar así los html querremos que se creen un montón de ficheros con una determinada estructura, mientras que para el pdf lo querremos todo en un archivo monolítico. Bien, vale, pero me estoy enrollando. Vamos con las opciones, no voy a ser exhaustivo, porque están bien explicadas en la documentación de org-mode. Voy a explicar, brevemente las que he puesto en el ejemplo anterior y alguna más porque la considero importante conocer.

H
Establece el número de niveles de cabecera que se exportarán como tal. A partir del número expresado, el resto de cabeceras org se exportarán como elementos de una lista.
num
Establece si queremos que las cabeceras se numeren al exportar. Un valor de nil hará que se omita el número. También podemos tenerlo activado mediante t y si, en el documento, queremos que algún apartado no sea numerado se le puede añadir una propiedad (C-c C-x p) UNNUMBERED puesta a t. Si ponemos esa propiedad a notoc, el apartado y todos sus subapartados no aparecerán tampoco en el índice de contenido.
toc
Establece si al exportar se generará un índice de contenido para el fichero. Si en lugar de nil o t aparece un número, lo que hace es limitar el nivel de encabezado que aparecerá en el índice de contenido.
\n
Establece si debe preservar los saltos de línea cuando realiza la exportación.
:
Establece si las regiones de ancho fijo (que comienzan cada línea con un carácter : y un espacio o retorno de carro) se exportan al fichero generado o se ocultan. Si establecemos el valor a nil, podemos utilizar estas secciones como si fueran comentarios dentro de nuestro fichero org que luego no aparecerán en la salida. Podemos hacer algo similar con los drawers y la opción d.
|
Establece si exportará las tablas.
^
Establece cómo se tratarán los subíndices y superíndices. Los valores pueden ser nil, t ó {}. Los dos primeros desactivan y activan, respectivamente, la notación que emplea los caracteres _ para subíndices y ^ para superíndices. La opción marcada con las llaves indica que sólo tendrá efecto, convertir a subíndice o superíndice, en aquellas cadenas que se encuentren entre llaves a continuación de uno de esos caracteres.
-
Activar o desactivar la conversión de cadenas especiales. Es decir, si activamos esta opción la salida interpretará las cadenas especiales \-, -- y ---.
f
Activa o desactiva la exportación de las notas a pie de página.
*
Activa o desactiva la exportación de texto enfatizado, negrita, cursiva, etc.
<
Activa o desactiva la inclusión de marcas de tiempo y fecha en la exportación.

Hay más y todas interesantes y están muy bien explicadas en la documentación de org-mode. Además, otra opción que me parece muy importante es poder exportar el contenido con otro nombre. Como es normal, por defecto, el contenido se exportará a un fichero con nombre idéntico al fichero org pero con la extensión adecuada: html, pdf, etc.

Si como hemos visto antes, tenemos un fichero que realizará la exportación a html y otro a pdf, no podemos llamar a los dos con el mismo nombre, porque ya hemos visto que podemos necesitar diferentes opciones de exportación. Por ejemplo, si tenemos un fichero exportar-html.org y otro exportar-pdf.org, por defecto se generarán los archivos de salida exportar-html.html y exportar-pdf.pdf ... feo ¿no? Nos gustaría obtener como resultado exportar.html y exportar.pdf. ¿Cómo lo podemos hacer? Añadiendo en cada fichero el nombre del fichero donde queremos exportar, por ejemplo, en nuestro fichero exportar-html.org:

#+setupfile: mi-plantilla-html.org
#+export_file_name: exportar.html

Opciones de publicación

Mucho de lo que voy a hablar ahora, ya lo conté en el artículo sobre publicar html que dije antes. Voy a repetir algunas cosas, pero añadiendo la opción de que queremos exportar tanto a html en ficheros distintos, como en pdf en un fichero monolítico.

Mi costumbre, como ya conté, es tener en el proyecto un fichero elisp para configurar los proyectos de exportación y cargarlo según lo necesite. Pongo aquí uno que podría servirnos de ejemplo, o plantilla para nuestro proyecto de doble exportación:

(require 'ox-publish)

(setq org-publish-project-alist
      '(
        ("org-to-html"
         :base-directory "~/proyectos/programa/documentacion/"
         :base-extension "org"
         :publishing-directory "~/proyectos/programa/docs/"
         :language es
         :publishing-function org-html-publish-to-html
         :exclude "documentacion-pdf.org"
         :recursive t
         :section-numbers nil
         :headline-levels 6
         :html-preamble t)
        ("org-to-pdf"
         :base-directory "~/proyectos/programa/documentacion"
         :base-extension "org"
         :language es
         :publishing-directory "~/proyectos/programas/docs"
         :exclude "documentacion-html.org"
         :recursive nil
         :section-numbers t
         :publishing-function org-latex-publish-to-pdf
         :headline-levels 5)
        ("org-auxiliares"
         :base-directory "~/proyectos/programa/documentacion/"
         :base-extension "css\\|js\\|png\\|ttf\\|pdf"
         :publishing-directory "~/proyectos/programa/docs/"
         :recursive t
         :publishing-function org-publish-attachment)
        ("documentacion" :components ("org-to-html" "org-to-pdf" "org-auxiliares"))))

Ese código está planteado para una estructura tal que:

.
├── docs
│   └── ... (directorio donde se publicará)
├── documentacion
│   ├── documentacion-html.org
│   └── documentacion-pdf.org
├── publicacion-docs.el
├── org
│   ├── css
│   │   └── ... (hojas de estilo)
│   ├── img
│   │   └── ... (ficheros de imagen)
│   ├── js
│   │   └── ... (ficheros javascript)
│   └── ... (ficheros org)
├── plantillas
│   ├── plantilla-html.org
│   └── plantilla-pdf.org
└── README.org

Como se puede ver, tenemos dos tipos de plantillas: para html y para pdf. Dos tipos de ficheros fuente: para html y para pdf. ¿Cómo evitamos que al exportar el sistema nos cree más salida de la que necesitamos. Es decir, sólo necesitamos que se genere html desde el fichero documentación-html.org y sólo necesitamos que se genere pdf desde el fichero documentación-pdf.org. Para esto tenemos dos proyectos de exportación: org-to-html y org-to-pdf. Pero vemos que, aunque los contenidos al final serán los mismos las opciones cambian. Especialmente hay que señalar que el otro generador es excluido del proyecto. Cuando generamos html queremos que utilice el org correspondiente e ignore el otro.

Montar un servidor local

Cuando trabajamos en un proyecto que se visualizará como una página web es útil, muchas veces, contar con una manera de montar un servidor local que actúe como si fuera un sitio de Internet general, pero sólo accesible desde localhost (127.0.0.1). No tienes por qué hacerlo desde Emacs si no quieres, pero ya que estás editando con él, para qué lo vas a hacer desde fuera. Desde fuera hay muchas maneras: hay lenguajes que proporcionan sus propios servidores locales y que podemos utilizar.

Por ejemplo, en Python 3.x:

python -m http.server 8080

En PHP:

php -S localhost:8080

En Ruby:

ruby -run -e httpd . -p 8080

El listado puede ser muy largo, porque parece que cada lenguaje que se utiliza de uno u otro modo para programar para la web tiene un sistema de hacerlo. En todos los casos anteriores se cuenta que el lanzamiento se hace situándose en el directorio donde se encuentran los ficheros de salida y utilizan, algunos sin mencionarlo, el directorio actual (.) para levantar un demonio httpd. Además, en todos los ejemplos anteriores se ha utilizado el puerto 8080, pero se podría utilizar cualquier otro al uso, recordando que los puertos recomendados para los servicios, ─por ejemplo, 80 es el puerto http por defecto─, necesitan permisos de root para habilitarlos.

Es bastante cómodo tener el servidor levantado, al hacer cambios y generar la salida en su correspondiente directorio, podemos ir viendo el efecto de esos cambios con cualquier navegador.

En los ejemplos anteriores hemos podido ve que las herramientas para montar servidores locales, necesitan todas un par de datos: el directorio donde está la página y el puerto por el que servir el contenido. Normalmente, en los ejemplos anteriores el directorio se omite, porque se entiende que el comando se lanza desde una consola estando situados en él. De la misma manera, en Emacs, necesitamos especificar qué directorio y qué puerto queremos utilizar. Esto lo hacemos con un poco de código elisp. Por ejemplo, una de las estrategias para configurar nuestro servidor local puede ser ajustar los valores necesarios en el mismo fichero que cargábamos antes con los proyectos de publicación, añadiendo las siguientes líneas:

(setq httpd-port 8080)
(setq httpd-root "~/mi-directorio")
(httpd-start)

Si sólo tienes un proyecto de publicación html, lo puedes establecer mediante M-x customize-group <RET> simple-httpd. En todo caso, esas tres líneas de código bastan para lanzar nuestro servidor. Las podemos evaluar con el código del proyecto de publicación o tenerlas a mano en algún buffer donde las podamos evaluar... o establecerlas una a una con M-x.

Flujo de trabajo

Más que por simple-httpd.es, que es el fuente donde descansa nuestro servidor, las preguntas estaban enfocadas al flujo de trabajo con html. Bien, hasta aquí hemos hablado de los primeros pasos:

  1. Crear el contenido con org-mode.
  2. Publicar el contenido con las herramientas de Emacs.
  3. Servir los html desde un servidor local para visualizarlos.

¿Cómo seguimos? Cuando tenemos alguna modificación que comprobar la publicamos y para eso, sólo hay que ir repitiendo los pasos del 1 al 3 y viéndolos en el navegador que más nos guste. Por otro lado, a algunos no os gusta partir de un css ya hecho, para ir modificando los distintos aspectos del mismo. La justificación que me habéis dado es válida: terminas con un css con un montón de elementos que tiene que cargar el navegador, pero que no son útiles. Por otro lado, además de la declaración del css que se incluye en la cabecera en la misma aparece un apartado de style, no sólo es que queda feo, es que ocupa también. Se puede aligerar la cabecera desactivando la exportación de esos valores mediante:

#+options: html-style: nil

Si queremos crear nuestro css desde lo más básico a lo más general, podemos observar dicha inclusión y tomarla como código básico para exportación. Al menos, la exportación desde org-mode establece las siguientes clases específicas:

p.author
Información del autor incluyendo el email.
p.date
Fecha de publicación
p.creator
Información sobre la versión de org-mode y Emacs.
.title
Título del documento.
.subtitle
Subtítulo del documento.
.todo
palabras clave TODO.
.done
palabras clave DONE.
.WAITING
clase para encabezados a la espera.
.timestamp
etiqueta de tiempo.
.timestamp-kwd
palabra clave asociada a una etiqueta de tiempo, como scheduled.
.timestamp-wrapper
espacio alrededor de la etiqueta de tiempo y su palabra clave.
.tag
Etiqueta en una cabecera. Típicamente las que aparecen a la derecha de la cabecera.
._HOME
Cada etiqueta utilizándose como una clase, reemplazando @ por _
.target
objetivo para links.
.linenr
número de línea en bloques de código
.code-highlighted
líneas de código destacadas
div.outline-N
Nivel de cabecera, donde N es un número (1, 2, ... 6)
div.outline-text-N
div extra para el texto de la cabecera.
.section-number-N
Número de sección de la cabecera.
.figure-number
Etiqueta para las figuras tal que «Figure 1:»
.table-number
Etiqueta para las tablas, tal que «Table 1:»
.listing-number
Etiqueta para bloques de código «Listing 1:»
div.figure
Clase para imágenes en líneas de texto.
pre.src
Código fuente formateado.
pre.example
bloques example
p.verse
Párrafos verse
div.footnotes
Cabecera para la sección de notas al pie.
p.footnote
Párrafo que contiene una nota al pie.
.footref
Número de referencia de una nota al pie (siempre como <sup>).
.footnum
Número de una nota al pie (siempre como <sup>).
.org-svg
Clase por defecto para una imagen .svg enlazada.

¿Qué ocurre si quiero definir mis propias clases? Pues es algo sencillo. Vamos a imaginar que quiero crear una clase para el css que me formatee con un determinado estilo, por ejemplo, un aviso, que haga que el texto se escriba en rojo para destacarlo. El código css es muy sencillo:

.aviso {
  color: #FF0000;
}

Hacer que un párrafo de nuestro documento se muestre con el formato para la clase aviso es tan sencillo como escribir en nuestro fichero org:

...

#+attr_html: :class aviso
Este es un párrafo de aviso que mostrará el texto en rojo.

...

Si no quiero definir una clase y utilizar directamente las propiedades de html podría haber escrito el código así:

...

#+attr_html: :class aviso :style color:red;
Este es un párrafo de aviso que mostrará el texto en rojo.

...

Además de las clases mencionadas arriba, un css básico debe contar con definiciones para las etiquetas de texto habituales en un fichero html: <html>, <body>, <h1> ... <h6>, <p>, <em>, <i>, <b>, <table>, <dt>, <dh>, <dd>, <li>, <ol>, <ul>, <img>... y también puede definir estilos especiales para dos tipos de elementos marcados con id=: #preamble, #content y #postamble.

De estos tres últimos elementos, nuestro fichero org genera sólo, por decirlo así, el content. El pie y la cabecera están controladas por variables:

org-html-preamble
si no es nil genera un preámbulo con el contenido de la variable org-html-preamble-format.
org-html-preamble-format
cadena html que se mostrará en la exportación. Por defecto está vacía.
org-html-postamble
si no es nil genera un pie de página con el contenido de la variable org-html-postamble-format.
org-html-postamble-format

cadena html que se mostrará. Por defecto, su valor se establece:

(setq org-html-postamble-format
      '(("en" "<p class=\"author\">Author: %a (%e)</p>
<p class=\"date\">Date: %d</p>
<p class=\"creator\">%c</p>
<p class=\"validation\">%v page</p>")))

Algunos sistemas de publicación, se basan en todas estas estructuras, variables y métodos para generar sitios web estáticos. Por ejemplo, org-static-blog, con el que está hecho este blog, se basa en estos procedimientos añadiéndoles un poco de funcionalidad mediante código elisp.

Conclusiones

Este no es un artículo muy coherente. He escrito sobre distintos aspectos de lo mismo y hecho muchas referencias a un artículo anterior que no tienes por qué haber leído. Sin embargo, espero que hayas podido ver, o al menos intuir, toda la flexibilidad que tiene org-mode a la hora de exportar y publicar contenido.

Todo lo que he escrito lo he sacado de la documentación, por lo que la contestación rápida a las preguntas hubiera sido: lee el puto manual. Pero no me sale ser tan borde y prefiero contestar, porque muchas veces me obliga a buscar el porqué de las cosas y entender mejor lo que creía que ya sabía.

A veces, la necesidad de concisión hace que dé por sabido algo que parece no serlo. Eso es fuente de muchas de las preguntas que me hacéis y para las que, de vez en cuando, tampoco tengo una respuesta clara, porque yo también las puedo estar haciendo por inercia y sin leer el puto manual... así que: ¡gracias por las preguntas! Porque me obligan a buscar las respuestas.

Footnotes:

1

Hay quien me ha dicho: de sitios solventes como tu blog... ¿solvente mi blog? Revisa el concepto, por favor.

-1:-- Publicar con org-mode II (Post )--L0--C0--March 03, 2021 08:19 AM

Notxor tiene un blog: En qué ando estos días

Tengo la sensación, quizá subjetiva de que escribo poco en el blog últimamente. Aunque algún que otro artículo he sacado, me parece que podría quizá ser más generoso en mis escritos. Lo cierto es que estoy liado con mis cosas y tengo que contarlo. Así pues, en este artículo, os vais a encontrar un poco de todo: hablaré sobre el blog y su cambio de aspecto, hablaré sobre rust y sobre cómo estoy utilizando Emacs para aprender con algún que otro problemilla que he ido solventando sobre la marcha.

Cambio de aspecto del blog con css

Los cambios recientes en el blog están incompletos, aún me faltan algunas cosas que quiero matizar un poco. Lo fundamental es que he abandonado el diseño de una columna por el de dos y la cabecera aparece ahora a la izquierda con su menú. Lo que me ha costado más ha sido hacerme con un fondo para el blog. No quería simplemente utilizar alguna fotografía de las miles que se pueden encontrar por Internet para fondos web; prefiero algo más personal. Alguno de los antiguos lectores recordarán que hice una animación1 para un tema en Esperanto y he tomado de ahí algunos de los modelos para fabricar el fondo. No es un fondo espectacular, ni profesional, pero al menos es mío.

Trabajar en Emacs para la web

Aprovechando la tesitura de los cambios, ─y puesto que algunos me habéis preguntado cómo me las apaño para levantar un servidor web con el editor─, os cuento cómo lo hago con las pruebas.

En este caso, para toquetear el css y ver cómo van reaccionando los distintos parámetros en la página, sin estropear nada de la actual, lo que hago es copiar algunos ficheros en otro directorio. Me explico:

  1. Tengo copia local del blog para hacer pruebas en el directorio ~/public_html y cuando publico algo, org-static-mode lo guarda ahí. Hago pruebas de visualización en local, corrijo errores y cuando creo que está todo correcto lo subo a su sitio en Internet con FileZilla.
  2. Para no estropear ese directorio y terminar arrastrando demasiada basura al sitio correspondiente lo que hago es copiar algunos directorios y ficheros para las pruebas. Para este caso:
    • ~/public_html/medios, donde se encuentran agrupados css, fuentes, img y js que son las cosas necesarias para el diseño de la página.
    • Algunos ficheros html, como el index.html y los últimos artículos con su estructura de directorios para interactuar un poco en las pruebas.
  3. Todo eso va copiado a un directorio que se puede llamar, por ejemplo, ~/proyectos/cambios-web que será donde tengamos que levantar el servidor de pruebas:
    • M-x httpd-serve-directory tras pulsar <RET> le decimos nuestro directorio de trabajo, en el ejemplo ~/proyectos/cambios-web.
    • Y por último, levantamos el servidor con M-x httpd-start
  4. Abrimos el navegador con la dirección http://localhost:8080. Por defecto el puerto donde se sirve el contenido es 8080. Si quieres cambiarlo, digamos por el 6969, tienes que evaluar la expresión:

    (setq httpd-port 6969)
    

Posteriormente el trabajo consiste en ir haciendo las modificaciones que consideramos oportunas e ir actualizando la visualización pulsando <F5> en el navegador. Algunas veces, incluso se pueden ir modificando los pichorros en las herramientas de desarrollador, C-s-i, en el navegador para probar directamente y posteriormente pasar esos parámetros al código.

El servidor lo podemos parar con el comando M-x httpd-stop. Tampoco quiero enrollarme mucho sobre el tema. Si te parece interesante y te gustaría saber un poco más sobre cómo trabajar en Emacs para la web me lo dices por los canales habituales y dedico un artículo completo con todo lujo de detalle al tema.

Aprendiendo rust

Llevo un tiempo ya aprendiéndolo, como un mes leyendo documentación y haciendo pruebas simples. Algunos me han preguntado si he abandonado erlang y no es el caso. Ese lenguaje llegó para quedarse y ya me encuentro bastante cómodo con él. Como lenguaje concurrente es increíble y lo uso con bastante asiduidad ahora para prototipado rápido, cuando antes tiraba de Python. Pero mi idea era también avanzar en algún lenguaje compilado, que no es para hacer prototipos rápidos pero sí veloces de ejecución. C/C++ ya lo conozco y tengo algunas habilidades2. El caso es que me propuse aprender Rust, que parece que todo el mundo dice que es muy rápido y muy seguro.

Después de leerme el libro del lenguaje y, como ocurre en estas ocasiones, enterarme de más bien poco, ─porque no aprendo hasta que no tropiezo─, decidí iniciar un proyecto para tropezar. Si has leído más cosas en el blog te sonará una serie de programar un raytracer con erlang, pues bien: voy a hacer lo mismo con Rust aunque sin contarlo por aquí, porque eso me convertiría en el pesao de los raytracer.

De momento, no soy nada productivo con el lenguaje. Su sintanxis e idiosincrasias lo hacen un lenguaje un tanto farragoso al principio. Además, su intención de ser seguro lo llevan casi a la paranoia y se queja por todo. Bien es cierto que en esas mismas quejas advierte claramente qué problemas encuentra y sugiere cómo se pueden atajar. Pero creo que es un buen lenguaje y me está gustando.

Aún no siendo productivo aún con Rust, sí creo que le estoy cogiendo el tranquillo y, aunque el proyecto avanza muy lentamente, voy consiguiendo pequeños logros, sin copiar el código de ningún sitio. Mi primera pelea fue con las interfaces hasta que las encontré, la segunda para separar el código en módulos, luego con los operadores y cómo definirlos para nuevos tipos de datos, luego con los tests, luego escribir la salida en un fichero... y así a trompicones avanzo poco a poco.

Configurando Emacs para usarlo con Rust

Hay un paquete para trabajar con Rust en Emacs que se llama rustic. Ya os advierto que más rústico y rural que yo no lo hay. La instalación es como siempre sencilla:

M-x package-install <RET> rustic <RET>

En la configuración sólo añadí un escueto:

(require 'rustic)

Sin embargo, cada vez que abría un fichero .rs el modo rustic preguntaba por lsp3. Como sabéis, lsp es un modo que permite a Emacs convertirse en un IDE moderno integrándose con otros paquetes como company, projectile o flycheck. Hasta ahora no había probado lsp porque la otra vez que lo intenté, resultó en un enlentecimiento casi desesperante del editor y no le vi la utilidad.

Supongo que aquel problema sería con respecto al modo de edición, que en aquella ocasión era Python, esta vez, siguiendo los pasos de configuración, que no han sido muchos, la cosa va un poco mejor. Tarda en arrancar el Emacs, ha duplicado el tiempo de carga y se sitúa en tres segundos y medio, más o menos. Cuando abro algún proyecto de Rust también tarda en cargar el fichero de código mientras levanta el servidor y se conecta, pero luego funciona con soltura.

El problema creo que viene del montón de dependencias que tiene lsp-mode cuando lo instalas. Tienes que instalar también otros paquetes, como lsp-ivy (o lsp-helm), company-lsp, lsp-ui, dap-mode y también parece que es recomendable instalar eglot. Después de intentar configurarlo todo he ido renunciando a algunas cosas, aunque mantengo los paquetes instalados por compatibilidad, lo demás que uso viene en el código:

(require 'lsp-mode)
(add-hook 'rust-mode-hook #'lsp)
(add-hook 'rust-mode-hook '(lsp-install-server 'rust-analyzer))
(add-hook 'rustic-mode-hook 'englot-ensure)

El paquete dap-mode4 he sido incapaz de hacerlo funcionar, pero puesto que es un paquete de depuración tiro del clásico gdb de toda la vida para hacer lo mismo.

Depuración con gdb

Y si no funciona el chismático de depuración moderno, pues habrá que tirar del clásico. Es un poco menos vistoso pero funciona con solvencia. El problema es que al no estar integrado en el IDE tienes que hacer un par de cosas más tú a mano.

Si ya has utilizado antes Emacs como un entorno gráfico de depuración con gdb te puedes saltar éste punto. Si no lo has hecho, voy a dar unas breves pinceladas de cómo lo hago yo. Si crees que es interesante el tema, ya me lo dices y prometo que escribiré un artículo completo sobre el tema.

Arrancar gdb en Emacs es sencillo: M-x gdb, nos pregunta por el comando que utilizará, que por defecto es gdb -i=mi y obtendremos una ventana parecida a:

Captura-pantalla_gud.png

Es un buffer que se llama gud y que muestra el prompt del depurador gdb. Si estamos acostumbrados a utilizar gdb desde la línea de comandos lo podemos hacer aquí directamente. Si os sale una ventana divida en varios buffers, es porque tenéis configurada la variable gdb-many-windows a t.

Captura-pantalla_gdb-many-windows.png

En todo caso, si no tenéis esa variable activada y queréis activar los buffers de visualización, sólo tenéis que teclear M-x gdb-many-windows y os aparecerán.

De momento, hemos cargado el depurador pero en vacío y no hay un programa que depurar. Para hacerlo, nos vamos al buffer gud, si no estamos en él, y tecleamos file nombre-del-ejecutable. En este caso yo he tecleado:

file ~/proyectos/rust/rustracer/target/debug/rustracer

Debería abrirnos el fichero principal de código también, pero si no es así, lo abrimos nosotros... La pantalla quedaría así:

Captura-pantalla_gud-cargado.png

Ahora sólo necesitamos hacer que nuestro programa se pare en algún sitio durante la ejecución para poder inspeccionar cómo evoluciona. Establecer un punto de parada o breakpoint podemos hacerlo de varias formas. Yo utilizo dos, principalmente. Una es teclear en el buffer gud el comando break NN donde NN es el número de línea donde quiero establecer el punto de parada. La otra es ir al buffer donde se muestra el código fuente, ir a la línea donde quiero hacer la parada y llamar al comando gud-break.

Captura-pantalla_break-points.png

Sea cual sea el método empleado, podemos observar que nos señala gráficamente el punto de parada con un círculo rojo la línea donde lo hemos establecido y además aparece en la lista del buffer de breakpoints, abajo a la derecha.

El resto de acciones las podemos llevar a cabo manualmente desde gud o utilizar la barra de botones, que es muy similar a cualquier otra herramienta de depuración.

Conclusiones

Ando liado porque soy así de liable, siempre con un montón de proyectos, siempre con ganas de aprender cosas nuevas y agotando todo mi tiempo libre para no permitirme descansar a mí mismo. Y ahora, después de haberos cansinado con varias cosas deslabazadas, sin un hilo conductor coherente os estaréis preguntado Y ¿a mí qué? a lo que yo os respondo: A mí tampoco, ¡gracias!. Bueno, de acuerdo, era sólo por escribir un poco y que no penséis que tengo el blog abandonado... es que no doy para más: hago lo que puedo.

Footnotes:

1

Si no lo recuerdas, lo puedes ver en https://www.youtube.com/watch?v=CxhFjPa_wd0

2

Por ejemplo, compilando erlang la última vez me lanzó un par de errores de C++ en mi máquina y pude resolverlas fácilmente.

3

Language Server Protocol

4

Un paquete adaptador para Debug Adapter Protocols, que sería la herramienta de depuración del entorno.

-1:-- En qué ando estos días (Post )--L0--C0--February 09, 2021 02:52 PM

Notxor tiene un blog: Tablas para cálculos en org-mode

No es la primera vez que en este blog hablo sobre las tablas y todas las cosas que nos proporcionan a los usuarios de org-mode. Algunos, al haberme referido a ellas como hojas de cálculo, esperaban tener la suerte de que se utilizaran de la misma manera y se han topado con un pequeño muro de dificultades. Me han preguntado por cómo funcionan y cómo las pueden utilizar y por qué las he llamado en alguna ocasión hojas de cálculo en texto plano si no lo son. Este artículo trata esos temas e intentará dar ejemplos suficientes para aquellos que habiendo manejado hojas de cálculo, quieran probar la potencia de las tablas de org-mode.

Direcciones de celda

Si tienes experiencia con las hojas de cálculo, desde que Lotus 1-2-3 impuso la nomenclatura de utilizar letras para las columnas y números para las filas, la cosa ha cambiado poco. El primer concepto a tener en cuenta, en org-mode, es que en las tablas no sólo hay direcciones absolutas, sino también relativas: por ejemplo, podemos utilizar la versión absoluta de una celda con el formato @FILA$COLUMNA, además, las columnas, por ejemplo, ─pero las filas igual─, se pueden referenciar como $+1 o $-2... o también $< y $> son referencias a la primera y la última de las columnas. De manera similar ocurre con las filas: se pueden utilizar las referencias @-2 ó @+3, de forma relativa o @< y @> para la primera y la última fila respectivamente. Teniendo en cuenta que las líneas de separación no se cuentan ni en vertical | ni en horizontal -, sólo cuentan las filas y columnas con datos. @0 implica la fila actual y $0 la columna actual, aunque generalmente se omiten. De esta manera si el cálculo de la celda @2$3 implica el contenido de otra celda de la fila, pongamos la de la columna 5, podríamos escribir la referencia como @2$5, o @0$5, o $5. Si utilizamos la primera, la dirección es absoluta. Si luego queremos aplicar la fórmula en otras celdas de otras filas, el cálculo se hará siempre con el contenido de esa celda particular. Las otras dos formas son equivalentes y referencian el contenido de la misma fila en su quinta columna.

La forma de los rangos de celdas es similar a las hojas de cálculo a las que estamos acostumbrados, se utiliza la notación de dos caracteres .: $1..$4 indica las columnas de la uno a la cuatro de la fila actual.

También se pueden referenciar valores que se encuentran en otras tablas. Para no liarnos mucho, vamos con un ejemplo sencillo, aunque más práctico.

Ejemplo práctico

Vamos a suponer que queremos montar nuestro propio sistema de calificaciones, de una asignatura. Tenemos cinco alumnos y hemos planificado tres exámenes distintos, de tipo test. En realidad lo podemos hacer con una tabla un poco más compleja, como veremos al final, pero para que sirva de ejemplo, haremos una tabla por cada examen parcial.

Vamos con la práctica, copia la siguiente tabla o escribe una similar, primero vamos con la definición de los exámenes:

#+name: Pruebas
| Examen | Preguntas | Alternativas |
|--------+-----------+--------------|
|        |           |              |
|        |           |              |
|        |           |              |

En esta tabla no vamos a hacer cálculos, sino definir las características de nuestros exámenes. El ponerle un nombre con el parámetro #+name: no aporta nada visualmente, pero nos permitirá referenciar el contenido de la misma con la forma remote(name,ref). Vamos a rellenar los campos con los siguientes datos.

Examen Preguntas Alternativas
P1 40 4
P2 35 5
P3 100 2

Y ahora vamos a preparar nuestra primera tabla, para el primer examen.

#+name: NotasP1
| N | Nombre          | Aciertos | Errores | Nota | Dec |
|---+-----------------+----------+---------+------+-----|
| 1 | Pepe López      |          |         |      |     |
| 2 | Amanda Torres   |          |         |      |     |
| 3 | Juan Pérez      |          |         |      |     |
| 4 | Elisa Ronchón   |          |         |      |     |
| 5 | Adalberto Épila |          |         |      |     |

Una vez creada la plantilla sitúo el cursor en la celda de la primera línea de datos, que corresponde al ficticio alumno Pepe López justo en la bajo la columna de Nota.

Captura-pantalla_nueva-formula.png

Vamos a meter ahora la fórmula de calificación de un examen de alternativas. Como sabéis, el cálculo se no sólo a los aciertos obtenidos, sino que se elimina el factor de puntuación obtenida por respuestas aleatorias que pueden dar los alumnos, restando a esos aciertos el número de errores dividido por el número de alternativas menos uno. Es decir, siendo los aciertos \(A\), los errores \(E\) y las alternativas \(a\) la fórmula sería:

\[ Nota = A - \frac{E}{a - 1} \]

Para introducir dicha fórmula, situados en la celda que he mencionado antes, tecleamos a continuación la fórmula:

:=$3-($4/(remote(Pruebas,@2$3)-1))

Como se ve, primero se teclea la entrada := y a continuación las referencias de las celdas que necesitamos. $3 será el número de aciertos en la prueba de nuestro ficticio alumno Pepe López, ~\(4\) es la celda en la columna de Errores para la misma fila y luego, necesitamos las alternativas, que está en la tabla que hemos llamado Pruebas y lo llamamos con remote(Pruebas,@2$3). Al pulsar <RET>, o <TAB> obtenemos algo así

Captura-pantalla_primera-formula.png

Hay que fijarse especialmente en la última línea que ha aparecido automágicamente: es nuestra fórmula.

#+TBLFM: @2$5=$3-($4/(remote(Pruebas,@2$3)-1))

Vamos a deconstruirla para entenderla. Tiene una etiqueta especial con la forma #+tblfm:, que viene a significar algo así como fórmulas de la tabla. A continuación establece que la celda (@2$5) se calcula con nuestra fórmula asignando a la referencia su valor con un signo =.

Puesto que queremos que se pueda calcular con la misma fórmula todas las celdas de la columna, podemos borrar de esa referencia el @2. Así pues, sitúa el cursor en la línea de la fórmula y borra el primer @2 de la izquierda, la línea debe quedar así:

#+TBLFM: $5=$3-($4/(remote(Pruebas,@2$3)-1))

Sin mover el cursor de esa línea pulsa C-c C-c y la tabla se recalcula así:

Captura-pantalla_recalcular-formula.png

Muy bonito, pero aún no calcula nada, porque no hay datos. Vamos a repetir el proceso de cálculo para que lo veamos más claro. Introduce los siguientes datos en ella:

  1. Pepe López: Aciertos = 35, Errores = 5
  2. Amanda Torres: Aciertos = 35, Errores = 6
  3. Juan Pérez: Acierto*s = 32, *Errores 3
  4. Elisa Ronchón: Aciertos = 40, Errores = 0
  5. Adalberto Épila: Aciertos = 36, Errores = 4

Regresa a la línea de la fórmula tras haber introducido esos datos y pulsa C-c C-c.

Captura-pantalla_calculo-con-datos.png

Está calculado... pero queda algo fea la tabla con los números desalineados, unos con 5 decimales y otros sin ningunos. Para solucionarlo, situados en la línea de la fórmula, la completamos añadiendo a la misma ;%.3f. Dicho de otro modo: separamos la fórmula del formato con el caracter ; y le decimos que el formato será el valor de la celda % con un número de coma flotante de tres decimales: .3f... el resultado queda así:

Captura-pantalla_formato-celdas.png

Vamos con nuestra última columna. Colocándonos en cualquier celda de la misma tecleamos la siguiente secuencia:

:=10*($5/remote(Pruebas,@2$2));%.3f

Como vemos, es sólo una fórmula sencilla que convierte la nota directa en nota decimalizada y también le da un formato de tres decimales.

Las fórmulas de las dos columnas se encuentran en la misma cláusula #+tblfm, sin embargo también podríamos tener las fórmulas separadas de la siguiente manera:

#+name: NotasP1
| N | Nombre          | Aciertos | Errores |   Nota |    Dec |
|---+-----------------+----------+---------+--------+--------|
| 1 | Pepe López      |       35 |       5 | 33.333 |  8.333 |
| 2 | Amanda Torres   |       35 |       6 | 33.000 |  8.250 |
| 3 | Juan Pérez      |       32 |       3 | 31.000 |  7.750 |
| 4 | Elisa Ronchón   |       40 |       0 | 40.000 | 10.000 |
| 5 | Adalberto Épila |       36 |       4 | 34.667 |  8.667 |
#+tblfm: $5=$3-($4/(remote(Pruebas,@2$3)-1));%.3f
#+tblfm: $6=10*($5/remote(Pruebas,@2$2));%.3f

Dividirlo así puede facilitar la lectura y la edición de las diversas fórmulas de una tabla. Podemos, además, calcular las fórmulas que hayamos modificado exclusivamente o quizá recalcular toda la tabla. Para hacer que se recalculen todas las fórmulas se utiliza la combinación de teclas C-c *. Si tuviéramos que calcular algunas fórmulas que dependan unas de otras, pueden necesitar que se calculen de forma recursiva, si fuera necesario ésto se hace con C-u C-u C-c *.

De todas formas, encuentro que es más interesante tener las fórmulas en una sola línea y editarlas con la combinación C-c '. Este comando abrirá un buffer de edición donde se listan las fórmulas de la tabla, una por línea, para trabajar más cómodamente.

Las fórmulas pueden utilizar cualquier función que comprenda el paquete calc. Pero además, también podemos utilizar la notación de elisp, Por ejemplo, podemos escribir '(apply '+ '($1..$4));N'

Captura-pantalla_notas-3-parciales.png

Tablas complejas

Hasta ahora en el artículo se ha seguido una política de tablas simples: cálculos directos de filas y columnas sin marear mucho la perdiz, aunque se han utilizado celdas de otras tablas. Sin embargo, también se pueden utilizar algunas características de tablas más complejas, como poner nombre a columnas o parámetros.

Para poner un ejemplo, vamos a hacer todos los cálculos que realizábamos antes con cuatro tablas, ahora en una sola tabla como ésta:

|   | Nombre          |  D_1 |  E_1 |  D_2 |  E_2 |  D_3 |  E_3 | 1^er Par. | 2^o Par. | 3^er Par. | Final |
|---+-----------------+------+------+------+------+------+------+-----------+----------+-----------+-------|
| / |                 |    < |      |      |      |      |      |         < |          |         > |       |
| ! |                 |   D1 |   E1 |   D2 |   E2 |   D3 |   E3 |        N1 |       N2 |        N3 |       |
|---+-----------------+------+------+------+------+------+------+-----------+----------+-----------+-------|
| # | Pepe López      |   35 |    5 |   25 |    2 |   60 |    2 |      8.33 |     7.00 |      5.80 |  7.04 |
| # | Amanda Torres   |   35 |    6 |   18 |    3 |   55 |    3 |      8.25 |     4.93 |      5.20 |  6.13 |
| # | Juan Pérez      |   32 |    3 |   32 |    2 |   80 |   10 |      7.75 |     9.00 |      7.00 |  7.92 |
| # | Elisa Ronchón   |   40 |    0 |   25 |    0 |   55 |   10 |     10.00 |     7.14 |      4.50 |  7.21 |
| # | Adalberto Épila |   36 |    4 |   30 |    4 |   80 |    4 |      8.67 |     8.29 |      7.60 |  8.19 |
|---+-----------------+------+------+------+------+------+------+-----------+----------+-----------+-------|
| # | Medias          |      |      |      |      |      |      |      8.60 |     7.27 |      6.02 |  7.30 |
|   | Preg./Altern.   |   40 |    4 |   35 |    5 |  100 |    2 |           |          |           |       |
| ^ |                 | max1 | alt1 | max2 | alt2 | max3 | alt3 |           |          |           |       |
#+tblfm: $9=10*($D1-($E1/($alt1-1)))/$max1;%.2f::$10=10*($D2-($E2/($alt2-1)))/$max2;%.2f::$11=10*($D3-($E3/($alt3-1)))/$max3;%.2f::$12=vsum($N1..$N3)/3;%.2f::@8$9=vsum(@3..@7)/5;%.2f::@8$10=vsum(@3..@7)/5;%.2f::@8$11=vsum(@3..@7)/5;%.2f::@8$12=vsum(@3..@7)/5;%.2f

Hay que remarcar la primera columna rellena con caracteres que marcan líneas especiales. Al exportar, las líneas especiales no se imprimirán, como se puede ver a continuación:

Nombre D_1 E_1 D_2 E_2 D_3 E_3 1^er Par. 2^o Par. 3^er Par. Final
Pepe López 35 5 25 2 60 2 8.33 7.00 5.80 7.04
Amanda Torres 35 6 18 3 55 3 8.25 4.93 5.20 6.13
Juan Pérez 32 3 32 2 80 10 7.75 9.00 7.00 7.92
Elisa Ronchón 40 0 25 0 55 10 10.00 7.14 4.50 7.21
Adalberto Épila 36 4 30 4 80 4 8.67 8.29 7.60 7.59
Medias             8.60 7.27 6.02 7.18
Preg./Altern. 40 4 35 5 100 2        

A veces, en tablas complejas es difícil, a la hora de meter fórmulas saber las coordenadas de una determinada celda perdida en medio de la tabla. Para ayudarnos a esto podemos activar org-table-toggle-coordinate-overlays pulsando la combinación de teclas C-c }, no confundir con C-c { que activa ─o desactiva─ la depuración del cálculo de las fórmulas.

Captura-pantalla_edicion-formulas.png

Como se puede ver en la imagen nos muestra información sobre el número de filas y columnas, de manera que podemos editar las fórmulas más cómodamente. Para desactivarlo, volvemos a utiliza la combinación de teclas y es suficiente.

Otra cosa importante es entender las filas especiales, que no aparecen en la impresión pero que proporcionan funcionalidad interesante:

/
La fila que comienza con carácter / se refiere a la visualización de las celdas. En concreto, en este ejemplo, los caracteres < y > indican o señalan qué líneas verticales debe dibujar. Hay más opciones y es recomendable leer la documentación sobre tablas del manual de org-mode.
!
Una línea que comience con el carácter ! establecerá el nombre de la columna. Por eso en el ejemplo, en las fórmulas se emplean los nombres $D1, $E1, $D2, etc. en lugar del nombre genérico de $3, $4, etc. Eso nos permite poner nombre a las columnas que sea más fácil de interpretar para nosotros que un simple número.
#
Las filas que comienzan por un carácter # se recalcularán automáticamente cuando dentro de la tabla se puls <TAB> o <RET> o se utilice el comando C-u C-c * para recalcular la tabla. Las filas que no estén así marcadas no se ven afectadas por dicho comando.
^
Las filas que están marcadas con un carácter ^ identifican el valor de la fila superior con un nombre. En nuestras fórmulas de la tabla, se utilizan los valores $max1 o alt1, por ejemplo, en lugar de sus posiciones @10$3 o @10$4. Si en lugar de utilizar ^ encontramos - el efecto es similar, pero en ese caso, los nombres se refieren a los valores de la línea inferior.
*
Aunque en nuestro ejemplo no se ha utilizado ninguna fila marcada con un * es bueno tener en cuenta que al utilizarla hacemos que una línea sea ignorada cuando se produce un recálculo general de la tabla con el comando C-u C-c *. Esto se hace cuando los cálculos demoran mucho el redibujado de la tabla.
$
Tampoco he utilizado esta marca en la tabla. Se utiliza para establecer en una determinada fila algún valor con nombre del estilo maximo=200, para luego utilizar en las fórmulas el nombre de $maximo en lugar de una celda de la tabla.

Conclusiones

Como se puede apreciar, la forma de manejar tablas de org-mode nos pueden facilitar los cálculos para nuestra documentación. Hay muchos detalles que no he llegado a mostrar en este pequeño artículo y como siempre aconsejo: leeros la documentación que viene con org-mode, es bastante clarificadora.

En un principio pensé en incluir también la generación de gráficos con gnuplot desde nuestras tablas, pero al final lo dejo para un posterior artículo, puesto que éste ha quedado ya suficientemente pelma.

Es recomendable que practiques un poco cómo he van editando las tablas y calculando las fórmulas, para poder apreciar así, todas las facilidades que nos provee org-mode para hacerlo con más facilidad.

-1:-- Tablas para cálculos en org-mode (Post )--L0--C0--January 22, 2021 07:49 AM

MGallego: Comprobado de Faltas de Ortografía en Emacs

your_img

Ahora que estoy con una instalación limpia de Ubuntu/Debian y estoy volviendo a escribir un poco en el blog para documentar lo que voy haciendo tengo que configurar el flyspell para que me compruebe según voy escribiendo, para que no se me escape ninguna falta de ortografía.

Para ejecutarlo es tan sencillo como dentro del buffer que queraos comprobar lanzar el comando con M-x flyspell-mode el problema que me encuentro es que no tengo el diccionario es_ES instalado, así que vamos a ver como lo instalamos en Ubuntu/Debian

El error que nos da es el siguiente: Error enabling Flyspell mode: (Error: No word lists can be found for the language "es_ES".)

Lo único que tenemos que haces es instalar el paquete de lenguaje de aspell en el sistema, en mi caso con sudo apt install aspell-es y volver a cargar el modo flyspell. Con esto emacs ya comenzará a marcarnos los errores en nuestro texto con un subrayado en rojo.

-1:-- Comprobado de Faltas de Ortografía en Emacs (Post )--L0--C0--December 07, 2020 11:01 AM

MGallego: Mostrar Informacion con LSP UI en Emacs - Sideline

your_img

lsp-ui es un paquete que nos ayuda mostrando información útil sobre el servidor de lenguaje en nuestra interfaz. Voy a ver como configurarlo un poco para ver que utilidad nos puede dar.

En los ejemplos veremos imágenes del servidor de lenguaje de Scala que es lo que estoy configurando ahora mismo.

¿Qué es LSP?

LSP es un protocolo que sirve para comunicar servidores de lenguaje con editores, lo cual nos da en los editores las mismas o similares funcionalidades que ya existían en los IDEs, como por ejemplo navegación entre código, resaltado de sintaxis, comprobación de errores en tiempo real, refactorización …

Antiguamente para poder tener estas características teníamos que tener un modo (plugin) para cada uno de los lenguajes que usásemos, con su configuración, atajos de teclado, etc. Con este cambio solo necesitamos tener el modo LSP que se conectará al servidor de lenguaje que corresponda y tendremos todas las funcionalidades que nos de ese servidor, que por cierto, ese servidor será común entre todos los editores que soportan LSP.

Como no es el tema que quiero tratar en este post no voy a entrar mas en detalle, solo añado que LSP es lo mejor que le ha pasado a Emacs en los últimos años y diría que se podría decir lo mismo para otros editores como Vim

Aquí dejo un par de enlaces con mas información, uno de la Wikipedia y otro de la página de Microsoft.

¿Qué es lsp-ui?

lsp-ui es un modo de emacs que nos crea una interfaz, una UI (User Interface) por encima de LSP, dándonos información en tiempo real del código en el que nos encontramos, como firmas de funciones, acciones que podemos realizar sobre el cursor y documentación relacionada.

Esto es mas o menos lo que estamos acostumbrados a ver en los IDEs mas comunes y ahora lo tenemos en emacs con una configuración mínima.

Instalación

Para la instalación lo mejor es ir a la web del proyecto, apenas son 2 líneas, pero estará mas actualizado que este post.

Configuración

Para ir viendo los ejemplos no los voy a meter en mi fichero de configuración, lo que voy a hacer es ir evaluándolos con M-: para ir viendo en tiempo real como funciona y si merece la pena añadirlo a posteriori en mi fichero de configuración.

Toda la configuración está en la web oficial, pero como quiero probarlo yo mismo aprovecho y lo documento.

lsp-ui-sideline

El sideline es la información que se va a mostrar al final de la propia linea en la que estamos trabajando, por defecto cuando programo con PHP lo tengo desconectado porque me resulta un poco incómodo, sobre todo porque aparece demasiado a la derecha, pero en Scala con el tema del tipado creo que mas que útil va a acabar siendo necesario, así que vamos a ver que ofrece y como activarlo o desactivarlo

Para que todo funcione tenemos que tener el modo lsp-ui-sideline activado para ello ejecutamos M-x lsp-ui-sideline-mode

Apunte rápido

Todo lo que voy a ir metiendo son funciones en lisp para setear variables, con algo así como (setq variable valor) este valor puede ser t para true, activar, y nil, nulo, para desactivar. Como ya he dicho antes las voy a evaluar en mi caso directamente en el buffer de scala, si las queréis dejar activas para todos los buffer de Scala tendréis que añadirlo a la configuración de lsp-ui

  • lsp-ui-sideline-show-diagnostics: Nos sirve para mostrar un diagnostico en tiempo real en el caso de que haya fallado algo (setq lsp-ui-sideline-show-diagnostics t)

Este puede ser muy útil y lo voy a activar en mi modo lsp-ui

  • lsp-ui-sideline-show-hover: Muestra información sobre el objeto o la línea en el que se encuentre el cursor, esto es configurable.

También útil, por ahora lo meteré en mi configuración.

  • lsp-ui-sideline-show-code-actions: Muestra las acciones que podemos ejecutar en la posición actual del cursor. (setq lsp-ui-sideline-show-code-actions t)

Este también lo configuraré por defecto.

Hay mas opciones que no voy a cambiar, dejaré las que vienen por defecto, como el delay para que pinte la información o la forma de pintarla. Para mas opciones lo mejor es la leer la documentación oficial.

Y así es como quiero dejarlo:

Apunte rápido

Como podéis ver no he tocado nada de scala, ni modos ni nada, así que este paquete y su configuración nos valdría para cualquier lenguaje que tengamos con su servidor de lenguaje correspondiente.

-1:-- Mostrar Informacion con LSP UI en Emacs - Sideline (Post )--L0--C0--December 07, 2020 10:58 AM

MGallego: Fijar un Repositorio Para un Paquete en Emacs

Estos días estoy configurando mi Emacs para programar en Scala y voy a intentar ir documentando todos los pasos que vaya haciendo y lo que vaya descubriendo, porque la verdad es que la documentación que he encontrado sólo consiste en explicar la instalación, pero el uso tienes que investigarlo tú mismo.

En este post no voy a contar nada de Scala, pero está relacionado con un problema que me he encontrado y quería documentar como lo he solucionado.

Al arrancar Scala Metals flycheck da un problema porque necesita la última versión para funcionar, pero la última versión no está en el repostirio de melpa-stable, así que no hay forma de instalarlo por defecto, aunque lo busques en el listado de paquetes sólo va a aparecer el de melpa-stable. Pues así es como he conseguido solucionarlo.

Fijando un repositorio para un paquete de emacs

Cuando definimos los repositorios que queremos usar para descargar los paquetes de emacs podemos fijarles una prioridad a cada uno, el problema es que cuando encuentra un paquete en el primero ya el resto los ignora, así que como en mi caso, y en el de la mayoría de la gente, el repositorio con mas prioridad es melpa-stable no podremos seleccionar paquetes de melpa porque no los podremos ver en el listado y el instalador de paquetes siempre resolverá en stable

Cuando en nuestra configuración usamos use-package tenemos varios parámetros que podemos definir, uno de ellos es pin. En mi caso el único paquete que quiero poder usar de un repositorio diferente al primero es flycheck así que lo he configurado de la siguiente manera:

     (use-package flycheck
       :ensure t
       :pin melpa
       )
   

Si refrescamos el listado de paquetes ahora podremos ver un nuevo flycheck que no está instalado y si nos fijamos corresponde al del repositorio melpa así que ahora solo nos queda instalarlo y poder usar el paquete en su última version, eso sí, puede que ahora no se estable, pero a veces es un riesgo que hay que correr si queremos que todo funcione correctamente.

-1:-- Fijar un Repositorio Para un Paquete en Emacs (Post )--L0--C0--December 07, 2020 09:31 AM

Blog uGeek: Borrando líneas en blanco de un texto con Emacs

Borrando líneas en blanco de un texto con Emacs

A veces cuando copio un documento en la terminal, lo hace dejando líneas en blanco entre líneas. Para eliminar esto con Emacs es muy sencillo:...

Sigue leyendo el post completo de Borrando líneas en blanco de un texto con Emacs

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Borrando líneas en blanco de un texto con Emacs (Post )--L0--C0--October 26, 2020 05:45 PM

Blog uGeek: Añadiendo texto al principio de cada línea en Emacs

Añadiendo texto al principio de cada línea en Emacs

Como podéis imaginar, yo creo y edito mis scripts con Emacs. Hay momentos en los que quiero añadir "#" en un bloque de código para que no se ejecute, o...

Sigue leyendo el post completo de Añadiendo texto al principio de cada línea en Emacs

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Añadiendo texto al principio de cada línea en Emacs (Post )--L0--C0--October 24, 2020 10:30 AM

Blog uGeek: Visualizar aparte una Cabecera de un OrgMode en Emacs

Visualizar aparte una Cabecera de un OrgMode en Emacs

Hay momentos, al menos a mi me pasa, de todas las notas que voy registrando en mi orgmode, quiero exporta una ya sea en formato txt, pdf, markdown,......

Sigue leyendo el post completo de Visualizar aparte una Cabecera de un OrgMode en Emacs

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Visualizar aparte una Cabecera de un OrgMode en Emacs (Post )--L0--C0--September 03, 2020 05:45 PM

Blog uGeek: Compilar Emacs 27.1 para Ubuntu, Debian, Raspbian y derivadas

Compilar Emacs 27.1 para Ubuntu, Debian, Raspbian y derivadas

En el Artículo anterior compilamos Nano y ahora toca el turno de Emacs. Los que utilizamos Debian, Ubuntu, Raspbian... tenemos el problema que en los repositorios oficiales, no encontramos nunca...

Sigue leyendo el post completo de Compilar Emacs 27.1 para Ubuntu, Debian, Raspbian y derivadas

Visita uGeek Blog

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Compilar Emacs 27.1 para Ubuntu, Debian, Raspbian y derivadas (Post )--L0--C0--August 12, 2020 09:10 PM

La Pipa Plena: La entrada 37 de emacs

Aprovechando el confinamiento en /home hemos terminado la entrada 37 de lo que llamamos el curso de emacs pero más que curso, son nuestros apuntes sobre los temas con los que nos vamos encontrando y en esta ocasión es fill-column-indicator, customize-themes, ffap, free-keys y auto-save-buffers El enlace es: http://lapipaplena.duckdns.org/emacs/ ¡¡Buen confinamiento para todos y excelentes … Sigue leyendo La entrada 37 de emacs
-1:-- La entrada 37 de emacs (Post la pipa plena)--L0--C0--April 12, 2020 02:32 PM

La Pipa Plena: subida la entrada 36 al curso de emacs

Hemos subido más cosas de las que nos vamos encontrando con emacs y las hemos puesto en la entrada número 36 para tenerlas siempre a mano. Recordamos que el archivo org puede descargarse de: http://lapipaplena.duckdns.org/emacs/curs_emacs.org y el curso completo de: http://lapipaplena.duckdns.org/emacs/
-1:-- subida la entrada 36 al curso de emacs (Post la pipa plena)--L0--C0--March 24, 2020 03:22 PM

La Pipa Plena: No estamos durmiendo…

Aunque parezca que tenemos el blog abandonado, cosa no muy descabellada, la verdad es que continuamos a pleno rendimiento pero en aspectos no tan evidentes como son las entradas de un blog. Una muestra del git log del tractatus así lo confirma: Y además hemos revisado y corregido varias cosas del curso de emacs que … Sigue leyendo No estamos durmiendo…
-1:-- No estamos durmiendo… (Post la pipa plena)--L0--C0--February 23, 2020 09:34 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ños1, 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:

  1. Abro Emacs.
  2. Leo en la lista de tareas qué me queda por hacer y en el diario qué hice el día anterior.
  3. 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.
  4. Trabajo. Escribo, programo, busco papers … abro ramas y envío actualizaciones al repo según corresponda con Magit o desde la terminal.
  5. Actualizo la lista de tareas y el diario con lo que vaya terminando y las conclusiones sacadas.
  6. 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!


  1. Dudo que vaya a querer, pero podré↩
-1:-- Mi entorno de trabajo (Post Ondiz)--L0--C0--October 16, 2019 03:00 PM

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

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

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

Jubilación Efectiva: Spacemacs ¿Editor definitivo?.

Pues, para mí, va a ser que no, aunque en mi lento retorno a estos andurriales, me he visto sorprendido por este entorno. Lo cierto es que este verano me he encontrado con un pequeño problema ya que se me ha oxidado algo el Emacs, por falta de uso y en la búsqueda de vídeos …

Spacemacs ¿Editor definitivo?. Leer más »

La entrada Spacemacs ¿Editor definitivo?. se publicó primero en Gestión del Conocimiento Personal.

-1:-- Spacemacs ¿Editor definitivo?. (Post Antonio Simón)--L0--C0--August 22, 2019 05:19 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

Jubilación Efectiva: Compilando Emacs en Debian Stretch.

Una de las últimas tareas que acometí en mi Debian, antes de pasarme al mundo de Antergos, fue la de compilar GNU Emacs, algo necesario para dispones de su última versión, dado el sistema de gestión de paquetes de esta distribución. La tarea me imponía algo de respeto, porque hacía muchos años que no me …

Compilando Emacs en Debian Stretch. Leer más »

La entrada Compilando Emacs en Debian Stretch. se publicó primero en Gestión del Conocimiento Personal.

-1:-- Compilando Emacs en Debian Stretch. (Post Antonio Simón)--L0--C0--April 18, 2019 01: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

Jubilación Efectiva: GTD con org-mode. Primer intento.

Bueno, pues aquí estamos. Tras la formación GTD, Nivel 1, que os comenté en esta entrada anterior me he encontrado con un sistema GTD funcionando, que hay que aprovechar y sobre el que hoy os quiero hablar. Me parece importante comenzar a explicar los ajustes que, seguro, iré haciendo a mi sistema GTD para ver …

GTD con org-mode. Primer intento. Leer más »

La entrada GTD con org-mode. Primer intento. se publicó primero en Gestión del Conocimiento Personal.

-1:-- GTD con org-mode. Primer intento. (Post Antonio Simón)--L0--C0--February 17, 2019 09:55 PM

Jubilación Efectiva: Adquisición de hábitos con ayuda de org-mode.

Introducción. Cuando hablamos de «mejora personal«, utilizar un sistema como GTD es fundamental para realizar un seguimiento de las acciones realizadas, lo que favorece la revisión y el análisis de nuestras buenas o malas prácticas. Dentro de estas acciones hay una serie de ellas, conocidas como hábitos, que son una base fundamental de nuestro día …

Adquisición de hábitos con ayuda de org-mode. Leer más »

La entrada Adquisición de hábitos con ayuda de org-mode. se publicó primero en Gestión del Conocimiento Personal.

-1:-- Adquisición de hábitos con ayuda de org-mode. (Post Antonio Simón)--L0--C0--January 27, 2019 07:45 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

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

Podcast uGeek: Como gestiono Mis Notas Markdown

Como gestiono Mis Notas Markdown

Como gestiono Mis Notas Markdown...

Sigue leyendo el post completo de Como gestiono Mis Notas Markdown

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Como gestiono Mis Notas Markdown (Post )--L0--C0--October 14, 2018 10:34 PM

Podcast uGeek: Podcast: Iniciándonos en Emacs y Org Mode de un Modo muy muy Fácil.

Podcast: Iniciándonos en Emacs y Org Mode de un Modo muy muy Fácil.

Podcast: Iniciándonos en Emacs y Org Mode de un Modo muy muy Fácil....

Sigue leyendo el post completo de Podcast: Iniciándonos en Emacs y Org Mode de un Modo muy muy Fácil.

Visita uGeek Podcast

Visita uGeek Podcast

Suscribete al Blog de uGeek

Suscribete al Podcast de uGeek

-1:-- Podcast: Iniciándonos en Emacs y Org Mode de un Modo muy muy Fácil. (Post )--L0--C0--October 09, 2018 10:26 PM

Jubilación Efectiva: Mis maestros: Drymer, el Emacs en castellano.

Cuando descubrí org-mode y, como consecuencia, me topé con Emacs, me sentía bastante inseguro como para  trabajar en inglés sobre todo ello, y al hacer la recopilación de recursos, que por cierto creo debiera reorganizar :(, el descubrimiento del sitio de Planet Emacses, a día de hoy inactivo, fue una auténtica alegría y se convirtió …

Mis maestros: Drymer, el Emacs en castellano. Leer más »

La entrada Mis maestros: Drymer, el Emacs en castellano. se publicó primero en Gestión del Conocimiento Personal.

-1:-- Mis maestros: Drymer, el Emacs en castellano. (Post Antonio Simón)--L0--C0--October 05, 2018 04:19 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

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

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

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