May I recommend… / En mayo recomiendo…

De momento he hecho una especie de "Hola mundo" un poco más complejo, usando la función let de Elisp para declarar variables.

Es una función muy sencilla, que pide al usuario el nombre, y luego le da los buenos días y la fecha. Con esta función he usado por primera vez let, y además he descubierto la distintas formas en las que se puede conseguir una fecha con la función format-time-string.

A continuación dejo el código y un ejemplo de uso cuando el usuario introduce la cadena "Carlos" por teclado.

  (defun holamundo()
  (interactive)
  "Hola mundo interactivo que pide el nombre del usuario y dice la fecha de hoy."
  (let ((nombre (read-string "Introduce tu nombre: "))
    (diasem (format-time-string "%A"))
    (dia (format-time-string "%d"))
    (mes (format-time-string "%B")))
    (message "Buenos días %s, hoy es %s %s de %s" nombre diasem dia mes)))

(holamundo)

  "Buenos días Carlos, hoy es domingo 22 de marzo" 

En los posts que tengo en español que yo recuerde no los he usado para nada, y en los que tengo en inglés alguna vez le he pasado alguna frase para que me revisara la gramática.

Aparte de eso, igual en el futuro hago algún experimento con Gemini, ChatGPT, Grok o el modelo que sea, pero en principio no me apoyo en LLMs para escribir.

En mi día a día a veces uso Gemini sobre todo si veo que me puede ahorrar tiempo para buscar algo, o para preguntar alguna curiosidad que me surja.

También he probado algunos modelos locales con ollama, pero como no tengo mucha potencia de cálculo local eran modelos muy sencillos.

• Programando: Aplicación Economía Circular con Xcrud
• Leyendo: Circo Máximo de Santiago Posteguillo
• Leyendo: JavaScript: The Definitive Guide, 7th Edition de David Flanagan
• Jugando: Pokémon Leyendas Z-A
• Jugando: Nethack (tnnt.org)
• Viendo: Stranger Things

While maintenance sometimes is seen as something boring, I think it's the perfect way to start learning things. First, you have to know how things work in order to change and improve them. Thus, if I spent more time maintaining my Emacs configuration, I would surely learn enough Emacs Lisp to write more complex functions and be able to improve my config a lot.

So, while a lot of people spend more time tweaking their Emacs configuration file than actually using Emacs, for me it's just the opposite. I wish I spent more time tweaking my Emacs setup.

El mantenimiento normalmente se ve como una tarea aburrida o secundaria, pero yo creo que es la base para entender cómo funcionan los sistemas. Primero tienes que saber de qué forma está algo montado para luego poder cambiarlo o mejorarlo. Por eso creo que el primer paso para aprender más Emacs Lisp sería pasar más tiempo manteniendo mi configuración, y esto me permitiría escribir funciones más complejas que harían que mi configuración mejorase un montón.

Así que, mientras que la mayoría de gente que leo en blogs se suele quejar de que pasa más tiempo configurando Emacs que usándolo, para mí es justo al revés, creo que debería pasar más tiempo revisando y manteniendo mi configuración.

Me dio por leer algunas reseñas en varios blogs y vi que Gene Wolfe no era un escritor cualquiera. Además de ser un ingeniero mecánico que había colaborado en el diseño de la máquina que hace las patatas Pringles, también diseñaba sus libros como si fueran un auténtico rompecabezas.

No enterarse de nada cuando lees por primera vez un libro de Gene Wolfe no es algo raro, es lo normal. Son libros que están diseñados para releerse, con infinidad de matices y capas ocultas. Si bien en una primera lectura atenta se pueden unir muchas piezas, es imposible armar todo el puzzle sin volver a leer su obra varias veces.

Lo mágico de estas relecturas es cómo va cambiando la novela a medida que el lector se va introduciendo en el mundo. La segunda vez que me leí "La sombra del torturador" me pareció que me estaba leyendo otro libro distinto. No sólo le presté mucha más atención, si no que ya conocía aunque fuera de refilón el mundo y sus personajes, y ya estaba preparado para empezar a entender la historia. Y sin embargo, la tercera vez que me lo leí disfruté infinitamente más que las dos primeras, porque ya me sentía como alguien que conocía a Severian (el protagonista), y estaba empezando a unir los hilos de todos los pequeños detalles que van apareciendo por la novela.

Leer a Gene Wolfe no es algo fácil, hace falta concentración. Sus novelas no tratan al lector como un ente sin inteligencia que sólo quiere echar el rato. Hace falta esfuerzo para sacarle el jugo a sus obras. Pero la recompensa merece la pena. Es muy gratificante ir viendo cómo se forma el mundo que en un primer momento ni siquiera te habías dado cuenta de que estaba ahí.

Emacs is an extensible text editor. You can configure it beyond your imagination. It adapts to your needs, and you can mold it to your liking. With Emacs you can discover the beauty of plain text. You can start doing simple things and gradually build your perfect setup. Whether it's mailing, writing, journaling, taking notes, programming or even making books, Emacs has you covered.

Emacs es un editor de texto totalmente personalizable. Lo puedes configurar más allá de tu imaginación. Se adapta como un guante a tus necesidades, y lo puedes moldear a tu gusto. Con Emacs, descubrirás la belleza del texto plano. Puedes empezar haciendo cosas simples, y poco a poco ir construyendo tu configuración perfecta. Ya sea escribir correos, textos, diarios, tomar notas, programar o inculuso editar libros, Emacs tiene todo lo que necesitas.

En el vídeo que ha hecho conmigo hablamos sobre Emacs en la ingeniería, fútbol, España y la libertad de acceso a las publicaciones en el mundo académico, entre otras cosas.

El enlace al vídeo está aquí.

En Emacs, el lector de RSS que uso se llama Elfeed. Su configuración y uso es muy simple, pero a la vez es muy potente. Permite etiquetar las diversas entradas de forma automática o manual, y usar filtros para ocultar o mostrar lo que nos interese.

Una de las ventajas de RSS es que se pueden generar fácilmente los archivos xml que usan los lectores como Elfeed. Por ejemplo, se pueden sacar xml de canales de Youtube, y así se puede estar al tanto de los vídeos nuevos sin tener que visitar Youtube.

Como ejemplo, dejo mi lista de feeds, parte de mi configuración de Emacs:

(elfeed-feeds
   '(("https://yewtu.be/feed/channel/UCDy1lHSVGBDL0d2_C5NZNJw" Themaoisha
      Video)
     ("http://antirez.com/rss" Antirez Blog)
     ("https://stallman.org/rss/rss.xml" RMS)
     ("https://notxor.nueva-actitud.org/rss.xml" Noxtor Blog)
     ("http://finaprosadigital.com/publish/blog/rss.xml" CPR)
     ("https://taonaw.com/index.xml" Emacs TAONAW)
     ("http://feeds.feedburner.com/uGeekBlog" Emacs uGeek)
     ("https://daemons.it/posts/index.xml" Emacs daemon)
     ("https://lukesmith.xyz/rss.xml" Luke)
     ("https://videos.lukesmith.xyz/feeds/videos.xml?sort=-publishedAt&filter=local"
      Video)
     ("https://www.youtube.com/feeds/videos.xml?channel_id=UCaifrB5IrvGNPJmPeVOcqBA"
      Kruggsmash Video)
     ("https://www.bay12games.com/dwarves/dev_now.rss" Dwarf Fortress
      Video)
     ("https://www.youtube.com/feeds/videos.xml?channel_id=UCD6VugMZKRhSyzWEWA9W2fg"
      Video)
     ("https://karl-voit.at/feeds/lazyblorg-all.atom_1.0.links-only.xml"
      Blog Voit)
     ("https://planet.emacslife.com/atom.xml" Emacs)
     ("https://protesilaos.com/master.xml" Prot Blog)
     ("https://greenwald.substack.com/feed" Glenn Blog)
     ("https://victorhckinthefreeworld.com/feed/" Victr Blog)
     ("https://sachachua.com/blog/feed/" Sacha Blog)
     ("https://www.danielclemente.com/cambios/cambios.xml" Blog)
     ("https://edwardsnowden.substack.com/feed.xml" Snowden Blog)
     ("https://twobithistory.org/feed.xml" 2bit Blog)))

Contacto

Sin embargo, a la hora de exportar a pdf un calendario para imprimirlo, la mejor opción que he descubierto es el comando "t m" una vez dentro del calendario integrado que se invoca con M-x calendar (también está la opción H m para exportar a html).

Una vez exportado el calendario, podemos usar el comando C-c C-b dentro del archivo .tex exportado, y esto nos generará un archivo .dvi. Con la orden dvi2pdf podemos convertir finalmente el .dvi a pdf para después imprimirlo.

Según el manual de Emacs, también se puede exportar el calendario de la org-agenda pero el proceso parece bastante más complicado.

Antes de exportar el calendario, sobre el mismo archivo .tex, podemos modificar las diferentes fechas para incluir los eventos que queramos. De momento no he encontrado la forma de incluir los eventos del archivo diario para integrarlos automáticamente, pero si no son muchos no es difícil hacerlo a mano.

MinUI

La interfaz es muy agradable, e incluso incluye música de fondo en el menú principal por defecto. Además se puede conectar a diversas web para recolectar las carátulas, sinopsis y varios meta datos más sobre todos los juegos que tengamos con sólo pulsar un botón.

Sin embargo, a diferencia del sistema operativo por defecto de Anbernic, hay que configurar un poco diferentes aspectos para poder tener la misma experiencia de juego que nos ofrece Anbernic, que a día de hoy es bastante completa.

En primer lugar hay que configurar los shaders o efectos gráficos, si queremos que los juegos se vean como en las consolas originales. Tampoco están por defecto los marcos de diferentes consolas que rellenan el espacio en negro que se queda en pantalla si la relación de aspecto del sistema que estemos jugando no es exactamente 4:3.

En general, a día de hoy es un sistema muy completo y bonito, pero si sólo nos interesa encender y jugar con todo ya listo creo que es mejor opción el sistema operativo por defecto de Anbernic.

Como sistema operativo trae un Ubuntu 22.04, modificado por Anbernic y listo para jugar con una buena interfaz y varias opciones para emular.

Por un lado tiene Retroarch con varios cores disponibles, y por otro los emuladores sueltos. Además se puede activar SSH para meter juegos en la microSD de la consola por SFTP.

Para ello basta con ejecutar un script (por ejemplo: https://github.com/xgbox/rg35xxsp-ssh-samba/blob/main/scripts/ssh_enable.sh) que tendremos que colocar previamente en la carpeta de APPS de la microSD de la consola para luego poder ejecutarlo desde la propia Anbernic. Una vez ejecutado, podemos ver la ip de la consola en la configuración del sistema y acceder por ssh.

A falta de probar otros sistemas operativos disponibles como Knulli, de momento estoy muy contento con el sistema que trae de serie. Sólo he encontrado problemas al intentar conectar mandos por Bluetooth o stremear con Moonlight, pero por lo demás funciona perfecto.

Después de instalarlo sólo hay que cargarlo con (require 'calfw-org) y ejecutar la orden M-x cfw:open-org-calendar para ver nuestra agenda en formato calendario.

Además, aprovechando que el x270 que tengo tiene pantalla táctil he decidido probar a asignarle esta orden a un toque de la pantalla para que aparezca la agenda en modo calendario.

Para la asignación en vez de código he usado Embark. Una vez abierto el menú de Emacs con M-x, y estando sobre la orden cfw:open-org-calendar, invoco Embark con C-. y luego pulso g para asignar un atajo de teclado global. Después pulso la pantalla y ya tengo configurado todo para poder ver mi agenda al toque.

Sin embargo, no funciona si no estamos dentro de Emacs. Para que funcione globalmente usando el gestor de ventanas i3 windows manager, podemos añadir la siguiente línea al archivo config situado normalmente en ~/.config/i3/config:

bindsym XF86AudioMicMute exec emacsclient --eval "(eshell2fa)"

He usado un atajo de teclado un poco raro, pero es que el Thinkpad X230 que uso tiene un botón de fácil acceso de silenciar el micrófono que nunca uso, y me viene perfecto para tener el 2FA a mano. Por supuesto se puede cambiar por cualquier otra tecla.

Con esto ya podemos tener acceso al código 2FA cómodamente pulsando un botón.

Una vez hecho esto, cuando se hayan descargado las librerías, nos saldrá un submenú que contiene las placas de la familia ESP8266 en la pestaña de "Herramientas > Placa" del IDE. Ahí ya podemos seleccionar la placa D1 R2.

Con todo esto configurado, ya se puede programar como si fuera cualquier otra placa de Arduino.

Como echaba en falta poder gestionar distintas terminales sin tener que estar abriendo y cerrando un montón de ventanas, estuve aprendiendo lo básico de GNU Screen, un multiplexor de terminales.

En Debian se puede instalar desde los repositorios fácilmente con un sudo apt install screen. Una vez instalado, se puede iniciar con la orden screen, y nos saldrá un mensaje de bienvenida que se puede saltar pulsando intro.

La forma básica de interactuar con Screen es pulsando Control + a y después la orden correspondiente. Para ver todos los atajos de teclado se puede pulsar Control + a + ?.

La interfaz de Screen es muy minimalista por defecto, tanto que de hecho es difícil saber si estás o no dentro de Screen. Para salir del programa basta con escribir exit y nos saldrá un mensaje informándonos que la sesión de Screen ha terminado.

Dentro de Screen podemos crear terminales con Control + a + c, cerrarlos con Control + a + k o cambiar entre terminales con Control + a + n o Control + a + p.

Además de este uso básico, también se pueden crear distintas ventanas dentro de una misma terminal, o crear un archivo de configuración que ejecute scripts o configure las teclas de configuración de Screen.

Por ejemplo, para cambiar Control + a por Control + t como tecla principal de Screen podemos incluir la siguiente línea en un archivo llamado .screenrc en nuestro directorio personal:

escape ^Tt

En /etc/screenrc si estamos en Debian podemos encontrar un archivo de configuración base para Screen para no empezar la configuración de cero.

Con este uso básico de un multiplexor es mucho más fácil trabajar con distintas terminales de forma cómoda y rápida.

En mi caso prefiero tener separación vertical entre cada columna, así que miré el manual para ver cómo solucionarlo. Hay que insertar una fila vacía con el carácter de control / y luego un carácter menor que seguido de uno mayor que <> en cada columna de la tabla.

Ahora al exportar el archivo .org a html o pdf ya tendremos nuestra tabla correctamente formateada.

Tenía una función básica, que no recuerdo dónde la saqué, pero requería tener un búfer de Eshell en segundo plano para que funcionara.

(defun eshell2fa ()
    (interactive)
    "Devuelve el id del 2FA en el portapapeles."
    (with-current-buffer "*eshell*"
    (eshell-return-to-prompt)
    (insert "id > /dev/kill")
    (eshell-send-input))
    )

La línea del insert es la que se encarga de obtener la clave a través del alias id, que usa oathtool para obtener el código. Luego se redirige al portapapeles con > /dev/kill.

El alias se define de la siguiente forma: alias id oathtool --counter=30 --totp=SHA1 -d 6 -b "clave-de-2FA"

Para mejorarla he añadido una línea que crea el búfer de Eshell si no ha sido creado anteriormente, con un unless

(defun eshell2fa ()
    (interactive)
    "Devuelve el id del 2FA en el portapapeles."
    (unless (gnus-buffer-live-p "*eshell*") (eshell) (switch-to-prev-buffer))
    (with-current-buffer "*eshell*"
    (eshell-return-to-prompt)
    (insert "id > /dev/kill")
    (eshell-send-input))
    )

Y luego sólo queda asignarla (por ejemplo a f12) para poder tener el código pulsando un botón.

(global-set-key (kbd "<f12>") 'eshell2fa)

Decidí instalar Flycheck, y lo configuré según la web de forma muy sencilla. Lo que más me costó fue dar con el motor para comprobar la sintaxis, pero al final lo único que hay que instalar es ghdl (en Debian viene en los repositorios). Una vez instalado y activado el modo con M-x flycheck-mode, seleccioné el motor de sintaxis en un búfer con el modo VHDL pulsando C-c ! v.

Por último me instalé el paquete Perspective para poder tener todo lo relacionado con VHDL en un espacio de trabajo aparte, y que no se mezcle con el resto de mis búferes de Emacs.

En menos de 5 minutos ya tenía todo funcionando, y así evito tener que usar el horrible editor de texto de ISE, el entorno propietario para programar FPGAs de Xilinx.

Pero desde hace un tiempo no consigo que me funcione la red de la universidad, y, como hace relativamente poco que me instalé Debian 12 en mi Thinkpad X230, no tenía ningún programa para cronometrar el tiempo que tardo en hacer el cubo.

Miré el manual de Elisp, pero los temporizadores que hay sólo llegan a precisión de segundos, y yo necesitaba hasta las centésimas de segundo. Recordé que en informática de cuarto dimos temporizadores POSIX, pero no tenía ganas de ponerme a hacer un programa en C y tener que mirarme el estándar sólo para hacer un pequeño programa.

Me acordé de que existe un programa en GNU/Linux que se llama time, que cronometra el tiempo que tarda en ejecutarse un comando. Estuve mirando entre los programas en C que tenía de informática hechos por el profesor, y había uno que se llamaba pierde_tiempo.c.

El programa es tan sólo un bucle infinito, y sirve para demostrar el funcionamiento de los hilos y los procesos en C + POSIX. Pero lo interesante es que al combinarlo con time puedo saber con precisión de milésimas de segundo cuánto tiempo ha estado ejecutándose el programa hasta que lo pare con C-c.

Así, con una sola línea en la terminal, improvisé un cronómetro casero para poder cronometrarme con una precisión de centésimas de segundo. Añadí una macro de Emacs para poder pausar el programa con F12 y no perder tiempo pulsando C-c, y ya tenía todo listo, y sin usar internet en ningún momento.

Introducción

(setq tetris-allow-repetitions nil)

;;Shape 1 (O) Yellow
;;Shape 2 (L) Orange
;;Shape 3 (J) Dark blue
;;Shape 4 (S) Green
;;Shape 5 (Z) Red
;;Shape 6 (T) Magenta
;;Shape 7 (I) Light blue

  (setq tetris-x-colors [[1 1 0]
   [1 0.27 0]
   [0 0 0.55]
   [1 0 0]
   [0 1 0]
   [1 0 1]
   [0 0.86 0.9]]
  )

(defun tetris-hold-shape ()
  "Con esta función se puede dibujar una pieza cualquiera por la cara en el tetris. Pones setq tetris-shape al número de la pieza que quieras y listo."
  (interactive)
  (setq tetris-next-holded-piece tetris-shape)
  (setq tetris-shape tetris-holded-piece)
  (setq tetris-rot 0)
  (setq tetris-next-shape (if tetris-allow-repetitions
                              (random 7)
                            (tetris--seven-bag)))
  (setq tetris-pos-x (/ (- tetris-width (tetris-shape-width)) 2))
  (setq tetris-pos-y 0)
  (if (tetris-test-shape)
      (tetris-end-game)
    (tetris-draw-shape)
    (tetris-draw-next-shape)
    (tetris-update-score))
  (setq tetris-holded-piece tetris-next-holded-piece))

(defun tetris-erase-shape ()
  "Con esta función se puede eliminar una pieza cualquiera del juego."
  (interactive)
  (dotimes (i 4)
    (let ((c (tetris-get-shape-cell i)))
      (gamegrid-set-cell (+ tetris-top-left-x
                            tetris-pos-x
                            (aref c 0))
                         (+ tetris-top-left-y
                            tetris-pos-y
                            (aref c 1))
                         tetris-blank))))
(defun tetris-reserva()
  "Función para implementar la reserva de piezas en el tetris."
  (interactive)
  (progn
    (tetris-erase-shape)
    (tetris-hold-shape)
    (tetris-update-score)
    )
  )

(global-set-key (kbd "C-ñ") 'tetris-reserva)
;;Shape 0 (O) Yellow
;;Shape 1 (L) Orange
;;Shape 2 (J) Dark Blue
;;Shape 3 (S) Green
;;Shape 4 (Z) Red
;;Shape 5 (T) Magenta
;;Shape 6 (I) Light Blue

;;; etris.el ---implementation of Tetris for Emacs  -*- lexical-binding:t -*-

;; Copyright (C) 1997, 2001-2024 Free Software Foundation, Inc.

;; Author: Glynn Clements <glynn@sensei.co.uk>
;; Old-Version: 2.01
;; Created: 1997-08-13
;; Keywords: games

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:

(eval-when-compile (require 'cl-lib))

(require 'gamegrid)

;; ;;;;;;;;;;;;; customization variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defgroup tetris nil
  "Play a game of Tetris."
  :prefix "tetris-"
  :group 'games)

(defcustom tetris-use-glyphs t
  "Non-nil means use glyphs when available."
  :type 'boolean)

(defcustom tetris-use-color t
  "Non-nil means use color when available."
  :type 'boolean)

(defcustom tetris-draw-border-with-glyphs t
  "Non-nil means draw a border even when using glyphs."
  :type 'boolean)

(defcustom tetris-default-tick-period 0.3
  "The default time taken for a shape to drop one row."
  :type 'number)

(defcustom tetris-update-speed-function
  'tetris-default-update-speed-function
  "Function run whenever the Tetris score changes.
Called with two arguments: (SHAPES ROWS)
SHAPES is the number of shapes which have been dropped.
ROWS is the number of rows which have been completed.

If the return value is a number, it is used as the timer period."
  :type 'function)

(defcustom tetris-mode-hook nil
  "Hook run upon starting Tetris."
  :type 'hook)

(defcustom tetris-tty-colors
  ["blue" "white" "yellow" "magenta" "cyan" "green" "red"]
  "Vector of colors of the various shapes in text mode."
  :type '(vector (color :tag "Shape 1")
                 (color :tag "Shape 2")
                 (color :tag "Shape 3")
                 (color :tag "Shape 4")
                 (color :tag "Shape 5")
                 (color :tag "Shape 6")
                 (color :tag "Shape 7")))

(defcustom tetris-x-colors
  [[0 0 1] [0.7 0 1] [1 1 0] [1 0 1] [0 1 1] [0 1 0] [1 0 0]]
  "Vector of RGB colors of the various shapes."
  :type '(vector (vector :tag "Shape 1" number number number)
                 (vector :tag "Shape 2" number number number)
                 (vector :tag "Shape 3" number number number)
                 (vector :tag "Shape 4" number number number)
                 (vector :tag "Shape 5" number number number)
                 (vector :tag "Shape 6" number number number)
                 (vector :tag "Shape 7" number number number)))

(defcustom tetris-buffer-name "*Tetris*"
  "Name used for Tetris buffer."
  :type 'string)

(defcustom tetris-buffer-width 30
  "Width of used portion of buffer."
  :type 'natnum)

(defcustom tetris-buffer-height 22
  "Height of used portion of buffer."
  :type 'natnum)

(defcustom tetris-width 10
  "Width of playing area."
  :type 'natnum)

(defcustom tetris-height 20
  "Height of playing area."
  :type 'natnum)

(defcustom tetris-top-left-x 3
  "X position of top left of playing area."
  :type 'natnum)

(defcustom tetris-top-left-y 1
  "Y position of top left of playing area."
  :type 'natnum)

(defcustom tetris-allow-repetitions t
  "If non-nil, use a random selection for each shape.
If nil, put the shapes into a bag and select without putting
back (until empty, when the bag is repopulated."
  :type 'boolean
  :version "29.1")

(defvar tetris-next-x (+ (* 2 tetris-top-left-x) tetris-width)
  "X position of next shape.")

(defvar tetris-next-y tetris-top-left-y
  "Y position of next shape.")

(defvar tetris-score-x tetris-next-x
  "X position of score.")

(defvar tetris-score-y (+ tetris-next-y 6)
  "Y position of score.")

;; It is not safe to put this in /tmp.
;; Someone could make a symlink in /tmp
;; pointing to a file you don't want to clobber.
(defvar tetris-score-file "tetris-scores"
;; anybody with a well-connected server want to host this?
;(defvar tetris-score-file "/anonymous@ftp.pgt.com:/pub/cgw/tetris-scores"
  "File for holding high scores.")

;; ;;;;;;;;;;;;; display options ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar tetris-blank-options
  '(((glyph colorize)
     (t ?\040))
    ((color-x color-x)
     (mono-x grid-x)
     (color-tty color-tty))
    (((glyph color-x) [0 0 0])
     (color-tty "black"))))

(defvar tetris-cell-options
  '(((glyph colorize)
     (emacs-tty ?O)
     (t ?\040))
    ((color-x color-x)
     (mono-x mono-x)
     (color-tty color-tty)
     (mono-tty mono-tty))
    ;; color information is taken from tetris-x-colors and tetris-tty-colors
    ))

(defvar tetris-border-options
  '(((glyph colorize)
     (t ?\+))
    ((color-x color-x)
     (mono-x grid-x)
     (color-tty color-tty))
    (((glyph color-x) [0.5 0.5 0.5])
     (color-tty "white"))))

(defvar tetris-space-options
  '(((t ?\040))
    nil
    nil))

;; ;;;;;;;;;;;;; constants ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defconst tetris-shapes
  [[[[0  0] [1  0] [0  1] [1  1]]]

   [[[0  0] [1  0] [2  0] [2  1]]
    [[1 -1] [1  0] [1  1] [0  1]]
    [[0 -1] [0  0] [1  0] [2  0]]
    [[1 -1] [2 -1] [1  0] [1  1]]]

   [[[0  0] [1  0] [2  0] [0  1]]
    [[0 -1] [1 -1] [1  0] [1  1]]
    [[2 -1] [0  0] [1  0] [2  0]]
    [[1 -1] [1  0] [1  1] [2  1]]]

   [[[0  0] [1  0] [1  1] [2  1]]
    [[1  0] [0  1] [1  1] [0  2]]]

   [[[1  0] [2  0] [0  1] [1  1]]
    [[0  0] [0  1] [1  1] [1  2]]]

   [[[1  0] [0  1] [1  1] [2  1]]
    [[1  0] [1  1] [2  1] [1  2]]
    [[0  1] [1  1] [2  1] [1  2]]
    [[1  0] [0  1] [1  1] [1  2]]]

   [[[0  0] [1  0] [2  0] [3  0]]
    [[1 -1] [1  0] [1  1] [1  2]]]]
  "Each shape is described by a vector that contains the coordinates of
each one of its four blocks.")

;;the scoring rules were taken from "xtetris".  Blocks score differently
;;depending on their rotation

(defconst tetris-shape-scores
  [[6] [6 7 6 7] [6 7 6 7] [6 7] [6 7] [5 5 6 5] [5 8]] )

(defconst tetris-shape-dimensions
  [[2 2] [3 2] [3 2] [3 2] [3 2] [3 2] [4 1]])

(defconst tetris-blank 7)

(defconst tetris-border 8)

(defconst tetris-space 9)

(defun tetris-default-update-speed-function (_shapes rows)
  (/ 20.0 (+ 50.0 rows)))

;; ;;;;;;;;;;;;; variables ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar-local tetris-shape 0)
(defvar-local tetris-rot 0)
(defvar-local tetris-next-shape 0)
(defvar-local tetris-n-shapes 0)
(defvar-local tetris-n-rows 0)
(defvar-local tetris-score 0)
(defvar-local tetris-pos-x 0)
(defvar-local tetris-pos-y 0)
(defvar-local tetris-paused nil)
(defvar-local tetris--bag nil)

;; ;;;;;;;;;;;;; keymaps ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar-keymap tetris-mode-map
  :doc "Keymap for Tetris games."
  :name 'tetris-mode-map
  "n"       #'tetris-start-game
  "q"       #'tetris-end-game
  "p"       #'tetris-pause-game

  "SPC"     #'tetris-move-bottom
  "<left>"  #'tetris-move-left
  "<right>" #'tetris-move-right
  "<up>"    #'tetris-rotate-prev
  "<down>"  #'tetris-move-down)

(defvar-keymap tetris-null-map
  :doc "Keymap for finished Tetris games."
  :name 'tetris-null-map
  "n"       #'tetris-start-game
  "q"       #'quit-window)

(defconst tetris--menu-def
  '("Tetris"
    ["Start new game"    tetris-start-game
     :help "Start a new Tetris game"]
    ["End game"          tetris-end-game
     :active (tetris-active-p)
     :help "End the current Tetris game"]
    ;; FIXME: Pause and resume from the menu currently doesn't work
    ;;        very well and is therefore disabled.  The game continues
    ;;        running while navigating the menu.  See also
    ;;        `snake--menu-def' which has the same problem.
    ;; ["Pause"             tetris-pause-game
    ;;  :active (and (tetris-active-p) (not tetris-paused))
    ;;  :help "Pause running Tetris game"]
    ;; ["Resume"            tetris-pause-game
    ;;  :active (and (tetris-active-p) tetris-paused)
    ;;  :help "Resume paused Tetris game"]
    )
  "Menu for `tetris'.  Used to initialize menus.")

(easy-menu-define
  tetris-mode-menu tetris-mode-map
  "Menu for running Tetris games."
  tetris--menu-def)

(easy-menu-define
  tetris-null-menu tetris-null-map
  "Menu for finished Tetris games."
  tetris--menu-def)
(setq tetris-holded-piece 1)
(setq tetris-next-holded-piece 1)
(setq tetris-holded-siguiente "s")
;; ;;;;;;;;;;;;;;;; game functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun tetris-display-options ()
  (let ((options (make-vector 256 nil)))
    (dotimes (c 256)
      (aset options c
            (cond ((= c tetris-blank)
                   tetris-blank-options)
                  ((and (>= c 0) (<= c 6))
                   (append
                    tetris-cell-options
                    `((((glyph color-x) ,(aref tetris-x-colors c))
                       (color-tty ,(aref tetris-tty-colors c))
                       (t nil)))))
                  ((= c tetris-border)
                   tetris-border-options)
                  ((= c tetris-space)
                   tetris-space-options)
                  (t
                   '(nil nil nil)))))
    options))

(defun tetris-get-tick-period ()
  (let ((period (apply tetris-update-speed-function
                       tetris-n-shapes
                       tetris-n-rows nil)))
    (and (numberp period) period)))

(defun tetris-get-shape-cell (block)
  (aref (aref  (aref tetris-shapes
                     tetris-shape) tetris-rot)
        block))

(defun tetris-shape-width ()
  (aref (aref tetris-shape-dimensions tetris-shape) 0))

(defun tetris-shape-rotations ()
  (length (aref tetris-shapes tetris-shape)))

(defun tetris-draw-score ()
  (let ((strings (vector (format "Shapes: %05d" tetris-n-shapes)
                         (format "Rows:   %05d" tetris-n-rows)
                         (format "Score:  %05d" tetris-score))))
    (dotimes (y 3)
      (let* ((string (aref strings y))
             (len (length string)))
        (dotimes (x len)
          (gamegrid-set-cell (+ tetris-score-x x)
                             (+ tetris-score-y y)
                             (aref string x)))))))
(defun tetris-draw-hold ()
  (if (eq tetris-holded-piece 0)
      (setq tetris-holded-siguiente "O")
      )
  (if (eq tetris-holded-piece 1)
          (setq tetris-holded-siguiente "J")
      )
  (if (eq tetris-holded-piece 2)
          (setq tetris-holded-siguiente "L")
      )
  (if (eq tetris-holded-piece 3)
          (setq tetris-holded-siguiente "Z")
      )
  (if (eq tetris-holded-piece 4)
          (setq tetris-holded-siguiente "S")
      )
  (if (eq tetris-holded-piece 5)
          (setq tetris-holded-siguiente "T")
      )
  (if (eq tetris-holded-piece 6)
          (setq tetris-holded-siguiente "I")
      )

  (let ((strings (vector (format "Shapes: %05d" tetris-n-shapes)
                         (format "Rows:   %05d" tetris-n-rows)
                         (format "Hodl:  %05s" tetris-holded-siguiente))))
    (dotimes (y 3)
      (let* ((string (aref strings y))
             (len (length string)))
        (dotimes (x len)
          (gamegrid-set-cell (+ 15 x)
                             (+ 15 y)
                             (aref string x)))))))

(defun tetris-update-score ()
  (tetris-draw-score)
  (tetris-draw-hold)
  (let ((period (tetris-get-tick-period)))
    (if period (gamegrid-set-timer period))))

(defun tetris--shuffle (sequence)
  (cl-loop for i from (length sequence) downto 2
           do (cl-rotatef (elt sequence (random i))
                          (elt sequence (1- i))))
  sequence)

(defun tetris--seven-bag ()
  (when (not tetris--bag)
    (setq tetris--bag (tetris--shuffle (list 0 1 2 3 4 5 6))))
  (pop tetris--bag))

(defun tetris-new-shape ()
  (setq tetris-shape tetris-next-shape)
  (setq tetris-rot 0)
  (setq tetris-next-shape (if tetris-allow-repetitions
                              (random 7)
                            (tetris--seven-bag)))
  (setq tetris-pos-x (/ (- tetris-width (tetris-shape-width)) 2))
  (setq tetris-pos-y 0)
  (if (tetris-test-shape)
      (tetris-end-game)
    (tetris-draw-shape)
    (tetris-draw-next-shape)
    (tetris-update-score)))

(defun tetris-draw-next-shape ()
  (dotimes (x 4)
    (dotimes (y 4)
      (gamegrid-set-cell (+ tetris-next-x x)
                         (+ tetris-next-y y)
                         tetris-blank)))
  (dotimes (i 4)
    (let ((tetris-shape tetris-next-shape)
          (tetris-rot 0))
      (gamegrid-set-cell (+ tetris-next-x
                            (aref (tetris-get-shape-cell i) 0))
                         (+ tetris-next-y
                            (aref (tetris-get-shape-cell i) 1))
                         tetris-shape))))

(defun tetris-draw-shape ()
  (dotimes (i 4)
    (let ((c (tetris-get-shape-cell i)))
      (gamegrid-set-cell (+ tetris-top-left-x
                            tetris-pos-x
                            (aref c 0))
                         (+ tetris-top-left-y
                            tetris-pos-y
                            (aref c 1))
                         tetris-shape))))

(defun tetris-erase-shape ()
  (interactive)
  (dotimes (i 4)
    (let ((c (tetris-get-shape-cell i)))
      (gamegrid-set-cell (+ tetris-top-left-x
                            tetris-pos-x
                            (aref c 0))
                         (+ tetris-top-left-y
                            tetris-pos-y
                            (aref c 1))
                         tetris-blank))))

(defun tetris-test-shape ()
  (let ((hit nil))
    (dotimes (i 4)
      (unless hit
        (setq hit
              (let* ((c (tetris-get-shape-cell i))
                     (xx (+ tetris-pos-x
                            (aref c 0)))
                     (yy (+ tetris-pos-y
                            (aref c 1))))
                (or (>= xx tetris-width)
                    (>= yy tetris-height)
                    (/= (gamegrid-get-cell
                         (+ xx tetris-top-left-x)
                         (+ yy tetris-top-left-y))
                        tetris-blank))))))
    hit))

(defun tetris-full-row (y)
  (let ((full t))
    (dotimes (x tetris-width)
      (if (= (gamegrid-get-cell (+ tetris-top-left-x x)
                                (+ tetris-top-left-y y))
             tetris-blank)
          (setq full nil)))
    full))

(defun tetris-shift-row (y)
  (if (= y 0)
      (dotimes (x tetris-width)
        (gamegrid-set-cell (+ tetris-top-left-x x)
                           (+ tetris-top-left-y y)
                           tetris-blank))
    (dotimes (x tetris-width)
      (let ((c (gamegrid-get-cell (+ tetris-top-left-x x)
                                  (+ tetris-top-left-y y -1))))
        (gamegrid-set-cell (+ tetris-top-left-x x)
                           (+ tetris-top-left-y y)
                           c)))))

(defun tetris-shift-down ()
  (dotimes (y0 tetris-height)
    (when (tetris-full-row y0)
      (setq tetris-n-rows (1+ tetris-n-rows))
      (cl-loop for y from y0 downto 0 do
               (tetris-shift-row y)))))

(defun tetris-draw-border-p ()
  (or (not (eq gamegrid-display-mode 'glyph))
      tetris-draw-border-with-glyphs))

(defun tetris-init-buffer ()
  (gamegrid-init-buffer tetris-buffer-width
                        tetris-buffer-height
                        tetris-space)
  (let ((buffer-read-only nil))
    (if (tetris-draw-border-p)
        (cl-loop for y from -1 to tetris-height do
                 (cl-loop for x from -1 to tetris-width do
                          (gamegrid-set-cell (+ tetris-top-left-x x)
                                             (+ tetris-top-left-y y)
                                             tetris-border))))
    (dotimes (y tetris-height)
      (dotimes (x tetris-width)
        (gamegrid-set-cell (+ tetris-top-left-x x)
                           (+ tetris-top-left-y y)
                           tetris-blank)))
    (if (tetris-draw-border-p)
        (cl-loop for y from -1 to 4 do
                 (cl-loop for x from -1 to 4 do
                          (gamegrid-set-cell (+ tetris-next-x x)
                                             (+ tetris-next-y y)
                                             tetris-border))))))

(defun tetris-reset-game ()
  (gamegrid-kill-timer)
  (tetris-init-buffer)
  (setq tetris-next-shape (random 7))
  (setq tetris-shape    0
        tetris-rot      0
        tetris-pos-x    0
        tetris-pos-y    0
        tetris-n-shapes 0
        tetris-n-rows   0
        tetris-score    0
        tetris-paused   nil)
  (tetris-new-shape))

(defun tetris-shape-done ()
  (tetris-shift-down)
  (setq tetris-n-shapes (1+ tetris-n-shapes))
  (setq tetris-score
        (+ tetris-score
           (aref (aref tetris-shape-scores tetris-shape) tetris-rot)))
  (tetris-update-score)
  (tetris-new-shape))

(defun tetris-update-game (tetris-buffer)
  "Called on each clock tick.
Drops the shape one square, testing for collision."
  (if (and (not tetris-paused)
           (eq (current-buffer) tetris-buffer))
      (let (hit)
        (tetris-erase-shape)
        (setq tetris-pos-y (1+ tetris-pos-y))
        (setq hit (tetris-test-shape))
        (if hit
            (setq tetris-pos-y (1- tetris-pos-y)))
        (tetris-draw-shape)
        (if hit
            (tetris-shape-done)))))

(defun tetris-move-bottom ()
  "Drop the shape to the bottom of the playing area."
  (interactive nil tetris-mode)
  (unless tetris-paused
    (let ((hit nil))
      (tetris-erase-shape)
      (while (not hit)
        (setq tetris-pos-y (1+ tetris-pos-y))
        (setq hit (tetris-test-shape)))
      (setq tetris-pos-y (1- tetris-pos-y))
      (tetris-draw-shape)
      (tetris-shape-done))))

(defun tetris-move-left ()
  "Move the shape one square to the left."
  (interactive nil tetris-mode)
  (unless tetris-paused
    (tetris-erase-shape)
    (setq tetris-pos-x (1- tetris-pos-x))
    (if (tetris-test-shape)
        (setq tetris-pos-x (1+ tetris-pos-x)))
    (tetris-draw-shape)))

(defun tetris-move-right ()
  "Move the shape one square to the right."
  (interactive nil tetris-mode)
  (unless tetris-paused
    (tetris-erase-shape)
    (setq tetris-pos-x (1+ tetris-pos-x))
    (if (tetris-test-shape)
        (setq tetris-pos-x (1- tetris-pos-x)))
    (tetris-draw-shape)))

(defun tetris-move-down ()
  "Move the shape one square to the bottom."
  (interactive nil tetris-mode)
  (unless tetris-paused
    (tetris-erase-shape)
    (setq tetris-pos-y (1+ tetris-pos-y))
    (if (tetris-test-shape)
        (setq tetris-pos-y (1- tetris-pos-y)))
    (tetris-draw-shape)))

(defun tetris-rotate-prev ()
  "Rotate the shape clockwise."
  (interactive nil tetris-mode)
  (unless tetris-paused
      (tetris-erase-shape)
      (setq tetris-rot (% (+ 1 tetris-rot)
                          (tetris-shape-rotations)))
      (if (tetris-test-shape)
          (setq tetris-rot (% (+ 3 tetris-rot)
                              (tetris-shape-rotations))))
      (tetris-draw-shape)))

(defun tetris-rotate-next ()
  "Rotate the shape anticlockwise."
  (interactive nil tetris-mode)
  (unless tetris-paused
        (tetris-erase-shape)
        (setq tetris-rot (% (+ 3 tetris-rot)
                            (tetris-shape-rotations)))
        (if (tetris-test-shape)
            (setq tetris-rot (% (+ 1 tetris-rot)
                                (tetris-shape-rotations))))
        (tetris-draw-shape)))

(defun tetris-end-game ()
  "Terminate the current game."
  (interactive nil tetris-mode)
  (gamegrid-kill-timer)
  (use-local-map tetris-null-map)
  (gamegrid-add-score tetris-score-file tetris-score))

(defun tetris-start-game ()
  "Start a new game of Tetris."
  (interactive nil tetris-mode)
  (tetris-reset-game)
  (use-local-map tetris-mode-map)
  (let ((period (or (tetris-get-tick-period)
                    tetris-default-tick-period)))
    (gamegrid-start-timer period 'tetris-update-game)))

(defun tetris-pause-game ()
  "Pause (or resume) the current game."
  (interactive nil tetris-mode)
  (setq tetris-paused (not tetris-paused))
  (message (and tetris-paused "Game paused (press p to resume)")))

(setq tetris-current-shape nil
      tetris-hold-shape nil)

(defun tetris-hold-piece ()
  (interactive nil tetris-mode)
    (let ((current-shape tetris-current-shape)
          (current-rot tetris-rot))
      (if tetris-hold-shape
          (progn
            (setq tetris-current-shape tetris-hold-shape
                  tetris-rot 0)
            (setq tetris-hold-shape current-shape
                  tetris-piece-held t))
          (progn
            (tetris-draw-next-shape)
            (setq tetris-hold-shape current-shape
                  tetris-rot 0
                  tetris-piece-held t))))
)

(defun tetris-active-p ()
  (eq (current-local-map) tetris-mode-map))

(put 'tetris-mode 'mode-class 'special)

(define-derived-mode tetris-mode nil "Tetris"
  "A mode for playing Tetris."
  :interactive nil

  (add-hook 'kill-buffer-hook 'gamegrid-kill-timer nil t)

  (use-local-map tetris-null-map)

  (setq show-trailing-whitespace nil)

  (setq gamegrid-use-glyphs tetris-use-glyphs)
  (setq gamegrid-use-color tetris-use-color)

  (gamegrid-init (tetris-display-options)))

;;;###autoload
(defun mitetris ()
  "Play the Tetris game.
Shapes drop from the top of the screen, and the user has to move and
rotate the shape to fit in with those at the bottom of the screen so
as to form complete rows.

`tetris-mode' keybindings:
\\<tetris-mode-map>
\\[tetris-start-game]   Start a new game of Tetris
\\[tetris-end-game]     Terminate the current game
\\[tetris-pause-game]   Pause (or resume) the current game
\\[tetris-move-left]    Move the shape one square to the left
\\[tetris-move-right]   Move the shape one square to the right
\\[tetris-rotate-prev]  Rotate the shape clockwise
\\[tetris-rotate-next]  Rotate the shape anticlockwise
\\[tetris-move-bottom]  Drop the shape to the bottom of the playing area"
  (interactive)

  (select-window (or (get-buffer-window tetris-buffer-name)
                     (selected-window)))
  (switch-to-buffer tetris-buffer-name)
  (gamegrid-kill-timer)
  (tetris-mode)
  (tetris-start-game))

(provide 'mitetris)

;;; tetris.el ends here

No sé si fue porque ya estaba acostumbrado por el Dwarf Fortress a ver gráficos en ASCII, pero no me costó empezar a jugar, y para mi sorpresa, descubrí que era un juego increíblemente entretenido, que era algo más que una simple curiosidad.

El objetivo del juego es de lo más simple. Tienes que bajar a las mazmorras para conseguir el amuleto de Yendor y entregárselo a tu Dios.

Pero realmente en una partida de Nethack puede suceder de todo, y para muestra dejo un resumen de algunas de mis muertes favoritas en el juego.

Con un precio de alrededor de 700€ y 1000€ para los dos primeros, no son opciones que estén al alcance de todos los bolsillos. Así que como opción económica sólo queda el Pinephone, que incluso en su versión Pro cuesta 400€, muy por debajo del Fairphone.

El Pinephone normal se puede adquirir por 150€ o 200€ a día de hoy, así que es la única opción de bajo presupuesto actualmente.

Debido a eso me lo he comprado, y como viene con un sistema operativo basado en Arch Linux, nada más encenderlo e intentarlo actualizar ya empezó a dar fallos.

Así que como no tenía tiempo que perder, decidí meterle Mobian y dejarme de líos. Desde hace ya muchos años uso Debian como sistema operativo principal, y como es la distribución más robusta que hay es difícil que falle.

Lo primero que vi que había que hacer según la documentación del Pinephone es instalar Towboot. Siguiendo los pasos de la propia web de Towboot es muy fácil de hacer, sólo hace falta una microSD y un lector de microSD. Una vez bajada la imagen no hay más que ejecutar el comando dd para grabarla en la sd.

Luego, otra vez con dd, copié una imagen de Mobian en la microSD. Al encender el Pinephone ya tenía Mobian instalado y lo configuré en un momento.

Me funcionan los datos, las llamadas, el wifi y la cámara. Ahora mismo no he visto que falle nada. Si bien es un prototipo y no es fiable, para el uso que le doy hasta ahora me ha ido todo perfectamente.

Alguna vez se me ha reiniciado, y si no se suspende la batería se acaba en un par de horas por un problema del módem EG25. Por lo demás, lo uso acompañado de una batería externa por si se me olvida suspenderlo.

Obviamente no tiene apps porque es un sistema GNU/Linux, no Android, pero es una pasada poder tener un ordenador de verdad en el bolsillo. Además mi edición venía con un dock USB tipo C para poder conectarlo por HDMI, y también tiene varios USB normales.

Con todo esto se puede montar en un momento un ordenador de sobremesa en cualquier lado, y llevártelo en el bolsillo a donde quieras. Espero que los móviles GNU/Linux sigan en desarrollo y se puedan ver en el futuro en las tiendas, de momento como opción económica y de prueba el Pinephone es un buen sustituto.

En concreto es bastante útil si hay cabeceras personalizadas con funciones y estructuras predefinidas y no quieres estar todo el rato de un lado para otro mirando definiciones.

Por suerte me acordaba de dónde tenía que consultar cómo crear el archivo para poner en funcionamiento el sistema y lo hice sobre la marcha, pero por si acaso no me acuerdo en el futuro lo voy a dejar aquí documentado.

La característica a la que me refiero se llama TAGS en el manual de Emacs, y se puede consultar más sobre su funcionamiento en el nodo Tags tables, que a fecha de este post es el punto 29.4.2 del manual.

Si no entendido mal todo consiste en crear un archivo al que Emacs pueda acudir para mirar las definiciones correspondientes y saltar hacia donde sea necesario. Para crear este archivo basta con ejecutar por ejemplo find . -name "*.[chCH]" -print | etags - en el directorio base del proyecto y luego pulsar M-. en la definición que queramos mirar.

A pesar de no tener internet en el momento de la práctica pude consultar todo esto con tan sólo un C-h i, y montar el archivo aunque no me acordaba de como se hacía. Y como resultado pude comprender la práctica de forma mucho más fácil y conseguí hacerla sin desesperarme, todo gracias a Emacs :).

El nuevo nombre es una referencia un poco oscura a un capítulo de "Aquí no hay quien viva", pero también he pensado en escribir sobre otros temas además del software libre, como libros o cubos de Rubik, así que es un buen nombre por partida doble.

Además del cambio de nombre me queda pendiente arreglar algunas cuestiones técnicas del blog, como los enlaces a entradas antiguas que siguen teniendo el nombre del dominio anterior. Espero poder ir arreglándolo poco a poco.

El problema que estaba teniendo es que siempre que intentaba instalar Emacs desde cero en otro ordenador, la gestión de paquetes me daba problemas, y tenía que reiniciar Emacs varias veces para completar la instalación.

Mi objetivo es que con mi archivo de configuración pueda coger un ordenador cualquiera, iniciar Emacs y tenerlo todo configurado y listo, como si estuviera en mi propio ordenador (excepto en lo referente a archivos personales, claro).

Así que la solución a la que llegué con Prot fue hacerme mi propia macro, para gestionar así todo lo que tenga que ver con los paquetes, y saber qué está pasando en cada momento. La macro a la que he llegado es:

(defmacro my-package-install (package &rest body)
  "Installs PACKAGE.
If the package cannot be installed, remind the user to add the package-archives. Then, the user can configure the PACKAGE."
  `(progn
     ;;First stage; package installation
     (unless (package-installed-p ,package)
       (unless package-archive-contents
  (package-refresh-contents))
       (or (ignore-errors (package-install ,package))
    (message "Did you add MELPA to the `package-archives'")))
     ;;Second stage; package configuration
     (require ,package)
     ,@body
     )
  )

Básicamente lo que hace es comprobar si un paquete está instalado, y si lo está, lo configura con los argumentos que se le pasen. Además para evitar el error que tenía anteriormente, la macro te da una posible solución al error.

Con todo esto listo, ahora sólo tengo que implementar la macro con los paquetes de mi configuración. Una vez lo tenga todo hecho, debería poder usar Emacs en cualquier ordenador con sólo pulsar un botón.

Simplemente hay que añadir las siguientes líneas al config de i3:

bindsym Shift+XF86AudioRaiseVolume exec pactl -- set-sink-volume 0 +10% && pkill -RTMIN+10 i3blocks bindsym Shift+XF86AudioLowerVolume exec pactl -- set-sink-volume 0 -10% && pkill -RTMIN+10 i3blocks

Y así, al pulsar shift y el botón de subir o bajar el volumen, se subirá por encima del 100% o se bajará en incrementos del 10%.

Tanto ha sido así que estoy ya me lo he leído cuatro veces, y desde que descubrí las infinitas capas de profundidad que da Gene Wolfe a sus relatos se ha convertido probablemente en el libro que más he disfrutado de todos los que he leído.

Es un escritor que ya en el mundo anglosajón es poco conocido (es conocido entre escritores, pero no gusta tanto a los lectores), cuanto más en España, por lo que he decidido dejar aquí adaptada en español la guía sobre cómo leer a Gene Wolfe que hizo en su día Neil Gaiman, con el objetivo de facilitar su lectura. Son libros densos, cuya lectura requiere poner atención, estar concentrado y atento a los detalles, pero es altamente gratificante ir descifrando los misterios y el universo que propone Wolfe.

Según Gaiman, para disfrutar la lectura de Gene Wolfe hay que:

1. Confiar en el texto implícitamente. Las respuestas están ahí.
2. No te fíes del texto a ciegas. Está lleno de trucos y engaños, el narrador no es una persona en la que se pueda confiar.
3. Vuelve a leer. Es mejor la segunda vez. Será aún mejor la tercera vez. Y de todos modos, los libros se transformarán sutilmente mientras estés lejos de ellos. El libro "Paz" realmente era una memoria agradable del Medio Oeste la primera vez que lo leí. Solo se convirtió en una novela de terror en la segunda o tercera lectura.
4. Hay lobos ahí dentro, acechando detrás de las palabras. A veces salen en las páginas. A veces esperan hasta que cierres el libro. El almizcleño olor a lobo a veces puede ser enmascarado por el perfume aromático del romero. Ten en cuenta que estos no son lobos de hoy, que se arrastran grises en manadas por lugares desiertos. Estos son lobos excepcionales, enormes y solitarios que podrían mantenerse en pie frente a los osos pardos.
5. Leer a Gene Wolfe es un trabajo peligroso. Es un acto de lanzar cuchillos, y como todos los buenos actos de lanzar cuchillos, puedes perder dedos, dedos de los pies, lóbulos de las orejas o ojos en el proceso. A Gene se la refanfinfla, él es el que está lanzando los cuchillos.
6. Ponte cómodo. Sirve una tetera de té. Cuelga una señal de NO MOLESTAR. Comienza en la página uno.
7. Hay dos tipos de escritores astutos. Los que señalan cuán astutos son, y los que no ven la necesidad de señalar cuán astutos son. Gene Wolfe es del segundo tipo, y la inteligencia es menos importante que la historia. No es inteligente para hacerte sentir estúpido. Es inteligente para hacerte inteligente también.
8. Él estaba allí. Lo vio suceder. Sabe cuál fue la reflexión que vieron en el espejo esa noche.
9. Estar dispuesto a aprender.

He adaptado el código de System Crafters (https://systemcrafters.cc/learning-emacs-lisp/creating-minor-modes), y he creado sendas funciones para asignar el movimiento de las piezas del tetris a las teclas "j" y "k". El modo se llama "tetritecla-basic-mode" y básicamente sólo sirve para añadir esos atajos de teclas, junto a "k" para rotar piezas y "h" para bajarlas.

Si ahora activo el modo "tetritecla-basic-mode" con un hook al iniciar el programa "tetris", ya obtengo las nuevas teclas de forma automática cada vez que quiera jugar. ¡Fácil y cómodo!

A continuación dejo el código:

(make-variable-buffer-local
  (defvar tetritecla-basic-mode nil
    "Alterna tetritecla-basic-mode."))

(defvar tetritecla-basic-mode-map (make-sparse-keymap)
  "El keymap para tetritecla-basic-mode")

;; Definición de las teclas para jugar.
(define-key tetritecla-basic-mode-map (kbd "j")
  (lambda ()
    (interactive)
    (tetris-move-left)))

(define-key tetritecla-basic-mode-map (kbd "k")
  (lambda ()
    (interactive)
    (tetris-rotate-prev)))     

(define-key tetritecla-basic-mode-map (kbd "h")
  (lambda ()
    (interactive)
    (tetris-move-down)))

(define-key tetritecla-basic-mode-map (kbd "l")
  (lambda ()
    (interactive)
    (tetris-move-right)))

(add-to-list 'minor-mode-alist '(tetritecla-basic-mode " tetritecla"))
(add-to-list 'minor-mode-map-alist (cons 'tetritecla-basic-mode tetritecla-basic-mode-map))

(defun tetritecla-basic-mode (&optional ARG)
  (interactive (list 'toggle))
  (setq tetritecla-basic-mode
        (if (eq ARG 'toggle)
            (not tetritecla-basic-mode)
          (> ARG 0)))

  ;; Aviso de activación de modo
  (if tetritecla-basic-mode
      (message "tetritecla-basic-mode activado")
    (message "tetritecla-basic-mode desactivado")))

Su uso básico es tan simple como activar notmuch-indicator-mode y listo. Por supuesto, como cualquier paquete de Protesilaos, viene con una documentación excelente que explica todos los detalles y las posibilidades del paquete.

Con esto podemos tener fácilmente una integración perfecta del correo electrónico dentro de Emacs, y así maximizar el tiempo que pasamos dentro del mejor editor del mundo.

Antes que nada, para que funcione es necesario configurar la conexión de ssh para poder acceder a través de una clave al servidor. Por ejemplo, si ya tenemos la clave generada podemos usar:

ssh-copy-id -i ~/.ssh/id_ed25519.pub pi@192.168.1.125

Ahora, configuramos el hook:

(add-hook 'org-publish-after-publishing-hook '(lambda () ((async-shell-command "scp -r ~/blog pi@192.168.1.125:/var/www/html/publish" "publicando"))))

Y listo, cada vez que se publique una entrada con org-static-blog-publish se subirá el contenido al servidor automáticamente.

Edit: Me he confundido con el hook, el org-publish-after-publishing-hook es un hook de org-publish no de org-static-publish, por lo tanto su configuración es un poco más complicada y el hook que he puesto arriba no funciona. La función lambda sin embargo sí que es válida, la usaré en una futura entrada en la que configuré el hook correctamente.

En el caso de company-mode, tuve problemas cuando estaba configurándolo porque busqué por todos lados la documentación oficial pero solo encontraba posts en diversos blogs, que aunque pudieran ser muy útiles, no contenían el material de referencia que estaba buscando.

Quizás debido a que estoy ya acostumbrado a la extensa documentación de gran calidad de GNU, ni siquiera consideré que no existiera un manual como tal, y simplemente dejé de buscar porque pensé que no era capaz de encontrarlo. Pero hace poco descubrí que efectivamente el manual de company-mode se publicó en enero de 2022 si no me equivoco.

Está disponible online en https://company-mode.github.io/manual/Getting-Started.html, o, dependiendo de la versión de Emacs instalada se puede acceder al manual desde el propio Emacs con C-h R company RET.

Para integrarlo en mi flujo de trabajo en Emacs, decidí usar popper.el https://github.com/karthink/popper. Esto me permite tener a mano la consola de Octave con solo pulsar un botón.

Primero lo activo con popper-mode, después elijo el búfer que contiene la consola de Octave (por ejemplo el búfer que se crea al usar run-octave) y una vez en ese búfer con popper-toggle-type se convierte en un búfer fijado.

Luego se puede asignar popper-toggle-latest a cualquier tecla (por ejemplo f9), y al pulsar esa tecla la consola de Octave aparece y desaparece.

Es una buena forma de tener una consola de lo que sea siempre a mano.

Así que he encontrado otra forma de copiar los arcihvos a través de scp. Sigue siendo un proceso muy simple, quizás incluso más con scp que con sshfs. La única orden que uso es:

scp -r ~/blog pi@192.168.1.125:/var/www/html/publish

Con esto vuelvo a poder publicar entradas de forma cómoda en un momento.

Fuente: https://ugeek.github.io/blog/post/2021-04-01-scp-copias-por-ssh.html

Sin embargo seguí usando Bash para conectarme por ssh a mi servidor en la Raspberry Pi. Hace poco descubrí que no es necesario hacer ésto si uso la Eshell. Simplemente puedo abrir una conexión con Tramp desde Emacs, y una vez que esté por ejemplo en un directorio remoto con dired, abrir la Eshell. Mágicamente estaré ya dentro del servidor como si de una conexión por ssh se tratase.

Lo único que me queda por resolver es la configuración de Tramp, ya que ahora mismo se me queda pillado a veces y no consigo conectarme al servidor a través de él, aunque pueda hacerlo por ssh normalmente.

Una vez registrado, en el apartado de DNS RECORDS he asociado el nombre del dominio a mi ip, y así finalmente puedo entrar a mi blog con una dirección web normal.

He seguido las instrucciones de la página web de Luke Smith (https://landchad.net/dns)

La configuración resultante la tengo en Gitlab (https://gitlab.com/gnuhack/dotfiles/-/blob/master/.emacs.d/emacs-literario.org). El repositorio del blog modificado lo tengo en ~/blog.

Finalmente, cuando quiera publicar una entrada no tengo más que usar M-x org-static-blog-create-new-post, escribir el post, y luego ejecutar M-x org-static-blog-publish.

Para terminar, monto la Raspi en una carpeta de mi sistema sshfs pi@192.168.1.130:/var/www/html ~/Public y luego paso el contenido de mi ordenador a la Raspi cp -r blog/ Public/.