El Blog de Marcelo!

Hace un rato que estoy leyendo sobre virtualización, pero no de CPU, sino de I/O (otro más acá)… muy interesante, me aclaró algunas dudas que tenía, dado que últimamente al configurar este tipo de software se me confundían las cosas

Resulta que a nivel de I/O tenemos algo parecido a la virtualización al nivel de CPU: emulación, paravirtualización y ejecución “directa”, por llamarlo de alguna manera. Sugiero leer el artículo para más detalles, pero sólo quiero agregar que recién estamos en la etapa de paravirtualización, y que (en buena hora) Intel y AMD agregaron unidades IOMMU en sus últimos diseños para poder asignar dispositivos directamente a una (o más, según el caso) VM, evitando el Hypervisor y ahorrando ciclos de CPU. Pero esto parece estar verde aún.

Virtio vendría a ser como una serie de drivers de paravirtualización de I/O. Lo bueno es que no sabía que VirtualBox soportaba para las interfaces de red, algo que al parecer (y de esta manera) intenta ser un estándar  (net y block devices por ahora),  ya que tiene una API de comunicación Host <–> Guest abierta, independiente y en paralelo a la propuesta de KVM como hypervisor.

Luego de ver un poco todo esto, me puse  a configurarlo en una VM con WinXP, le instalé estos drivers y ya estoy usando menos CPU para la parte de red en mi guest

Acá se ve un poco la mejora a nivel de tráfico de red *real* que hay usando I/O paravirtualizado:

http://www.linux-kvm.org/page/Using_VirtIO_NIC

En fin, esperemos que todo esto mejore más aún. KVM ya soporta virtio para dispositivos de almacenamiento, además de los de red (linkeo la instalación de los drivers de Windows porque lógicamente Linux tiene estas baterías ya incluídas, je).

Saludos

Para los que no están enterados, Streaming Replication es la nueva gran característica de PostgreSQL 9.0 (ex-8.5), todavía en desarrollo. Estoy muy contento por la noticia, realmente era algo pendiente ver integrado algo de esto en PostgreSQL mismo (ya que hay productos y/o versiones modificadas para hacer esto, pero no es lo mismo que “el original”, claro está ) y lo hace cada vez más adecuado para evitar (o al menos dejar a uno la opción de) utilizar motores de bases de datos muy buenas pero caras y propietarias (Oracle) o lamentablemente en problemas políticos/de gestión (MySQL).

Básicamente SR permite que exista un proceso “sender”en el master que envíe a procesos “receiver” en el/los nodos secundarios porciones de WAL (Write-Ahead Log), es decir, de transacciones “comiteadas” recientemente. Antes (PostgreSQL 8.4 y anteriores) los WAL se podían archivar a otro nodo una vez se hayan completado 16 MB de transacciones (por defecto), con lo cual si se tenía una BD que “cambie poco”, 16 MB podían representar un lapso de tiempo físico importante. A partir de ahora, el lapso de tiempo se reduce a unos pocos segundos de diferencia en el master y la/las réplicas (dependiendo el enlace, la carga del master, etc.), con lo cual es una mejora substancial en las capacidades y posibilidades de PostgreSQL.

Hay que resaltar que por ahora este proceso es asincrónico, y aunque hay usuarios que pueden necesitar replicación sincrónica, cada esquema tiene sus ventajas y desventajas, y sin lugar a dudas esta primera versión de momento atiende muchísimas necesidades.  Combinado con otra de las novedades de 9.0 que es la posibilidad de usar un nodo secundario (recibiendo WALs mediante SR o el método tradicional) como Sólo Lectura (característica llamada “Hot Standby“), 9.0 da un paso muy adelante con respecto a versiones anteriores.

Para más adelante (y planificado para hacerse, ojo) quedó la opción de Straming Replication sincrónico y obtener más y mejor info del proceso de replicación (lag, estadísticas, etc.). Otro punto flojo, que espero se resuelva mejor (o con un mecanismo estándar), es que uno tiene que scriptear a mano el Failover, es decir, el proceso de recuperación (heartbeat es una herramienta genérica para este tipo de cosas).

Dejo algunos links relacionados con más info y demostraciones:
http://www.depesz.com/index.php/2010/02/01/waiting-for-9-0-streaming-replication/
http://www.depesz.com/index.php/2010/01/08/waiting-for-8-5-hot-standby/

¡Saludos!
Marcelo

Hoy me encontré con otro un hilo en la lista de PyAr que me deja un link más que interesante: ¡Existe un binding para usar Webkit sobre GTK desde Python, y lo mejor de todo es que ya está incluido en los repositorios de Ubuntu 9.10!

Webkit es un motor de renderizado (“dibujado”) de páginas web, que es utilizado en el corazón en cada vez más navegadores, como Chrome, Safari, Konqueror, etc. Es super completo y veloz; y permite ejecutarse en muchísimas plataformas y sistemas diferentes.  Si bien existen otros métodos para embeber un navegador en una aplicación PyGTK, como por ejemplo gtkmozembed (que embebe el motor de Firefox), éste no es muy poderoso, o por lo menos no deja meterle mucha “mano” para personalizarlo, y uno termina teniendo relativamente muy poco “poder”. En cambio con Webkit/GTK se pueden hacer muchas más cosas, tan sólo hace falta ver la documentación y un ejemplo (links al final, claro).

No podía dejar de probarlo. Entonces me puse manos a la obra, y salió esto, tratando de imitar lo que se posteó en la lista:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
""" 
    SimpleBrowser - Navegador muy muy simple de internet, sólo de ejemplo,
                    que utiliza la biblioteca Webkit GTK desde Python (PyWebkitGTK).
 
    Marcelo Fidel Fernández - http://www.marcelofernandez.info 
    Licencia: BSD. Disponible en: http://www.freebsd.org/copyright/license.html
"""
 
import sys
import gtk
import webkit
 
DEFAULT_URL = 'http://www.python.org'
 
class SimpleBrowser:
 
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
        self.window.connect('delete_event', self.close_application)
        self.window.set_default_size(800, 600)
 
        vbox = gtk.VBox(spacing=5)
        vbox.set_border_width(5)
 
        self.txt_url = gtk.Entry()
        self.txt_url.connect('activate', self._txt_url_activate)
 
        self.scrolled_window = gtk.ScrolledWindow()
        self.webview = webkit.WebView()
        self.scrolled_window.add(self.webview)
 
        vbox.pack_start(self.txt_url, fill=False, expand=False)
        vbox.pack_start(self.scrolled_window, fill=True, expand=True)
        self.window.add(vbox)
 
    def _txt_url_activate(self, entry):
        self._load(entry.get_text())
 
    def _load(self, url):
        self.webview.open(url)
 
    def open(self, url):
        self.txt_url.set_text(url)
        self.window.set_title('SimpleBrowser - %s' % url)
        self._load(url)
 
    def show(self):
        self.window.show_all()
 
    def close_application(self, widget, event, data=None):
        gtk.main_quit()
 
if __name__ == '__main__':
    if len(sys.argv) > 1:
        url = sys.argv[1]
    else:
        url = DEFAULT_URL
 
    # PyWebkitGTK necesita habilitar el soporte de los hilos en PyGTK
    gtk.gdk.threads_init()
    browser = SimpleBrowser()
    browser.open(url)
    browser.show()
    gtk.main()

¡Y Listo!

Todo lo que se necesita en Ubuntu 9.10 para poder correr esto es instalar el paquete “python-webkit”; sin embargo, esta versión es la 1.1.5, mientras que PyWebkitGTK va por la 1.1.7 y Webkit/GTK va por la 1.1.15, así que todavía hay lugar para mejoras.

Aquí dejo algunos links:

• PyWebkitGTK se llama el proyecto de llevar Webkit/GTK (escrito naturalmente en C) a Python.
• Acá hay un ejemplo muchísimo más completo de un navegador con múltiples pestañas y todo.
• Lamentablemente, la documentación de la biblioteca en Python no existe aún (es un ticket del proyecto), así que por ahora habrá que conformarse con la documentación de Webkit/GTK; sin embargo, yo lo encuentro bastante legible, ya que enseguida uno se adapta a “traducir” cómo se llamaría un método en C a uno en Python.

Espero que les sirva. Me divertí mucho haciéndolo.

Saludos

Dado que alguien me pidió vía twitter un ejemplo de cómo hacer un zoom de una imagen en PyGTK, hice este ejemplito sencillo que sólo carga una imagen en un widget Gtk.Image.

Maneja el movimiento de la imagen con el mouse, las teclas del cursor y hace zoom con F1 (“0 o adaptar a ventana”), F2 (+25%), F3 (+50%), F4(+75%) y F5(“%+100 o 1:1″).

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
""" 
    SimpleImageViewer - Visor simple de imágenes, de ejemplo, que utiliza PyGTK.
    Marcelo Fidel Fernández - http://www.marcelofernandez.info
 
    Licencia: BSD. Disponible en: http://www.freebsd.org/copyright/license.html
 
    TODO: 
        * Dar la opción de usar el scroll del mouse para hacer zoom.
        * Mejorar el código y peformance (quizás).
"""
 
import os
import sys
import pygtk
pygtk.require('2.0')
import gtk
 
 
# Variables globales para el ejemplo; podrían ir en un archivo de configuración, 
# como por ejemplo 'config.py' e importarlo.
# Mapeo de teclas - Ver constantes en el modulo gtk.keysyms
import gtk.keysyms as kb
 
# Estructura: teclas (en mayúscula, contempla minúsculas también)
# (offset_X_pixeles, offset_Y_pixeles)
OFFSET_GRAL = 50
MOVE_KEYS = { kb.Up : (0, -OFFSET_GRAL), # Arriba
              kb.Down : (0,  OFFSET_GRAL), # Abajo
              kb.Right : (OFFSET_GRAL, 0),  # Derecha
              kb.Left : (-OFFSET_GRAL, 0), # Izquierda
            }
 
# Estructura: tecla: nivel de zoom (zoom_ratio)
ZOOM_KEYS = { kb.F1: 0.0,
              kb.F2: 25.0,
              kb.F3: 50.0,
              kb.F4: 75.0,
              kb.F5: 100.0,
            }
 
DEFAULT_IMAGE = '/usr/share/backgrounds/Cherries.jpg'
 
class SimpleImageViewer:
 
    def __init__(self, image_file):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.connect("delete_event", self.close_application)
        self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
        self.window.set_default_size(800, 600)
 
        self.pixbuf = gtk.gdk.pixbuf_new_from_file(image_file)
        self.ancho_pixbuf = float(self.pixbuf.get_width())
        self.alto_pixbuf = float(self.pixbuf.get_height())
        self.image = gtk.Image()
        self.image.set_from_pixbuf(self.pixbuf)
 
        self.viewport = gtk.Viewport()
        # No están por defecto, los agrego
        self.viewport.add_events(gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.BUTTON1_MOTION_MASK) 
        self.viewport.connect('button-press-event', self.on_button_pressed)
        self.viewport.connect('button-release-event', self.on_button_released)
        self.viewport.connect('motion-notify-event', self.on_mouse_moved)
        # Lo conecto a la ventana, ya que siempre tiene el foco
        self.window.connect('key-press-event', self.on_key_press) 
 
        self.viewport.add(self.image)
        self.scrolled_wnd = gtk.ScrolledWindow()
        self.scrolled_wnd.add(self.viewport)
        self.window.add(self.scrolled_wnd)
        self.window.show_all()
 
 
    def _update_image(self, zoom_ratio):
        """ Updates the image in the widget according to the zoom_ratio
            Actualiza la imagen en el widget Image con el zoom_ratio de parámetro 
        """
        # TODO: Prioriza que encaje el ancho por sobre el alto de la imagen 
        # al estar maximizado. Mejorar.
 
        # Obtengo las dimensiones actuales del viewport
        rect = self.viewport.get_allocation()
        # Resize de la imagen conservando las proporciones de la imagen
        if self.ancho_pixbuf > self.alto_pixbuf:
            base = self.ancho_pixbuf - rect.width
            ancho = int(rect.width + (base * (zoom_ratio/100)))
            relacion = (self.alto_pixbuf*100)/self.ancho_pixbuf
            alto = int(ancho * relacion/100)
        else:
            base = self.alto_pixbuf - rect.height
            alto = int(rect.height + (base * (zoom_ratio/100)))
            relacion = (self.ancho_pixbuf*100)/self.alto_pixbuf
            ancho = int(alto * (relacion/100))
 
        scaled_buf = self.pixbuf.scale_simple(ancho, alto, gtk.gdk.INTERP_BILINEAR)
        self.image.set_from_pixbuf(scaled_buf)
 
 
    def _move_image(self, offset_x, offset_y):
        """ Moves the image inside the viewport to the specified offset (+ or - pixels)
            Mueve/Desplaza la imagen del viewport según el offset que se le especifique 
        """
        vport = self.viewport
        xadjust = vport.props.hadjustment
        newx = xadjust.value + offset_x
        yadjust = vport.props.vadjustment
        newy = yadjust.value + offset_y
        # Si las cosas están dentro de los bordes, seteo
        if (newx >= xadjust.lower) and \
               (newx <= (xadjust.upper - xadjust.page_size)):
            xadjust.value = newx
            vport.set_hadjustment(xadjust)
        if (newy >= yadjust.lower) and \
               (newy <= (yadjust.upper - yadjust.page_size)):
            yadjust.value = newy
            vport.set_vadjustment(yadjust)
 
 
    def on_key_press(self, widget, event):
        """ Callback to handle the keys pressed in the main window
            Callback que maneja las teclas que se presionan en la ventana
        """
        keycode = gtk.gdk.keyval_to_upper(event.keyval)
        newx = newy = 0
        if keycode in MOVE_KEYS.keys():
            offset_x, offset_y = MOVE_KEYS[keycode]
            self._move_image(offset_x, offset_y)
        elif keycode in ZOOM_KEYS.keys():
            self._update_image(ZOOM_KEYS[keycode])
        else:
            return False
        return True # Con True cancelo el evento
 
 
    def on_mouse_moved(self, widget, event):
        """ Callback to the mouse movement inside the viewport
            Callback que es llamado cuando el mouse se mueve en el viewport 
        """
        # Ver: http://www.pygtk.org/pygtk2tutorial-es/sec-EventHandling.html
        if event.is_hint:
            x, y, state = event.window.get_pointer()
        else:
            state = event.state
        x, y = event.x_root, event.y_root
        if state & gtk.gdk.BUTTON1_MASK:
            offset_x = self.prevmousex - x
            offset_y = self.prevmousey - y
            self._move_image(offset_x, offset_y)
        self.prevmousex = x
        self.prevmousey = y
 
 
    def on_button_pressed(self, widget, event):
        """ When the user presses the left mouse button, save the x and y pixel positions,
            and change the cursor.
            Cuando el usuario presiona el botón izquierdo, guardo los puntos x, y de 
            origen del evento y cambio el cursor a "moviéndose".
        """
        if event.button == 1:
            self.change_vport_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR))
            self.prevmousex = event.x_root
            self.prevmousey = event.y_root
        return True
 
 
    def on_button_released(self, widget, event):
        """ When the user releases the left mouse button, set the normal cursor.
            Cuando el usuario suelta el botón izquierdo, vuelvo el cursor al normal """
        if event.button == 1:
            self.change_vport_cursor(None)
        return True
 
 
    def change_vport_cursor(self, type):
        self.viewport.window.set_cursor(type)
 
 
    def close_application(self, widget, event, data=None):
        gtk.main_quit()
        return False
 
 
if __name__ == "__main__":
    if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
        image_file = sys.argv[1]
    else:
        image_file = DEFAULT_IMAGE
    SimpleImageViewer(image_file)
    gtk.main()

Queda pendiente manejar el scroll del mouse para hacer zoom (ya que GTK mueve el gtk.Scrollwindow que contiene la imagen por defecto). Si bien funciona copiando y pegando esto en un archivo, también pueden descargar el ejemplo desde acá.

Espero que le sirva a alguien.

Actualización: ¡Gracias StyXman por la comparativa con PyQT! Ahí agregué la licencia y sobre el código… bueno, sólo agregar que es un ejemplo, la idea era hacer el código verborrágico apropósito. Por otra parte, y como conclusión personal, veo que QT tiene una clase QGraphicsView que maneja solito el tema del arrastrar y mover la imagen (eso lleva unas cuantas líneas en GTK).

Saludos

Me gustaría hacer un post bien largo acerca de todo lo que me dejó personalmente la última PyCon Argentina, pero lamentablemente estoy complicado con el tiempo, ya que no sólo quiero leer y escribir acerca de todo el “bombardeo” de información que te deja cada charla, sino que también quisiera investigar un poco cada cosa y dejar acá algo más que solamente los links. Pero bueno, vamos a hacer el intento de resaltar lo primero que me viene a la mente.

Cappuccino y la Web que se viene

Uno de los muy interesantes punteros que me dejó la conferencia tiene que ver con las keynotes[1][2], y la existencia por un lado de la aplicación web 280Slides y por el otro del framework en el cual se basa, Cappuccino. Sugiero pegarle una mirada, más que nada a las demos (para los faltos de tiempo como yo); me parece que es sencillamente genial, hay mucha influencia del OS X acá, y se nota. Es una aplicación donde la línea entre lo desktop y web se esfuma, literal y definitivamente. Lástima que hay que aprender oootro lenguaje nuevo, Objective-J.

Y esto parece que no se va a detener, tal como dijo Jacob. Más si nos enteramos que hay desarrollos bastante avanzados para integrar contextos canvas 3D en los navegadores, y leemos algunas características futuras de HTML5. En resumen, él plantea que toda la toolchain web actualmente apesta, incluso Python, y propone algunas líneas de solución para que Python sea el lenguaje web del 2020, cuando HTML 5 sea el estándar y el navegador web sea el nuevo Sistema Operativo. Ya había escrito algo de esto.

Código más rápido, código más optimizado: LLVM

De la segunda plenaria, me quedó claro que al fin surgió un contendiente de relativa importancia al venerable GCC, y se llama LLVM. Acá tengo más todavía para investigar, pero básicamente el branch performante de Python llamado Unladen Swallow implementará (entre varias cosas más) un JIT para CPython implementado por medio de LLVM; algo así como V8 o TraceMonkey son para Javascript. Una de las cosas en las que Collin afirmó varias veces fue que “no pretendemos ser originales, queremos robar ideas de cualquier paper, de donde sea, con tal de hacer Python más rápido” . Lo malo es que al parecer, y si bien era una de las ideas iniciales del proyecto, eliminar el GIL no será tan fácil (de paso y relacionado, ¡excelente charla la de Multiprocesamiento en Python!).

LLVM está haciendo muchos méritos para ser considerado, como por ejemplo que Apple está apostando muy fuertemente por él, incluso tiene la idea de reemplazarlo definitivamente dejando atrás a GCC. En Snow Leopard (OS X 10.6), ya mismo se ofrece una interfaz compatible con GCC para LLVM además de toda la toolchain para compilar software desde los fuentes con él. FreeBSD también está trabajando para migrar a él. Y si bien todavía le falta bastante camino por recorrer (tiene escaso soporte para C++, o que no compila el kernel de Linux, por ejemplo), ya se pueden ver algunas muestras de su potencial, y personalmente encontré varios comentarios de que es mucho más sencillo contribuir y entender el código del proyecto comparado con GCC.

En fin, repetí en ambos párrafos, en asuntos totalmente diferentes, la palabra toolchain, que significa literalmente “cadena de herramientas”, y está relacionado generalmente al uso de varias herramientas como un conjunto en las diferentes etapas de la creación de aplicaciones. Evidentemente, tanto en el mundo de las aplicaciones web, como en el de los lenguajes de programación, se está yendo hacia la optimización de los recursos que tenemos. ¡Buenísimo!

[1] Snakes on the Web – Jacob Kaplan-Moss
[2] Unladen Swallow – Collin Winter

¡Gracias a PyAr por una excelente PyCon!
Saludos

Mucho no me gusta hacer posts con casi nada de aporte propio, pero en este caso se lo merece. Este post sólo va a referenciar al excelente sitio de Doug Hellman, PyMOTW (Python Module of the Week). Básicamente el autor presenta una vez por semana un módulo de la biblioteca estándar de Python, realizando un análisis del mismo y mostrando ejemplos de uso.

En particular, esta semana hizo una introducción al módulo dis, que desensambla código Python mostrando el bytecode respectivo. Lo bueno es que muestra varios usos para el mismo (nuevos para mí), como en el caso de un debug o en el de optimizar el funcionamiento ahorrando bytecodes.

En fin, preparándome para la inminente PyCon Argentina, me entusiasmé leyendo y probando los ejemplos de este post. No puede haber programador python que no esté subscripto a su feed.

Saludos!

Sólo me voy a limitar a copiar el texto de la invitación… de más está decir que espero ansioso los días para ir, y creo que va a estar buenísima. Si sos programador o estás haciendo tus primeras armas en la programación, ¡no podés faltar!

Está abierta la inscripción para participar de PyCon Argentina 2009, la primera conferencia en castellano sobre el lenguaje de programación Python, a realizarse los días 4 y 5 de septiembre en la sede de la Universidad de Belgrano, Zabala 1837, en la Ciudad de Buenos Aires.

En esta primera edición contaremos con la participación de Jacob Kaplan-Moss (creador de Django) y Collin Winter (core developer de Python) como invitados especiales del evento, y con más de 30 charlas sobre Python y temas relacionados, desde tutoriales para principiantes hasta charlas de nivel avanzado.

Cronograma de charlas:
http://ar.pycon.org/2009/conference/schedule/

La entrada es libre y gratuita. Para evitar contratiempos, confirmar su asistencia y recibir credencial y demás materiales de la conferencia, se recomienda realizar inscripción previa en el sitio web.

Inscripción y más información:
http://ar.pycon.org/2009/registration/

Espero conocer gente ahí… ¡nos vemos!

Anoche estuve probando cerca de una hora el Alpha 3 de lo que va a ser Ubuntu 9.10. No suelo testear las alphas de Ubuntu en etapas tan tempranas del desarrollo (generalmente porque hay pocas cosas novedosas salvo actualizaciones de infraestructura como el kernel, gcc y X.org), pero en esta oportunidad sabía qué iba a buscar

Si bien hay pocos cambios visuales (a lo que dice este artículo le agregaría que la configuración del audio ahora sí va a estar un poco más integrada con PulseAudio), quería comentar que incorpora los últimos y nuevos drivers de Intel 2.8, publicados como estables esta última semana, que al fin elimina completamente el soporte a DRI1/EXA, y pone a DRI2/UXA como nuevo esquema de drivers (más, acá).

Lo bueno es que (a pesar de que lo probé poco tiempo), todos los problemas que estuvimos y estamos teniendo con los drivers Intel parecen haberse ido, ¡y la performance es excelente! Si, ya que que glxgears no es una herramienta de benchmark, pero si ahora mi máquina con Ubuntu 9.04 está tirando algo así como ~700 FPS y con problemas feos como este:

En cambio con Karmic Alpha 3 glxgears está escupiendo ¡~4800FPS!, y este bug no está, además de tener KMS (Mode-Setting de video por el núcleo directamente) funcionando perfectamente. Ahora puedo cambiar entre X (modo gráfico) y las consolas de texto en forma instantánea, así:

Por lo tanto, y sólo por esto a pesar de que faltan meses para la próxima versión, para mí ya va a valer mucho la pena actualizar en Octubre a Ubuntu 9.10.

Actualización: En Phoronix son optimistas, pero los resultados de sus tests dan ganador a Ubuntu 9.04 en performance. Lean el artículo acá.

¡Saludos!

Dando vueltas por ahí, me entero que es muy sencillo utilizar localmente versionado de código fuente (gracias a los sistemas de control de versiones distribuidos, como por ejemplo Mercurial, GIT y Bazaar) para luego subir/actualizar los cambios a un repositorio Subversion principal. Es decir, en vez de usar los comandos svn como clientes de un servidor Subversion, es posible utilizar alguno de estos sistemas distribuidos como clientes “consumidores” del repositorio principal, para luego aprovechar sus importantes ventajas en forma local.

En principio, admito que no conozco ningún VCS distribuido, más que nada por vagancia (je), pero esto en particular sí lo necesito de vez en cuando, principalmente cuando no estoy conectado, y/o cuando los cambios que hago con respecto a trunk son profundos, llevan tiempo y quiero tener un control más “fino” en lo que hago.

A ver, habiendo nombrado primero los sistemas más conocidos (por mí), se desprende que tenemos:

• Mercurial-Svn: Si bien el autor del artículo que me inspiró a escribir esto (Vadim Zeitlin, desarrollador de wxWidgets) comentaba que le gusta muchísimo Mercurial por su fácil uso, al momento de probar esta extensión para subir los cambios al servidor SVN de wxWidgets tuvo problemas de performance, uso de memoria, etc. De todas maneras, el código fuente en el repositorio de wxWidgets es bastante grandote (~330MB), así que quizás funcione bien para proyectos chicos/medianos, y más si uno ya conoce Mercurial.

• Git-Svn: Bueno, citando nuevamente a Vadim, parece que critica un poco lo complicado de los comandos Git, sin embargo termina recomendándolo en forma rotunda por su velocidad y poca utilización de espacio extra en el disco*. Acá parece haber un tutorial cortito para utilizarlo (Google me devuelve muchísimos enlaces más por si es poco).

• Bazaar-Svn: A Bazaar lo conozco por su relación estrecha con Launchpad y Ubuntu, por lo tanto yo probaría a este primero… ah, y ellos mismos elaboraron una comparativa (imparcial) entre Bazaar y Git por un lado, y entre Bazaar y Mercurial por el otro.

En fin, recién me sumerjo en la lectura y experimentación de todo esto, pero para aquellos que trabajan contra un servidor SVN** y suben sus cambios con poca frecuencia al repositorio principal, “rompiendo todo” cada vez que lo hacen (guiño, guiño), me parece que esto les viene perfecto.

Además, tengo entendido que no es difícil usar Bazaar (por poner uno de ejemplo), y realmente está muy cool poder volver atrás en los cambios que uno hizo desde que hizo el checkout/update del SVN, mientras desarrolla, y sin tener que conectarse a Internet (VPN/SSH/etc.).

(*) Cuando el cliente de control de versiones distribuido hace un checkout del repositorio Subversion, no sólo descarga la última versión de trunk, sino que descarga todas las versiones pasadas de todas las ramas existentes, con lo cual el consumo de espacio en disco local pasa a ser un asunto importante. Git, según Vadim, parece tener poco overhead en este sentido comparado con la extensión de Mercurial.

(**) Una de las cuestiones que no le hacen perder valor e importancia a SVN es que, al ser centralizado, sigue siendo relevante en empresas que quieren tener un control más o menos estricto de su código; por lo tanto, la migración a sistemas distribuidos no siempre estará bajo su radar. Es por eso que hablo de “diferencias” en el título del post y no de una “futura migración”, es decir, que los distribuidos sean los “nuevos vecinos de la cuadra” no quiere decir que vengan a reemplazar a los viejos y conocidos.

¡Saludos!

Leyendo un post sobre Windows 7 (no quiero opinar al respecto, sólo me voy a limitar a decir que no me gustó el post), quisiera rescatar este comentario de Mauro Verón:

A veces lo que jode del sistema operativo es que no nos gusta el “modelo” o la forma de hacer algo y está bien. Yo no lo veo a mi viejo en linux, porque esta acostumbrado a levantar el telefono y pedir comida por delivery, limitandose al menu del mismo. A mi me gusta Linux porque es como tener un chef al lado que te pregunta “que quiere comer señor?” y hace exactamente lo que le digo, cuando le digo, como le digo y rápido. Puede que necesite dare instrucciones complejas y especificas al chef si quiero algo muy extravagante pero, hey!, tengo un chef y puedo comer lo que yo quiera !
Para no dejar de lado al querido OSX este vendría a ser como un finísimo restaurante, con la mejor comida, el mejor vino, las mozas mas lindas, el servicio más rápido pero solo vende carne (haciendo referencia a lo “cerrado” que es apple en su hard/soft).

En fin gente, esa fue mi humilde opinión. Espero que se haya entendido y aclaro: yo hago que las cosas se adapten a mí. Si algo no se adapta, busco la alternativa para lo que necesito y listo ! no existe una solución universal a todos los problemas, por eso la vida es tan linda

Me pareció un excelente párrafo para citar, típico del “consumidor/analista que piensa”, y aunque mi opinión esté más del lado del “Ubuntu sirve para cualquier persona que no desee jugar los últimos juegos, incluso para mi viejo, y mientras yo esté a una llamada de distancia”, felicito a Mauro por la claridad de su comentario.

Ojalá todos pudiéramos evaluar las cosas de esa manera, antes de dejarnos llevar por cuestiones sin real importancia, como el cubo de Compiz, o poder ejecutar fácilmente el Photoshop sólo para eliminar los “ojos rojos” de las fotos del fin de semana.

Sin entrar en guerras santas, mis 2 ctvs.

¡Saludos!