Planet Emacses

48.1 The Package Menu Buffer en el manual de Emacs

-1:-- Cambiando estados de forma masiva en mis Org Mode (Post )--L0--C0--April 17, 2019 08:33 AM

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

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

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

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

paquetes

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

Referencias

Solo del punk no se vive, hoy suenan trompetas.

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

MGallego: Introduccion a Emacs Lisp: Seteando Variables

Existen dos formas de setear una variable en Lisp:

Usando set

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

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

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

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

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

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

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

Usando setq

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

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

La q de setq es de quoted.

Creando un contador sencillo.

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

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

     counter ; resultado

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

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

MGallego: Introduccion a Emacs Lisp: Listas

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

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

Listas

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

     '(rose
       violet
       daisy
       buttercup)

Átomos

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

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

Listas vacías

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

Expresiones simbólicas

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

Espacios en blanco

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

      '(atom1 atom2 atom3)

      '(atom1
        atom2
        atom3)

      '(atom1          atom2   atom3)

Ejecución de código

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

Al evaluar una lista de lisp pueden ocurrir tres cosas:

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

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

Evaluando expresiones en Emacs

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

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

Generar mensajes de error

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

Variables

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

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

Evaluar una variable como una función

    (fill-column)

Esto devolvería un error del tipo:

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

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

Evaluar una función como una variable

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

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

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

Argumentos

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

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

La función message

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

Conclusión

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

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

Notxor tiene un blog: Cómo trabajar con SQLite3 desde Emacs

Cómo trabajar con SQLite3 desde Emacs

En mi último artículo hablé de cómo trabajo en formato texto con Emacs y son varios los que me han preguntado por el apartado de base de datos. ¿Cómo me las apaño para tener las bases de datos de SQLite en modo texto?

Lo primero es confesar que no tengo todas, sino sólamente aquellas que quiero tener controladas en repositorios git. La otras las guardo en el fichero de base de datos que genera SQLite, porque es más sencillo y rápido acceder a los datos así. Pero aunque no las tenga en formato de texto, sí hay consultas, en mi fichero de consultas, que las referencias.

Para explicar mejor el proceso que sigo, voy a contar desde cero y pondré también capturas de pantalla, paso a paso.

Crear una base de datos

Lo primero que hago es crear un fichero con el nombre que quiero ─en el ejemplo lo llamaré base-de-datos, por ejemplo─ y le añado una extensión sql. Al abrir este fichero, Emacs entrará en modo SQL, y por defecto se colocará en modo ANSI.

Como se puede ver en la imagen, la barra de estado marca el modo SQL[ANSI], aunque el archivo aún está vacío. Lo primero es decirle al editor que vamos a utilizar, concretamente SQLite. Para ello utilizo el comando M-x sql-set-product RET sqlite RET.

Estando en el buffer del fichero sql, que permanece vacío, vamos a levantar también un entorno interactivo para SQLite dentro de Emacs: así no tenemos que estar entrando y saliendo del editor, sino sólo cambiando de buffer. Para lanzarlo utilizo la combinación de teclas C-c TAB también se podría llamar mediante M-x sql-product-interactive. Al lanzarlo nos pide un nombre para la base de datos, en mi ejemplo base-de-datos.db y nos mostrará el típico prompt de SQLite.

Ahora podemos dar el siguiente paso en cualquier de los dos buffers pero para mí resulta mucho más sencillo hacerlo directamente en el interactivo de SQLite. Vamos a crear una tabla dentro de nuestra base de datos.

CREATE TABLE Gente (
    id       integer primary key autoincrement,
    Nombre   text,
    Telefono text);

Y para que no esté vacía la base de datos, voy a añadir un par de registros a esa tabla:

insert into Gente(Nombre, Telefono) Values('Juan', '987654321');
insert into Gente(Nombre, Telefono) Values('Juan', '987654321');

Bien, vamos a hacer una consulta y como me gusta ver las cosas ordenadas, también añado los comandos .mode column y .headers on para que se muestren las consultas, como por ejemplo:

SELECT * FROM Gente;

id          Nombre      Telefono  
----------  ----------  ----------
1           Pepe        123456789 
2           Juan        987654321

Como vemos, hasta ahora hemos trabajado como si lo hiciéramos desde la herramienta interactiva de SQLite3, y además tenemos dos ficheros, la base de datos db con una tabla y dos registros y un fichero sql vacío:

Convertir la base de datos a texto

Cuando tenemos la base de datos creada la podemos pasar a formato texto desde el mismo buffer de SQLite con dos sencillos comandos:

.output base-de-datos.sql
.dump

Esos dos comandos, primero lo que hacen es dirigir la salida de SQLite al fichero base-de-datos.el y luego volcar toda la base de datos (también soporta hacerlo por tablas). Si ahora recargamos el fichero de texto, veremos lo siguiente:

Ahora, podemos borrar el fichero binario de base de datos y trabajar sólo con el sql. Por ejemplo, me he dejado un par de detalles que en formato de texto se pueden modificar sobre la marcha. En nuestra base de datos no tendría sentido tener teléfonos sin nombre, o nombres sin teléfonos, así que debería haber marcado esos campos como NOT NULL. Así, he modificado el fichero de texto para dejarlo como sigue:

PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;
CREATE TABLE Gente (
  id       integer primary key autoincrement,
  Nombre   text    not null,
  Telefono text    not null);
INSERT INTO Gente VALUES(1,'Pepe','123456789');
INSERT INTO Gente VALUES(2,'Juan','987654321');
DELETE FROM sqlite_sequence;
INSERT INTO sqlite_sequence VALUES('Gente',2);
COMMIT;

Si borramos la base de datos binaria la podremos recargar desde ese fichero de texto, generado antes. Vamos a hacer la prueba para demostrar lo sencillo que es. Volvemos a lanzar el entorno interactivo desde el buffer de nuestro código sql con C-c TAB y el nombre del fichero, que podemos utilizar, que puede ser el mismo u otro. Una vez hecho, si pedimos que nos muestre el .schema de la base de datos nos dirá que está vacía, pero si desde nuestra base de datos en sql le lanzamos el buffer con C-c C-b y volvemos a preguntar, ya veremos nuestra estructura cargada.

Así mismo, si por algún casual una base de datos va a gestionarse desde un entorno de base de datos, como puede ser MariaDB o PostgreSQL o el cualquier otro que comprenda el sql, bastaría con modificar mínimamente ese fichero para ajustarse a las idiosincrasias de cada base de datos y convertirla con facilidad. Por eso es recomendable que utilicemos siempre código sql lo más estándar posible para facilitar luego la exportación de datos.

Fichero para consultas

Ya he explicado un poco por encima cómo funciona el Emacs en modo sql. En este caso sobre SQLite3, pero se puede conectar a un buen puñado de bases de datos relacionales.

Además suelo tener en «el cargador» otro fichero que guarda código para hacer determinadas consultas. La mayoría de esas consultas se hacen sin cargar el entorno interactivo sin abrir el fichero sql y es lo que mostré en el artículo anterior, por lo que no me extenderé en ello demasiado. Por ejemplo:

#+begin_src elisp :export code
(require 'sqlite)
(let ((db (sqlite-init "~/proyectos/tutorial-sqlite/base-de-datos.db")))
  (sqlite-query db ".headers on")
  (setq resultado (sqlite-query db "select * from Gente"))
  (sqlite-bye db)
  resultado)
#+end_src

#+RESULTS:
| id | Nombre | Telefono   |
|  1 | Pepe   | 123456789  |
|  2 | Juan   | 987654321  |

Guardarlo así me permite generar tablas complejas y que son devueltas en un formato muy próximo al que puede gestionar org-mode. En el ejemplo, puesto que se tratan de datos muy básicos y no hay datos cruzados entre diferentes tablas, puede parecer innecesario. Sin embargo, cuando la base de datos se complica y/o las consultas implican varios join o necesitas trabajar los resultados de otra forma, como llevarlos a un informe, por ejemplo; el tener ese fichero de consultas es un ahorro de tiempo y quebraderos de cabeza. El código de consulta sql lo tienes a mano, lo puedes modificar para ajustarlo a la consulta que necesitas en ese momento y los resultados los tienes inmediatamente al pulsar C-c C-c en el bloque de código.

-1:-- Cómo trabajar con SQLite3 desde Emacs (Post )--L0--C0--April 12, 2019 12:00 AM

Notxor tiene un blog: Ventajas del texto plano

-1:-- Ventajas del texto plano (Post )--L0--C0--April 07, 2019 12:00 AM

Blog uGeek: Exportando bonito a html mi OrgMode y creando web estática

Hoy os traigo un paquete que exporta tus archivos orgmode a formato html de un modo más bonito y con más calidad ...

Sigue leyendo el post completo de Exportando bonito a html mi OrgMode y creando web estática

-1:-- Exportando bonito a html mi OrgMode y creando web estática (Post )--L0--C0--April 02, 2019 06:00 PM

Blog uGeek: Notificaciones Org Mode en Telegram con mi Bot

En artículos anteriores, así como en el Podcast, os he explicado como enviar notificaciones de texto, imágenes y archivos, a través de un Bot en Telegram que podemos crear...

Sigue leyendo el post completo de Notificaciones Org Mode en Telegram con mi Bot

-1:-- Notificaciones Org Mode en Telegram con mi Bot (Post )--L0--C0--March 31, 2019 09:30 AM

Notxor tiene un blog: Utilizando Dired para reemplazar cadenas en varios ficheros

-1:-- Utilizando Dired para reemplazar cadenas en varios ficheros (Post )--L0--C0--March 30, 2019 12:00 AM

La Pipa Plena: Tutorial emacs

Entre un montón de elementos linuxeros hemos realizado una traducción del tutorial de emacs de: https://www.computerhope.com/unix/uemacs.htm Seguramente tiene bastantes deficiencias pero ahí queda para quien lo quiera usar. Lo hemos colgado en el apartado emacs de la cabecera i está en: http://lapipaplena.duckdns.org/emacs/emacs_tut.html M-x felices-orgasmos Anuncios

-1:-- Tutorial emacs (Post la pipa plena)--L0--C0--March 24, 2019 05:15 PM

Blog uGeek: Actualizado: Cursos, Webs, Grupos, Tutoriales... Todo sobre Emacs y OrgMode

Muchos de vosotros me comentáis si os puedo recomendar un sitio donde iniciaros con Emacs y OrgMode...

Sigue leyendo el post completo de Actualizado: Cursos, Webs, Grupos, Tutoriales... Todo sobre Emacs y OrgMode

-1:-- Actualizado: Cursos, Webs, Grupos, Tutoriales... Todo sobre Emacs y OrgMode (Post )--L0--C0--March 15, 2019 10:00 PM

Blog uGeek: Curso de Emacs en vídeo

Muchos de vosotros me comentáis si os puedo recomendar un sitio donde iniciaros con Emacs y OrgMode...

Sigue leyendo el post completo de Curso de Emacs en vídeo

-1:-- Curso de Emacs en vídeo (Post )--L0--C0--March 15, 2019 05:00 PM

Notxor tiene un blog: Creación de un modo mayor para emacs

-1:-- Creación de un modo mayor para emacs (Post )--L0--C0--March 15, 2019 12:00 AM

Maxxcan's Site: Programación literaria para todos con Emacs

Introducción Hace tiempo hice una serie de charlas sobre programación literaria en distintos escenarios como…

Read the post

-1:-- Programación literaria para todos con Emacs (Post maxxcan)--L0--C0--March 12, 2019 03:54 PM

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

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

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

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

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

Notxor tiene un blog: Reorganizar las capturas de la agenda con plantillas

-1:-- Reorganizar las capturas de la agenda con plantillas (Post )--L0--C0--March 06, 2019 12:00 AM

Bad Daemons: Gomic y primeras impresiones sobre Go

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

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

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

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

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

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

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

Lenguaje compilado: Esto lo ves nada más empezar a leer sobre go. Lo que no ves de primeras es que no es necesario compilar. Es recomendable y deberías crear binarios, pero para desarrollar puedes usar go run . y se ejecuta del tirón. Incluso se pueden hacer scripts en go. Hay formas de hacerlo, más o menos estándar, aquí hablan más del tema. Pero si a este script se le da permisos de ejecución y se ejecuta con ./script.go, funciona sin más:

//usr/bin/go run $0; exit
package main
import "fmt"
func main () {fmt.Println("Holi")}

Declarar tipo de variable VS asignar valor a una variable: No se si es así en otros lenguajes de tipado estático, pero en go se puede hacer de ambas formas:

var variable "holi"
variable := "holi"

El módulo de logueo: Como se ve aquí, se usa del tirón. Esto es algo que en python siempre me ha molestado mucho, para loguear tienes que hacer movidas muy raras. En go puedes usar log.Println para loguear a nivel info y log.Fatal para errores. Hasta se encarga de parar el programa al haber detectado un error fatal.
Docker friendly: Una cosa muy interesante que tiene go, a diferencia de java por ejemplo, es que puedes compilar binarios dinámicos o estáticos. La diferencia básica es que el primero solo funcionará en un SO con las mismas características que en el que se ha compilado (es decir, mismas librerías), y el segundo en cualquiera. Mola por que si lo compilas estáticamente, no hace falta nada más. Y cuando digo nada más es literalmente nada más, se puede usar la imagen scratch para crear la imagen. Por comparar, veamos el tamaño de la imagen de drone-xmpp (python) comparado con la de gomic:

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

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

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

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

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

repl: Gore es un repl, puedes hacer pruebas rápidas con ello.
Paquetes nativos muy potentes: Como se puede ver si se lee el código, no he tenido que usar ningún paquete externo para el programa. En un principio usé grab para descargar ficheros, pero realmente no me aportaba demasiado. Además, no dejaba escoger que nombre le ponía al fichero, lo cual es un problema. Pero seguramente lo que llama más la atención es que el servidor http nativo sea tan potente. O igual no es tan sorprendente, si tenemos en cuenta que go se usa mucho para la generación de apis.
Tipos de datos: Esto fue de lo que más me costó entender, aunque no tengo claro haberlo entendido del todo. Al ser tipado estático, tienes que saber exactamente el tipo de todas las variables, por ejemplo al hacer un return de una función. Me encontré con que no podía convertir estructuras (struct, que se llama) a tipos simples, como es un string o un integer. En realidad no sabia por que no podía, el tema de las estructuras lo descubrí después de muchas horas. Concretamente, lo que estaba haciendo era intentar convertir el tipo os.FileInfo a string. Y claro, no encontraba por internet la forma de hacerlo, por que, salvando las distancias, es como si intentase convertir una clase de python en un string. Sentido cero. Al final era mucho más simple, como solo me interesaba el atributo Nombre, solo habia que acceder al atributo de una forma intuitiva, con os.FileInfo.Name().
Muy buena documentación: La documentación está muy bien escrita y muchas veces tiene incluso ejemplos.
Bulma: Esto no tiene que ver con go directamente, pero lo cuento igual por que mola. Cuando hice la primera iteración del programa, la interfaz era esta.

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

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

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

Onda Hostil: Lo que he aprendido: AUCTeX

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

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

Unas órdenes básicas

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

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

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

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

Embellecedores

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

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

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

Doblado

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

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

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

Autocompletado

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

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

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

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

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

Otras magias

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

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

RefTeX

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

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

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

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

Archivo de configuración

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

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

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

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

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

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

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

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

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

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

Si fuera perfecto no sería divertido.

Referencias

Manual de AUCTeX

Chuleta de AUCTeX (pdf)

Manual de RefTeX

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

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

Company AUCTeX

Company mode

Actualización (21/03/2019)

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

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

Me estoy leyendo los artículos de Notxor sobre Elisp y pronto sabré lo que hago ¡JA!
Y esta en Archive, que te den Google.

-1:-- Lo que he aprendido: AUCTeX (Post Ondiz)--L0--C0--February 07, 2019 12:00 PM

Bad Daemons: Doom: un framework para configurar emacs

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

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

Las características principales que tiene son:

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

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

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

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

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

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

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

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

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

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

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