-1:-- Prueba de concepto para crear un asistente de voz (Post )--L0--C0--August 22, 2019 12:00 AM
Tras adquirir mi nueva Raspberry 4 y la aparición de la nueva debian Buster, estoy utilizando Emacs remotamente...
Sigue leyendo el post completo de Corrector Ortagráfico para Emacs en Raspbian
-1:-- Corrector Ortagráfico para Emacs en Raspbian (Post )--L0--C0--August 16, 2019 02:50 PM
-1:-- Estudiando org-page (Post )--L0--C0--August 10, 2019 12:00 AM
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 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.
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):
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.
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
Hay quien no se acostumbra a utilizar Orgzly ni Emacs cuando toma notas con su movil, en cambio le gustaría el tener el backup de todas las notas de su cuenta Google Keep en un único archivo Org Mode. También hay quien le gustaría tenerlas en Markdown...
Sigue leyendo el post completo de Exportando tu Notas de Google Keep a Org Mode o Markdown
-1:-- Exportando tu Notas de Google Keep a Org Mode o Markdown (Post )--L0--C0--July 26, 2019 09:00 PM
-1:-- Convertir un pdf de imágenes a texto org-mode (Post )--L0--C0--July 25, 2019 12:00 AM
A partir de la versión Org 9.2, ya no es posible utilizar el atajo que utilizábamos en versiones anteriores...
Sigue leyendo el post completo de Emacs 26.2 en Ubuntu
-1:-- Emacs 26.2 en Ubuntu (Post )--L0--C0--July 22, 2019 10:43 AM
A partir de la versión Org 9.2, ya no es posible utilizar el atajo que utilizábamos en versiones anteriores...
Sigue leyendo el post completo de Añadir cajetilla de código en orgmode como antes
-1:-- Añadir cajetilla de código en orgmode como antes (Post )--L0--C0--July 13, 2019 07:00 PM
-1:-- Gestionar bibliografía con Emacs (Post )--L0--C0--June 30, 2019 12:00 AM
Estaba escribiendo en un repositorio de GitHub en el archivo README.org, el resumen de un vídeo de un curso en Python buenísimo que he visto en YouTube. La intención era el poner la imagen del vídeo y debajo escribir un poco el resumen de este, para cuando quisiera acceder a un determinado tema, asociarlo al vídeo y clicar sobre esta imagen para que me lleve a YouTube...
Sigue leyendo el post completo de youtube2org. Añadir la Imagen de un Vídeo de YouTube, en un OrgMode o Markdown
-1:-- youtube2org. Añadir la Imagen de un Vídeo de YouTube, en un OrgMode o Markdown (Post )--L0--C0--May 01, 2019 07:00 PM
-1:-- Presentaciones con org-beamer-mode (Post )--L0--C0--April 30, 2019 12:00 AM
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.
En fin, aquí lo dejo, por si hay otro genio como yo por ahí al que le resulta útil. A cuidarse.
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
Existen dos formas de setear una variable en Lisp:
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.
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.
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
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
Lisp está basado en listas, un ejemplo de lista es el siguiente
'(rose
violet
daisy
buttercup)
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.
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"
La representación de átomos o listas es llamada representación simbólica, Symbol Representation también denominada s-expression
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)
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:
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.
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.
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.
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:
(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.
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.
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"
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")
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
-1:-- Tutorial emacs (Post la pipa plena)--L0--C0--March 24, 2019 05:15 PM
-1:-- Programación literaria para todos con Emacs (Post maxxcan)--L0--C0--March 12, 2019 03:54 PM
Simplenote, es una aplicación de notas muy conocida de Software Libre, totalmente multiplataforma y gratuita...
Sigue leyendo el post completo de Notas y Documentos en la nube para compartir, trabajar en equipo,...
-1:-- Notas y Documentos en la nube para compartir, trabajar en equipo,... (Post )--L0--C0--March 11, 2019 04:45 AM
Go, también llamado golang, es un lenguaje de programación diseñado por Google. Es de tipado estático, compilado y similar a C. Algunas diferencias con este son que tiene protección de memoria, recolector de basura y concurrencia nativa. Este articulo tiene dos fines, enseñar lo bonico que me ha quedado un programa que he hecho en go y plasmar mis impresiones sobre mi primera incursión en este lenguaje.
Empecemos por el principio. Hace un tiempo decidí que quería hacer un programa que descargase imágenes y las mostrase como una galería en un servidor web tonto. No iban a ser unas imágenes cualquiera, en un principio quería que fuesen los cómics que hace Julia Evans (recomiendo muy fuerte echarle un ojo a su blog). Mediante cómics explica conceptos y herramientas tecnológicas con un estilo muy interesante. Quería poder ver uno de ellos de forma aleatoria, visitando una página web. Me parecía interesante por que hay veces que en el trabajo tengo cinco minutos muertos mientras espero que se ejecute alguna CI, y me parece que aprender cosas que no se suelen buscar es una forma útil de usar ese tiempo.
Tenia pensado hacerlo en python, por que ya he tocado alguna cosilla en flask. El proceso lo tenia claro. Hacia falta un fichero con la lista de las imágenes a descargar. Una vez descargadas, habría que lanzar un servidor web que mediante templates de html, renderizaria una página con las imágenes. Teniendo tan claro lo que habia que hacer, decidí hacerlo en algún otro lenguaje for the lulz.
Go es un lenguaje por el que siento curiosidad desde hace un tiempo. Muchas de las tecnologías que he estado usando el último año están hechas en go, como por ejemplo docker, kubernetes, terraform o prometheus. Y alguna vez me he encontrado algún funcionamiento fuera de lo normal y no he sabido determinar si era un bug o cosa mia, y si hubiese sabido algo de go me habría venido bien.
Como el fin de semana pasado estaba malo y no podía hacer mucho, decidí darle al tema. Y salió gomic.daemons.it.
No entraré en detalles de como se hace nada, porqué el código del programa está muy comentado. De lo que hablaré es de las cosas de este lenguaje que me han llamado la atención (sobretodo en comparación con python) y las cosas que me han gustado del proyecto.
Disclaimer: Mis conocimientos de programación son limitados, por lo que es probable que suelte alguna burrada.
go run . y se ejecuta del tirón. Incluso se pueden hacer scripts en go. Hay formas de hacerlo, más o menos estándar, aquí hablan más del tema. Pero si a este script se le da permisos de ejecución y se ejecuta con ./script.go, funciona sin más://usr/bin/go run $0; exit
package main
import "fmt"
func main () {fmt.Println("Holi")}var variable "holi"
variable := "holi"El módulo de logueo: Como se ve aquí, se usa del tirón. Esto es algo que en python siempre me ha molestado mucho, para loguear tienes que hacer movidas muy raras. En go puedes usar log.Println para loguear a nivel info y log.Fatal para errores. Hasta se encarga de parar el programa al haber detectado un error fatal.
Docker friendly: Una cosa muy interesante que tiene go, a diferencia de java por ejemplo, es que puedes compilar binarios dinámicos o estáticos. La diferencia básica es que el primero solo funcionará en un SO con las mismas características que en el que se ha compilado (es decir, mismas librerías), y el segundo en cualquiera. Mola por que si lo compilas estáticamente, no hace falta nada más. Y cuando digo nada más es literalmente nada más, se puede usar la imagen scratch para crear la imagen. Por comparar, veamos el tamaño de la imagen de drone-xmpp (python) comparado con la de gomic:
r.daemons.it/gomic 9.24MB
r.daemons.it/drone-xmpp 139MBEs normal la diferencia. La imagen de gomic solo tiene un binario y un par de htmls, css y js. En cambio la de drone-xmpp tiene alpine, que aún siendo un SO muy pequeño, sigue siendo mucho más que nada.
Linter chulo: Emacs tiene un paquete de linters llamado flycheck. He intentado sacar como funciona por debajo para dar una visión más general para quien no use emacs, pero no he sido capaz. Si alguien lo sabe, que comente. El motivo por el que me ha gustado tanto es que es capaz de decirte que no puedes asignar la variable a de tipo string al valor 1 por que este un integer. Parece algo como muy tonto, pero me sorprende mucho tener un análisis estático del código en tiempo real y que no consume recursos de forma aparente.
Control de error obligatorio (casi): Según he visto en muchas de las funciones que he usado suelen obligan a controlar el error. Por ejemplo:
file, err := os.Create(filePath)
if err != nil {
log.Print("error creating " + filePath)
log.Print(err)
}Por que digo que es obligatorio (o casi)? os.Create devuelve la descripción del fichero (file descriptor, creo que se traduce así) y un objeto de error (vacío si no existe). Al devolverlo la función, hay que asignar a ambos valores una variable. Si una variable no es usada en go, el programa no compila. Y ale, de esta forma tan tonta te obligan a tener que hacer algo con esta variable, lo normal seria usarla para comprobar que no hay ningún error. Hay formas de usar la variable para saltarse el bloqueo sin que sea útil, pero la excusa de hacer eso es más bien pequeña.
repl: Gore es un repl, puedes hacer pruebas rápidas con ello.
Paquetes nativos muy potentes: Como se puede ver si se lee el código, no he tenido que usar ningún paquete externo para el programa. En un principio usé grab para descargar ficheros, pero realmente no me aportaba demasiado. Además, no dejaba escoger que nombre le ponía al fichero, lo cual es un problema. Pero seguramente lo que llama más la atención es que el servidor http nativo sea tan potente. O igual no es tan sorprendente, si tenemos en cuenta que go se usa mucho para la generación de apis.
Tipos de datos: Esto fue de lo que más me costó entender, aunque no tengo claro haberlo entendido del todo. Al ser tipado estático, tienes que saber exactamente el tipo de todas las variables, por ejemplo al hacer un return de una función. Me encontré con que no podía convertir estructuras (struct, que se llama) a tipos simples, como es un string o un integer. En realidad no sabia por que no podía, el tema de las estructuras lo descubrí después de muchas horas. Concretamente, lo que estaba haciendo era intentar convertir el tipo os.FileInfo a string. Y claro, no encontraba por internet la forma de hacerlo, por que, salvando las distancias, es como si intentase convertir una clase de python en un string. Sentido cero. Al final era mucho más simple, como solo me interesaba el atributo Nombre, solo habia que acceder al atributo de una forma intuitiva, con os.FileInfo.Name().
Muy buena documentación: La documentación está muy bien escrita y muchas veces tiene incluso ejemplos.
Bulma: Esto no tiene que ver con go directamente, pero lo cuento igual por que mola. Cuando hice la primera iteración del programa, la interfaz era esta.
Se lo enseñe a Ameba y como cualquier persona con ojos, se sintió muy ofendida por el “diseño”. Por ello, hizo una primera implementación de bulma, un framework CSS como lo es bootstrap. Viendo que se habia tomado la molestia, por sentido de la vergüenza y por que en realidad soy consciente de que la UX es importante, decidí terminar de implementarlo (con mucha ayuda) y aprender bastante de conceptos básicos de html, css y js, que siempre voy muy pez. Y ha quedado algo más cuqui, como se puede ver en la primera imagen.
Poco más que añadir. Go me parece un lenguaje interesante y probablemente siga aprendiendo porque hace ya tiempo que quiero tener algún otro lenguaje a parte de python. Es improbable que Gomic reciba muchas más actualizaciones más allá de añadir más orígenes, pero cualquier sugerencia siempre será bienvenida.
-1:-- Gomic y primeras impresiones sobre Go (Post )--L0--C0--February 24, 2019 04:00 PM
Me he hartado de usar más de un programa y he decidido que las pocas veces que escriba en LaTeX a pelo lo haré también en Emacs. Así soy, cada día más simple. Para ello estoy usando AUCTeX, un modo hiperpotente que tiene una manual de solo 130 páginas y que se autodefine como un sofisticado entorno TeX para Emacs.
Lo curioso del tema es que instalé AUCTeX hace más de un año porque fue la única manera de hacer funcionar CDLaTeX, el modo menor que ayuda a crear entornos y movidas matemáticas y que uso con Org. En todo este año no he configurado AUCTeX y he seguido usando Texmaker y Kile por pura inercia. Ahora que lo he puesto a mi gusto y que llevo usándolo una semana, he desinstalado el resto de editores de LaTeX y no creo que vuelva atrás, ¡me encanta!
Como siempre, para usar AUCTeX hay que instalarlo y activarlo, a mí se me activa solo al abrir un archivo con extensión .tex, pero si no fuera el caso, M-x LaTeX-mode y adelante. Cuidado con confundirlo con latex-mode, el modo para LaTeX que viene con Emacs. Sí, lo hacemos aposta para liar.
Usar AUCTeX es bastante sencillo, hay un par de atajos de teclado que valen para casi todo y que os listo aquí. La palabreja que pongo en cursiva es con lo que yo relaciono la combinación de teclas para acordarme (que puede o no ser la idea del autor original).
Como hereje del Emacs que soy os voy a decir algo: no hace falta aprenderse todo esto. Utilizad la GUI y los menús desplegables sin pudor alguno (yo lo hago, un botón tiene un leoncito muy cuqui).
AUCTeX tiene herramientas interesantes para que nos resulte más sencillo escribir y entender lo que hemos escrito. Lo que yo llamo embellecedores son sus capacidades de sustituir las letras griegas y otros símbolos con su equivalente Unicode (prettify) y de escribir la letra que está entre etiquetas de formato con el formato en sí (fontify).
Así, cuando escribimos \omega nos pone una ω, si escribimos \emph{cosa en cursiva}, nos escribe el texto en cursiva y demás. Creo que la parte de cambiar la fuente viene activada por defecto pero para los símbolos hay que llamar al modo prettify-symbols-mode.
Tiene además un montón de opciones para previsualizar trocitos de documento, aunque yo no las uso porque estoy muy acostumbrada a escribir en LaTeX y generalmente no la organizo estoy acostumbrada a compilar y mirar los errores en el log por otros editores que he utilizado.
Otra cosa que nos ayuda a la hora de leer lo que hemos escrito es el doblado (folding) que consiste en ocultar etiquetas como \section o \emph dejando solamente el texto con el formato.
Si activamos el modo de doblado con M-x TeX-fold-mode y hacemos C-c C-o C-b nos quita el barullo y nos deja un documento mucho más sencillo de leer. Haciendo click o entrando sobre el ítem doblado con el puntero vuelve a mostrarse como LaTeX.
Como esta herramienta me encanta, hago que Emacs me la active siempre cuando uso AUCTeX, más abajo en el archivo de configuración pone cómo lo he hecho.
Esto ha sido sin duda lo más difícil de configurar, probablemente porque soy una novata del Emacs1 y pego cosas sin sentido en el archivo de configuración. Después de hurgar en diferentes modos y destruir, me he quedado con la variante para AUCTeX de Company mode que se llama contra todo pronóstico Company AUCTeX.
Para que me funcione tengo que activar company-mode y luego evaluar (company-auctex-init) así que he puesto eso en el archivo de configuración, probablemente haya maneras mejores.
En fin, dejando a un lado la configuración, esto sirve para que según vayas escribiendo las órdenes Emacs te de sugerencias.
En la imagen se ven además las variables locales que me ha escrito AUCTeX. Ese TeX-master: t significa que este archivo es el archivo maestro, algo muy útil cuando estamos usando subdocumentos, ya que podemos mandar la orden de compilar desde cualquiera de ellos y AUCTeX sabrá cuál es el maestro. Esto me aparece ahí porque le digo en el archivo de configuración que me pregunte la primera vez que compilo cuál es el archivo maestro con (setq-default TeX-master nil).
Este modo hace muchas más cosas, por ejemplo, M-RET al final de línea en un entorno predice lo que necesitamos en la línea siguiente, probadlo en las tablas, vais a ver.
He instalado además el paquete latex-extra para poder abrir y cerrar los títulos como hago en Org.
Estoy usando además RefTeX en combinación con AUCTeX para manejar las referencias y las citas. Este modo lo escribió el creador de Org y es utilísimo para las académicas como yo.
Os pongo un par de atajos que se aprenden rápido por la lógica que se usa generalmente al referenciar en el mundillo (referencias a algo del propio documento entre paréntesis y a la bibliografía entre corchetes):
\label)Tiene muchas más opciones pero yo tengo un tiempo de vida limitado.
Añadiendo todas las cosas que he comentado, la parte de AUCTeX del archivo de configuración me queda así:
;; Activar CDLaTeX (add-hook 'LaTeX-mode-hook 'turn-on-cdlatex) ;; Activar prettify (add-hook 'LaTeX-mode-hook 'prettify-symbols-mode) ;; Autocompletar (add-hook 'LaTeX-mode-hook (lambda ()(company-mode 1))) (company-auctex-init) ;; Pide archivo maestro, para documentos con subdocumentos (setq-default TeX-master nil) ;; Parser automático (setq TeX-parse-self t) ; activar el parser al cargar (setq TeX-auto-save t) ; activar el parser al guardar ;; Fold por defecto (add-hook 'LaTeX-mode-hook (lambda ()(TeX-fold-mode 1))) ;; Activar RefTeX (add-hook 'LaTeX-mode-hook 'turn-on-reftex) (setq reftex-plug-into-AUCTeX t) ;; LaTeX extra para tener doblado de secciones como Org (add-hook 'LaTeX-mode-hook #'latex-extra-mode)
Estoy muy contenta. hay que saber de LaTeX para sacarle partido, pero es maravilloso. Hasta he grabado un minivídeo para que se viesen algunas de las cosas de las que hablo2:
Lo único raro que me ocurre es que no me cierra los paréntesis. Los corchetes, las llaves y los dólares sí, el problema solo es con los paréntesis.
Si fuera perfecto no sería divertido.
What is your favorite Emacs and/or AUCTeX command/trick? en TeXExchange
Useful shortcuts or key bindings or predefined commands for emacs+AUCTeX en TeXExchange
En Vim se puede hacer más o menos lo mismo, tenéis un ejemplo en el flujo de trabajo de este chico para coger apuntes
Sonando este homenaje a Cantona, un futbolista que tiene los nada desdeñables méritos de salir en una película de Ken Loach, decirle a la peña que sacase su dinero del banco para hacer caer el sistema y darle una patada voladora en la boca a un racista.
-1:-- Lo que he aprendido: AUCTeX (Post Ondiz)--L0--C0--February 07, 2019 12:00 PM
Emacs es seguramente la tecnología a la que más tiempo de estudio le he dedicado (y dedico) desde que empezó mi interés por los ordenadores. Y si algo he sacado en claro es que, dado mis otros intereses, nunca le dedicaré el tiempo a mi configuración personal que se merece. Lo he hecho durante mucho tiempo y lo seguiré haciendo, pero he decidido que no lo haré “a pelo”, sino que usaré ciertas facilidades que da doom.
Qué es doom? En realidad es la configuración de emacs de hlissner. Este humano quería usar emacs con los atajos de vim y quería que emacs se pareciese a un IDE moderno. Además, decidió que quería que la gestión de este fuese mediante la terminal.
Las características principales que tiene son:
Makefile para gestionar la instalación de paquetes, actualización y otrosdef-package, un wrapper para use-package y quelpashackleevil-modecompany-modeprojectilepersp-modeQuien ya use estos programas, puede que piense que es una tontería, que no aporta nada. Pero la principal característica, que no mencionan en la página del proyecto es que alrededor de todos estos paquetes mencionados, hay wrappers que hacen que se integren entre ellos. Veremos más adelante a que me refiero.
La característica que más me gusto fue la de workspaces. Ahora solo tengo que ejecutar projectile-switch-project y el proyecto que abra, se abrirá en un workspace nuevo, sin que los buffers que abra se mezclen con los que ya tengo abiertos. Un video vale más que mil palabras.
En este video se puede ver que en el primer workspace, abro el proyecto de mi página web. En el segundo, en cambio, abro uno gestión de infraestructura con ansible. Y ambos están separados, cuando en cada uno de ellos ejecuto find-file, me muestra solo los ficheros de ese proyecto
Para probarlo rápidamente, se puede ejecutar lo siguiente:
git clone https://github.com/hlissner/doom-emacs ~/.emacs.d
cd ~/.emacs.d
cp init.example.el init.el
make install
emacsEn adelante mi configuración estará en este repositorio. Dado que hay muchos cambios respecto a como lo tenia antes, prefiero crear un repositorio nuevo y mantener el antiguo como referencia.
-1:-- Doom: un framework para configurar emacs (Post )--L0--C0--February 04, 2019 09:11 PM
-1:-- GNU-Linux, Emacs,.. ¿porqué? (Post )--L0--C0--November 21, 2018 08:53 PM
-1:-- Cómo Emacs me hace mejor profesor (1ª Parte) (Post maxxcan)--L0--C0--November 18, 2018 09:13 PM
-1:-- Gestión de contraseñas con Emacs (Post maxxcan)--L0--C0--November 12, 2018 01:09 PM
Por culpa del Podcast de atareao.es, he estado probando Kde Connect y la verdad es que ha pasado a ser una aplicación imprescindible en mi día a día. Tal como explica en su Podcast, existe la posibilidad de utilizarla con Emacs y como podéis imaginar, no me he podido resistir a probarla. Os explico como utilizarla:
Teniendo los repositorios de Melpa:
YA ESTA!!!
Ahora si copiamos un texto en el portapapeles de nuestro Emacs, podremos pegarlo en el otro dispositivo gracias a Kde Connect.
Vamos a enviar un texto desde Emacs al otro dispositivo M-x kdeconnect-ping-msg RET Texto
Os dejo el resto de funciones para que juguéis y el repositorio donde está toda la información:
Resto de Funciones disponibles
| Función | Descripción |
|---|---|
| kdeconnect-get-active-device | Mostrar el dispositivo activo |
| kdeconnect-list-devices | Muestra todos los dispositivos visibles, incluso los no disponibles. |
| kdeconnect-ping | Enviar una notificación al dispositivo activo. |
| kdeconnect-ping-msg | Envía una notificación con un mensaje personalizado al dispositivo activo |
| kdeconnect-refresh | Escanee la red y actualice las conexiones disponibles |
| kdeconnect-ring | Hacer que suene el dispositivo activo (útil para encontrarlo) |
| kdeconnect-select-active-device | Seleccione el dispositivo activo de kdeconnect-devices |
| kdeconnect-enviar-archivo | Enviar el archivo seleccionado al dispositivo activo |
| kdeconnect-enviar-sms | Enviar un SMS al destino especificado |
Escucha más Podcast en el Reproductor de la web ►Play
Tags: , blog , emacs , kdeconnect ,
<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>-1:-- Kde Connect en Emacs (Post )--L0--C0--November 02, 2018 12:00 AM
Vamos a convertir nuestros archivos Markdown a Org Mode gracias a Pandoc. Para ello, primero necesitamos instalar Pandoc en nuestro Ubuntu:
sudo apt install pandoc
Ahora tenemos 2 posibilidades, transformar únicamente un archivo .md a .org, o aprovechando la magnífica gestión de los archivos Org Mode, convertir todos los archivos Markdown de una carpeta a un único archivo Org Mode.
1) Markdown a Org Mode. Ejecutamos este comando en la terminal.
pandoc -f markdown -t org -o nuevo_archivo.org archivo_a_convertir.md
2) Muchos archivos Markdown a un único Org Mode.
Vamos a la carpeta donde están todos los Markdown que queremos convertir y Llamamos a find vía Pandoc:
find . -name \*.md -type f -exec pandoc -f markdown -t org -o {}.org {} \;
Recordar verificar que la conversión se ha hecho correctamente.
Escucha más Podcast en el Reproductor de la web ►Play
<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>-1:-- Convertir de Markdown a Org Mode gracias a Pandoc (Post )--L0--C0--November 01, 2018 12:00 AM
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
-1:-- Sincronización Selectiva en Syncthing, Markdown en Emacs, Blog Jekyll, Escritorio i3 (Post )--L0--C0--October 29, 2018 07:06 PM
-1:-- Curso emacs 32. Actualizaciones, maps, suggest y envios (Post la pipa plena)--L0--C0--October 22, 2018 01:45 PM
-1:-- Racket en Emacs (Post maxxcan)--L0--C0--September 29, 2018 06:21 AM
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 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.
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
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
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 horizontalC-b % division verticalaparecera una shell sin hacer nada mas
podemos deambular por las “divisiones” con
C-b o saltar a la siguienteC-b ← saltar a la derechaC-b ↑ saltar arribaC-b → saltar a la derechaC-b ↓ saltar abajoC-b C-← redimencionar hacia la derechaC-b C-↑ redimencionar hacia arribaC-b C-→ redimencionar hacia la derechaC-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 siguienteC-b p anteriorC-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
Hace un tiempo que dejé de usar php+-mode, mas que nada porque parece que lo han sacado de Melpa y me gusta tenerlo todo actualizado, así que decidí volver a php-mode, un modo que no usaba ya que php+-mode me parecía mas completo.
En php+ tenías proyectos donde podías configurar muchas cosas, como por ejemplo los tests, cosa que con php-mode no se puede, el tema es que para lo de los proyectos hace mucho que uso projectile, un modo imprescindible para programar, pero me faltaba la integración de phpunit. Por suerte tenemos phpunit.el una libreía con la cual podremos ejecutar nuestros tests.
Yo he tenido que añadir alguna cosa en mi configuración que no viene en la documentación oficial, como por ejemplo que coja el ejecutable de phpunit de una ruta de mi carpeta, si vosotros lo tenéis en el path del sistema no creo que tengáis problemas.
Pues bien, esta es toda la configuración que he tenido que añadir a mi fichero de configuración:
(use-package phpunit
:ensure t
:config
(add-hook 'php-mode-hook (lambda ()
(setq phpunit-default-program (concat (projectile-project-root) "bin/phpunit"))
))
)
Esto es lo que hace la configuración:
Esto último me dio algunos problemas, ya que no se me había ocurrido ejecutarlo en el hook y se ejecutaba en la propia configuración, que al estar versionada con git pues también la tengo como proyecto.
Con esto ya podremos usar las funciones del modo phpunit, que podréis encontrar en su documentación. Lo suyo es que os las asignéis a alguna combinación de teclas, yo tengo que F2 me ejecute el test en el que me encuentro posicionado y F3 me ejecuta todos los tests de la clase.
(global-set-key[f2] 'phpunit-current-test)
(global-set-key[f3] 'phpunit-current-class)
Los tengo globales, porque es como los usaba en php+-mode, es algo que aún tengo pendiente de cambiar, en esos refactors infinitos que hacemos durante toda nuestra vida en la configuración de emacs.
-1:-- Ejecutando Test de PHPUnit en Emacs (Post )--L0--C0--September 14, 2018 03:30 PM
Una de las cosas que siempre he tenido ganas pero me ha dado mucha pereza ponerme a hacer ha sido configurar el correo para gestionarlo a través de emacs. Hace un par de días decidí dar el paso, hoy lo he estado probando y ha merecido la pena el esfuerzo
Aquí están todos los pasos que he tenido que dar para configurar una cuenta de Gmail en Emacs y en Debian.
Lo primero que necesitamos es un cliente de imap. Este cliente será el que se encargue de actualizar nuestra cuenta de gmail, sincronizando los cambios entre nuestro local y el servidor de Google. Para eso he instalado offlineimap
sudo apt-get install offlineimap
Después de descargar el programa debemos configurarlo de la siguiente manera, comenzaremos creando un fichero de configuración en: ~/.offlineimaprc
El contenido del fichero es el siguiente. Esta es la configuración básica que he encontrado en los ejemplos, de aquí deberemos cambiar el usuario del email, en el ejemplo está como usuario@gmail.com. Importante fijarse que está en dos lineas.
También podremos cambiar la carpeta donde queramos que se descargue el correo. El password como podéis ver no está añadido, ese es el siguiente paso.
[general]
accounts = Gmail
maxsyncaccounts = 1
pythonfile = ~/.offlineimap.py
[Account Gmail]
localrepository = Local
remoterepository = Remote
[Repository Local]
type = Maildir
localfolders = ~/Maildir
[Repository Remote]
type = Gmail
remoteuser = usuario@gmail.com
remotepasseval = get_password_emacs("imap.gmail.com", "usuario@gmail.com", "993")
realdelete = no
folderfilter = lambda foldername: foldername not in ['[Gmail]/Spam', '[Gmail]/All Mail', '[Gmail]/Starred', '[Gmail]/Important']
holdconnectionopen = true
keepalive = 60
sslcacertfile = /etc/ssl/certs/ca-certificates.crt
Para no tener que guardar el password en texto plano en nuestra configuración de offlineimap debemos crear un par de ficheros mas y hacer alguna cosilla. Empezaremos por crear un fichero ~/.offlineimap.py con el siguiente contenido dentro:
#!/usr/bin/python
import re, os
def get_password_emacs(machine, login, port):
s = "machine %s login %s port %s password ([^ ]*)\n" % (machine, login, port)
p = re.compile(s)
authinfo = os.popen("gpg -q --no-tty -d ~/.authinfo.gpg").read()
return p.search(authinfo).group(1)
Del fichero .py no hay que tocar nada, simplemente se encarga de leer un fichero que crearemos ahora donde se encontrará la contraseña.
El siguiente paso es crear el fichero ~/.authinfo, en este fichero deberemos introducir lo siguiente, cambiando usuario@gmail.com por nuestro usuario y aquivaelpassword por nuestra contraseña.
machine imap.gmail.com login usuario@gmail.com port 993 password aquivaelpassword
machine smtp.gmail.com login usuario@gmail.com port 587 password aquivaelpassword
Y ahora viene el encriptado del fichero, ya que si lo dejamos así estaría en texto plano.
El cifrado lo realizaremos desde emacs, ejecutando el siguiente comando y seleccionado el fichero .authinfo que acabamos de crear.
M-x epa-encrypt-file
Esto nos generará un fichero ~/.authinfo.gpg, una vez creado debemos eliminar el original.
Y con esto ya tenemos configurado nuestro imap lo siguiente sería sincronizar con el siguiente comando y tomarnos algo mientras tanto, porque tardará bastante.
$ offlineimap
Posiblemente tendréis habilitado un segundo factor de autenticación en vuestra cuenta, en ese caso no podréis usar vuestra contraseña, para solucionar eso tenemos dos opciones:
He visto quien desaconseja esta última opción ya que sería como quitar el doble factor de autenticación y recomiendan usar el token de Oauth. Mi impresión es que estaríamos en las mismas, ya que el password de aplicación tiene también la opción de cancelarlo y así invalidar esa aplicación.
Al ejecutar todo el proceso en otra máquina me encontré con el siguiente error a la hora de ejecutar offlinimap: gpg: Sorry, no terminal at all requested - can't get input
La solución mas sencilla que he encontrado ha sido cambiar en el script de Python gpg por gpg2. Quizás antes tengais que instalarlo, en Debian sería con apt-get install gnupg2 y habría que dejar el script ~/.offlineimap.py de la siguiente manera:
#!/usr/bin/python
import re, os
def get_password_emacs(machine, login, port):
s = "machine %s login %s port %s password ([^ ]*)\n" % (machine, login, port)
p = re.compile(s)
authinfo = os.popen("gpg2 -q --no-tty -d ~/.authinfo.gpg").read()
return p.search(authinfo).group(1)
Una vez ya ha terminado offlineimap de sincronizar debemos indexar, para ello nos hará falta mu, como también nos hará falta mu4e lo instalamos e indexamos.
sudo apt-get install mu4e
mu index --maildir=~/Maildir
Lo siguiente que he hecho y que mas me ha costado encontrar es como hacer estas tareas cada X tiempo, no por que sea complejo si no porque no he visto nada relacionado. Yo he decidido crear un cron que lo ejecute cada 5 minutos.
crontab -e
Y como contenido:
*/5 * * * * offlineimap -u quiet && mu index --maildir=~/Maildir
Para envíar los correos desde emacs hace falta instalar lo siguiente en Ubuntu/Debian
sudo apt-get install gnutls-bin
Aún no he tocado demasiado, estoy aún aprendiendo el modo mu4e, así que esta configuración es opcional. Dejo aquí la mía como ejemplo.
(require 'mu4e)
;; default
(setq mu4e-maildir (expand-file-name "~/Maildir"))
(setq mu4e-drafts-folder "/[Gmail].Borradores")
(setq mu4e-sent-folder "/[Gmail].Enviados")
(setq mu4e-trash-folder "/[Gmail].Papelera")
;; don't save message to Sent Messages, GMail/IMAP will take care of this
(setq mu4e-sent-messages-behavior 'delete)
;; setup some handy shortcuts
(setq mu4e-maildir-shortcuts
'(("/INBOX" . ?i)
("/[Gmail].Enviados" . ?s)
("/[Gmail].Papelera" . ?t)))
;; allow for updating mail using 'U' in the main view:
(setq mu4e-get-mail-command "offlineimap")
(setq
user-mail-address "usuario@gmail"
user-full-name "Nombre Apellido"
)
(require 'smtpmail)
(setq message-send-mail-function 'smtpmail-send-it
starttls-use-gnutls t
smtpmail-starttls-credentials
'(("smtp.gmail.com" 587 nil nil))
smtpmail-auth-credentials
(expand-file-name "~/.authinfo.gpg")
smtpmail-default-smtp-server "smtp.gmail.com"
smtpmail-smtp-server "smtp.gmail.com"
smtpmail-smtp-service 587
smtpmail-debug-info t)
Nos pintará en nuestra barra un sobrecito con el número de correos sin leer, lo ejecutará cada minuto y además mostrará alertas del sistema.
(use-package mu4e-alert
:ensure t
:after mu4e
:init
(setq mu4e-alert-interesting-mail-query
(concat
"flag:unread AND maildir:/INBOX AND NOT flag:trashed "
))
(mu4e-alert-enable-mode-line-display)
(defun gjstein-refresh-mu4e-alert-mode-line ()
(interactive)
(mu4e~proc-kill)
(mu4e-alert-enable-mode-line-display)
)
(run-with-timer 0 60 'gjstein-refresh-mu4e-alert-mode-line)
)
Como podéis ver este código por ahora es prácticamente copiado y pegado de las fuentes, como he dicho aún no he tenido tiempo de tocarlo demasiado y quizá tampoco me haga falta.
Pues poco puedo contar de este modo, aún tengo que aprender a manejarlo bien. Si ejecutáis en emacs M-x mu4e os mostrará un pequeño dashboard donde podréis comenzar a usarlo, con documentación incluida.
Solo llevo un día de uso y me ha resultado muy útil, sobre todo para hacer limpieza de correos. Me costó un poco configurarlo todo, pero una vez conseguido ha merecido mucho la pena.
Una recomendación que me gustaría daros es que no uséis gmail, en este caso lo hice porque es el correo del trabajo, podéis usar cualquier correo que acepte IMAP y SMTP y seguramente con algún protocolo mas también. Os dejo con un listado de servicios y herramientas que si tienen en cuenta la privacidad del usuario, ahí podréis encontrar buenos servicios de email.
Cualquier duda puedes preguntarme por gnusocial.net.
-1:-- Usando Emacs Como Cliente De Correo (Post )--L0--C0--September 07, 2018 06:44 PM
-1:-- Curso emacs 31. Recordatorio de cositas varias, zone, dissociated-press, spook (Post la pipa plena)--L0--C0--August 26, 2018 08:58 AM
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}
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
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
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
¡He aprendido a cambiar la fuente de Emacs! Y no solo eso, sino que he conseguido que sea diferente según el sistema operativo en el que nos encontremos.
Todo esto ha venido porque la fuente por defecto de Emacs en Windows no me diferenciaba los ceros y la letra O y los unos y la L minúscula y me estaba volviendo loca. Aprovechando que en Matlab me había pasado a Consolas, decidí que de ahora en adelante usaría Consolas al estar en Windows (es una fuente propietaria pero que viene incluida en Microsoft Office). En GNU/Linux he seguido con la que se establecía por defecto1, Roboto Mono, que aunque la creó Google, lleva licencia Apache.
Como yo quería que Emacs eligiera la fuente según el sistema operativo, necesitaba averiguar primero cómo le llamaba Emacs a mi sistema operativo. Esto puede conseguirse evaluando la variable system-type, o bien con M-x eval-expression o con M-:. Así supe que esta variable toma el valor de windows-nt en Windows y gnu/linux en GNU/Linux. Algo totalmente inesperado dicho sea de paso.
Bien, ahora me faltaba averiguar cómo cambiar la fuente y crear un if. Lo primero es simple, solo hay que añadir cualquiera de estas líneas al archivo de configuración:
;; Establecer fuente (set-face-attribute 'default t :font FUENTE :height TAMAÑO) ;; Establecer familia de fuentes (set-face-attribute 'default t :family FAMILIA :height TAMAÑO)
El if tampoco es mucho más complejo, solo hay que tener en cuenta que tiene miles de paréntesis:
(if (condición) (Expresiones si se cumple la condición) (Expresiones si no se cumple la condición))
Fusionando ambas cosas me quedó esto:
;; Fuente
(if (eq system-type 'windows-nt)
(set-face-attribute 'default nil :family "Consolas" :height 110)
(set-face-attribute 'default nil :family "Roboto Mono" :height 110)
)
Evidentemente se puede mejorar añadiendo una condición de que use la fuente correspondiente solo si está disponible o de otras manera diversas que ahora no se me ocurren pero a vosotros sí porque sois muy listos. La cuestión es que hurgando un poco se puede conseguir casi cualquier cosa en Emacs y por eso me encanta.
Ale pues, os dejo, ¡contadme cosas en los comentarios!
How to determine the operating system in elips? en StackOverflow
Emacs: Font Setup en Ergo Emacs
38.3 Operating System Environment en el manual de Emacs
37.12.1 Face Attributes en el manual de Emacs
Sonando:
M-x describe-font ↩
-1:-- Lo que he aprendido: fuente de Emacs (Post Ondiz)--L0--C0--May 26, 2018 05:20 PM
-1:-- Curso emacs 30. url-copy, más sobre el tiempo y menús con hydra (Post la pipa plena)--L0--C0--May 13, 2018 08:07 AM
-1:-- eshell (Post la pipa plena)--L0--C0--April 30, 2018 06:29 PM
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
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
pues nada, aunque tiene sus marcadores, si se presiona la combinacion C-l nos
muestra y selecciona la ruta actual… Copiar, modificar o pegar!
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)
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)
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
Este miércoles 25 de abril, a las 20:00, daré una charla sobre emacs en la Brecha Digital. Veremos, a grandes rasgos, qué es exactamente emacs, sus orígenes, comparación con vim para darle emoción, que posibilidades de uso tiene y cómo empezar a usarlo. El nivel de la charla será introductorio, pero si ya conoces emacs siempre puedes aprovechar la ocasión para ver la Brecha Digital, un grupo que se reúne en La Brecha, un centro social alquilado, en el que nos untamos habitualmente para dar charlas y aprender tecnologías molonas en común. Más información de La Brecha Digital aquí, echadle un ojo para ver como llegar a La Brecha.
-1:-- Charla: Emacs no necesita esteroides (Post )--L0--C0--April 21, 2018 08:42 PM
Para programar en PHP me gusta usar el modo mayor php+-mode y uno de los modos menores que uso es ac-php para usar company-mode y realizar el autocompletado. Este modo menor es bastante útil, sobre todo porque crea una tabla de tags muy buena, pero no he encontrado una forma automática de crearla, cada cierto tiempo ejecutaba el comando de generación de tags para autocompletar.
Tenía previsto desde hace mucho tiempo hacer que se regenere cuando guardo un buffer en modo php+ pero por pereza lo he ido dejando, incluso asigné una tecla al comando de tags, pero al final me decidí a hacer las cosas bien.
Este es el código que finalmente he añadido a mi configuración, a continuación os lo explico.
(defun remake-ac-php-tags ()
"Remake php tags from current buffer"
(when (eq major-mode 'php+-mode)
(ac-php-remake-tags))
)
(add-hook 'after-save-hook #'remake-ac-php-tags)
Como veis lo primero que hago es crear una función que será la que lanzaremos con el hook, podría decirle al hook que lanzase directamente la de generación de tags, pero la que he creado también filtra por el modo en el que nos encontramos.
(when (eq major-mode 'php+-mode) (ac-php-remake-tags))) Aquí está lo interesante, la condicion que dice que el modo mayor debe ser php+-mode y dentro la ejecución del comando que deseamos.
(add-hook 'after-save-hook #'remake-ac-php-tags) El siguiente paso ya es simplemente añadir la función al hook que se lanzará siempre que se guarde un fichero.
Al final el código es sencillo a mas no poder, es mas la pereza de buscar el cómo se hace, que el hacerlo. Espero que os sirva de ayuda a la hora de lanzar vuestras acciones al guardar un fichero.
Debería mejorarlo para que en realidad mirase si está el modo menor ac-php activo, pero la verdad es que aún no se como hacerlo.
-1:-- Lanzando Hook al Guardar Buffer en Un Modo en Particular de Emacs (Post )--L0--C0--April 18, 2018 08:26 PM
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
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 mmodificadores
$ 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 bufferfin 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.
(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
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 modoC-c TAP cambiar syntaxis de entradaC-c C-r ir a coincidencia previaC-c C-s ir a coincidencia siguienteisearch 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 interactivamenteC-M-y ingresar a la regexp el caracter del buffer sobre el que esta el puntoC-M-w borrar el ultimo caracter de la regexpM-s C-e ingresar a la regexp el resto de la linea apartir de la posicion del puntoC-y traer ultima cadena del anillo de la muerteM-y iterar sobre el contenido del anillo de la muerteM-c cambiar la sensivilidad a las mayusculas-minusculasC-s siguiente coincidenciaC-r anterior coincidenciay 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
-1:-- Keep Regexp (Post )--L0--C0--April 08, 2018 04:50 PM
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:
Adquirir un pecado, de cualquier tipo, longitud > 30 cm
Congelarlo durante la noche
Siéntese frente a la PC, ejecute vi
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.
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
.
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
.
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
He empezado a usar Magit. Tanto escuchar Magit es el mejor modo para git jamás creado y yo empecé a usar Emacs por Magit me han convencido a darle una oportunidad. Eso y que el modo git normal que usaba no me carrula bien en el ordenador del curro (¡Windows!).
La cuestión es que Magit me flipa, puedo manejar mi repo desde Emacs solo dando a un par de teclas y ayudando por tanto a mis pobres bracitos lesionados por el ordenador.
Lo más curioso de este modo es que funciona a base de ventanitas (pop ups) en las que se nos dan opciones diversas. A cada ventanita se accede con una tecla y podemos acceder a la ventanita de las ventanitas con h (help). Cada ventanita se divide en dos pedazos, en la parte superior activamos las opciones y en la inferior elegimos el comando. No os preocupéis que enseguida lo veremos todo mucho más claro.
Por cierto, si como yo usáis Emacs con GUI y menús (¡sacrilegio!) tendréis en la barrita un menú de Magit con las diferentes órdenes y sus teclas correspondientes.
Empezamos a usar Magit en un repositorio existente diciéndole que nos muestre el estado del mismo en una de sus ventanitas con la siguiente orden:
M-x magit-status RET
La ventanita de estado
La documentación nos aconseja asignarle la combinación de teclas C-x g a este comando ya que lo usaremos a menudo. Esto ya lo hemos hecho otras veces, no hace falta más que añadir una línea mágica al archivo de configuración:
(global-set-key (kbd "C-x g") 'magit-status)
Si no empezamos desde un repo existente, podemos iniciar uno con M-x magit-init o clonarlo con M-x magit-clone, que nos pedirá un nombre y una URL.
La ventanita de estado nos lista todos los archivos del repo, categorizados como Unstaged, Staged y Modified. Podemos movernos por la ventanita y decirle a Magit que haga el seguimiento a archivos o a trocitos de archivos, que haga un commit o que envíe los cambios a un repositorio remoto solo dando a una tecla.
Posicionándonos sobre el nombre de un archivo sin seguimiento o uno modificado y pulsando s (stage) lo añadiremos a los archivos a vigilar. Si nos posicionamos en el título y le damos a la s, añadiremos todos los de la sección. También podemos ignorar archivos con u (unstage).
Cuando estemos satisfechos de los añadido, le damos a la c para que se abran las opciones del commit y le vamos siguiendo el juego: pulsamos c para un commit normal, escribimos el mensaje y hacemos C-c C-c para decirle que hemos acabado. Antes os decía que las ventanitas tenían dos partes, la de las opciones y la de los comandos, los comandos se eligen dándole a la tecla correspondiente y las opciones superiores se activan posicionándose en la línea y pulsando RET, son los flags con los que Magit llamará al comando de git en cuestión.
Una de las cosas que más me gusta de Magit es que la información de las ventanitas se divide en secciones que se comportan como las de mi adorado Org y, por lo tanto, se expanden una vez con TAB y del todo con C-TAB.
La ventanita de estado ya nos muestra los cambios al expandir el archivo con TAB, pero si queremos hacer más cosas tenemos la ventanita de los diffs, que contra todo pronóstico abrimos con d cuando estamos en la ventana de estado.
La ventanita de los diff
Las ramas en sí se tratan en la ventanita de las ramas que se abre con b y gestiona la creación y la destrucción de ramas así como saltar de una a otra con checkout.
Las fusiones de ramas, en cambio se tratan en la ventanita de merge que se abre con m y los stash en otra ventanita específica a la que llamamos con la z.
El tema de los remotos tiene su miga por los términos que se utilizan. Yo como de git sé bastante poco, voy a contar el par de cosas que uso yo y os dejo unos enlaces para que leáis el manual.
Los remotos se gestionan con la ventanita que aparece al darle a la M, ahí se puede añadir un remoto, quitarlo o cambiarle el nombre. Cuando ya lo tengamos configurado, podemos hacer fetch o pull con f y F respectivamente, cada cual con su ventana de opciones correspondiente. Luego con P abrimos la ventanita de hacer push y mandamos los cambios a la rama remota que nos parezca.
En Windows, como suele ser habitual, el tema de pushear funciona distinto. Si estáis en ese caso el manual es vuestro amigo.
Un tema interesante para no malgastar recursos es desactivar VC, el modo de Emacs para el control de versiones. Nos dicen en la docu que para ello añadamos esta línea al archivo de configuración:
(setq vc-handled-backends nil)
Así como resumen os diré que me ha gustado Magit, es sencillo e intuitivo y a pesar de que me encante usar git desde la terminal y liarla petarda porque no me acuerdo de los comandos, usaré Magit siempre que edite cosas bajo control de versiones en Emacs.
¡Recordad! Para usar Magit solo hace falta abrir la ventanita de estado (M-x magit-status) y luego darle a teclas diversas. No nos exige además mucha memoria, solo con acordarnos de que la h nos abre la ventanita de ventanitas es suficiente. ¡Ah! Salir de las ventanitas es tan fácil como darle a la q.
Ya me contaréis qué tal.
La ventanita de ayuda
Sonando:
-1:-- Lo que he aprendido: magit (Post Ondiz)--L0--C0--March 31, 2018 02:00 PM
Casi es más largo el título que la definición o solución del problema.
Por mostrar un caso real explicaré el problema que tenia. Uso el paquete Projectile, que sirve para gestionar proyectos en emacs, recomiendo fuertemente que le echéis un ojo. Cuando se han abierto unos cuantos proyectos puede usarse la función projectile-switch-project, que permite cambiar el proyecto. El tema es que muchos directorios de mi home son en realidad enlaces simbólicos a otros sistemas de ficheros. Esto hace que los proyectos se me muestren con las rutas reales, no las rutas de los enlaces simbólicos. Por ejemplo, un proyecto en /home/drymer/Documentos/Ansible/roles/upgrade-all se me muestra como /media/.secret/Casa/Documentos/Ansible/roles/upgrade-all, lo cual es horroroso.
Lo que yo necesito es hacer que los proyectos en /media/.secret/Casa/ se muestren como /home/drymer/. Investigando, vi que lo que me hacia falta era usar una función de asesoramiento. No tengo claro si se traduce así, en inglés son Advising Functions. El tema es que estas funciones permiten, entre otras cosas, modificar la salida de una función elisp sin tener que redefinirla.
Por lo tanto, hay que averiguar que función es la que hay que modificar. En este caso, la función que da el nombre a los proyectos es projectile-project-root. Ahora crearemos una función simple que ejecute un replace-regexp-in-string en la salida:
(defun daemons/projectile-project-root (arg)
(replace-regexp-in-string "\\(/media/.secret/Casa\\)" (getenv "HOME") arg))Un ejemplo de la ejecución de esta función:
(daemons/projectile-project-root "/media/.secret/Casa/Proyectos/nikola.el")Solo nos queda añadir el filtro:
(advice-add 'projectile-project-root :filter-return #'daemons/projectile-project-root-filter)Desgranemos el código:
advice-add: Añade función de asesoramiento.projectile-project-root: La función que modificaremos.filter-return: De que modo modificamos la función.daemons/projectile-project-root-filter: Función con la que modificaremos el comportamiento de la primera.La parte más interesante es la de filter-return, ya que este no es el único parámetro que se puede definir. Si quisiésemos, podríamos sustituir la función entera de muchas formas distintas. De hecho, si quisiésemos redefinir una función ya definida en alguna parte, las buenas prácticas dicen que hay que usar las funciones de asesoramiento. Recomiendo leer su sección del manual.
-1:-- Modificar la salida de una función de emacs lisp sin redefinirla (Post )--L0--C0--February 06, 2018 10:10 PM
Este es un paquete al que cuesta cogerle el punto. Pisa un poco las funcionalidades de las macros, es un poco especialito y hay que tener un poco de imaginación al usarlo, pero una vez le pillas el truco es muy útil.
El paquete que muestra el siguiente gif es de multiple-cursors, y hace exactamente esto, abrir múltiples cursores en emacs. Lo he estado usando últimamente que he tenido que he estado usando Terraform en el trabajo, y se presta al uso de este paquete. Veamos un ejemplo:
La primera función es mc/mark-next-like-this, que crea un cursor en el siguiente elemento que es igual al que se está seleccionando. Tiene su equivalente mc/mark-previous-like-this para lo mismo pero para atrás. La siguiente función es mc/mark-next-lines que marca la siguiente linea sin más. Igual que la anterior, tiene su equivalente inverso, mc/mark-previous-lines. Y por último, el más útil, como todos los dwim, Do What I Mean. Se comporta de forma distinta según desde dónde se ejecute. Si se selecciona una región, introduces una cadena de carácteres y inserta cursores en esas regiones. En otra región hará otra cosa.
En la fabulosa página de Emacs Rocks hay un screencast sobre este paquete. Son solo tres minutos y muestra otro ejemplo de como usar este modo.
-1:-- Múltiples cursores en emacs (Post )--L0--C0--December 11, 2017 07:30 AM
-1:-- Mitos sobre GNU Emacs (Post admin)--L0--C0--December 07, 2017 05:34 PM
Última actualización:
August 24, 2019 08:00 AM
Las horas son UTC.
Si quieres que aparezca un blog en este planet, manda un correo con la dirección del feed a planet [EN] emacs-es.org. A poder ser, el feed de la categoria de emacs, si el sitio web tiene otra temática.
Estamos en:
Funciona con:
El repositorio de la web está aquí.
