Tag Archive: software libre


PdfMod 0.8 publicado

Por fin se ha liberado la nueva versión 0.8 de PdfMod, hace tiempo que no se realizaba ningún cambio en el proyecto y ya iba siendo hora que los cambios realizados a finales de Septiembre y principios de Octubre se publicaran bajo una nueva versión :) . Parece ser que se han añadido a última hora mejoras en el estilo del código, pero hay que decir que eso no tiene repercusión alguna para el usuario final, al menos no en esta versión, puede que en versiones futuras facilite la programación y se acelere el trabajo.

Como en otras versiones, los que hemos colaborado somos unos cuantos, principalmente se han añadido traducciones, se ha añadido la posibilidad de cargar más de un documento a la vez a través del diálogo de fichero y se ha mejorado levemente la usabilidad, asociando la combinación Ctrl-Shift-Z a “rehacer” y añadiendo un asterisco al nombre de fichero mostrado cada vez que tenga modificaciones no guardadas.

Podéis ver el changelog en esta dirección: http://git.gnome.org/cgit/pdfmod/plain/NEWS y el anuncio oficial de Gabriel Burt en su blog: http://gburt.blogspot.com/2009/11/pdf-mod-08.html .

Linux Magazine edición comunidad

Linux Magazine ha liberado su número 53 bajo licencia Creative Commons By-Nc-Nd (supongo que la versión 3.0 ya que no indican cuál de ellas), para los que la queráis descargar lo podéis hacer desde ésta página:

http://www.linux-magazine.es/Readers :

Los números no están completos pero no por ello dejan de tener cierto interés, de momento solo hay dos números publicados como Edición Comunidad, pero supongo que iran lanzando más números de ahora en adelante.

Saludos!

Este año voy a ser asesor de estudiantes para los alumnos de primer curso que por primera vez entran en la universidad. Mi trabajo consiste en guiar y resolver dudas que puedan ir surgiendo a los estudiantes a lo largo de su primer año en la UAB (Universitat Autònoma de Barcelona), no es gran cosa, si me encuentran por los pasillos simplemente tendré que ser amable y atento. Hace poco tuve que recoger datos de los que querían ser asesorados y tenía que mandarlos vía email para que se pudieran hacer estadísticas y llevar un control de las dudas que van apareciendo. Lo que me ha hecho empezar este artículo es la plantilla que recibí del grupo de asesores para que les enviara los datos recogidos.

La plantilla que recibí era un archivo .doc de MS Office , un fichero que no usa un formato ni estándar ni abierto. Antes de abrirlo ya me he mosqueado un poco, pero en cuanto lo he hecho la cosa ha quedado clara, no se podía visualizar correctamente, todos los elementos aparecían desplazados (¿alguien esperaba alguna otra cosa? Lo he abierto con OpenOffice.org 3.1).

El problema de estos formatos no sólo reside en problemas menores como el que he mencionado. Me explico, los formatos cerrados se llaman así por el hecho de que o bien no se conoce su especificación interna, o bien está prohibido crear software que manipule esa estructura sin pagar unos determinados royalties. Las implicaciones del segundo caso no hace falta comentarlas. El primer caso implica que el único software que será capaz de manejar esos formatos cerrados será el propio de la empresa diseñadora del formato, por lo que los usuarios que trabajen con dichos documentos serán cautivos de esa empresa, le deberán “lealtad” y tendrán que pagar lo que la empresa pida por sus productos sin poder buscar alternativa alguna, es decir, podrán mantener un monopolio (algo que ya se sabe es que los monopolios siempre traen consigo consecuencias negativas, que no me dedicaré a explicar aquí). A veces hay “valientes” que se dedican a realizar ingeniería inversa y con ello consiguen desentrañar ya sea parcial o totalmente la estructura de esos formatos cerrados. Con ésto se pueden implementar otros productos que le den soporte y el monopolio podría desaparecer… pero no, casi siempre el soporte dado es parcial y no total, y para postres, los diseñadores del formato original siempre se pueden reservar un as en la manga: ¡Cambiar otra vez la estructura del formato para la siguiente versión!

Lo del cambio del formato para cada nueva versión del programa tiene dos vertientes, una es boicotear los intentos de ingeniería inversa, otra es obligar a los usuarios a comprar las nuevas versiones de sus productos para poder seguir abriendo los nuevos documentos creados con las nuevas versiones (lo que puede acabar constituyendo un enorme desembolso económico solo por el derecho de seguir accediendo a ciertos datos). De hecho esto es lo que ha estado sucediendo a lo largo de los últimos 15 años con las sucesivas versiones de Ms Office, podéis intentar abrir un fichero creado con la versión 2007 del programa en el Ms Office 95 y me decís que tal va la cosa, ahora bien, no os auguro precisamente que lo vayáis a conseguir.

Continuando con lo de los documentos escritos en formatos cerrados dentro de la UAB, a parte de las razones esgrimidas, que sólo pueden servir para incentivar a la gente a acometer un cambio en su forma de trabajar con el ordenador (y no para obligar), en la UAB existe un estatuto [1] que explica claramente que los documentos publicados deben ser accesibles mediante formatos abiertos y libres. Esto que en un principio parece un deber debe ser considerado un derecho para los “consumidores” de dichos documentos (por ejemplo yo en este caso), ya que se nos asegura que no tendremos que ser clientes de ninguna empresa concreta para acceder a la información generada en la UAB… aun así este derecho es vulnerado sistemáticamente en mi universidad, que es lo que me ha impulsado a quejarme hoy aquí.

Algunos profesores ya han cambiado sus políticas al respecto y publican sus documentos en formatos abiertos, si bien es cierto que a la vez siguen usando los formatos propietarios de Microsoft para todos aquellos que no sepan aún lo que supone su uso y no causarles molestias, esto tampoco supone un problema porque no vulnera ningún derecho. Otros pasan olímpicamente del asunto aun después de que se les haya explicado la problemática que supone usar esos formatos, y la mayoría viven en la inopia sin saber ni sospechar que la mayoría de lo que escriben es parcialmente inaccesible a un número cada vez mayor de usuarios de productos informáticos que han decidido prescindir de los productos del monopolio más grande que haya existido jamás sobre la faz de la Tierra.

Referencias:

  1. http://ddd.uab.cat/pub/llibres/estatutsuab_a2003.pdf , Article 3.4.c del Capítol “Naturalesa, Autonomia, Principis d’Actuació i Finalitats de la Universitat”
  2. [Historias de formatos olvidados (en inglés) ] : http://www.kdedevelopers.org/node/4067

PDF Mod 0.7

Se ha publicado la versión 0.7 de Pdf Mod hace un día con pocas novedades… aunque me alegra anunciarlo porque he hecho mi minicontribución a ella.

Las novedades son:

Mejoras:

  • Añadido soporte para vista de pantalla completa
  • Añadida traducción de la documentación al catalán

Corrección de errores:

  • Correcciones en la construcción para *BSD
  • Ahora se actualiza la lista de documentos recientes tras la apertura de un documento
  • Correcciones en Hyena (relacionadas con el la ruta hacia el directorio de las librerías)

Podéis ver el anuncio oficial de Gabriel Burt en su blog :) . Por mi parte voy a seguir haciendo aportaciones para mejorar este programa, siempre modestas porque no conozco el código lo suficientemente bien todavía pero supongo que ya me iré familiarizando.

A todos aquellos que no hayáis colaborado nunca en un proyecto de software libre y sintáis ganas de empezar os animo a que colaboréis también en Pdf Mod, que es un proyecto prácticamente en su fase inicial, con mucho por hacer y con un código muy entendible. Por otro lado hay muchos proyectos de Gnome en los que es posible colaborar sin excesivos conocimientos… y sinceramente, después de haber visto la dinámica interna del desarrollo Enlightenment y la de KDE… creo que Gnome tiene un equipo más fresco, activo y en el que es más fácil entrar para colaborar.

Saludos! :)

Vía Menéame -> tecnometro.blogspot.com me entero de que el grupo de desarrollo de FFmpeg ha encontrado unas cuantas empresas que incumplen las licencias GPL y LGPL bajo las que han publicado FFmpeg y han creado una página, el Salón de la Verguenza (en inglés), para que todo el mundo sepa de qué empresas se trata.

He escrito este post porque piden que se les enlace para dar a conocer estos casos de incumplimiento de las licencias y la verdad es que estoy muy de acuerdo en que es necesario que se den a conocer estos casos para acabar con ellos. No es justo que se aprovechen del software libre creando programas privativos y sin reconocer la autoría de los creadores de ciertos componentes que usan para sus programas (sobretodo cuando la licencia así lo explicíta).

Estaría bien que os animárais a enlazar también en vuestros blogs el Salón de la verguenza para que suba su pagerank y sea más accesible al público en general.

Saludos! :)

Novedades en CMD Twitt

No hay mucho que decir pero ha habido algunos avances significativos desde que escribí el primer post. He añadido algunas opciones más para que el programa sea más útil, he corregido dos pequeños bugs relativos a la gestión de errores y he simplificado la gestión de la codificación de texto gracias a una característica de la librería python-twitter que me había pasado desapercibida. También he creado alguna función más que me ha permitido simplificar un poco más el código.

Lo que me queda por hacer:

  1. Añadir un modo interactivo, lo programaré con la librería curses
  2. Aprovechar la capacidad de internacionalización del programa y traducirlo al castellano y al catalán
  3. Empaquetarlo para Debian
  4. Si a alguien se le ocurre algo más, tiene todo el derecho del mundo a decirlo :) .

Algunas cosillas más :) :

Añadí el proyecto a Launchpad ( CMD Twitt ) ya que gracias a ésto ahora tengo un bug tracker donde todo el mundo puede indicar los bugs que encuentre en el programa :) y también dejar sugerencias de mejora en los Blue Prints.

Saludos!

Cmd Twitt

Hace tres días empecé a programar Cmd Twitt (y lo acabé ayer, bueno, supongo que todavía se puede mejorar pero no le voy a dedicar mucho más tiempo a no ser que se reporten bugs alguien tenga buenas ideas para mejorarlo). Éste programa es un simple programa de consola que permite acceder a los servicios de la popular red social Twitter.

Lo programé en Python usando la librería python-twitter, que se puede instalar mediante aptitude o apt-get en sistemas Debian o Ubuntu. Hay algunos detalles interesantes del programa sobre los que me gustaría escribir porque aprendí algunas cosillas mientras lo estaba haciendo, entre otras cosas las siguientes:

  • Internacionalización de aplicaciones Python
  • Correcto funcionamiento con diferentes codificaciones de texto
  • Gestión sencilla de ficheros de configuración
  • Poner colorines en la consola, jeje
  • Esto tiene poco que ver con la programación en sí, pero es interesante también: Trabajar con git y gitorious

Os cuelgo el código y acto seguido vamos con la explicación:

#!/usr/bin/env python
# encoding: utf-8
# -*- coding: utf-8 -*-

############################################################################
#                     --- cmd-twitt 2009.08.16 ---                         #
#                                                                          #
#   Copyright (C) 2009 by Andreu Correa Casablanca  (Original Author)      #
#                                                                          #
#   Email: castarco@gmail.com (Andreu Correa Casablanca)                   #
#                                                                          #
#   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, write to the                          #
#   Free Software Foundation, Inc.,                                        #
#   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.              #
############################################################################

import ConfigParser
import getpass
import gettext
import locale
import optparse
import os
import sys
import twitter
import urllib2

# An alias that allows us to imitate the touch command
touch = lambda file: open(file, "w").close()

cmd_usage   = 'usage: %prog [option] [num_of_twits_per_timeline]'
cmd_version = '2009.08.16'

conf_dir  = os.environ["HOME"] + "/.cmdtwitt/"
conf_file = conf_dir + "user.conf"

encoding  = locale.getpreferredencoding().lower()

user = ''
pswd = ''

color = {}
color['green']   = '\033[1;32m'
color['nocolor'] = '\033[1;0m'
color['red']     = '\033[1;31m'
color['white']   = '\033[1;37m'
color['yellow']  = '\033[1;33m'

# Translate some global vars
def init_vars():
        global cmd_usage

        cmd_usage   = _(cmd_usage)

# Load the account settings
def load_config():
        global user, pswd

        cfg = ConfigParser.ConfigParser()

        try:
                cfg.readfp(file(conf_file))
        except:
              raise

        user = cfg.get ('TWIT_ACCOUNT', 'User')
        pswd = cfg.get ('TWIT_ACCOUNT', 'Pswd')

#Set the account settings
def set_config():
        global conf_dir, conf_file

        print _("Settings:")

        cfg = ConfigParser.ConfigParser()
        cfg.add_section('TWIT_ACCOUNT')

        cfg.set('TWIT_ACCOUNT', 'User', raw_input(_('\tUser: ')) )

        pswd_not_set = True
        while pswd_not_set:
                pswd1 = getpass.getpass(_('\tPassword       : '))
                pswd2 = getpass.getpass(_('\tRepeat password: '))

                if pswd1 == pswd2:
                        pswd_not_set = False
                else:
                        print _('The passwords don\'t match. Please try to write it again.')

        cfg.set('TWIT_ACCOUNT', 'Pswd', pswd1)

        if os.access(conf_file, os.F_OK) == False:
                try:
                        touch(conf_file)
                except IOError:
                        try:
                                os.mkdir(conf_dir, 0700)
                        except IOError:
                                print _('It was impossible to create the config dir.')
                                raise

                        try:
                                touch(conf_file)
                        except:
                                print _('It was impossible to create the config file.')
                                raise

        try:
                cfg.write(file(conf_file, 'w'))
        except:
                raise

# Manage connection errors
def manage_connection_error(e, code):
        if e.getcode() == code:
                print _('\tUnauthorized acces, you should set a correct username and password.')
        else:
                print _('It seems twitter is down. Try it later.')

# Sends a message to a user
def send_msg_to_user(_user):
        global user, pswd, cmd_version

        api = twitter.Api(username=user, password=pswd)

        msg = unicode(raw_input( _('Type your message:\n\t') ), encoding)[:140]

        try:
                api.PostDirectMessage(_user, msg)

        except urllib2.HTTPError, e:
                print _('Error sending the message:')

                manage_connection_error(e, 401)

# Show the user status
def show_status():
        global user, pswd

        api = twitter.Api(username=user, password=pswd)

        try:
                status = api.GetUserTimeline(user)[0].text

                print _('Your status is:\n\t' + status)
        except urllib2.HTTPError, e:
                print _('Error reading your status:')

                manage_connection_error(e, 404)

# Format the timeline to show in the console
def show_timeline(num_msgs, statuses):
        global color

        _status = statuses[0]
        print color['green']+_status.user.name + ' :\n' + color['yellow'] + _status.GetRelativeCreatedAt() + ' > ' + color['nocolor'] + _status.text + '\n'

        for status in statuses[1:num_msgs]:
                if status.user.name == _status.user.name:
                        name = color['yellow'] + status.GetRelativeCreatedAt()+' > ' + color['nocolor']
                else:
                        name = color['green']+status.user.name + ' :\n' + color['yellow'] + status.GetRelativeCreatedAt() + ' > ' + color['nocolor']

                print name + status.text + '\n'
                _status = status

# Shows the timeline of a specific twitter user
def show_usertimeline(_user, num_msgs):
        global user, pswd, color

        api = twitter.Api(username=user, password=pswd)

        try:
                statuses = api.GetUserTimeline(_user)

                print color['red'] + _user + _(' Timeline:\n') + color['nocolor']

                show_timeline(num_msgs, statuses)

        except urllib2.HTTPError, e:
                print _('Error reading the timeline:')

                manage_connection_error(e, 401)

# Shows the Home timeline
def show_friendstimeline(num_msgs):
        global user, pswd, color

        api = twitter.Api(username=user, password=pswd)

        try:
                statuses = api.GetFriendsTimeline(user)

                print color['red'] +_('Home Timeline:\n') + color['nocolor']

                show_timeline(num_msgs, statuses)

        except urllib2.HTTPError, e:
                print _('Error reading the timeline:')

                manage_connection_error(e, 401)

# Shows the Home timeline
def show_publictimeline(num_msgs):
        global user, pswd

        api = twitter.Api(username=user, password=pswd)

        try:
                statuses = api.GetPublicTimeline()

                print color['red'] + _('Public Timeline:\n') + color['nocolor']

                show_timeline(num_msgs, statuses)

        except urllib2.HTTPError, e:
                print _('Error reading the timeline:')

                manage_connection_error(e, 401)

# Send a message to twitter
def send_msg(_user):
        global user, pswd, cmd_version

        api = twitter.Api(username=user, password=pswd)

        try:
                if _user != '':
                        _user = '@'+_user+' '

                api.PostUpdate( ( _user + unicode(raw_input( _('Write your message and press Enter:\n\t') ), encoding) )[:140] )

        except urllib2.HTTPError, e:
                print _('Error sending the message:')

                manage_connection_error(e, 401)

# The main program
def main(argv=None):
        global user, pswd

        if argv == None:
                argv = sys.argv

        # Internationalization
        gettext.install('cmd-twitt')

        init_vars()

        cmd_parser = optparse.OptionParser(usage=cmd_usage, version=cmd_version, conflict_handler='resolve')

        cmd_parser.add_option('-h', '--help',    action='help',    help=_('print this help text and exit'))
        cmd_parser.add_option('-v', '--version', action='version', help=_('print program version and exit'))

        cmd_parser.add_option('-c', '--config', dest='config', action='store_true', help=_('Configure your twitter account'))
        cmd_parser.add_option('-s', '--status', dest='status', action='store_true', help=_('Shows your status'))

        cmd_parser.add_option('-p', '--publictimeline',  dest='publictimeline',  action='store_true', help=_('Shows the public timeline'))
        cmd_parser.add_option('-u', '--usertimeline',    dest='usertimeline',    action='store_true', help=_('Shows the user timeline'))
        cmd_parser.add_option('-F', '--friendtimeline',  dest='friendtimeline',  metavar='FRIEND',    help=_('Shows the timeline of a friend'))
        cmd_parser.add_option('-f', '--friendstimeline', dest='friendstimeline', action='store_true', help=_('Shows the friends timeline'))

        cmd_parser.add_option('-m', '--private-message', dest='private_msg', metavar='USER', help=_('Sends a private message to a twitter user'))
        cmd_parser.add_option('-M', '--public-message',  dest='public_msg',  metavar='USER', help=_('Sends a public message to a twitter user'))

        (cmd_opts, cmd_args) = cmd_parser.parse_args()

        if cmd_opts.config:
                try:
                        set_config()
                except:
                        print _("It was impossible to set the settings.")
                        return 1
        else:
                try:
                        load_config()
                except:
                        print _('There is not a config file, you should set your user and password in the settings option.\n')
                        cmd_parser.print_help()
                        return 1

                try:
                        num_msgs = int(cmd_args[0])
                except:
                        num_msgs = 10

                if cmd_opts.private_msg:
                        send_msg_to_user(cmd_opts.private_msg)
                elif cmd_opts.public_msg:
                        send_msg(cmd_opts.public_msg)
                elif cmd_opts.status:
                        show_status()
                elif cmd_opts.usertimeline:
                        show_usertimeline(user, num_msgs)
                elif cmd_opts.friendtimeline:
                        show_usertimeline(cmd_opts.friendtimeline, num_msgs)
                elif cmd_opts.friendstimeline:
                        show_friendstimeline(num_msgs)
                elif cmd_opts.publictimeline:
                        show_publictimeline (num_msgs)
                else:
                        send_msg('')

if __name__ == "__main__":
        sys.exit(main())

Internacionalización

Lo primero que se tiene que hacer es escribir la linia import gettext para cargar el módulo que nos ayudará en nuestro quehacer. La segunda línea (no del texto, sino referente a la internacionalización, la podemos encontrar en la función main) gettext.install('cmd-twitt') se dedica a cargar la traducción al idioma por defecto del sistema para las cadenas de texto que usa el programa. La traducción se cargará desde el directorio /usr/share/locale/[abreviatura para el lenguaje por defecto del sistema]/LC_MESSAGES/cmd-twitt.mo.

Por último (en cuanto se refiere al código) lo que se tiene que hacer para que todas las cadenas que queramos sean susceptibles de traducción a través del módulo gettext es escribirlas de ésta forma _('cadena'). La función _() es un alias para gettext.gettext().

Quedan otros pasos que no tienen mucho que ver con el código, sinó con la traducción en sí. Para empezar a traducir el programa lo primero que debemos hacer es obtener un fichero especial sobre el que se basarán las traducciones. Lo haremos así:

gettext cmd-twitt.py

Ésto generará un fichero llamado messages.po que contendrá parejas de cadenas, las originales junto con sus traducciones. Para empezar la traducción al castellano generamos un nuevo fichero a partir de messages.po que será el que contendrá la traducción en sí (messages.po lo guardamos como base para traducciones a otros lenguajes). Lo haremos como se sigue:

msginit --locale=es -i messages.po

Éste programa nos pedirá algunos datos acerca de nosotros (para que quede constancia de quienes son los traductores,  está bien que se sepa de quien es la autoría) y finalmente creará un fichero llamado es.po , que es el que nos dedicaremos a modificar.

Finalmente el fichero puede ser editado por herramientas tales como gtranslator o ktranslator para luego ser compilado a un fichero con extensión .mo que será el que irá al directorio de traducciones que mencionamos anteriormente. (Cambiando su nombre es.mo a cmd-twitt.mo)

Codificaciones de texto

Éste es un tema que ha dado mucho por saco, la verdad sea dicha. De hecho la librería python-twitter no funciona demasiado bien en este aspecto, falta que la pulan un poco (y no solo por lo de la codificación de texto, yo ya he tenido que corregir algunos bugs en la versión de mi sistema, tengo que ver ahora si es la versión de Ubuntu o la del repositorio oficial de código tiene los mismos errores).

Percibí el problema en cuanto intenté enviar mensajes con acentos a través de Cmd Twitt a Twitter, ¿Cual era el problema? El programa reventaba. Mi primer logro consistió en hacer que funcionara para mi sistema, pero luego ajusté un poco mejor el funcionamiento.. y CREO (no estoy del todo seguro) que funcionará en sistemas con diferentes codificaciones de texto.

Primera solución:

Supongamos que str es una cadena que hemos obtenido a través de la función raw_input() , la solución consistía en usar la cadena resultantde de aplicar la función unicode() a str, de la siguiente forma: unicode(str, 'utf-8') . Si no se añade el segundo argumento la función unicode() intenta leer str como si fuera ASCII y el programa revienta igualmente (que es justo lo que se hace en la librería python-twitter, un error un poco burdo, se nota que no deben hablar otras lenguas los creadores de la librería).

Ésta solución funciona en mi sistema porque usa UTF-8 para la codificación de las cadenas… pero eso no es necesariamente así en todos los sistemas.

Segunda solución:

La segunda solución pasa por el uso del módulo locale, así que tenemos que hacer un import de éste. Simplemente tenemos que sustituir la cadena ‘utf-8′ por el resultado de locale.getpreferredencoding().lower() .

Ficheros de configuración

No me extenderé mucho con ésto. He usado el módulo ConfigParser , y en cuanto a la introducción de la contraseña de usuario para twitter he utilizado un módulo llamado getpass que permite introducir caracteres sin tener que mostrarlos por pantalla. És fácil de aprender viendo el código como ejemplo.

Colorines

Lo reconozco, hay que estar un poco zumbado para dedicar una sección entera de la explicación ssólo para los colorines, qué le vamos a hacer, soy así. Aunque se reduce a algo tan simple como añadir al principio de la cadena que queremos colorear ciertas cadenas características que harán cambiar el color del texto de la consola (incluso después de haberse cerrado el programa). Ésto solo funciona para algunas consolas concretas.. no las he provado, pero aseguro que funciona con Bash, y también aseguro que no funciona en MS Windows.

Las cadenas son de la forma ‘\033[1;32m’ en la que para escoger el color sólo se tienen que cambiar los dos números del final, ésta en particular es para el color verde. Al final del artículo encontraréis un enlace para ver la tabla de códigos y sus colores correspondientes.

Git y Gitorious

Me da pereza seguir explicándolo todo como si fuera un cuento, voy al grano:

  • Crear una cuenta en gitorious.org
  • Subir una clave pública de ssh a Gitorious, si ya existe en vuestro sistema la tendréis en el fichero /home/usuario/.ssh/id_rsa.pub . En caso de no tenerla, lo podéis hacer mediante el comando ssh-keygen -t rsa .
  • Crear un proyecto y un repositorio, es todo guiado así que resulta muy sencillo.
  • Ahora toca la parte de configurar el repositorio en nuestro ordenador de trabajo. Tendremos que tener instalados ssh y git antes que nada. Los pasos que seguiremos son:
    • cd directorio_proyecto
    • git init  # Creamos el repositorio local
    • git add . # Ésto añade el directorio a la lista de ficheros del repositorio git
    • git commit -a -m "Y se hizo la luz"  # El comentario no es realmente importante (almenos en el primer commit, vamos)
    • git remote add origin git@gitorious.org:miproyecto/mainline.git # Esto nos servirá para "conectar" nuestro repositorio local con el remoto de Gitorious.org, en la documentación que encontré ponían origen en vez de origin pero luego el siguiente paso no se podía hacer de la manera "corta" que seguidamente indico
    • git push origin master # Con ésto subimos los cambios que hemos hecho al repositorio remoto, las próximas veces sólo tendremos que escribir git push

Ahora os dejo las fuentes que me han servido para informarme un poco:

Internacionalización:

Ficheros de configuración en Python:

Colorines:

Configuración de Git y Gitorious:

Hasta otra :) .

Pdf Mod

Hace una semana descubrí en el agregador de blogs Monologue (de Mono-Project) un proyecto iniciado por Gabriel Burt llamado Pdf Mod que parece avanzar a pasos agigantados y puede resultar muy útil.

Se trata de un programa diseñado para modificar PDFs escrito en C# para la plataforma Mono. Utiliza las librerías Poppler, PdfSharp, Gtk#, Cairo, y la librería Hyena de Banshee, y es precisamente ésto lo que ha permitido el rápido desarrollo que ha tenido.

Sus características actuales son:

  • Abrir documentos arrastrándolos desde Nautilus y soltándolos sobre Pdf Mod.
  • Soporta ficheros Pdf protegidos por contraseña.
  • Rotar, extraer y eliminar páginas.
  • Añadir páginas arrastrándolas desde otro documento abierto.
  • Cambiar el orden de las páginas mediante “Arrastrar y soltar”
  • Leer y cambiar las propiedades del documento.
  • Exportar imágenes.
  • Traducido a un porrón de idiomas (yo lo he traducido a castellano, y lo voy a traducir al catalán a no ser que se adelante alguien)
  • Y supongo que algunas más, ahora van por la versión 0.5 y me parece que han ido aumentando el número de versión aproximadamente cada 3 días.

Yo por mi parte lo utilizaré para unificar los Pdfs de Linux Magazine, que ofrecen todas sus revistas digitales separadas en artículos individuales… creo que será más sencillo tener sólo tantos pdfs como revistas y no tantos como artículos (ah, y podré quitar la publi para reducir peso, jeje).

Saludos :) .

Actualización: he añadido enlaces a traducciones de los tres primeros Documentos de Halloween.

Navegando por internet buscando información sobre Mono (lo que en realidad buscaba era un benchmark comparativo entre Mono y Java) he acabado encontrando unos documentos bastante interesantes elaborados por ciertos ingenieros de Microsoft que datan del año 1998 (almenos el primero, no sé de qué años son los siguientes). Estos documentos son llamados los Documentos de Halloween y tratan sobre las estrategias que planeaba seguir Microsoft para luchar contra el movimiento del Open Source ( o Software libre ).

Es interesante ver como desde Microsoft veían este movimiento, cómo pensaban atajarlo y la evolución que ha tenido todo este mundillo desde el año 1998, la verdad es que las cosas han empeorados para el gigante del software.

Aquí os dejo una traducción al castellano del primer documento (de hecho es el primero que he encontrado):

Y aquí un enlace a los documentos completos (comentados por Eric S. Raymond) (en inglés):

http://www.catb.org/~esr/halloween/

Por si alguien lo duda, parece ser que estos documentos son reales, Microsoft confirmó que esos documentos habían sido redactados en su seno. Sé que es un asunto antiguo y medio olvidado, pero como yo tenía por aquel entonces unos 10 añitos, era improbable que me hubiera enterado de algo en esa época de mi vida.

Un cabo suelto que me queda es leer un escrito de Eric S. Raymond (fue él quien publicó los Documentos de Halloween) , en la traducción se enlaza a un texto en inglés (pero han traducido el título como Cuidando la Noósfera), en cambio en la Wikipedia (en el artículo de Eric S. Raymond) lo traducen como Colonizando la Noosfera y en su página particular de la Wikipedia Colonizando la Noosfera se enlaza a una traducción que lleva por título Cultivando la Noosfera, parece que nadie se pone de acuerdo pero almenos no tendré que hacer el esfuerzo de leer en inglés, buscando en google y altavista con el primer nombre que encontré, obtuve que no había ni una sola traducción (de hecho la he encontrado sobre la marcha mientras escribía este post).

Ayer recibí una muy grata noticia, he sido aceptado como participante en el Google Summer of Code. Ahora lo que me queda es trabajar mucho para conseguir llegar a los objetivos propuestos (algunos sabrán que acostumbro a ser poco constante, por eso es un reto para mí). Por suerte tengo un mentor que me irá “poniendo a raya” si descuido n poco el tema y me podrá ayudar si me atasco demasiado. Se llama Michael Meeks y por lo visto es un gran hacker. Ésta mañana me ha hecho una llamada por teléfono y sonaba de lo más alegre… aunque sinceramente, me ha costado muchísimo entender qué me decí. Por cierto, tendré que perfeccionar mi inglés hablado o el pobre acabará creyendo que soy idiota (almenos debería isimular un poco mi condición, jeje).

Bien, mi propósito es mejorar el rendimiento de ciertos componentes de OpenOffice, y una de mis primeras tareas asignadas.. no tiene mucho que ver con eso: mejorar ciertos aspectos de la herramienta KCacheGrind (la versión de KDE4, que de momento sólo está en los repositorios de KDE, en Sourceforge y Freshmeat encontraréis versiones obsoletas para KDE3). La idea es mejorar la herramienta para poder trabajar mejor después cuando queramos encontrar los cuellos de botella en OpenOffice.

Hasta otra.

[Actualizado]

Intentaré escribir los siguientes artículos también en inglés para ir practicando y para que gente de otras partes pueda seguir el desarrollo de lo que vaya haciendo.

Powered by WordPress | Theme: Motion by 85ideas.