Noticias sobre mis proyectos

lunes, 29 de marzo de 2010

Comparación de sistemas de control de versiones (a.k.a.VCS o SCM)

En esta breve entrada quería invitarles a que visiten el sitio http://versioncontrolblog.com , sobre todo si están tratando de decidir cuál sistema de control de versiones utilizarán. Allí es posible ver una tabla que compara las funcionalidades de los sistemas que se seleccionen teniendo en cuenta varios criterios como.

  • Commits atómicos
  • Soporte para seguir copias de ficheros y carpetas
  • Duplicación remota del repositorio
  • Control de acceso
  • Posibilidad de trabajar en un único sub-directorio
  • Interfaz web
  • Disponibilidad de interfaces de usuario gráficas
  • ... mucho más ...

Espero les sea útil el consejo ;o)

Tutorial: Cómo crear enlaces directos en Windows con Python

Enlaces directos en Windows

En esta ocasión trataré de resumir varios artículos escritos por Mike Driscoll y Tim Golden. Todos estos tutoriales tratan de explicar diferentes vías para crear desde Python enlaces directos (a.k.a shortcuts) para acceder a aplicaciones de Windows. Mi intención es, primeramente, acordarme. En segundo lugar quisiera facilitar documentar en un solo lugar los enfoques disponibles, y tratar de ilustrar las diferencias más ventajas o desventajas. Finalmente el texto estará en español ;o). Antes que todo, si todavía no se ha dado cuenta le digo que solo hablaré de Microsoft Windows. El artículo puede servir también como un pequeño mini-tutorial acerca del uso de los módulos winshell, win32com, pythoncom y habrá hasta un poquito de corrutinas ;o). Si desea estar al tanto de próximos artículos igualmente útiles, le invito a suscribirse por medio de RSS.

Preparación

Python Programming on Win32

Lo primero que hay que hacer es instalar las extensiones de Python para Win32 que se encuentran en el paquete de Mark Hammond llamado PyWin32. Igualmente útil puede resultar tener listo el módulo winshell de Tim Golden. Este último permite ubicar fácilmente las carpetas especiales (semi-mágicas) del sistema.

Creando un enlace a una URL en el Escritorio

Quizás la tarea más sencilla es crear un enlace (a.k.a link) en el Escritorio para acceder fácilmente a un sitio conocido. En caso que sea suficiente utilizar el navegador de Internet predeterminado, solo tendríamos que hacer esto:

import os.path, winshell

desktop = winshell.desktop()
path = os.path.join(desktop, "myNeatWebsite.url")
target = "http://www.google.com/"
 
shortcut = file(path, 'w')
shortcut.write('[InternetShortcut]\n')
shortcut.write('URL=%s' % target)
shortcut.close()

Brevemente podemos apreciar cómo se utiliza el módulo winshell para obtener el camino al Escritorio del usuario y se crea un fichero con extensión .url dentro de esta carpeta. El contenido de este fichero es el requerido por el sistema operativo y, finalmente debe lucir más o menos así

[InternetShortcut]
URL=http://www.google.com/

¡Eso es todo! :o)

La solución a más bajo nível con pythoncom

Quizás la versión más complicada, y por tanto más explícita, es la que se obtiene al utilizar la API Win32 desde Python. Para ello se emplea el módulo pythoncom, que permite cargar cualquier objeto COM e interactuar casi directamente con las interfaces y otros elementos. Veamos el ejemplo.

import os, sys
import pythoncom
from win32com.shell import shell, shellcon
 
shortcut = pythoncom.CoCreateInstance (
  shell.CLSID_ShellLink,
  None,
  pythoncom.CLSCTX_INPROC_SERVER,
  shell.IID_IShellLink
)
program_location = r'C:\Program Files\SomeCoolProgram\prog.exe'
shortcut.SetPath (program_location)
shortcut.SetDescription ("My Program Does Something Really Cool!")
shortcut.SetIconLocation (program_location, 0)
 
desktop_path = shell.SHGetFolderPath (0, shellcon.CSIDL_DESKTOP, 0, 0)
persist_file = shortcut.QueryInterface (pythoncom.IID_IPersistFile)
persist_file.Save (os.path.join (desktop_path, "My Shortcut.lnk"), 0)

Como se puede apreciar esto no es muy pitónico que digamos, sobre todo debido a que la API Win32 está diseñada para ser utilizada desde lenguajes como C. Más adelante se verán otras formas más sencillas de hacerlo. Sin embargo, creo que es un ejemplo muy interesante porque revela que los conocedores de la API Win32 siempre podrán utilizarla desde Python de una forma muy similar a la que ya están acostumbrados. Veamos qué está pasando.

Después de importar los módulos necesarios, se carga una instancia de la clase ShellLink y se indica que se utilizarán los métodos de la interfaz IShellLink que ella implementa. Por suerte los GUID de ambos ya están definidos (i.e. win32com.shell.shell.CLSID_ShellLink, win32com.shell.shell.IID_IShellLink). La función pythoncom.CoCreateInstance no es más que un simple wrapper alrededor de la archi-conocida función con un nombre similar presente en la API Win32. A continuación se especifican los datos necesarios para crear el enlace (i.e. programa a ejecutar, descripción y el ícono). En este momento ya todo está casi listo.

Lo único que falta por hacer es crear el fichero con la información que hemos especificado anteriormente. El último bloque de instrucciones se encarga de esto. La función win32com.shell.shell.SHGetFolderPath es similar a la presente en la API Win32. En este caso se utiliza la constante win32com.shell.shellcon.CSIDL_DESKTOP para obtener el camino a la carpeta del escritorio del usuario. Allí se creará el fichero My Shortcut.lnk, que es el que deseamos. Para hacerlo, hay que utilizar el objeto COM anterior pero necesitamos el método Save definido en la interfaz IPersistFile (su GUID es pythoncom.IID_IPersistFile). El método QueryInterface hace todo el trabajo de preparación.

A continuación les presento un código que utiliza la misma filosofía para actualizar el enlace creado en la sección anterior y hacer que apunte a otra URL.

import os, sys
import pythoncom
from win32com.shell import shell, shellcon

shortcut = pythoncom.CoCreateInstance (
  shell.CLSID_InternetShortcut,
  None,
  pythoncom.CLSCTX_INPROC_SERVER,
  shell.IID_IUniformResourceLocator
)

desktop_path = shell.SHGetFolderPath (0, shellcon.CSIDL_DESKTOP, 0, 0)
shortcut_path = os.path.join (desktop_path, "myNeatWebsite.url")
persist_file = shortcut.QueryInterface (pythoncom.IID_IPersistFile)
persist_file.Load (shortcut_path)

shortcut.SetURL ("http://python.org")
persist_file.Save (os.path.join (shortcut_path, "myNeatWebsite.url"), 0)

Creando un enlace al Media Player Classic con win32com

Python

Este ejemplo será un tin más complejo. Utilizaremos el módulo win32com para crear un enlace. Este módulo brinda acceso desde Python a ciertos componentes implementados sobre la tecnología COM, así que se trata de una operación digamos que a bajo nivel. Sin embargo, La ventaja en este caso consiste en que se facilitan varios pasos que sí son necesarios si se utiliza la API Win32 directamente con otros lenguajes (e.g. C, Object Pascal), o cómo se mostró en el ejemplo anterior. Veamos el código.

import os, winshell
from win32com.client import Dispatch
 
desktop = winshell.desktop()
path = os.path.join(desktop, "Media Player Classic.lnk")
target = r"P:\Media\Media Player Classic\mplayerc.exe"
wDir = r"P:\Media\Media Player Classic"
icon = r"P:\Media\Media Player Classic\mplayerc.exe"
 
shell = Dispatch('WScript.Shell')
shortcut = shell.CreateShortCut(path)
shortcut.Targetpath = target
shortcut.WorkingDirectory = wDir
shortcut.IconLocation = icon
shortcut.save()

Como se puede apreciar, en este caso se utiliza el shell de Windows mediante la interfaz IDispatch (más bien su equivalente en Python win32com.client.Dispatch ;o). Se utiliza el identificador WScript.Shell para cargar el objeto COM que deseamos y luego se utilizan sus métodos para asociarle el camino donde se guardará el enlace, el del ejecutable, el directorio de trabajo inicial, y el ícono que se mostrará. Este último puede ser el camino a un fichero .ico o a un ejecutable o dll'. La última llamada al método Save es muy importante, pues es la que hace que el enlace se haga persistente (i.e. se escriba en el disco)

A continuación les muestro una función que puede ser útil para manejar ambos casos.

from win32com.client import Dispatch
import os.path
 
def createShortcut(path, target='', wDir=None, icon=''):
    if wDir is None :
        wDir = os.path.dirname(os.path.abspath(target))
    ext = path[-3:]
    if ext == 'url':
        shortcut = file(path, 'w')
        shortcut.write('[InternetShortcut]\n')
        shortcut.write('URL=%s' % target)
        shortcut.close()
    else:
        shell = Dispatch('WScript.Shell')
        shortcut = shell.CreateShortCut(path)
        shortcut.Targetpath = target
        shortcut.WorkingDirectory = wDir
        if icon <> '':
            shortcut.IconLocation = icon
        shortcut.save()

Creando el enlace en Archivos de programas utilizando winshell

Ya hemos visto varias variantes pero sin dudas esta resultará la más económica en cuanto a líneas de código.

import os, winshell
 
program_files = winshell.programs()
winshell.CreateShortcut (
               Path=os.path.join (program_files, 'My Shortcut.lnk'),
               Target=r'C:\Program Files\SomeCoolProgram\prog.exe')

En este caso se guardará el enlace My Shortcut.lnk en la carpeta Archivos de programas del menú de inicio del usuario actual. El camino lo devuelve winshell.programs(). La función winshell.CreateShortcut hace exactamente lo que necesitamos. Además de los argumentos mostrados en el ejemplo, también es posible utilizar los siguientes:

  • Path : el camino dónde se creará el enlace
  • Target : el fichero que se ejecutará al activar el enlace
  • Arguments : Los argumentos (i.e. línea de comandos) que recibirá la aplicación
  • StartIn? : directorio de trabajo inicial
  • Icon : ícono que se mostrará en el Explorador de Windows
  • Description : Descripción del enlace

Resolviendo los enlaces

En este caso trataremos de implementar para Windows una funcionalidad que se obtiene casi sin esfuerzo al utilizar los enlaces simbólicos de sistemas Unix. A diferencia de este último, en Windows los enlaces directos son ficheros comunes y corrientes para el sistema de archivos, pero como ya vimos para el shell representan objetos de tipo IShellLink. Esta diferencia nos obliga a poner el parche porque ya salió el hueco ;o). A continuación leeremos una lista de ficheros y, si encontramos un enlace directo, lo seguiremos para retornar el fichero de destino.

import os, sys
import glob
import pythoncom
from win32com.shell import shell, shellcon

def shortcut_target (filename):
  link = pythoncom.CoCreateInstance (
    shell.CLSID_ShellLink,    
    None,
    pythoncom.CLSCTX_INPROC_SERVER,    
    shell.IID_IShellLink
  )
  link.QueryInterface (pythoncom.IID_IPersistFile).Load (filename)
  #
  # GetPath devuelve el camino y una estructura de tipo `WIN32_FIND_DATA`
  # que se ignorará. El parámetro indica si se desea obtener el 
  # nombre corto, el UNC o el camino (a.k.a. "raw path").
  # Por alguna extraña razón la documentación indica que las 
  # constantes correspondientes se pueden combinar :-$ .
  #
  name, _ = link.GetPath (shell.SLGP_UNCPRIORITY)
  return name

def shell_glob (pattern):
  for filename in glob.glob (pattern):
    if filename.endswith (".lnk"):
      yield (filename, shortcut_target (filename))
    else:
      yield (filename, filename)

desktop = shell.SHGetSpecialFolderPath (None, shellcon.CSIDL_DESKTOP)
for filename in shell_glob (os.path.join (desktop, "*")):
  print filename

¿Se podría mejorar este ejemplo utilizando winshell?

Conclusiones

Hay múltiples variantes para utilizar Python con el fin de crear enlaces directos en Windows. La más sencilla parece ser la que utiliza la función winshell.CreateShortcut. Sin embargo, hay tela por donde cortar y níveles de complejidad para todos los gustos.

Espero que le haya sido útil este corto tutorial. Si es así, le invito a estar al tanto de los próximos artículos. Trataré de abordar temas tan útiles y recurrentes como este. Me sentiría satisfecho si logro sacarle de un apuro o darle una idea para mejorar sus scripts de Python.

miércoles, 10 de marzo de 2010

Funcionalidades de Gmail Labs que voy a extrañar

GMail Labs

Recientemente Google ha decidido graduar y descontinuar funcionalidades de GMail Labs. Finalmente han permanecido 6 y se han retirado 5 Según se plantea, la decisión de quién se queda y quién se va se ha tomado considerando la cantidad de usuarios que los utilizaban. Ahora mi pregunta es relativamente simple: ¿acaso la popularidad es el mejor medidor en este caso ?

Graduados y expulsados

Para ser más explícitos, las mejoras que quedaran en el servicio resultan ser

  • Search Autocomplete
  • Go To Label
  • Forgotten Attachment Detector
  • YouTube Previews
  • Custom Label Colors
  • Vacation Dates

Retiradas las firmas aleatorias

Por otra parte se ha decidido prescindir de los siguientes Labs

  • Muzzle
  • Email Addict
  • Location in Signature
  • Random Signature
  • Fixed Width Font

Entre estos sentiré especial nostalgia por los dos últimos . Las firmas aleatorias me resultaban muy útiles al ser un canal muy propicio para aprovechar las listas de correos y promocionar con un mínimo esfuerzo varias páginas o sucesos. Su utilidad fue más evidente después de que le agregaron el título y el enlace que ofrecía el RSS de origen.

Letras con ancho fijo

Letras con ancho variable

Por otra parte el uso de letras con ancho fijo era muy útil para personas (como yo ;o) que incluyen código fuente muy frecuentemente al enviar mensajes a listas de correo. En este caso no soy el único que siente la ya confirmada desaparición de estas herramientas. Ahora yo me pregunto, ¿es que acaso es más útil tener un jueguito de serpientes en la Bandeja de entrada? No sé pero mi impresión es que la popularidad en este caso deja mucho que desear. Como dice Leonid Mamchenkov : it sucks to be a minority .

Retiradas las firmas aleatorias

viernes, 5 de marzo de 2010

La cara oculta de Fibonacci (en Python)

Leonardo de Pisa

Este artículo puede ser muy útil para que todos aquellos que se aferran a los resultados y conclusiones teóricas pues sean más cuidadosos al analizar sus resultados. Los números de Fibonacci nos revelerán las grandes distancias que pueden existir entre la teoría y la práctica. Esta famosa sucesión, que en sus orígenes fue útil para cuantificar la reproducción de los conejos, todavía sigue sorprendiendo a los teóricos de las matemáticas y otras ramas como las ciencias de la computación. En este caso revelaremos el secreto que se esconde tras un algoritmo aparentemente simple. No hay trucos, ni engaños de ningún tipo. Continúe leyendo hasta el final y seguro que se sorprenderá. Este es el primer espacio que dedico a analizar algoritmos útiles y sus diversas implementaciones. Si le interesa este tema o cualquier otro que se trate en este blog, Usted puede suscribire para recibir los próximos artículos. Le comento que pronto mencionaré sucesos realmente polémicos y candentes. Le invito también a que siga este blog, para así recorrer juntos el camino que nos lleve a todos a la comprensión de las tecnologías actuales y sus fundamentos.

Algoritmo simple para generar la serie

Seguramente todos conocen un algoritmo sencillo y eficiente (e.g. O(n)) para calcular los números de Fibonacci. A continuación les muestro su implementación en Python :

def Fibonacci(n):
  fn = f1 = f2 = 1
  for x in xrange(2, n):
    fn = f1 + f2
    f2, f1 = f1, fn
  return fn

if __name__ == '__main__' :
  from time import time
  
  def measure(n) :
    st = time()
    Fibonacci(n)
    return time() - st
  
  for data in ((x, sum(measure(x) for _ in xrange(10)) / 10) for x in xrange(25000)):
    print "%s,%s" % data

Sencillo, ¿verdad? Es muy fácil darse cuenta de que el número de sumas que se necesitan es proporcional al valor del argumento n. Por tanto a nadie dudaría al afirmar que esta implementación es muy eficiente y del órden O(n). Pero sería bueno preguntarse : ¿es esto lo que sucede realmente cuándo se ejecuta?

El ser tiene memoria ontológica en la praxis

Verifiquemos si el tiempo de ejecución de este algoritmo es realmente lineal. En este caso deberíamos obtener valores con pequeñas desviaciones alrededor de una recta. Las variaciones pueden estar dadas por la intervención del planificador de procesos del sistema operativo, la atención a interrupciones y otros muchos factores que realmente están fuera de nuestro control y pueden variar de un momento a otro, o de una computadora a otra. Grafiquemos los tiempos de ejecución para números menores que 46. Cada valor mostrado es el promedio los tiempos reportados por el comando que aparece a continuación al realizar 10 ensayos con el mismo valor de n :

$ python work/temp/fib/fib.py > work/temp/fib/fib.csv

Tiempos de ejecución -46 valores-

¿Cuáles son los resultados? Bueno realmente no hay nada más parecido a una recta. En este momento Usted se preguntará ¿cuál es el misterio? , ¿me están tomando el pelo?, ¿esto es una broma?, ¿me están hacendo perder mi tiempo?. No se deje llevar por las apariencias. Veamos otro gráfico obtenido al repetir los ensayos con los números enteros menores que 25,000 (tomados a intervalos de 50 para que los datos no sean tan voluminosos ;o).

Tiempos de ejecución -25

¡No es posible! El incremento en este caso no es para nada lineal, sino que la curva parece una parábola. Incluso si se trata de realizar un ajuste con una función cuadrática la coincidencia se hace muy evidente. ¿Cómo es posible que se comporte con este crecimiento cuadrático (i.e. O(n2))?

Revelando el secreto

La causa fundamental por la que en este caso los resultados teóricos difieren tan significativamente de los prácticos es que en el primer caso se asumió que durante la ejecución todas las sumas se ejecutaban en un tiempo constante, pero esto no es así cuando se lleva a cabo el proceso en un ordenador real. El hecho de que para números pequeños la linealidad se mantiene, nos da una pista muy importante para buscar la raíz del problema. ¿Todavía no se les ocurre nada? Todos aquellos que mencionaron la aritmética de los números enteros grandes definitivamente acertaron.

Tiempos de ejecución -250

A medida que se van computando nuevos números de la sucesión, los valores se van haciendo tan grandes, que exceden los 32 bits (y eventualmente también los 64 bits) de la arquitectura de base. Por tal razón hay que apelar al tipo long. Claro que el lenguaje es consistente y todo esto resulta transparente para el programador. Pero, al mismo tiempo el costo para calcular cada suma se va haciendo proporcional a la longitud del número de Fibonacci previo. La adición de dos números grandes de longitud O(n) es un algoritmo lineal (i.e. O(n)).

La demostración matemática

A continuación les presento un análisis que explica la baja eficiencia del algoritmo mencionado, cuando se ejecuta en una PC real. Se considera el procesamiento adicional y solapado realizado por la librería bigint.

En cada iteración i se realiza un número de operaciones del órden O(número de dígitos de fib_N) = O(digits(fib_N)). Por tanto es necesario sumar todos estos valores para cada número (i.e. valor de i) entre 1 y n:

http://3.bp.blogspot.com/_DpPqqMKo7KA/S5Fa1euOSSI/AAAAAAAAAHY/-x4tijjOTg0/s400/f1.png

Pero, ¿cuál es el número de dígitos del enésimo número de Fibonacci? Como punto de partida tomaremos la fórmula de Binet. La misma enuncia que el enésimo número de Fibonacci puede ser expresado por calculado utilizando la fórmula siguiente :

http://4.bp.blogspot.com/_DpPqqMKo7KA/S5Fa1hbqTkI/AAAAAAAAAHg/vlyabGb-4-k/s400/f2.png

El número de dígitos de un número se puede calcular hallando la parte entera del valor log 10 (number) + 1. Por tanto la cifra que buscamos es nada más y nada menos :

http://3.bp.blogspot.com/_DpPqqMKo7KA/S5Fa1w7ofOI/AAAAAAAAAHo/JJn3URon2po/s400/f3.png

Al sumar todos los costos en los que se incurre para el valor final, se obtiene la siguiente expression:

http://3.bp.blogspot.com/_DpPqqMKo7KA/S5FbGxccmUI/AAAAAAAAAHw/BJ6PN6g89IA/s400/f4.png

Se puede observar cómo el tiempo de ejecución de este algoritmo "lineal" realmente resulta ser cuadrático, considerando que cada suma se ejecuta en un tiempo proporcional a la cantidad de dígitos de los números de Fibonacci involucrados.

Conclusiones

Los métodos y resultados teóricos son de un valor tremendo para las matemáticas y las ciencias de la computación en general. La belleza y al mismo tiempo complejidad de las demostraciones es una fuente de sorpresa. Su comprensión desarrolla nuestra capacidad de razocinio y otras habilidades que nos permitirían comprender más a fondo el mundo que nos rodea. Sin embargo, la realidad suele ser mucho más rica. Por tanto es de vital importancia comprender y validar las hipótesis antes de emitir un juicio definitivo, y aplicar los teoremas y corolarios con mucho cuidado.

Si desea participar en este recorrido que realizaré para ilustrar aspectos interesantes de varios algoritmos famosos, le invito a estar al tanto de los próximos artículos. Pero estos no son los únicos temas que se tratan aquí en el blog de Simelo. Le invito también a que siga este blog. ¡ Seguro que no se arrepentirá !

jueves, 4 de marzo de 2010

Soporte para Hessian (RPC) en Trac

API multi-protocolos para RPC

El día de hoy es histórico. Recientemente Odd Simon Simonsen me ha invitado a participar en el desarrollo del muy útil y exitoso plugin TracXmlRpc. El mismo permite que las aplicaciones realicen diversas operaciones sobre los entornos de administración de proyectos gestionados con Trac. En estos momentos se desarrolla una API que permitirá ejecutar los métodos disponibles a través de múltiples protocolos. Hace solo unos minutos efectué la primera llamada exitosa utilizando Hessian. Este es un protocolo binario muy popular en el ámbito de Java, pero puede ser implementado en cualquier otro lenguajes, y eso incluye a Python . Los detalles ...

... bueno, no quiero adelantar mucho todavía porque la implementación no está estable y muy probablemente se le hagan cambios incompatibles al prototipo de la API que existe hoy. Pero bueno, el plugin implementa dos protocolos muy populares para efectuar llamadas a procedimientos remotos: XML-RPC, JSON-RPC. Hay soporte para el primero en la librería estándar (i.e. xmlrpclib.ServerProxy), mientras que el segundo es accesible si se utilizan otras librerías (e.g. wsgi-jsonrpc). En el caso específico de Hessian, se necesita hacer lo siguiente desde el cliente para conectarse al servidor:

>>> from hessian.client import HessianProxy as HSP
>>> auth = {'username' : 'olemis', 'password' : 'canhurtyoureyes'}
>>> hsp = HSP('http://localhost/trac/newprj/hessian', auth)
>>> getattr(hsp, 'system.getAPIVersion')()
[1, 1, 0]

¡Eso es todo! Si quiere estar al tanto del desarrollo de esta nueva funcionalidad les invito a seguir los próximos artículos. El soporte de Hessian para Trac es solo el principio ;o) .

martes, 2 de marzo de 2010

Robots activos para Google Wave: introducción a la versión 2 de la API

Los robots son una parte importante de la API de Google Wave, y se han convertido en una herramienta aún más poderosa. Recientemente Google ha puesto a la disposición de los programadores la versión 2.0 de la API de robots. En esta caso se incluyen varias nuevas prestaciones útiles :

Basado en el anuncio oficial en inglés.

  • API de robots activos : En esta versión los robots pueden interactuar con el servicio sin tener que esperar por una acción iniciada por los usuarios. Por tanto se elimina la necesidad de utilizar la API de tareas programadas (a.k.a. cron API, cuyo uso no es recomendado en lo sucesivo), puesto a que se puede actualizar la ola (wave) cuando cambie el estado del tiempo o cuando el precio de las acciones esté por debajo de un límite determinado. Se puede encontrar más información en la documentación de esta API.
  • Contexto : Los robots pueden especificar con mayor precisión cuanta información necesitan para reaccionar ante la ocurrencia de un evento. Si solo se necesita modificar el contenido de los blips y es preciso utilizar el ancho de banda eficientemente, entonces se puede especificar el nuevo contexto SELF. Si se necesita conocer toda la información que pueda aportar el contenedor (i.e. wavelet) entonces se puede utilizar el nuevo contexto ALL. Para más información se puede consultar la documentación de los contextos.
  • Filtros : De manera similar, con esta nueva versión es posible especificar un subconjunto de todos los eventos disponibles, de acuerdo a las necesidades del robot. El servicio solo notificará estos eventos, por lo que todos los demás pasarán inadvertidos. De esta manera se podrá utilizar racionalmente el ancho de banda. Más información está disponible en la documentación del filtrado de eventos.
  • Reportes de errores : Los robots son capaces de indicarle al servicio que desean recibir errores sobre operaciones fallidas. Para más información se puede consultar la documentación de los reportes de error.
  • Proxying-For : Los robots pueden indicarle a Google Wave que realizan una acción en nombre de un usuario diferente. Para ello debe utilizarse el campo proxyingFor. En casos como el del robot Buggy, que facilita la integración con el gestor de incidencias de Google Code, esto quiere decir que la ola (wave) puede ser actualizada haciendo referencia a un usuario que realizó la acción original, por lo que puede que no pertenezca al conjunto de cuentas con acceso a Google Wave, sino que abarca usuarios más allá de sus fronteras. Más detalles pueden ser consultados en la documentación de esta funcionalidad

Para comenzar a sacar provecho de estas nuevas características en los robots, se pueden consultar los consejos básicos y es preciso descargar las nuevas librerías para Java y Python. Las mismas están actualizadas con las mejoras hechas al protocolo de base del servicio, cuya especificación ha evolucionado para abrir las puertas a la implementación de librerías similares para otros lenguajes de programación.

Si se desea tener un ejemplo como referencia para mejorar, actualizar o comenzar un nuevo robot; se puede visitar la galería de ejemplos. Allí se pueden encontrar los robots Stocky, Submitty, y Twitter-Searchy, que ilustran el uso de la nueva interfaz de programación.

Finalmente, se experimentará el uso de Google Wave para llevar a cabo las discusiones acerca de la nueva API. Para ello se ha implementado un robot que facilitará las conversaciones. Para conocer más detalles acerca de cómo participar en estos debates se puede consultar esta página.

Google Wave Developer Blog: Introducing Robots API v2: The Rise of Active Robots

lunes, 1 de marzo de 2010

Comienza la era de la televisión 3D (el 10 de marzo ;o)

Videos sobre TV 3D

Después del gran éxito del largometraje Avatar, de las transmisiones del Rolland Garros y la consecuente aceptación de esta tecnología, se aproxima la era de la televisión 3D . Panasonic y Best Buy organizarán un evento el 10 de marzo del 2010 especialmente matizado por el lanzamiento exclusivo e inmediato del sistema de teatro casero 3D de alta definición 1080p . Los mismos serán vendidos (ver precios) inicialmente por Best Buy, según citan varios medios de prensa que recibieron invitaciones especiales para participar.

Después de una conferencia de prensa, una ronda de fotografías se llevará a cabo para promocionar la venta de estos artefactos que introducirán el 3D en las casas de los afortunados que decidan (y puedan) comprarlos. Esta tecnología fue una de las propuestas más relevantes del Consumers Electronics Show, organizado en enero en Las Vegas. La delantera en este terreno parecen llevarla las empresas Sony y Samsung. La primera ya vende sus tecnologías por mediación de Sony Style, mientras que Samsung ha anunciado su propia conferencia de prensa el 9 de marzo del 2010. Por su parte Sharp anunció que había desarrollado un prototipo. Panasonic aprovechó la ocasión del CES y el entorno actual para revelar su línea de productos 3D, y le echa leña al fuego en este sector emergente.

TV 3D facilita video-llamadas a través de Skype

Como es de esperar este suceso también viene acompañado de cierto escepticismo, pero a la larga no dudo que la TV 3D se irá imponiendo poco a poco, como lo han hecho otras tecnologías relacionadas con los medios audiovisuales y de comunicación . Por solo mencionar un ejemplo, ya en esta temprana fecha los primeros equipos de TV 3D de alta definición (50 - 65 pulgadas) presentados por Panasonic incluyen integración con Skype para efectuar video llamadas a través de esta red. Quizás esta sea solo la primera prueba del interés que generará esta tecnología.