joe di castro

Productividad & Linux: Ncdu

joe di castro — Fri, 19 Oct 2012 22:40:00 +0200

Esta es una pequeña aplicación que sigue la máxima de Doug Mcllroy que acabaría resumiendo la filosofía Unix "Escribe programas que hagan una sola cosa y que la hagan bien". Y siguiendo la línea de los programas que engloban esta serie de productividad sobre Linux, es un programa de consola que se maneja íntegramente con el teclado, y donde además los atajos están inspirados en los de Vim.

Ncdu

Ncdu es un acrónimo para "NCurses Disk Usage", es decir, "Uso de disco con interfaz ncurses". Lo que pretendía Yoran Heling, su autor, cuando creo ncdu, era obtener un analizador de uso de disco en consola que fuera lo suficientemente ligero para poder emplearlo en un servidor remoto a través de ssh. El gran acierto fue emplear la interfaz ncurses para poder navegar por los directorios con extrema facilidad al mismo tiempo que se presentaba la información en un formato legible y amigable. El segundo y no menos importante acierto, es emplear los conocidos atajos de teclado de Vim para navegar entre los directorios.

El resultado es un analizador de ocupación de disco que es realmente útil, agradable de utilizar y que es tan rápido y ligero que se puede emplear sin interfaz gráfica y en maquinas remotas. Es una gran ayuda para los administradores de sistemas, que hasta ahora nos teníamos que pelear con otras herramientas bastante menos agradables. Es la típica herramienta que cuando la utilizas por primera vez piensas ¿Por qué demonios no la habría encontrado antes?

Como se puede ver la interfaz es muy limpia y carece de elementos superfluos que nos distraigan de lo importante, un pecado que cometen algunas de las aplicaciones gráficas más famosas, que cuentan con unos gráficos muy bonitos, pero realmente no demasiado útiles. Es sencillisima de emplear una vez que conoces los atajos y cuenta con ayuda integrada a la que se accede pulsando ?. Incluso para aquellos que no están acostumbrados a navegar empleando las típicas teclas de vim (h, j, k, l), se pueden utilizar las teclas de dirección.

Características

Un programa de este tipo no necesita una funcionalidad muy elevada, pero destacare aquí algunas de las posibilidades que nos ofrece:

Podemos ordenar los directorios/ficheros en función de su nombre o de su tamaño y en orden ascendente o descendente
Se pueden eliminar directamente ficheros o directorios desde la aplicación, aunque también podemos iniciarla en modo solo lectura para prevenir borrados accidentales
Se muestra o no, el porcentaje de espacio ocupado de forma gráfica y/o numérica
El espacio empleado en disco puede hacer referencia al real o al aparente
Los directorios y ficheros ocultos pueden ser o no mostrados
Nos permite recalcular el espacio ocupado de un directorio concreto sin necesidad de volver a recalcular todo
Tenemos la posibilidad de volcar la información a un archivo, que puede también ser leído por el mismo programa
Es posible mostrar la información de un elemento individual en un cuadro emergente

La verdad es que lo único que hecho en falta en el programa es quizás un poco de color para distinguir entre ficheros y directorios de forma más visual. Por lo demás, es muy rápido calculando el espacio, no he hecho una comparación directa, pero me parece ligeramente más rápido que Baobab.

Alternativas

Existen varias alternativas decentes como aplicaciones gráficas, como los conocidos Baobab (que viene con las herramientas de Gnome) o JDiskReport. Después existen múltiples alternativas tanto en modo gráfico como en modo consola que, sinceramente, no puedo recomendar a nadie, bien porque son más vistosos que prácticos o bien porque son directamente insufribles. Existe una alternativa en modo texto que algunos prefieren a ncdu que es gt5.

Productividad & Linux: Ranger

joe di castro — Thu, 18 Oct 2012 21:50:00 +0200

Algunos pensarán, de acuerdo, podemos entender que prefieras un gestor de ventanas de mosaico, o que emplees aplicaciones como Pentadactyl, Newsbeuter, Zathura o Turses, pero Ranger... ya es demasiado. ¿A quien en su sano juicio se le ocurriría utilizar semejante engendro? A mí, y no solo lo utilizo a diario, si no que además opino que es quizás la mejor aplicación que he descubierto en el último año y medio. Y esto último es mucho decir para alguien, que como yo, está continuamente buscando formas de mejorar su modo de trabajo.

Ranger es un administrador de archivos en modo texto. Pero no es un administrador de archivos en modo texto clásico a dos columnas, como el norton commander y similares. No, Ranger es una pequeña joya con un planteamiento distinto y tan potente, que puede conseguir que olvides que no podías vivir sin un gestor de archivos gráfico como Nautilus, Konqueror, Dolphin o Thunar.

Ranger

Tengo que estar enormemente agradecido a su autor, Roman Zimbelmann no solo por su trabajo, si no por mostrarme que incluso en modo texto, se puede revolucionar el mundo de la usabilidad. Evidentemente, en una aplicación que basa su control en el teclado (tiene un soporte muy básico del ratón), es requisito imprescindible invertir algún tiempo en aprender a utilizarlo, ya que no es tan intuitivo como una aplicación gráfica. A menos que seas un usuario típico de Vim, entonces te encontrarás como en casa. Una vez que dominas esta aplicación, el moverse entre los directorios y el realizar operaciones se hace a velocidad de vértigo y con control absoluto (siempre que no seas un manazas con el teclado).

Ranger está desarrollado en Python y emplea una interfaz ncurses igual que Turses. Al contrario de lo que algunos puedan pensar, el estar desarrollado en Python no lo convierte ni en pesado ni en lento, si no que se mueve a velocidad endiablada y consume una cantidad de memoria ridícula comparada con cualquier gestor de archivos gráfico.

Aquí puede verse una imagen típica de ranger, visualizando el contenido de un directorio y previsualizando el contenido de un fichero, en este caso un fichero de código python.

Características

¿Qué se puede hacer con ranger?, bueno, quizás es mejor preguntarse que no se puede hacer con Ranger. Prácticamente todas las funciones a las que estés acostumbrado en un administrador de archivos gráfico se pueden realizar con Ranger. Vamos primero a ver un resumen de sus características:

Soporte de UTF-8 por defecto
Visualización en múltiples columnas
Previsualización del directorio o fichero seleccionado
Operaciones comunes sobre los ficheros. Crear, copiar, borrar, cambiar atributos (chmod), etc...
Combinaciones de teclado y consola inspiradas en Vim
Autodetección de tipos de fichero y apertura de los mismos con el programa adecuado
Permite establecer etiquetas y marcadores sobre archivos y directorios
Empleo de pestañas. Nos permite navegar por varios directorios simultáneamente sin necesidad de abrir otra instancia del programa. Además se pueden realizar operaciones entre ellas
Muestra una barra de progreso para las operaciones que lo necesitan

Conviene dejar claro que no es un programa para impacientes, hacerse con él y sus innumerables opciones requiere tiempo. Hay que leerse la ayuda del programa y practicar con él. A su vez, si queremos personalizar las opciones o ampliarlo, debemos comprender como funcionan sus archivos de configuración, mejor aún si tenemos conocimientos de Python. La documentación de su web, así como la de sus páginas man está un poco desactualizada, por lo que sacarle todo su jugo requiere algo de paciencia.

Ejemplos

Voy a intentar dar algo de visibilidad a algunas de las capacidades que nos ofrece ranger empleando una par de ejemplos que lo ilustren.

En el siguiente ejemplo vemos la previsualización que hace ranger en función del tipo de fichero que se trate.

Previsualización de archivos en ranger con varios tipos de archivo. Recomiendo ver en alta resolución y a pantalla completa.

La previsualización de imágenes en ASCII puede parecer una tontería, pero resulta muy útil a la hora de diferenciar entre distintas imágenes con nombre muy parecido. El fichero en HTML está renderizado en vez de mostrarnos el texto plano, algo más amigable. También se agradece mucho el que los ficheros de código se vean con resaltado de sintaxis.

Conviene aclarar que para realizar esta previsualización es necesario tener instalado una serie de pequeñas aplicaciones que se detallan en el sitio de ranger como dependencias.

Aquí vemos como se abren automáticamente los programas adecuados en función del tipo de archivo (se puede configurar que aplicaciones emplear y cuales usar en cada momento)

Ejecución automática de aplicaciones en función del tipo de archivo. Recomiendo ver en alta resolución y a pantalla completa.

En el caso del fichero Torrent, al que no tengo asociada ninguna aplicación en ranger, me abre un comando en el que puedo especificar directamente la aplicación que deseo emplear para gestionarlo. En este caso, ninguna. En el archivo comprimido solo me muestra el contenido del mismo, podría asociarle alguna aplicación, pero ya tengo comandos para manejarlos dentro del propio ranger, algo que veremos a continuación.

Mi configuración

No he personalizado mucho mi configuración de momento, pero quien quiera echarle un vistazo puede hacerlo en mi repositorio dotfiles en GitHub

Archivos de configuración

Para configurar ranger necesitamos editar ciertos archivos, que crearemos por primera vez con el siguiente comando:

$ ranger --copy-config=all

qué nos creara los siguientes archivos por defecto en la carpeta ~/.config/ranger/:

commands.py (python), en este archivo se configuran los comandos a emplear en la línea de comandos de ranger
options.py (python), el fichero de opciones principal de ranger
rc.conf (texto), aquí configuramos los atajos de teclado de ranger
rifle.conf (texto), para establecer los programas que ejecutaran o abrirán un tipo de archivo en orden de preferencia
scope.sh (bash), los programas empleados para previsualizar un determinado tipo de archivo

Adicionalmente, con el uso se añadirán tres ficheros más: bookmarks, history y tagged que guardarán los marcadores, la historia de comandos y las etiquetas respectivamente.

Gestionar la papelera

Por defecto ranger no contempla la gestión de la papelera de Linux que implementan escritorios como Gnome. Aunque no empleo ningún entorno de escritorio ni gestores de archivos gráficos, si me interesa gestionar la papelera, pues cada vez más aplicaciones la emplean para eliminar los archivos. De hecho en bash y zsh tengo un alias para rm que mueve los archivos a la papelera en vez de eliminarlos.

alias rm='mv --target-directory ~/.local/share/Trash/files'

Para gestionar la papelera desde ranger, añado dos atajos de teclado y un comando editando varios archivos de configuración de la siguiente manera:

Mandar archivos a la papelera

Para mandar a la papelera lo que tengamos seleccionado actualmente, en lugar de eliminarlo directamente, añadimos esta línea al fichero rc.conf

# move to trash
map DD shell mv -t ~/.local/share/Trash/files %s

de este modo, cada vez que pulsemos DD el contenido seleccionado es movido al directorio donde tenemos nuestra papelera.

Movernos a la papelera

Del mismo modo que ranger provee por defecto de atajos de teclado para movernos al directorio home, al directorio raiz, etc, he añadido un atajo de teclado siguiendo el mismo criterio para acceder a nuestra papelera. Añadimos lo siguiente al fichero rc.conf

# go to trash
map gp cd ~/.local/share/Trash/files

así, pulsando gp vamos directamente a la papelera, estemos donde estemos.

Vaciar la papelera

Para vaciar la papelera opto por emplear un comando, para ello tenemos que editar otro fichero, commands.py, y añadir lo siguiente

class empty(Command):
    """
    :empty

    Empties the trash directory ~/.local/share/Trash/files

    """

    def execute(self):
        self.fm.run("rm -rf ~/.local/share/Trash/files/{*,.[^.]*}")

por lo que vaciar la papelera se convierte en algo tan simple como teclear :empty o para los más cómodos :em↹

Desmontar una unidad con udiskie

Dada mi "particular" configuración, ya que no empleo ningún escritorio, empleo la herramienta udiskie para automontar unidades de almacenamiento externas, como unidades USB o tarjetas de memoria. El montado se hace de forma automática y solo el desmontado ha de hacerse de forma manual. Ya que no quiero teclear el comando cada vez que desee desmontar una unidad, lo que hago es hacerlo desde ranger. En el fichero rc.conf mapeamos este atajo

# umount a drive with udiskie
map un shell -d udiskie-umount %d/%f

así para desmontar una unidad inicio ranger (en mi caso Win + F1), me dirijo a las unidades externas montadas, gm, selecciono la unidad deseada y la desmonto, un. Un proceso que me lleva apenas dos segundos, sin abandonar las manos del teclado, compárese con hacerlo con un ratón y un entorno gráfico.

Expulsar un CD/DVD

Del mismo modo, en lugar de abrir un terminal y escribir el comando eject, en determinadas circunstancias, por ejemplo al acabar de examinar el contenido de un disco, prefiero hacerlo directamente desde ranger. Para ello en el fichero rc.conf creamos este atajo de teclado

# eject a CD-ROM/DVD
map ej shell -d eject

Trabajar con archivos comprimidos

Estos comandos los he sacado de el Wiki de Arch Linux y los he adaptado a la versión de ranger que estoy empleando en este momento, la 1.5.5

Extraer los ficheros de un archivo comprimido

Con el comando :extracthere extraemos el contenido de un archivo/s comprimido que previamente habremos seleccionado para copia (es decir empleando el atajo yy). El contenido se extrae en el directorio en el que nos encontremos actualmente. Es muy comodo para extraer múltiples archivos comprimidos a la vez, si quisieramos descomprimir solo un archivo y en el mismo directorio en el que este se encuentra, podríamos emplear el atajo 1l

Para añadir el comando a ranger, tenemos que insertar esta clase en el fichero commands.py

class extracthere(Command):
    def execute(self):
        """ Extract copied files to current directory """
        copied_files = tuple(self.fm.env.copy)

        if not copied_files:
            return

        def refresh(_):
            cwd = self.fm.env.get_directory(original_path)
            cwd.load_content()

        one_file = copied_files[0]
        cwd = self.fm.thisdir
        original_path = cwd.path
        au_flags = ['-X', cwd.path]
        au_flags += self.line.split()[1:]
        au_flags += ['-e']
        self.fm.env.copy.clear()
        self.fm.env.cut = False
        if len(copied_files) == 1:
            descr = "extracting: " + os.path.basename(one_file.path)
        else:
            descr = "extracting files from: " + os.path.basename(one_file.dirname)
        obj = CommandLoader(args=['aunpack'] + au_flags \
                + [f.path for f in copied_files], descr=descr)
        obj.signal_bind('after', refresh)
        self.fm.loader.add(obj)

Crear un archivo comprimido

Este comando te permite seleccionar uno o varios ficheros y crear un archivo comprimido al llamar al comando :compress. Este comando te permite (a través del autocompletado) darle un nombre automático a partir del directorio o uno personalizado. Te permite además seleccionar el tipo de compresión en función de la extension empleada.

En el fichero commands.py añadimos el siguiente código.

class compress(Command):
    def execute(self):
        """ Compress marked files to current directory """
        cwd = self.fm.thisdir
        marked_files = cwd.get_selection()

        if not marked_files:
            return

        def refresh(_):
            cwd = self.fm.env.get_directory(original_path)
            cwd.load_content()

        original_path = cwd.path
        parts = self.line.split()
        au_flags = parts[1:]
        descr = "compressing files in: " + os.path.basename(parts[1])
        obj = CommandLoader(args=['apack'] + au_flags + \
                [os.path.relpath(f.path, cwd.path) for f in marked_files], descr=descr)
        obj.signal_bind('after', refresh)
        self.fm.loader.add(obj)

    def tab(self):
        """ Complete with current folder name """
        extension = ['.zip', '.tar.gz', '.rar', '.7z']
        return ['compress ' + os.path.basename(self.fm.thisdir.path) + ext for ext in extension]

Productividad & Linux: Turses

joe di castro — Thu, 21 Jun 2012 22:50:00 +0200

Que medio mundo parece estar conectado a Twitter no es ninguna novedad. Y que si sigues a un buen número de personas, el intentar estar al tanto de todo lo que ocurre es una temeridad, tampoco debería sorprender a nadie. De hecho, dado su éxito y el enorme flujo de información que circula por él, se han desarrollado cientos de herramientas para gestionarlo.

Desde que cree mi cuenta en twitter, he probado unas cuantas, unas veinte (y solo en Linux, en el resto uso la web). La primera, y la elección más obvia ya que por aquel entonces usaba Ubuntu, fue Gwibber . Luego cansado de sus muchos problemas, probé un sinnúmero de aplicaciones, solo merece la pena reseñar una: Hotot. Es la mejor aplicación gráfica para twitter en Linux que conozco.

Pero guiado por el mismo objetivo de mejorar la productividad en mis herramientas habituales de trabajo, me lancé a la búsqueda de un cliente de twitter que encajara en la misma filosofía. No hay muchas alternativas, la mayoría, hay que reconocerlo, son demasiado "crudas" incluso para mí, que soy un amante de la consola. Pero entonces dí con una pequeña joya, Tyrs, desarrollada por Nicolas Paris. Era una herramienta sencilla, pero que cumplía muy bien con todo lo que buscaba de ella. Pero un buen día, Nicolas, en su afán por mejorarla, empezó a reescribir la herramienta empleando una nueva librería para gestionar el interfaz. Las primeras versiones tenían varios fallos y Nicolas pronto se vio desbordado por una tarea que no le apetecía continuar y a la que no podía dedicar más tiempo. Y decidió abandonar el proyecto, con la esperanza de que alguien se atreviera a retomarlo. Cuando leí la entrada de su blog no perdí la esperanza del todo, al fin y al cabo, estaba desarrollado en Python, un lenguaje con el que me desenvuelvo. Mientras esperaba que hacer, seguí usando la última versión estable a diario. Pero entonces, apareció el milagro, Turses

Turses

Alejandro Gómez, un usuario de Tyrs se lanzó a crear su propia aplicación basándose en él. Y no solo garantizaba la continuidad del buen trabajo empezado por Nicolas, si no que llegaba lleno de ideas frescas y muchas ganas de hacerlo bien. El propio Nicolas le felicitó por el trabajo y la iniciativa. A día de hoy, el proyecto se sigue desarrollando, y aunque aún tiene algunas metas marcadas por delante, la aplicación es perfectamente usable en el día a día, de hecho es mi cliente habitual.

Como ya se habrá podido deducir, Turses es un cliente de twitter para la consola con interfaz ncurses. Está desarrollado en Python y emplea la librería Urwid para crear la interfaz en curses. Lo mejor de esta aplicación es que emplea atajos de teclado inspirados en Vim y es totalmente controlable desde el teclado. Esto unido a que emplea una interfaz basada en texto, la convierten en la aplicación más ágil de todas las que haya probado. Hotot también tiene algunas combinaciones de teclas muy útiles, pero ni se acercan a lo que Turses te permite.

Aquí se puede ver el aspecto por defecto de Turses

Pero no se acaban ahí las bondades de Turses, tiene algunas características geniales como la gestión dinámica de bufferes (líneas temporales) y de columnas. Demos un repaso a lo que nos permite la aplicación:

Múltiples líneas temporales (bufferes). Es decir, nos permite consultar los tweets de la gente a la que seguimos, los nuestros, menciones, etc. Es decir, los bufferes habituales, incluidos conversaciones, búsquedas y hashtags. Y podemos tenerlas simultáneamente abiertas y navegar entre ellas muy fácilmente.
Múltiples columnas. En cada columna se sitúa un buffer, y podemos añadir o quitar columnas a voluntad de forma muy sencilla. Es decir, que podemos visualizar un solo buffer de forma predefinida, o podemos ver varios a la vez distribuidos en múltiples columnas.
Tweet, Reply, Retweet, Borrar. Vamos, que permite las operaciones habituales con los tweets. Además se puede hacer un Retweet editando el texto, algo que parece obvio, pero que en algunas aplicaciones no es tan sencillo.
Seguir/dejar de seguir a un usuario. Podemos hacerlo bien a través de un tweet o bien introduciendo el nombre del usuario.
Des/Marcar como favorito.
Enviar mensajes directos.
Abrir URLs en un navegador. Nos permite abrir las direcciones que aparecen en un tweet, así como abrir el propio tweet.
Visualizar conversaciones. Podemos abrir un nuevo buffer con la conversación relacionada con un tweet.
Contador de los no leídos funciona para todos los bufferes y nos permite ponerlo a cero manualmente cuando queremos ignorar algunos no leídos.
Búsqueda. Se puede buscar tanto por usuario como por termino.
Ver los tweets de cualquier usuario .
Visualizar el perfil de un usuario.
Totalmente personalizable y la configuración se guarda en un fichero de texto plano.
Múltiples cuentas, eso sí, una por ejecución.
Ayuda en línea con todas las combinaciones de teclas posibles. Accesible a través de la tecla ?

Interfaz de Turses mostrando múltiples columnas

Y entre las metas que tiene marcadas su autor, nos encontramos con el soporte para listas, streaming, notificaciones emergentes y múltiples sesiones. Estoy seguro de que las acabará incorporando, le sobra capacidad. Aunque he de reseñar que actualmente he contribuido con una porción de código minúscula al proyecto y que tengo la intención de seguir colaborando en todo lo que pueda. Si eres programador Python y te apetece echar una mano, anímate, Alejandro es muy receptivo y un tío muy majo que estará encantado con toda la ayuda que le podamos dar.

Mi configuración

Si a alguien le puede servir como inspiración mi configuración, esta disponible en GitHub

Turses mostrando la información del perfil del autor de un tweet

Alternativas

Solo conozco dos alternativas en la misma línea que merezca la pena reseñar, las demás que he probado no estaban a la altura:

TwitVim, es un plugin para Vim. Funciona fantásticamente bien, eso sí, solo apropiado para usuarios de Vim. La probé un tiempo y me gusto, pero personalmente no me gusta emplear Vim para esta tarea y Turses es bastante más manejable.
TTYtter, está escrito en Perl y no tiene interfaz. Trabaja en la línea de comandos a modo de interprete. Funciona muy bien y también lo usé un tiempo, pero su propio funcionamiento le reste eficiencia comparado con Turses.

Productividad & Linux: Newsbeuter

joe di castro — Mon, 18 Jun 2012 23:26:00 +0200

Uno de los pilares de la productividad es, como no, la gestión del tiempo. Otro de los pilares fundamentales es, inexorablemente, el conocimiento. Si pierdes el tiempo en tareas irrelevantes (o directamente procrastinando), tu productividad se resiente irremediablemente. Si no tiene los conocimientos adecuados y suficientes, consumes el tiempo aprendiendo a hacerlo o directamente lo pierdes haciéndolo mal. Hoy en día, rara es la actividad donde la formación continua no sea un requisito indispensable, no ya para mejorar o mantener tu rendimiento, si no simplemente para poder seguir ejerciéndola.

Por lo tanto nos vemos condenados a intentar mantenernos al día (y ampliar conocimientos), mientras que procuramos dedicarle el menor tiempo posible para no menoscabar nuestro rendimiento. Tal delicado equilibrio no es poca hazaña en nuestros días. Nos vemos inundados de tal cantidad de información, que el filtrado es la única manera de intentar sobrevivir a esa enorme vorágine de datos a la que nos enfrentamos. Afortunadamente tenemos herramientas. Desde hace muchos años he confiado esta tarea a emplear fuentes RSS de calidad y una buena herramienta para gestionarlas.

Mi búsqueda del cliente RSS ideal

He empleado muchas herramientas distintas para esta tarea, siempre intentando tener la más idónea para filtrar muchas fuentes RSS en el menor tiempo posible, sin pasar por alto lo que me interesa conocer. Algunas muy buenas, que usaba cuando aún empleaba Windows como SO principal, ya no existen. En Linux he pasado por las más conocidas (en orden cronológico):

Liferea, era muy buena cuando la deje, lo de mostrar los comentarios en las entradas es algo que no he vuelto a ver en ninguna otra herramienta. Pero después de varios años de uso, la abandoné cuando se había convertido en insufriblemente lenta.
Akregator, no era para mí, nunca acabe encontrándome a gusto con ella. Lo hacía todo medianamente bien, pero no destacaba en nada, pronto la abandoné.
Blogbride, su planteamiento es diferente al resto. Es una buena aplicación y estuve con ella muchos meses. Pero siempre seguí buscando algo más eficiente.
RSSOwl, la mejor aplicación para leer RSS para escritorio que he conocido. La he usado durante años. Está construida sobre Eclipse. Ofrece muchas posibilidades de personalización y filtrado. Es muy rápida, pero debido a que depende de Eclipse y java, si manejas un número considerable de fuentes (+1000 en aquella época), se puede volver un poco pesada. Además, si como yo, dejabas muchos artículos para leer en otro momento, la base de datos crecía de tal manera, que podía llegar a ser muy lenta. La abandoné buscando algo aún más ágil y productivo.
Google Reader, decidí darle una oportunidad. Por aquella época había empezado a usar Read it Later (hoy Pocket) para guardar aquello que quería leer en otro momento o con más calma. La integración con RIL me obligaba a abandonar el teclado y usar el ratón. Además el rediseño que hizo Google no me convencía. Decidí buscar algo aún más rápido y eficiente.

Durante todo ese tiempo probé muchísimas otras alternativas (incluidos complementos para navegadores web) y no encontraba nada que me valiese. Es muy difícil encontrar una aplicación de este tipo que te permita manejar un gran número de fuentes RSS de forma realmente eficiente. Al final ya estaba decidido a regresar a RSSOwl. Pero acostumbrado a Pentadactyl y Vim y las aplicaciones ncurses, decidí buscar algo en esa línea, y lo encontré.

Newsbeuter

Newsbeuter es un juego de palabras con la palabra alemana "Wildbeuter" que significa cazador-recolector, por lo que Newsbeuter vendría a ser algo así como Cazador/Recolector de Noticias. Newsbeuter es una aplicación para leer fuentes RSS y Atom que utiliza una interfaz tipo ncurses para consola. Quién esté familiarizado con el cliente de correo Mutt se sentirá cómodo enseguida, ya que se inspira en este. Está programado en C++ y dado que funciona en modo texto, una de sus ventajas es la enorme agilidad que proporciona para moverse entre fuentes y noticias.

Un resumen de sus características:

Permite suscribirnos a fuentes RSS y Atom
Soporta OPML tanto para importar como para exportar las subscripciones
Descarga de podcasts
Se pueden configurar todos los atajos de teclado libremente
Podemos realizar búsquedas entre todos los artículos descargados. Similar a Vim
Es posible crear etiquetas para dividir nuestras subscripciones en categorías y realizar filtrados y búsquedas en función a ellas
Se pueden sincronizar las fuentes con Google Reader y Tiny Tiny RSS
Podemos configurar el color y las cadenas de texto para personalizar su aspecto
Se pueden eliminar de forma automática artículos que no deseemos a través de un "killfile"
Es posible integrar cualquier fuente de datos a través de un flexible sistema de filtros y plugins: Fichero con urls, fichero OPML, fichero OPML online, Google Reader, varios ficheros...
Se pueden crear "meta fuentes" empleando un potente lenguaje de consultas
Permite crear marcadores a partir de cualquier enlace del articulo empleando una aplicación externa o un script
Permite guardar artículos en texto plano
Podemos otorgar etiquetas de un solo carácter que el autor denomina "flags" por articulo y varias por articulo. Útiles para emplearlas conjuntamente con los filtros
Se pueden definir macros
Linea de comandos para poder ejecutar comandos y cambiar opciones sobre la marcha
Funciona en Linux, Mac OS y FreeBSD
Programado en C++ y guarda los artículos en una BDD SQLite
Documentación bastante completa

Pantalla con la configuración por defecto de Newsbeuter

Lo que lo distingue

Muchas de estas características las comparte con otras aplicaciones de las mencionadas antes, pero lo que realmente distingue a Newsbeuter de todas ellas es lo siguiente:

Totalmente controlable desde el teclado, lo que unido a su velocidad, le proporciona una agilidad inigualable.
Basado en texto, lo que nos evita distraernos de lo importante, el contenido.
Consumo ridículo de memoria y recursos comparado con cualquiera aplicación mencionada antes. En el peor de los casos, me ha consumido unos 30 MiB de RAM (para la versión de 64 bits)
Se puede configurar el números de hilos de proceso para descargar noticias. En mi caso, con 8 hilos, tarda unos 40s en leer unos 250 canales RSS. Solo Google Reader por su funcionamiento, puede mejorar esto.
Configurable con un fichero de texto plano

Como dijo Zed Shaw y refrenda el autor de la aplicación, Andreas Krennmair,

"Newsbeuter es el Mutt de los lectores de noticias RSS"

Desde mi propia experiencia puedo decir que este programa ha cambiado mi forma de leer las noticias del día. Antes, para mi, era muy importante que el lector de noticias que empleara, utilizara un estilo homogéneo entre todas las fuentes y artículos, con el fin de centrarme en el contenido y no perder el tiempo con nimiedades. Es algo más importante de lo que pueda parecer a simple vista, cuando quieres emplear el menor tiempo posible en adquirir la información y al mismo tiempo quieres asimilar lo que lees. Si cuando vas a leer las noticias tienes 45 minutos y 300 artículos sin leer, el cambiar de un articulo con fondo negro y letra Sans Serif mediana a uno con fondo blanco y letra Serif enorme, te supone una distracción y una adaptación de la vista innecesarias e incomodas.

Vista de un articulo con mi configuración

Pero al comenzar a emplear Newsbeuter me di enseguida cuenta de algo, el carecer por completo de imágenes y compartir cabecera entre todos los artículos, me ha servido para pasar por alto o leer en diagonal aquello que menos me interesa. No solo filtro más rápido, si no que lo hago más eficientemente. Evidentemente hay artículos en los que las imágenes complementan necesariamente al articulo. En estos casos o bien la abro directamente en el navegador (tan sencillo como pulsar o ) o bien puedo abrir las imágenes de forma independiente en el mismo si me interesa por ejemplo ver solo una. En este sentido, Newsbeuter proporciona una lista de todas las Urls presentes en el articulo en forma de lista al final del mismo, pudiendo abrir cualquiera de ellas introduciendo el indice de la misma. De hecho, empleando el comando u podemos acceder a la lista completa de las mimas en una nueva ventana.

Mi configuración

Mi configuración no tiene demasiado de especial, quizás que emplea una combinación de colores distinta a la habitual y que empleo un par de scripts para las notificaciones y para crear marcadores. Esta se puede encontrar en mi repositorio de mis dotfiles en GitHub

Notificaciones

Para las notificaciones que emite Newsbeuter después de refrescar las noticias empleo el script notify.py que comentaba en este articulo ligeramente modificado para trabajar con Newsbeuter. En la imagen se puede ver una notificación del programa.

try:
    import os
    import sys
    import gtk
    import pynotify
    import textwrap
    NOT_NOTIFY = False
except ImportError:
    NOT_NOTIFY = True

def notify(title, msg, icon=None, wrap=None):
    """Send notification icon messages through libnotify.

    Parameters:

    (str) title -- The notification title
    (str) msg -- The message to display into notification
    (str / uri) icon -- Type of icon (ok|info|error|warm|ask|sync) or icon file

    """
    if NOT_NOTIFY:
        return
    if not pynotify.is_initted():
        pynotify.init(title)
    gtk_icon = {'ok': gtk.STOCK_YES,
                'info': gtk.STOCK_DIALOG_INFO,
                'error': gtk.STOCK_DIALOG_ERROR,
                'warm': gtk.STOCK_DIALOG_WARNING,
                'ask': gtk.STOCK_DIALOG_QUESTION,
                'sync': gtk.STOCK_JUMP_TO}
    if wrap:
        msg = os.linesep.join(textwrap.wrap(msg, wrap))
    try:
        note = pynotify.Notification(title, msg)
        helper = gtk.Button()
        gtk_icon = helper.render_icon(gtk_icon[icon], gtk.ICON_SIZE_BUTTON)
        note.set_icon_from_pixbuf(gtk_icon)
    except KeyError:
        note = pynotify.Notification(title, msg, icon)
    note.show()

def main():
    """Main section"""
    notify('Newsbeuter', sys.argv[1], '/home/joedicastro/.newsbeuter/icon.png')

if __name__ == "__main__":
    main()

Integración con Pocket

Utilizo Pocket como nexo de unión entre el navegador y el Newsbeuter para archivar todos aquello artículos que me interesa leer, pero que quiero dejar para otro momento más idóneo. Hubo un tiempo en que empleaba Delicious para esta tarea, pero me parece más adecuado Pocket.

Esto lo consigo empleando el comando para crear marcadores de Newsbeuter y un script en Python creado para ello. Esta es la parte del archivo de configuración que relaciona el comando con el script:

bookmark-cmd                            "~/.newsbeuter/send2ril.py"

El script hace uso de la API Python para Read it Later (como se llamaba anteriormente Pocket) para guardar la url del articulo en mi cuenta de Pocket. Así pulsando Ctrl + b se guarda el marcador en Pocket.

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    send2ril.py: Send a new url to Read it Later
"""

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "18/06/2012"
__version__ = "0.1"

import sys
import readitlater
import ril_config as config

def main():
    """Main section"""
    api = readitlater.API(config.RIL_APIKEY, config.RIL_USERNAME,
                          config.RIL_PASSWORD)

    new = [{"url":sys.argv[1], "title":sys.argv[2]}]
    api.send(new=new)

if __name__ == "__main__":
    main()

En el script se importa un modulo, ril_config, que es el que contiene las claves de mi cuenta de Pocket, este modulo sería algo similar a esto (evidentemente los valores son falsos):

# ril credentials
RIL_APIKEY = '987u1ksjsdfRk54kKLKL34jkjij9945k'
RIL_USERNAME = 'usuario'
RIL_PASSWORD = 'ADRKSD-Xk3kj5kjljFl'

Por lo tanto para hacerlo funcionar necesitamos crear un fichero ril_config.py con las credenciales de cada uno para Pocket. Los campos RIL_USERNAME y RIL_PASSWORD se corresponden evidentemente con el usuario y la contraseña que tengamos para el servicio. El otro campo, RIL_APIKEY es una clave que podemos obtener en esta página para registrar nuestra aplicación (en este caso nuestro script) y que pueda acceder de forma autorizada a la API de Pocket.

Copia de seguridad de las urls de Pocket

Del mismo modo, aprovechando la misma API que empleo en el anterior script, he creado otro script que ejecuto regularmente con cron, que me guarda una copia en mi disco duro con todas las urls que tengo guardadas en Pocket. Vamos, una copia de seguridad, uno nunca sabe cuando este tipo de servicios pueden dejar de funcionar. Estas direcciones las guardo en un fichero con formato Org-mode

#!/usr/bin/env python
# -*- coding: utf8 -*-

"""
    get.py: Get the urls stored in Read it Later & save them in a Org-mode file
"""

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "18/06/2012"
__version__ = "0.1"

try:
    import sys
    import os
    import readitlater
    import ril_config as config
except ImportError:
    # Checks the installation of the necessary python modules
    print((os.linesep * 2).join(["An error found importing one module:",
    str(sys.exc_info()[1]), "You need to install it", "Stopping..."]))
    sys.exit(-2)
import os

def main():
    """Main section"""
    api = readitlater.API(config.RIL_APIKEY, config.RIL_USERNAME,
                          config.RIL_PASSWORD)

    items = api.get(state="unread")
    lista = items["list"]
    with open("ril_urls.org", "w") as output:
        output.write("* Read It Later URLs" + os.linesep)
        for i, k in lista.items():
            output.write("** {0}{1}".format(k['title'].encode("utf8"),
                        os.linesep))
            output.write("   [[{0}][Enlace]]{1}{1}".format(k['url'].
                        encode("utf8"), os.linesep))

if __name__ == "__main__":
    main()

Conclusión

Newsbeuter no es para todo el mundo, por supuesto, la gran mayoría considerarían decimonónico el emplear un interfaz de texto en vez de uno gráfico. Muchos incluso llamarían herejía a usar el teclado en vez de el ratón (aunque luego se vuelvan locos con las pantallas táctiles). Lo respeto y lo entiendo, pero para aquellos que aman su tiempo y no están dispuestos a desperdiciarlo, deberían darle una oportunidad a esta aplicación.