joe di castro

Productividad & Linux: Aplicaciones

2012-06-07T22:40:00+02:00

En la anterior serie de artículos sobre Productividad en el escritorio Linux, hacia referencia a los lanzadores de aplicaciones y a los gestores de ventanas de mosaico como elementos diferenciadores a la hora de ser más productivos. Aunque la productividad en el escritorio es fundamental para trabajar de forma más eficiente, son las aplicaciones que empleamos, las que en último lugar, determinaran la realidad de nuestro día a día frente a la pantalla.

Gran parte de las aplicaciones para Linux (las más conocidas y extendidas) son realmente una adaptación de los conceptos de los sistemas operativos más difundidos: Windows & Mac OS. Esto es, aplicaciones muy pesadas, repletas de opciones y funciones de las que se aprovechan en realidad muy pocas. Además están por lo general fuertemente orientadas al empleo del ratón y muchas veces con un interfaz gráfico muy agradable visualmente pero con un concepto de usabilidad, en mi opinión, no siempre bien enfocado.

La usabilidad mal entendida, como enemiga de la productividad

La usabilidad, ese concepto tan de moda últimamente, está desde mi punto de vista, frecuentemente muy mal enfocado. Dejando a un lado lo que teóricamente se pretende, en el 80% de las ocasiones esto se traduce en la práctica en dos palabras en ingles: For dummies ("pá tontos", en castizo). Es decir, que cualquiera pueda manejar la aplicación sin grandes dificultades y en el menor tiempo posible. Reducir las barreras de entrada está muy bien, pero desgraciadamente muchas veces esto es una estrategia a corto plazo que no debería emplearse NUNCA de este modo en aplicaciones profesionales. Entiendo, y además apoyo, está estrategia en aplicaciones web y aplicaciones de consumo, pero lo veo nocivo a la hora de aplicaciones destinadas a producir datos y contenidos de forma masiva e intensiva. Y a mi modo de ver es un problema serio en un gran número de escenarios.

Un caso real de usabilidad engañosa

No proporcionare datos reales por respeto a las partes implicadas, pero quiero aportar aquí un ejemplo real que he podido vivir de cerca durante varios años, de lo que la pretendida usabilidad, ni lo es, ni ayuda a sacar más partido de las herramientas:

Escenario fallido : un negocio que se dedica el 90% del tiempo a editar grandes cantidades de texto. Se informatizan a mediados de los 80 y adoptan como procesador de textos WordPerfect para consola. Después de varios años, están en la versión de WordPerfect 5.1 para MSDOS con un 90% de los empleados (unos diez), con un dominio asombroso de la aplicación, basando todo su trabajo en atajos de teclado y una pantalla donde únicamente se visualiza el texto sobre el que están trabajando. Productividad: realmente elevada. Principios del siglo XXI, un consultor informático embaucador (aka comercial) los convence de que el futuro es WYSIWYG y que eso del terminal de texto es cosa del pasado. Tras una primera migración a WordPerfect para Windows, la productividad baja de forma significativa. La solución propuesta: Word, la productividad cae de forma dramática. La excusa del "asesor": necesidad de adaptación al nuevo concepto. Dos años después, la productividad sigue sin incrementarse, el trabajo se acumula y se contratan a dos personas más para refuerzo. El personal ya se ha adaptado y están tan hipnotizados por el ratón, los iconos y los "regalitos" que su software les proporciona en cada nueva versión, que se oponen radicalmente a volver al "pasado". En realidad, nadie desde dentro se cuestionaba que el problema real era que habían dejado de centrarse en el contenido, para centrarse en el continente. Lo más irónico: lo que realmente hacían era crear e imprimir documentos, impresos en impresoras matriciales que seguían imprimiendo con la misma calidad y la misma fuente Courier 11 sobre el mismo tipo de documentos oficiales.

Escenario exitoso : Paralelamente, en un área de negocio distinta, pero estrechamente relacionada con la anterior, una empresa que ha trabajado siempre en entorno de terminal contra un AS/400, presentaba una mentalidad y un resultado totalmente opuestos. Nunca se han dejado seducir por los cantos de sirena del marketing y se han opuesto radicalmente a cualquier cambio de sistema, simplemente han evolucionado el que ya tenían y conservando su plantilla prácticamente intacta durante el mismo periodo. El resultado: la productividad se ha mantenido constante a lo largo de los años y han podido asumir importantes picos de carga de trabajo sin demasiadas dificultades. Y un efecto secundario de esta toma de decisiones: el haberse mantenido dentro de un sistema maduro y estable les ha librado de un mantenimiento casi nulo en el área de software, limitándose el mismo al área de hardware (lo habitual). Como podéis imaginar, en un sistema basado en plataforma Windows y actualizaciones sucesivas de SO y aplicaciones, el mantenimiento del área de software les ha supuesto una importante carga económica al otro negocio.

Que cada uno extraiga sus propias conclusiones. La mía: que la carrera hacia adelante de fabricantes de sistemas operativos y aplicaciones (cuyo único recurso para seguir vendiendo ha sido con frecuencia un simple lavado de cara) ha supuesto, en muchos aspectos, un paso atrás en varias áreas de la informática.

La usabilidad bien entendida

No quiero decir con lo anterior, que las aplicaciones gráficas sean el problema ni mucho menos. De hecho, hay aplicaciones gráficas que son una maravilla de la usabilidad. Por ejemplo, Autocad, que te permite un control casi absoluto como usuario avanzado (con los comandos y AutoLISP) y que al mismo tiempo te permite realizar gran parte del trabajo de manera muy intuitiva (siempre teniendo en cuenta el contexto del usuario al que va dirigido) empleando la interfaz gráfica. Lo que permite que sea muy usable sin detrimento de la productividad. Lo que quiero decir, es que es necesario añadir el sentido común como un criterio más, si no el primero, a la hora de implementar la usabilidad.

Si consultamos la Wikipedia, encontramos dos definiciones de la ISO para el concepto de usabilidad :

La usabilidad se refiere a la capacidad de un software de ser comprendido, aprendido, usado y ser atractivo para el usuario, en condiciones específicas de uso

Usabilidad es la eficacia, eficiencia y satisfacción con la que un producto permite alcanzar objetivos específicos a usuarios específicos en un contexto de uso específico

Como decía anteriormente, la realidad dista mucho de la teoría. En la práctica se ha adoptado con bastante fidelidad la primera definición, eso sí, ignorando con bastante frecuencia la parte de "condiciones específicas" y la segunda definición parece haber sido ampliamente ignorada.

Si bien es cierto que la mayoría de las aplicaciones actuales pueden ser muy potentes, lo que yo veo mirando al pasado, es que la gran mayoría de los empleados que utilizaban una aplicación a diario eran usuarios avanzados y cuando no expertos. Hoy en día, y ciñéndonos al ámbito profesional, a algunos les cambias el icono de la misma, y no saben iniciarla. Y no es culpa de ellos, las aplicaciones se diseñan para que las puedan usar hasta los más reacios a la tecnología (siempre en su contexto), pero una vez que necesitas realizar algo complejo, existe un salto conceptual que la mayoría de los usuarios, ni se atreven a dar, ni quieren darlo.

Es realmente complejo, muy complejo, conseguir una interfaz de usuario que sea realmente amigable e intuitiva y que al mismo tiempo consiga satisfacer las necesidades reales tanto del usuario profesional, como del usuario ocasional. El problema de base está en intentar crear herramientas todoterreno. Ni maldita falta que le hace un Word actual a un usuario domestico y que demonios hace un escritor profesional empleándolo en vez de algo como Latex + editor de texto. Ni un usuario domestico necesita de herramientas para correspondencia, programar macros, etc, ni un escritor necesita preocuparse del formato del texto. Y sin embargo es empleado hasta por editores que deberían estar empleando herramientas de autoedición.

Por ejemplo, una aplicación que es un claro ejemplo de buena usabilidad y que está teniendo una buena acogida últimamente, es Sublime Text. Es bonita, es potente, es amigable y es francamente muy, muy usable. Realmente lo que han hecho ha sido recoger el testigo que dejo TextMate, que fueron los primeros en darse cuenta de algo muy sencillo. Esto es, los editores de texto y los IDEs para programadores son una de las aplicaciones en las que nunca llueve a gusto de todos, surgen continuamente nuevas alternativas, pero no se acaba por imponer ninguna. Por que en realidad, si nos fijamos en los programadores más experimentados, dos de los editores más utilizados y defendidos a muerte, son Vim y Emacs, ambos basados en conceptos de hace casi cuatro décadas. Es que la usabilidad ya estaba inventada hace mucho tiempo, y no tiene nada que ver ni con gráficos bonitos, ni con tratar a los usuarios como imbéciles. La usabilidad, señores, está en la adaptación del interfaz del ordenador de la manera más optima posible al interfaz que la naturaleza nos dio, nuestras manos. Y desde luego, jamás un ratón, con los botones que quieras ponerle, sera más eficaz que un teclado (usado con los diez deditos), al igual que no lo es más que un bolígrafo o una tableta gráfica con lápiz. Que para eso tenemos los dedos y no muñones. Si vamos a comprar un libro en Internet, el ratón es nuestro gran aliado para hacerlo de forma intuitiva sin conocimientos previos, pero si me vas a obligar a introducir entradas de almacén 40 horas a la semana con la misma aplicación, por favor, no me condenes a usar el ratón cada dos pasos. Sentido común!

Las aplicaciones amigas de la productividad

Este entrada pretende ser la introducción y el indice de una nueva serie de artículos dedicada a esas aplicaciones para Linux que para mi marcan la diferencia entre hacer el trabajo y marear la perdiz. Estas aplicaciones comparten en general tres puntos en común:

Son muy eficientes y ayudan a incrementar nuestra productividad.
Realizan a una sola tarea y lo hacen bien o muy bien.
No están muy extendidas.

Iré actualizando la entrada a medida que vaya creando los artículos para cada aplicación.

Aplicaciones

Estas son algunas de las aplicaciones que yo empleo a menudo y que al igual que a mí, pueden servirte para incrementar de forma notable tu productividad.

Pentadactyl, complemento para Firefox para controlar el navegador completamente desde el teclado, permite navegar entre las páginas a velocidad de vértigo. Además es muy potente y posee muchísimas opciones y posibilidades.
Newsbeuter, aplicación para leer subscripciones RSS y Atom. Funciona en modo texto, con una interfaz tipo ncurses y completamente controlable desde el teclado. Es una aplicación rapidisima y con un consumo muy escaso de recursos.
Turses, cliente twitter para la consola con interfaz ncurses. Controlable desde el teclado con atajos basados en Vim. Muy personalizable y con un funcionamiento muy versátil y ágil.
tmux, es un multiplexor de terminales. Permite agrupar varios terminales en una sola ventana de forma muy eficiente. La herramienta ideal para los amantes de la consola, desarrolladores y administradores de sistemas.
zathura, es un visor de documentos minimalista y controlable desde el teclado. Soporta documentos en formato PDF, DJVU, PostScript y Comic Book.
Ranger, es un administrador de archivos en modo texto y revolucionario en su interfaz y manejo. Muy potente y personalizable.
Ncdu, una herramienta con interfaz ncurses que nos permite conocer el espacio consumido en nuestro disco duro y navegar por los distintos directorios. La mejor herramienta del estilo que existe para la consola.

Logger, informes legibles para tus scripts Python

2011-05-07T23:02:00+02:00

Normalmente los scripts que se crean para ser ejecutados periódicamente, como los de administración de sistemas, realizan tareas que generan cambios que queremos conocer. Esta información se suele guardar en logs o se envía por correo a una dirección de email. Hay muchas formas de generar estos logs, pero normalmente es una simple salida de texto plano en consola, que no suele tener una presentación muy "amigable" o legible. Cuando tienes una cantidad generosa de estos scripts, los recibes por correo electrónico y con una frecuencia diaria o mayor, lo que menos deseas es andar buscando la información entre lineas de texto plano. Lo que yo quiero es poder identificar la información rápidamente de un vistazo, además tenía una idea rondando por la cabeza, que seria aún más cómodo si todos emplearan un formato similar. Con estas premisas cree un módulo Python, logger.py, que empleo en muchos de mis scripts en Python y que me permite analizar adecuadamente la información que me interesa.

Un ejemplo de informe generado por este modulo Python sería el siguiente (el mismo que se generaría si ejecutáramos el modulo como script):

SCRIPT =========================================================================
logger (ver. 0.3)
http://joedicastro.com

This is a test of class Logger
================================================================================

START TIME =====================================================================
                                                     Saturday 05/07/11, 21:51:27
================================================================================

BLOCK ==========================================================================
This
is
a
sample
of
Logger.block()
================================================================================

LIST ___________________________________________________________________________

This
is
a
sample
of
Logger.list()

This a sample of logger.free() text.

"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque sed
tortor eget justo vehicula consequat vel eu quam. Suspendisse non lectus eget
orci varius adipiscing."

END TIME =======================================================================
                                                     Saturday 05/07/11, 21:51:27
================================================================================

Este modulo contiene una clase, Logger(), que dispone de una serie de métodos que nos permiten diversas tareas, supongamos que tenemos un objeto log de la clase Logger():

log.header(url, msg)

Nos crea una cabecera para el script que nos aporta cierta información que nos sirve para identificar el mismo y el contexto en el que se ejecuta.

SCRIPT =========================================================================
nombre del script (versión)
http://miweb.com/script

mensaje que nos informa de la finalidad del mismo o de 
información dependiente del contexto. Totalmente 
personalizable.
================================================================================

log.time(title)

Nos permite registrar el tiempo de un evento. Normalmente lo empleo para registrar el comienzo y el final de la ejecución del script.

TITULO =========================================================================
                                                       Sábado 07/05/11, 22:18:27
================================================================================

log.block(title, content)

Crea un bloque de texto con titulo y enmarcado por líneas compuestas por el carácter =. Entre esas lineas y el contenido no hay ninguna linea en blanco. Es útil para destacar cierto contenido del resto de forma muy notable, suelo utilizarlo para ubicar el script en su contexto.
```
TITULO =========================================================================
contenido
sigue el contenido
...
================================================================================
```
log.list(title, content)

Como su nombre bien indica, es una lista de líneas con un simple encabezado que lo distinga del resto. Suelo emplearlo para volcar la información generada por el script. Entre el encabezado y la primera línea de texto existe una línea en blanco.
```
TITULO __________________________________________________

Primera línea del contenido
Segunda línea del contenido
...
```
log.free(content)

Texto libre, párrafos que se mostrarán tal y como son, sin formato ni cabecera alguna. Raramente lo empleo, pero es útil por ejemplo para introducir comentarios, licencias, etc.
log.send(subject, send_from='', dest_to='', mail_server='localhost', server_user='', server_pass='')

El meollo del script. Se emplea para mandar el resultado por correo electrónico. Si solo especificamos el asunto, empleará nuestro servidor de correo local para mandar el informe al buzón local del usuario que programó/ejecuto el script. Pero se pueden especificar tanto el empleo de un servidor de correo (SMTP) distinto como otro (o varios) destinatario(s) en particular.
log.write(append=False)

Escribe el resultado del log en un fichero de texto. El nombre de este fichero estará compuesto por el nombre del script sin extensión, más la extensión .log. Si append es True entonces añadirá el resultado al final de texto, si no, lo reescribirá en cada ejecución guardando únicamente el último informe.
log.get()

Nos devuelve el contenido del log. Es útil cuando estamos con tareas de depurado, con un print llamando a este método podemos volcar en la consola la información registrada en el log.

El código del script es el siguiente:

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

"""
    logger.py: Create a log object to log script messages in a elegant way
"""

#===============================================================================
# This module create a log object to log script messages in a elegant way
#===============================================================================

#===============================================================================
#    Copyright 2010 joe di castro <joe@joedicastro.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#===============================================================================

__author__ = "joe di castro <joe@joedicastro.com>"
__license__ = "GNU General Public License version 3"
__date__ = "10/09/2010"
__version__ = "0.3"

try:
    import sys
    import os
    import time
    import smtplib
    import socket
    from email.mime.text import MIMEText
    from email.mime.multipart import MIMEMultipart
    from email.utils import COMMASPACE, formatdate
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)

class Logger():
    """

    Create a log object to log script messages.

    These messages can be sended via email or writed in a log file

    """

    def __init__(self):
        """Create the object Logger itself and set various attributes.

        These attributes are about the python file wich invokes this module:

        __script_vers = The version of python file which invokes this module
        __script_name = The name of the python file which invokes this module
        filename = the log file's name

        """
        from __main__ import __dict__ as __dict
        self.__log = ''
        if '__version__' in __dict.keys():
            self.__script_vers = __dict['__version__']
        else:
            self.__script_vers = 'Unknown'
        self.__script_name = os.path.basename(__dict['__file__']).split('.')[0]
        self.filename = '{0}.log'.format(self.__script_name)

    def __len__(self):
        return len(self.__log)

    def __format__(self, tit, cont, decor):
        """Format a block or a list of lines to enhance comprehension.

        (str) tit -- title for the block or list
        (str or iterable) cont -- line/s for the list/block content
        ('=' or '_') decor - define if it's list or block and decorate it

        make the looks of self.block() and self.list()

        """
        ending = {'=':'', '_':os.linesep}[decor]
        end = {'=': '=' * 80, '_':''}[decor]
        begin = ' '.join([tit.upper(), (80 - (len(tit) + 1)) * decor]) + ending
        cont = [cont] if isinstance(cont, str) else cont
        sep = os.linesep
        self.__log += sep.join([begin, sep.join(cont), end, sep])

    def block(self, title, content):
        """A block of text lines headed and followed by a line full of '='.

        (str) title -- The title that start the first line of '='
        (str or iterable) content -- The line/s between the '=' lines

        There's not any empty line between the '=' lines and content, e.g.:

        TITLE ==================================================
        content
        ========================================================

        """
        if content:
            self.__format__(title, content, '=')

    def list(self, title, content):
        """A list of text lines headed by a line full of '_'.

        (str) title -- The title that start the line of '_'
        (str or iterable) content -- The line/s after the '_' line

        After the '_' line is a empty line between it and the content, e.g.:

        TITLE __________________________________________________

        content

        """
        if content:
            self.__format__(title, content, '_')

    def free(self, content):
        """Free text unformatted.

        (str) content -- Text free formated

        """
        if isinstance(content, str):
            self.__log += content + os.linesep * 2

    def time(self, title):
        """A self.block() formated line with current time and date.

        (str) title -- Title for self.block()

        Looks like this, the data and time are right-justified:

        TITLE ==================================================
                                       Friday 09/10/10, 20:01:39
        ========================================================

        """
        self.block(title, '{0:>80}'.format(time.strftime('%A %x, %X')))

    def header(self, url, msg):
        """A self.block() formated header for the log info.

        (str) url -- The url of the script
        (str) msg -- Message to show into the header. To Provide any useful info

        It looks like this:

        SCRIPT =================================================
        script name and version
        url

        msg
        ========================================================

        """
        script = '{0} (ver. {1})'.format(self.__script_name, self.__script_vers)
        self.block('Script', [script, url, '', msg])

    def get(self):
        """Get the log content."""
        return self.__log

    def send(self, subject, send_from='', dest_to='', mail_server='localhost',
             server_user='', server_pass=''):
        """Send a email with the log.

        Arguments:
            (str) send_from -- a sender's email address (default '')
            (str or list) dest_to -- a list of receivers' email addresses ('')
            (str) subject -- the mail's subject
            (str) mail_server -- the smtp server (default 'localhost')
            (str) server_user -- the smtp server user (default '')
            (str) server_pass --the smtp server password (default '')

        If 'send_from' or 'dest_to' are empty or None, then script user's
        mailbox is assumed instead. Useful for loggin scripts

        """
        local_email = '@'.join([os.getenv('LOGNAME'), socket.gethostname()])
        if not send_from:
            send_from = local_email
        if not dest_to:
            dest_to = [local_email]

        dest_to_addrs = COMMASPACE.join(dest_to) # receivers mails
        message = MIMEMultipart()
        message['Subject'] = '{0} - {1}'.format(subject,
                                                time.strftime('%A %x, %X'))
        message['From'] = send_from
        message['To'] = dest_to_addrs
        message['Date'] = formatdate(localtime=True)
        message.preamble = "You'll not see this in a MIME-aware mail reader.\n"
        message.attach(MIMEText(self.__log))

        # initialize the mail server
        server = smtplib.SMTP()
        # Connect to mail server
        try:
            server.connect(mail_server)
        except socket.gaierror:
            self.list('mail error', 'Wrong server, are you sure is correct?')
        except socket.error:
            self.list('mail error', 'Server unavailable or connection refused')
        # Login in mail server
        if mail_server != 'localhost':
            try:
                server.login(server_user, server_pass)
            except smtplib.SMTPAuthenticationError:
                self.list('mail error', 'Authentication error')
            except smtplib.SMTPException:
                self.list('mail error', 'No suitable authentication method')
        # Send mail
        try:
            server.sendmail(send_from, dest_to_addrs, message.as_string())
        except smtplib.SMTPRecipientsRefused:
            self.list('mail error', 'All recipients were refused.'
                      'Nobody got the mail.')
        except smtplib.SMTPSenderRefused:
            self.list('mail error', 'The server didn’t accept the from_addr')
        except smtplib.SMTPDataError:
            self.list('mail error', 'An unexpected error code, Data refused')
        # Disconnect from server
        server.quit()

    def write(self, append=False):
        """Write the log to a file.

        The name of the file will be like this:

        script.log

        where 'script' is the name of the script file without extension (.py)

        (boolean) append -- If true appends log to file, else writes a new one

        """
        mode = 'ab' if append else 'wb'
        with open(self.filename, mode) as log_file:
            log_file.write(self.__log)

def main():
    """Main section"""
    url = 'http://joedicastro.com'
    head = 'This is a test of class Logger'

    log = Logger()
    log.header(url, head)
    log.time('Start time')
    log.block('Block', 'This is a sample of Logger.block()'.split())
    log.list('List', 'This is a sample of Logger.list()'.split())
    log.free('''This a sample of logger.free() text.

"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque sed
tortor eget justo vehicula consequat vel eu quam. Suspendisse non lectus eget
orci varius adipiscing."''')
    log.time('End time')
    log.send('This is mail test')
    log.write(True)
    log.free('All of this had been recorded in {0}'.format(log.filename))
    print(log.get())

if __name__ == "__main__":
    main()

Para acceder a la versión más reciente del mismo, acudir a el repositorio Python Recipes en github.

Ejemplos de utilización de este modulo pueden ser lftp-mirror (incluido dentro del mismo), TEDTalks, dpkg_diff y ban_drupal_spammers