Quantcast
Channel: Mariano Reingart
Viewing all 33 articles
Browse latest View live

Actualizaciones Factura Electrónica y Software Libre

$
0
0
Terminando de actualizar Proyecto PyAfipWs:

Debido a la liberación del aplicativo y otros temas menores estuve modificando el sitio, resumo los cambios:

Páginas actualizadas:
  • Página principal: Preguntas y Respuestas mas frecuentes (incluyendo temas generales no técnicos y normativa)
  • Factura electrónica en python: actualizado a las últimas versiones, incluyendo herramientas y aplicativos nuevos, subproyectos desarrollados (diseño de facturas por CSV, archivos de ancho fijo)
  • PyAfipWs y PyRece: reordenamiento y canal de soporte por issues de google code
Nuevas páginas:

Gracias a Trac por los menues y tabla de contenidos automáticos, y por su facilidad de uso.

Se agradecerían comentarios, opiniones y cualquier colaboración en general es bienvenida (pruebas, difusión, mejoras, etc.)

Orientar al Software Libre la carrera de Analista de Sistemas (proyecto)

$
0
0
En el Instituto Superior Tecnológico Blaise Pascal (terciario donde trabajo dictando dos materias de la "Tecnicatura Superior en Análisis de Sistemas"), venimos analizando algunas dificultades que se presentan en el desarrollo de la carrera, entre ellas: dispersión de contenidos, problemas para alcanzar los objetivos téoricos y prácticos adecuados, falta de motivación, aislamiento, etc.

Para superar estas dificultades, y teniendo en cuenta el tiempo como un factor limitante (tanto de docentes como de alumnos), una primer medida fue unificar los trabajos prácticos y apoyarlos transversalmente desde distintas materias. Si bien hubo una mejora, también hubo algunas complicaciones. Principalmente, la variedad de proyectos y herramientas fue contraproducente, no alcanzando las horas de clase destinadas a la práctica para abordar correctamente las dificultades planteadas por cada alumno.

Por ello, y para terminar de reforzar los contenidos y superar todas estas dificultades, es donde surge el software libre como solución. Por sus características abiertas y participativas, no solo se unificarían y profundizarían los temas teóricos, generando una continuidad más armoniosa entre las distintas asignaturas (eliminando temas solapados y mejorando el aprovechamiento de los tiempos disponibles), sino que además proveería proyectos concretos y reales para la práctica profesional.
De este modo nació el "Proyecto Curricular Institucional de la Carrera Analista de Sistemas orientado al software libre", inicialmente como un conjunto de ideas planteadas en las distintas reuniones entre docentes, que luego organicé en un documento más formal, con su debida justificación, y esperamos terminar de discutir y aplicar para este ciclo lectivo.

Este proyecto cumple con el plan estudio propuesto por la provincia de Buenos Aires utilizando integramente software libre, y su estructura es similar a los planes que se dictan en universidades nacionales y privadas (en ocasiones también con herramientas libres), aunque la carga horaria y objetivo son sensiblemente diferentes, por ello también la necesidad de optimizar los tiempos y ampliar los horizontes de salida laboral. 
Si bien es un proyecto específico para este instituto (ya que tiene en cuenta la situación y contexto local), puede ser aplicable a otras instituciones, ya que se basa en la resolución provincial que regula la tecnicatura, por lo que cada institución podría adaptarlo según sus necesidades específicas con la correspondiente capacitación docente (para ello se está trabajando desde el nuevo programa INTI-Sol, desde el taller de Educación y Capacitación).

Como eje se plantea tres herramientas básicas principales: GNU/Linux como sistema operativo, Python como lenguaje de programación y PostgreSQL como la base de datos. La elección, que responde a varios criterios detallados en el documento, es la que estimamos más adecuada teniendo en cuenta sus características didácticas, nuestros conocimientos como docentes y la posibilidad de capacitación y desarrollo de los contenidos y objetivos de las asignaturas (y de hecho ya se venía trabajando con dicho software satisfactoriamente).
Seguramente otros docentes pueden estimar que para su problemática se ajustan otras herramientas, bienvenidas sean, en mi opinión la diversidad es una ventaja, no un problema. Igualmente se planea usar o estudiar otras alternativas (Windows, PHP, MySQL, OpenOffice Base/Basic simil Access/VB) para que el alumno pueda comparar y elegir libremente.

Cabe aclarar que además están disponibles herramientas libres para todas las necesidades de la carrera (desde el editor de textos hasta repositorio de código, diagramación, etc.), y de más esta decir que el software libre es maduro, comercialmente viable (usado por las principales empresas y organismos, estatales y privados) y no solo cumple con los contenidos teórico-prácticos sino que también contempla las implicancias éticas de la profesión en el contexto social de nuestro país, y permite al alumno proveer soluciones y servicios diferenciados y competitivos.

La idea es que, en la medida de lo posible, todos los materiales (apuntes, trabajos prácticos, etc.) sean libres (licencia GNU Free Documentation License -GFDL- o similar), garantizando para sus contenidos, exactamente los mismos derechos que tienen los usuarios del software libre sobre las aplicaciones.
Además, creo que es fundamental que estos materiales sean generados dentro de la comunidad (ya sea para compartir recursos y unificar criterios entre los distintos docentes, como para favorecer la investigación y actitud autodidacta de los alumnos). En esto vengo trabajando en los sitios de los grupos de usuarios de PythonPostgreSQL en Argentina, tratando de retribuir generando materiales (apuntes, tutoriales, presentaciones, traducción de documentación, etc.), ya que creo que un punto esencial para elegir estas herramientas es que existan localmente comunidades fuertes y activas.

Desde ya queda abierta la convocatoria para que podamos colaborar entre todos y lograr una enseñanza sustancial y significativa.

Por último, los interesados que deseen revisar el documento de trabajo pueden hacerlo en GoogleDocs:
http://docs.google.com/Doc?tab=edit&dr=true&id=dd9bm82g_428g8zvfvdx
Última Versión Publicada:

web2py: el marco de trabajo web impresionante

$
0
0
Aprovechando el lanzamiento de la lista de correo y sitio web para la comunidad en español de web2py ("el framework web empresarial" que permite el desarrollo rápido de aplicaciones web2.0 profesionales), publico esta traducción de una recomendación que hice en ohloh:

Habiendo trabajado con jsp, php, turbogears y/o django,  cuando conozca web2py no va a querer mirar átras...

Web2Py hace al desarrollo web fácil y más eficiente, permite enfocarse en la lógica del negocio y no en temas técnicos triviales o esotéricos.

Características principales imponentes (por lo menos para mí):
  • Instalación muy simple, practicamente sin configuración (tanto de forma independiente y mod_wsgi)
  • La capa de abstracción a la base de datos (DAL) permite consultas poderosas sin siquiera una única linea de SQL, y no se necesitan complejas clases del modelo (adiós ORMs...)
  • Intuitivo y con curva de aprendizaje muy baja, ideal para ser enseñado en el aula para niveles principiantes
  • Estructura sólida todo-incluido, incluyendo ajax, menús, formularios, caching, GAE, etc. Su diseño limpio y seguro previene los problemas más comunes del desarrollo web.
  • Verdaderamente pythónico: modelos, vistas y controladores dinámicos, simples y explícitos, con un lenguaje de plantillas programable con python y ayudantes HTML.
  • Sin complicaciones de línea de comandos, incluso incluye un entorno integrado de desarrollo y herramientas de administración totalmente en línea, con un editor de código y html web, sistema de tickets de error, subida de archivos, etc.

Factura Electrónica de Exportación y ejemplo soap simple

$
0
0
El Web Service de Factura Electrónica de Exportación (WSFEX) es un nuevo servicio web de la AFIP para autorizar facturas electrónicas de comercio exterior (obtener el CAE).

Para poder usar estos webservices, como se comento en varias oportunidades, desarrollamos interfaces propias hechas en Python debido a la incompatibilidad y complejidad de otras soluciones (.NET, Java, PHP).

A continuación se presenta un ejemplo de cuatro simples pasos, sobre como usar SoapClient y SimpleXmlElement para consultar fácilmente los servicios web de AFIP:

Paso 1: Importar las clases que necesitamos utilizar de nuestras librerias de XML y SOAP:
from simplexml import SimpleXMLElement
from soap import SoapClient

Paso 2: Revisar el wsdl que describe los servicios y extraer URL, acción y espacio de nombres (buscar atributos location, soapAction -sin la operación-, targetNamespace respectivamente):
WSFEXURL = "https://wswhomo.afip.gov.ar/wsfex/service.asmx"
SOAP_ACTION = 'http://ar.gov.afip.dif.fex/'
SOAP_NS = "http://ar.gov.afip.dif.bfe/"

Paso 3: Creamos nuesto cliente SOAP de servicio web:
client = SoapClient(WSFEXURL,action=SOAP_ACTION, namespace=SOAP_NS, trace=True)

Paso 4: Llamamos a la función remota, por Ej. FEXDummy que obtiene el estado de los servidores de la AFIP. Para ello debemos invocar el método "virtual" del objeto client de acuerdo como especifíca el wsdl (se recomienda leer el manual del desarrollador que proporciona AFIP ya que el wsdl no es muy intuitivo). Como respuesta nos devuelve un objeto XML al cual podemos acceder directamente por sus atributos:
response = client.FEXDummy()
result = response.FEXDummyResult
print str(result.AppServer)
print str(result.DbServer)
print str(result.AuthServer)

Esto es todo, si funcionan bien nos debería imprimir el estado de los servidores (OK si estan funcionando).

Notar la simplicidad y dinamismo gracias a Python, sin perder flexibilidad, pudiendo invocar métodos arbitrarios y convertir los tipos de datos según nuestras necesidades.

En este caso el método del servicio web no recibe parámetros, si los tuviera se pasarían como argumentos por nombre (usando valores simples, diccionarios u objetos) de Python, ej.: 
response = client.FEXGetPARAM_MON(Auth={"Token": token, "Sign": sign, "Cuit":long(cuit)})
También puede tomarse como referencia los ejemplos de AFIP hechos en PHP, ya que desarrollamos estas herramientas para que sean similares.

El código completo para utilizar el servicio web de factura electrónica de exportación puede ser descargado de google code

Para más información y novedades sobre estos temas exite un grupo de noticia, el sitio con información general del proyecto y la páginas sobre factura electrónicainformación técnica y la interfaz PyAfipWs.

Clase Abierta: Introducción a Python, PythonCard y Web2Py

$
0
0
Invitamos a los interesados en programación, desarrollo de aplicaciones y diseño web a presenciar una clase abierta de la carrera Analista de Sistemas de nuestro instituto, donde analizaremos las virtudes del lenguaje de programación Python, herramienta PythonCard para diseño simple de aplicaciones visuales (GUI) y Web2Py para diseño ágil de sitios interactivos web 2.0.

Fecha: Miércoles 31 de Marzo de 2010
Horario: 18:15 a 22:30
Lugar: Instituto Superior Tecnológico Blaise Pascal
Dirección: Puerto Argentino 4238 - González Catán - Buenos Aires - Argentina
Entrada libre y gratuita previa confirmación por email debido a cupos limitados.
http://www.institutopascal.edu.ar

Temario:

1. Introducción a Python: ¿Que es python?; El Interprete; Estructura Básica; Tipos de datos simples; Tipos de datos compuestos; Control de Flujo; Funciones, Clases y Objetos; Excepciones; Módulos, paquetes y espacios de nombre
2. Introducción a la Biblioteca Estándar: sistema operativo, fecha y hora, expresiones regulares, números decimales, aleatorios, matemática, acceso a sitios web, manejo de email, xml, compresión
3. Interfaces gráficas "visuales" con PythonCard. Similitudes y diferencias con Visual Basic.
4. Desarrollo web 2.0 con web2py. Similitudes y diferencias con PHP. Diseño web HTML/CSS. Interactividad con Ajax (javascript).

Se agradece difusión.

Abierta la inscripción a FLISOL 2010 en González Catán

$
0
0
FLISOL, el Festival de Instalación de Software Libre que reúne a toda Latinoamérica, estará presente en González Catán el sábado 24/04/2010
Podés traer tu computadora y te ayudamos a instalar programas libres, que podés copiar, estudiar, corregir, modificar, compartir y seguir copiando.
Además: charlas informativas y demos para que conozcas más y disfrutes mejor las ventajas del Software Libre.
La entrada es libre y gratuita, sólo necesitamos que te inscribas previamente por nuestra web:

http://www.institutopascal.edu.ar/flisol2010

Participan integrantes de las siguientes comunidades locales, quienes estarán a cargo de las instalaciones, charlas y demostraciones:

PyDay 2010 Rafaela, web2py y más

$
0
0
Está abierta la inscripción para participar de PyDay Rafaela 2010, la primer jornada sobre el lenguaje de programación Python en Rafaela (Santa Fé, Argentina),  a realizarse el día 8 de mayo en la sede de la
Universidad Católica de Santiago del Estero, Departamento Académico Rafaela, ubicada en Hipólito Irigoyen 1502, organizado por PyAr:



Más información en: www.pyday.com.ar


Hay varias charlas agendadas, entre ellas daré una charla de web2py y seguramente en las charlas relámpago comentaré sobre los proyectos PyAfipWs (factura electrónica libre), Gestión Libre y/o nuestro emprendimiento Sistemas Ágiles.

Curso de Factura Electrónica y Software Libre

$
0
0
Esta abierta la inscripción para la nueva edición del curso sobre las últimas novedades de Factura Electrónica y Servicios web AFIP, relacionado con la interfaz PyAfipWs de Software Libre hecha en Python:

Curso Facturación Electrónica y Software Libre
Fecha: Viernes 25 de Junio de 2010
Horario: 18 a 20 hs
Lugar: AUBA - Club de Programadores Asociación Civil
Dirección: Auditorio Congreso - Entre Ríos 166 - C.A.B.A.

El temario incluye una introducción a factura electrónica nacional original (WSFE), y los nuevos web services de bienes de capital (WSBFE), seguros de caución (WSSEG), factura electrónica de exportación (WSFEX).
También comentaremos sobre temas relacionados, como ser el Código de Trazabilidad de Granos -Carta de Porte- (WSCTG), depositario fiel (wDigDepFiel) y Remito Electrónico ARBA (COT).

A su vez, presentaremos el aplicativo PyRece (simil RECE - SIAP) libre y gratuito para generar y autorizar facturas electrónicas,
entre otros proyectos relacionados.

La entrada es libre y gratuita, los interesados pueden consultar los detalles e inscribirse en:

http://www.clubdeprogramadores.com/cursos/CursoMuestra.php?Id=600

Más información:

http://www.pyafipws.com.ar

Se agradece difusión,

PySimpleSOAP e integración con web2py

$
0
0
PySimpleSoap es una librería que desarrollamos inicialmente para comunicarse con los servicios web SOAP de Factura Electrónica de AFIP, a la que luego hice varias mejoras generales (desprendiéndola del proyecto original PyAfipWs), incluyendo:
  • Un despachador para construir servidores (similar a xmlrpclib)
  • Soporte para WSDL: instrospección y generación dinámica
  • Serialización y desserialización automática, con una representación de datos simple basada en diccionarios Python
  • Interoperabilidad con .NET, Java Axis y JBoss WS, probado con SoapUi y .Net Web Services Studio, cumpliendo con los estándares WS-I
  • Capacidad de realizar pedidos y respuestas crudas -sin procesar- (útiles para tipos de datos genéricos xsd:anyType u operaciones avanzadas)
  • Documentación WIKI, incluyendo ejemplos WSDL, pruebas básicas de compatibilidad y rendimiento
  • Limpieza y estabilización de la API (incluyendo mejoras a SimpleXMLElement, una forma fácil y rápida orientada a objetos de manipular XML)
A diferencia de otras soluciones, nuestro acercamiento es simple e intuitivo, no requiere complicadas definiciones XML o código autogenerado, flexibilizando el desarrollo rápido de webservices con el dinamismo de Python.

Desde la reciente versión 1.82.1, la integramos con web2py, lo que lo convierte en una plataforma con soporte completo para exponer y consumir servicios web, complementando la infraestructura previa de json y xml_rpc, con un enfoque simple similar.

Esta disponible un servicio online para pruebas, con una página que contiene la descripción y mensajes de ejemplo:
Los comentarios son bienvenidos, sobre todo reportes o casos de prueba, ejemplos, colaboración con otras librarías para mejorar la interoperabilidad, etc.

Restaurando un GPS chino con software libre

$
0
0
Hace un tiempo me llegó un GPS "chino" (Viutech, hay otras marcas porque son genéricos, internamente vienen con WindowsCE).
Traen un software de navegación LogicGear o Igo8 (no Garmin) y una aplicación multimedia para reproducir musica, video y documentos.

Todo bien, lastima que es bastante frágil, y cada tanto la memoria flash interna (1GB) se corrompe (dañandose los archivos y no pudiendo entrar), por lo que el software de navegación deja de funcionar.


A tal punto se daño que aparecían archivos y directorios estraños, del tipo "ñ}çávèv" que ni siquiera se podían borrar con el explorador desde la PC, ocupando todo el disco sin dejar espacio disponible.

La única solución que encontré fue formatear la memoria interna (ADVERTENCIA: esto puede incapacitar permanentemente el aparato, usar con mucho cuidado bajo su propia responsabilidad)

La buena noticia es que hay herramientas avanzadas de software libre para poder manipular estos dispostivos de "bolsillo": synce y compañía (y en Ubuntu están muy bien soportados).

Para ello hay que agregar como orígen de Software http://ppa.launchpad.net/synce/ubuntu y descargar los siguientes paquetes:
  •  synce-hal
  •  synce-gvfs y gnome-vfs (para explorar los archivos)
  •  synce-trayicon (para poder montar facilmente el dispositivo)

Luego, por línea de comando, una vez conectado el aparato, ejecutar la herramienta para correr programas (en este caso, el explorador) :

synce-prun explorer

Con esto se abrirá el explorador en el aparato, donde podemos ir al "Panel de Control", "Storage Mananger", y ahí desmontar y/o formatear la partición (PELIGRO: seguramente tiene varias particiones y dispositivos, un error en este punto puede incapacitar permanentemente el aparato, usar con mucho cuidado bajo su propia responsabilidad)

Una vez formateada, al reiniciar el aparato se debería reestablecer la memoria interna sin datos, y en ese caso es posible volver a restaurar los archivos originales.  Para ello se puede usar synce-pcp o el navegador visual Nautilus (desde el SynCe Tray Icon, click derecho, WinCe, Explore with Filemanager)

Se viene el PyDay 2010 Buenos Aires

$
0
0
Este sábado 4 de septiembre es la jornada sobre el lenguaje de programación Python "PyDay Buenos Aires 2010" organizado por PyAr:

http://www.pyday.com.ar/

Entre varias charlas agendadas estaré presentando web2py (una herramienta para desarrollo web simple y poderosa) y seguramente en los espacios abiertos y/o charlas relámpago hablaremos sobre los proyectos PyAfipWs (factura electrónica libre), PySimpleSOAP (webservices), PyFPDF, Gestión Libre, y demás temas generados desde nuestro emprendimiento "Sistemas Ágiles", sin olvidarnos de PostgreSQL y su nueva versión 9.0!

Dos casos de como extender módulos de Linux para temas particulares

$
0
0

Router linux: SyncLink + HDLC + Frame Relay?


Alla por el 2000, cuando internet por banda ancha no existia (en gran medida), en el lugar donde trabajaba decidimos contratar una linea dedicada de telefónica.

Para no comprar un costoso router, la idea era conectarla directamente al servidor linux.
Inicialmente desde la empresa de comunicaciones me habían confirmado que era una linea punto-a-punto común, con protocolo PPP, entonces compramos una placa SyncLink serie sincrónica de alta velocidad para conectar al "modem" de telefonica.

Lamentablemente no funcionó, ya que en realidad el servicio se conectaba directamente a la red Frame Relay, por lo que la placa por si sola (un puerto serie), no era suficiente (por algún malentendido no nos habían enviado la información técnica correcta... menos mal que no compramos un router más caro).

Si mal no recuerdo, en su momento, Linux soportaba levantar un canal DLCI de Frame Realy (con hardware especial), pero no había un módulo con la disciplina de linea HDLC para poder hacerlo desde un dispositivo serie.

Afortunadamente, gracias a que todos los fuentes del sistema operativo estan disponibles, no fue dificil armar un controlador que permitiera establecer este tipo de comunicación (mediante una interfaz de red "especial").

Subí este driver (es un par de archivos relativamente simples, incluyendo módulo, herramienta en modo usuario, scripts de configuración y compilación), por si alguien les puede ser de utilidad, pero creo que esto ya esta soportado en el kernel (de una manera más integrada):

hldc_fr_synclink.zip


Mis disculpas por no haber sido más prolijo en su momento y haberlo documentado mejor, incluyendo los créditos completos para los autores originales de cada porción de código tomada como base.

Picotux: "microcomputador" Linux


Allá por 2005, para un proyecto de control de acceso, donde se debía controlar varios dispositivos físicos (barreras, molinetes, sensores) y lectoras de tarjetas, experimenté con Picotux, una minicomputadora con linux embebido para aplicaciones empotradas.

Dicho aparato es bastante útil, sobre todo porque la conexión de red, memoria flash y capacidad de procesamiento superan por lejos a los microcontroladores convencionales, con la ventaja de que al tener GNU/Linux no solo se pueden administrar y programar remotamente, sino que también es posible usar muchos paquetes de software libre/código abierto (servidores web, protocolos de red, lenguajes de programación, etc.).

En mi opinión, la característica más importante fue, nuevamente, poder modificar el kernel de linux (núcleo del sistema operativo), para agregar funcionalidad particular, en este caso, convertir dos puertos "TTL" (GPIO pins) en serie, para poder controlar más de una lectora.
Gracias a tener disponibles las fuentes del sistema operativo y controladores (y varios ejemplos similares), con un poco de esfuerzo fue posible desarrollar un controlador para puertos serie (UART) por software (conocido como bit-banging) a muy bajo costo (comparado a tener que desarrollarlo por hardware).

También, por si alguien les puede ser de utilidad, subí este driver (un archivo bastante sencillo):
netarm_gpio_swuart.c

Conclusión


Mi idea de comentarlo aquí es solo a modo ilustrativo, de como el linux puede hacer una diferencia cuando tenemos que solucionar cierto tipo de temas particulares.

Además, creo que es un buen punto para educación, por ejemplo en materias como Sistemas Operativos y Redes, posibilitando profundizar y mejorar los contenidos teoricos y prácticos, de manera simple, con temas concretos usando software libre.

Si bien con otros sistemas operativos (no abiertos) se puede desarrollar drivers/controladores, en general no se tiene un acceso completo al código fuente para ver como estan hechas soluciones similares o como se debe comportar en determinados casos (o directamente modificar el sistema operativo para cubrir una necesidad particular), lo que puede impactar en el presupuesto y viabilidad de una solución.

Novedades PyAfipWs -Factura Electrónica- (instalador nsis, pythoncom, soap)

$
0
0
Recientemente liberé una nueva actualización de la biblioteca PyAfipWs, con varias mejoras:
http://www.pyafipws.com.ar/anuncios/nuevoinstalador106ayejemplosparawsfev1
A continuación se detallan los temas técnicos:

Extension a py2exe para generar un instalador NSIS:

Inicialmente usaba un .BAT para generar el instalador (7-zip autoextraible), para simplificar y mejorar el proceso (detectar archivos en uso, desinstalar copia previa, mostrar licencia, elegir directorio, internacionalización), desarrollé nsis.py, una extensión para py2exe, que agregando dos lineas a un setup.py crea un paquete unico con todo incluido, usando Nullsoft Scriptable Install System:

from nsis import build_installer
setup(
...
cmdclass = {"py2exe": build_installer}
)

Más info en:
http://code.google.com/p/pyafipws/source/browse/setup_wsfev1.py
http://code.google.com/p/pyafipws/source/browse/nsis.py

El código está adaptado de una ejemplo de py2exe para Inno Setup. 

PythonCOM y la ruta de instalación

Para poder acceder a archivos locales en un ambiente empaquetado con py2exe, en general es trivial salvo que el script sea una DLL, ya que el interprete Python se "embebe" dentro del programa anfitrión, y los métodos estándard para determinar donde está ubicado el script fallan.
La solución mas simple fue usar:

  • sys.executable para cuando el script es un .EXE
  • win32api.GetModuleFileName(sys.frozendllhandle) para cuando el script es un .DLL
  • __file__ cuando se ejecuta directamente el .PY

Más info en:
http://code.google.com/p/pyafipws/source/browse/wsfev1.py#129

Type Library y PythonCOM:

Algunos lenguajes de tipado estático (C#, versiones de Cobol) necesitan para las interfaces COM una librería de tipos (mejor conocidas como .TLB) para referenciar y determinar los métodos, parámetros y valores devueltos, ya que Python es un lenguaje dinámico que no ofrece dicha información.
Para mi sorpresa, las implementaciones en lenguajes de tipado estático tampoco parecen ofrecerla, y es necesario en todos los casos usar un compilador de un lenguaje especial de MS (IDL):
http://code.google.com/p/pyafipws/source/browse/pyafipws.idl
Para que lo reconozca hay que agregar al objeto python los atributos _typelib_guid_, _typelib_version_, _com_interfaces_
http://code.google.com/p/pyafipws/source/browse/pyafipws.py#57

Igualmente todo este tema esta deshabilitado ya que el tipado estático ocasiona más problemas que los que resuelve (sobre todo con el registro, DLL hell, falta de flexibilidad, etc.), y hay métodos alternativos más simples para acceder a PythonCOM desde C# y lenguajes similares.

Mi agradecimiento a Mark Hammond (el creador de python-win32) por señalar al ejemplo "pippo" en el directorio win32com\test, como muestra de una asociación entre un objeto Python COM y su TLB.

Mejorando la performance SOAP WSDL:

El protocolo SOAP es complejo, y analizar el XML de la descripción de un webservice (WSDL) para poder comunicarse con el, es un proceso un poco costoso.
Gracias a Python la solución se simplificó bastante, ya que permite guardar y recuperar las estructuras de datos ya procesadas, sin necesidad de artefactos o código generado como en otros lenguajes (.NET, Java, etc.):
http://code.google.com/p/pysimplesoap/source/browse/pysimplesoap/client.py#244

Con el módulo cPickle de la librería estándar (implementado en C) se mejoro el tiempo para cargar un WSDL de 0.4 segundos a aproximadamente a 0.001 segundos, ~ 400 veces más rápido. Con pickle nativo (implementado en python) la mejora era un poco menos significativa (~ 40 veces más rápido).
Los test fueron realizados en una netbook para un webservice medianamente complejo, YMMV

Avances PyRece: WSFEv1, varias mejoras (XML/TXT/DBF/JSON) y rediseño

$
0
0
Continuando con el constante trabajo y avance del proyecto de factura electrónica y software libre, ya esta publicado la nueva versión del aplicativo libre y gratuito para gestionar facturas electrónicas utilizando los webservices de AFIP:

http://sites.google.com/site/pyafipws/anuncios/actualizacionpyrece123e

Esta actualización contempla soporte para WSFEv1 (el servicio web "versión 1" de mercado interno que entra en vigencia el 1° de Julio y afecta principalmente a importadores, monotributistas, turismo, etc.)

Además, se realizó un rediseño interno separandolo en módulos reutilizables en dos áreas: Formatos de archivos de intercambio y generación de PDF:

  • formato_csv.py: para planillas de cálculo 
  • formato_txt.py: para archivos de texto de campos con ancho fijo (por ej. Cobol) similar a SIAP RECE 
  • formato_xml.py: para archivos similares al Facturador Plus (utilizando SimpleXmlElement para serialización automática)
  • formato_dbf.py: para tablas compatibles con dBase, Clipper y FoxPro
  • formato_json.py: que exporta/importa los diccionarios de Python con simplejson
  • pyfepdf.py: modulo ya existente para generar los PDF (reutilizado) aprovechando el diseñador visual

Esto fue posible luego de unificar la representación interna de las facturas electrónicas, ajustando los campos para diferentes formatos a una estructura en común compartida por todos los módulos.

A su vez, se resolvieron algunos bugs por el tema de la codificación de DBF que serán enviados al desarrollador de dicha librería a la brevedad.

Todos estos cambios posibilitan en el futuro agregar soporte para otros formatos y webservices (WSFEX Exportación -RG2758-, WSMTX -RG2904, Bonos fiscales, etc.), que será el próximo paso a implementar.

Si bien se mejoro un poco el aspecto de la interfaz, estamos trabajando para la modernización de la interfaz, implicando una separación en capas para la integración de las tres soluciones:


Por todos estos motivos, se buscan testers, empaquetadores y colaboradores interesados en estos temas, proximamente nos vamos a estar reuniendo en el PyDay de Catán para tratar el estado del proyecto y los pasos a seguir, los esperamos:

http://www.pyday.com.ar/catan2011

Invitación al Público "PyDay 2011 Gonzalez Catan"

$
0
0

PyAr, el grupo de usuarios de Python Argentina, está orgulloso de anunciar que se encuentra abierta la inscripción para el evento PyDay Gonzalez Catán 2011: "Jornada de Programación en Python" a realizarse el sábado 16 de Julio de 2011 de 9 a 19hs en el Instituto Superior Tecnológico Blaise Pascal que contará con Charlas Introductorias y Talleres Prácticos sobre este incipiente lenguaje de programación, reconocido en el ambiente del Software Libre y visto como una creciente alternativa a Java.NET y PHP por su simplicidad, versatilidad y facilidad de uso, utilizado actualmente por miles de empresas, incluyendo a Google, NASA y YouTube.

http://www.pyday.com.ar/catan2011

El evento, de fácil acceso ubicado en el conurbano bonaerense (aprox. 1 hora de Capital), contará con la presencia de DocentesProfesionalesAlumnos y Entusiastas de diferentes puntos del Gran Buenos Aires y de varias provincias del Interior del País, representantes de diversas comunidades de Software Libre (PythonUbuntuMozilla yPostgreSQL, entre otras).

El lema de la jornada es "Python en el mundo real" mostrando casos concretos de aplicación de este lenguaje con ejemplos simples al alcance de todos que demuestran su alta potencialidad e impacto actual.
Los temas principales de la jornada serán: Software LibreEducación (nivel secundario y terciario), Desarrollo Web(django, web2py), Aplicaciones Visuales (wx, gtk, qt), Presentación Proyectos (factura electrónica, voto electrónico, trabajos finales y tesis de graduados), VideojuegosCooperativas, Economía Social y Oportunidades Laborales.

Las distintas actividades se detallán en el sitio:
http://www.pyday.com.ar/catan2011/conference/schedule
    La jornada se enmarca en el Proyecto Curricular Institucional de la Carrera "Analista de Sistemas" orientado al Software Libre y se contempla reservar aulas para espacios abiertos, temas avanzados, posters, presentación de proyectos, stands de comunidades, reuniones, mini-sprints de desarrollo, charlas relámpagos espontáneas no programadas y consultas del público en general.
    Son bienvenidos los colaboradores, empresas, entidades y comunidades interesadas en participar y auspiciar la jornada.

    El evento es de entrada libre y gratuita previa inscripción web (cupos limitados):

    http://www.pyday.com.ar/catan2011/user/register

    Se entregarán Certificados de Asistencia emitidos por el Instituto (sin costo)

    Trazabilidad de Medicamentos, Operaciones Cambiarias y Remito Electrónico

    $
    0
    0
    En el proyecto PyAfipWs se ha agregado soporte para varios webservices:


    Con estos servicios web el proyecto PyAfipWs se ha expandido más allá de los webservices de AFIP, incluyendo otras entidades y servicios, completando e integrando las funcionalidades más usadas por sistemas de gestión en Argentina, no solo para python sino que con la interfaz COM se pueden usar desde otros lenguajes en Windows (Visual Basic, Visual Fox Pro, Delphi, ABAP - SAP, etc.) e incluso con interfaces de texto o por linea de comando en otras plataformas (DOS, UNIX).
    Próximamente se agregará soporte para archivos CSV, DBF (dBase, FoxPro, Clipper, etc.), extendiendo y facilitando aún más el acceso a estos servicios web desde lenguajes de programación legados.

    Respecto a la librería PySimpleSOAP, se realizaron las siguientes mejoras para soportar los nuevos webservices:

    • Mejoras en analisis de WSDL (separando nombres de elementos y tipos complejos, reconocimiento de las diferentes partes de los mensajes, tag vacios)
    • Soporte de SOAP Header (encabezados para autenticación)
    • Soporte básico para WSSE (WebService-Security Extensions)
    • Ajustes por servidor, para formar el requerimiento según cada plataforma evitando incompatibilidades (por ej., no enviar tag vacio a JBoss-AS pero si )
    Las modificaciones experimentales están en una rama propia del repositorio, ya que algunos cambios pueden introducir incompatibilidades hacia atrás o todavía no son del todo definitivos. Más información en:

    Gracias a tener un desarrollo propio para la comunicación SOAP se pudieron solucionar estos y otros inconvenientes, incluso cuando otras soluciones para webservices fallaban o no se ajustaban a los requerimientos (que por cierto, ningun servicio web ha sido igual a otro, cada nuevo webservice introduce ligeras incompatibilidades, interpretaciones diferentes del standard SOAP o nuevas características).

    El servicio COT no es un webservice tradicional ya que no utiliza XML para el requerimiento ni SOAP para la respuesta, teniendo su propio esquema, por lo que solo se uso SimpleXMLElement de PySimpleSOAP (manejo de xml simple estilo objetos), y se adapto un WebClient para codificar los métodos POST. 
    Gracias a Matias Gieco por aportar los ejemplos iniciales que posibilitaron desarrollar el componente.

    Más información sobre el proyecto en:


    Anuncios completos:

    pg8000 1.09 versión de mantenimiento (fork) liberado (conector python para postgresql)

    $
    0
    0
    pg8000 es una interface DB-API 2.0 compatible puramente hecha en Python para el motor de base de datos  PostgreSQL.
    Al no depender de bibliotecas externas (libpq) o modulos compilados, puede ser instalada practicamente en todos los entornos, y habilita un acceso más profundo al protocolo de PostgreSQL, permite flexibilidad y extensibilidad más simple y para los desarrolladores Python como ser el soporte para sentencias preparadas parametrizadas usando qmark, numeric, named, format o pyformat según el paramstyle de la DBAPI).

    Las características principales de esta versión 1.09 de mantenimiento son: commit en dos fases, soporte para autocommit, propiedad server_version property y corrección de errores para casi todas las incidencias reportadas desde la versión 1.08 (2010-06-08)

    Para los detalles de los cambios en esta liberación, ver las notas en:
    http://html.pg8000.googlecode.com/hg/changelog.html


    La versión de mantenimiento de pg8000 puede ser descargada de:
    http://code.google.com/p/pg8000/downloads/list


    Para más información ver:
    http://code.google.com/p/pg8000/


    Para la versión original ver:
    https://github.com/mfenniak/pg8000


    Mis agradecimientos a Mathieu Fenniak por la versión original y a los contribuidores que han reportado y/o enviado sus correcciones que se han aplicado en esta versión.


    PD: Vengo trabajando con esta bibilioteca hace más de un año, me ayudo donde psycopg2 no pudo ser instalado (por no poder compilarlo por cuestiones de dependencias viejas) y cuando necesité más flexibilidad (el tema de paramstyle). Como se ve que el autor original no la mantiene más, decidí hacer el fork en googlecode, con la esperanza de que les sea útil a otros.

    pg8000 1.09 maintenance version (fork) released

    $
    0
    0
    pg8000 is a DB-API 2.0 compatible Pure-Python interface to the PostgreSQL database engine.
    It is one of many PostgreSQL interfaces for the Python programming language. pg8000 is somewhat distinctive in that it is written entirely in Python and does not rely on any external libraries (such as a compiled python module, or PostgreSQL’s libpq library).
    This pure-python connector approach allows to run it where C compiled libraries cannot be installed, it allows deeper access to PostgreSQL protocol internals and it enables easier flexibility and extensibility for Python developers (like support for parameterized prepared statements using qmark, numeric, named, format or pyformat DBAPI paramstyle).

    The highlights of this 1.09 maintenance release are: two-phase commit support, autocommit feature, server_version property and bug fixes for almost all reported issues since 1.08 (2010-06-08) 


    For details of the changes in this release, please see the notes at:

    http://html.pg8000.googlecode.com/hg/changelog.html

    pg8000 maintenance version may be downloaded from:

    http://code.google.com/p/pg8000/downloads/list

    For more information see:

    http://code.google.com/p/pg8000/

    For the original version see:

    https://github.com/mfenniak/pg8000

    Acknowledgements to Mathieu Fenniak for the original version and thanks to the contributors that reported and/or sent patches applied for this release.


    PS: I've been working with this library since the last year, it helped me where psycopg2 couldn't be installed (dependency compilation issues in older systems) or when I needed more flexibility (i.e. paramstyle). As it seems that the original author don't maintain it anymore, I've decided to make a fork in googlecode, with the hope it could be useful to other people too.

    A new web2py online python debugger

    $
    0
    0
    I've finished a new online debugger, based on my previous work on qdb module (bdb/pdb enhancement):


    In contrast with pdb, this debugger is based on a client/server model, so it should be more stable and extensible than my previous approach (a piped command line loop, see current debug.py module, a naive attempt to use pdb in a web environment, it is mostly undocumented as it requires some advanced python skills to use pdb commands without blocking the whole web2py server).
    In fact, qdb is based on the python bdb debugger framework (borrowing most commands from pdb), and it comes with a CLI, a separate GUI frontend (using wxpython), and for web2py, this totally web based interface.

    Although this blog post is about web2py, qdb can be used to make debuggers for other frameworks too, you can use WebDebugger as a base to make controller/views with your favourite web stack.

    Currently, this web2py debug implementation uses threads (debug and web ui, automatically managed by default web2py development server) and queues to communicate between them, but this can be extended to use multiprocessingclient/listeners or anything with that interface (send, recv and poll, using socket or pipes).

    Download:

    The web2py package with integrated debugger can be downloaded from my site:

    http://www.sistemasagiles.com.ar/soft/web2py_src_debug.zip

    The full source code and revisions are in my web2py repo clone in googlecode:


    You can download it with mercurial: 


    Also, if you have the latest trunk, you can patch it with:


    (the changes are in the default branch so will not create nasty repository effects)

    Brief Changelog:

    web2py is great because it is small and concise, so most changes are less than 100 lines (and some were trivial):
    • added gluon.contrib.qdb , the debug backend and basic frontend
    • updated gluon.debug to create the qdb client/server debug queues and the web frontend
    • updated applications/admin/controller/debug with interact and breakpoints controllers
    • added applications/admin/views/debug/interact.html and breakpoints.html
    • updated applications/admin/views/default/edit.html to add toggle breakpoint button
    • updated applications/admin/models/menu.py to add top-level debug menu
    • updated applications/admin/js/static/ajax_editor.js (toggle breakpoints) and style.css
    • updated gluon.html.CODE and gluon.highligh to show the context relevant lines 
    The full change log is available in the repository here. It took me less than 8 hours to add a debugger to web2py, very nice!

    Usage:

    Basic interaction (step, next, continue, return, stop, etc.), with the highlighted code, locals/globals and a interactive console to execute python statements in the debug environment.
    Access it from the added "Debug" main menu button (or go to http://localhost:8000/admin/debug/interact):



    To evaluate an expression, enter it in the second textarea, press enter and it will be executed in the debugger.

    The result, if any, will be shown in the upper textarea. You can execute any valid python command, including python assignment statements.

    To execute the current statement, press step. If you do not want to enter to functions, press next. To run the program until it finish or a breakpoint is reached, press continue. To cancel execution, press stop.


    Breakpoints (including temporary and conditional ones, with hit count) can be accessed from the Breakpoints button at the main debug page (or go to http://localhost:8000/admin/debug/breakpoints):



    Temporary breakpoints are deleted automatically after the first hit, and conditional breakpoints only matches if the associated python expression evaluates to True. 
    Also, the breakpoint page can show the context source code according to the line number specified.

    The breakpoints can also be added and removed from the edit window (new Toggle Button near back/docs, for example, in http://localhost:8000/admin/default/edit/welcome/controllers/default.py):


     


    It also can debug exceptions (handled or unhandled, note the exception info and traceback). After you inspect the local or global variables, press continue so normal exception handling will be done:


      


    With this changes, web2py can offer a complete online and ubiquitous Integrated Development Environment, so you don't need to learn any external tool to create web sites!

    This debugger was tested this on Ubuntu and Windows XP, but it should work in mac and other linux flavours too, as it is pure-python and no third-party dependencies are required.

    Future enhancements (supported by the backend, but not implemented already in the web frontend):
    • Jump to line and Run to line
    • Moving Up/down through the stack trace
    • Watch variable list (now they can be manually inspected with the interactive console)
    Current drawbacks and limitations:
    • from gluon.debug import dbg;  dbg.do_debug() or dbg.set_trace() should be called from the model/controller to run under debug control (if not, normal web2py dispatch occurs, no breakpoint is honoured).UPDATE: the debugger is automatically started if debug interaction page is opened or breakpoints are set (see wsgibase web2py entry point to run controllers)
    • The debugger is threaded, so beware of apache prefork and similar (the backend supports remote debugging, but it is more trickier to set the breakpoints). This also applies to the current shell and similar tools like paste. See modwsgi Debugging Techniques (Browser Based Debugger). Anyway, I'm working in a full remote multiprocess debugger (that is supported by qdb CLI and GUI right now)
    • Secondary effects can appear if debug more than a function at a time (it will not die, but it is more difficult to follow)
    • I didn't find a way to add markers to editarea yet (ie. a red circle near the line number to indicate a breakpoint)
    • Debugging cannot be limited per application (FILTER_APPS and multi user mode cannot be enforced)
    • Compiled apps cannot be debugged as easily as non-compiled ones (breakpoints must be set manually with set_trace)
    • Some style/layout details are missing

    So, if you want to try it, just set breakpoints and execute your controller to start debugging and enjoy ;-)

    PyCon US 2012 ("lo que nunca te contaron...")

    $
    0
    0
    El siguiente texto nació como una especie de rant escrito en una madrugada de insomnio (tratando de escribirlo antes de olvidarme la mayoría de las cosas), pero ya está más depurado. Sepan disculpar los inconvenientes.

    La Previa

    Envío de Propuestas

    Para 2011 había enviado dos propuestas, una charla sobre factura elctrónica (pdf, webservices, etc.) y un poster sobre "pyreplica" (replicación para postgresql con python). 
    El poster fue aceptado, la charla no tuvo la misma suerte, pero recibí un correo de notificación explicando los motivos (resumido: la facturación es un nicho, y hay charlas mejores). Lo mismo me paso en 2009 en la primer Conferencia de Python Argentina, por lo que posiblemente la redacción de la propuesta no fue lo suficientemente clara y adecuada para este evento, dado que a mi humilde entender, la charla trataba sobre otros temas más generales como servicios web, pdf, cli/gui, rpc con otros lenguajes legados, bases de datos, etc.

    Charla "Python Caveats: Fixing Broken Windows"

    Para este año intenté mejorar la descripción de la charla, con un abtract abarcativo y un bosquejo detallado, citando referencias, links a código fuente, estadísticas, etc. Estaba inspirado por el cuasi-panel "Python Apesta" de PyConAr 2011.
    Al día de hoy desconozco puntualmente el motivo de rechazo, pero seguramente este año hubo charlas mejores (de hecho las propuestas superaron en 4 veces la cantidad de espacio disponible para charlas).
    Ver más adelante en la sección revisión algunos temas "no del todo documentados" relacionados con la selección de charlas. 
    Posiblemente haga una entrada de este blog para ir refinando el tema.  

    Poster "RAD2PY: platform+IDE for solid & predictable Rapid Application Development"

    Basado en mi trabajo de tesis de licenciatura, prepare un poster para presentar:


    Como toda la propuesta no entró en el poster principal, arme dos carteles complementarios (web2py y gui2py):



    Felizmente el poster fue aceptado: https://us.pycon.org/2012/schedule/presentation/147/

    El poster tenía contenidos similares a los de la charla, resumiendo las 200 hojas de investigación.
    Un consejo: si desean presentar algo en PyCon, por las dudas, preparen un póster (hasta tienen más posibilidades que una charla relámpago, ver más adelante...)
    Además, los posters se aprueban a medida que llegan (con una demora de 1 mes aproximadamente), por lo que es útil para solicitar una Carta de Invitación para ir tramitando la Visa.

    Por el presente agradezco públicamente a JuanBC que me ayudó con la tipografía y temas de diseño (y lo más importante, diseño el logo de rad2py).

    Revisión de Charlas

    Como voluntario, participe en algunas etapas de la selección de charlas. 
    Comenzar es sencillo, un email introductorio al Comité de Programa (indicando nombre de usuario del sitio web y una breve biografía) y te habilitan el acceso a todas las charlas, con la posibilidad de hacer comentarios y la correspondiente revisón. 

    La revisión se basa en la técnica Identify the Champion, básicamente un puntaje entre +1, 0, -1, para literarmente defender u oponerse en alguna medida a cada charla. 
    Traté de revisar algunas, revisar todas era físicamente imposible y además uno debería tener conocimientos en la materia, por lo que me limité a charlas de web, gui, postgresql, educación, etc.

    Hasta donde recuerdo, como reglas generales, se debía priorizar proyectos reconocidos con una base de usuarios considerable, con código funcionando, documentación, etc. (de lo contrario, sugerían poster). Las charlas de comunidad fueron casi todas rechazadas (ver más adelante charlas relámpago). La biografia del autor era muy influyente (haber dado una charla previamente y ser experto en la materia era casi excluyente). Las propuestas poco detalladas serían rechazadas si el autor no contestaba los comentarios o no proveía más información (con algunas excepciones de autores reconocidos o temas puntuales).
    En teoría se debía calificar respecto a la propuesta concreta, no sobre la hipotética charla que nos gustaría ver.

    Si mal no recuerdo, las charlas con todos los votos negativos se descartaron directamente. Las que no tenían algún +1 quedaban en el limbo como dudosas. Las que tenían exclusivamente +1 se aceptaban casi automáticamente, pero fueron las menos (IIRC). El esquema es parecido al que se usó en PyConAr los primeros dos años.

    Luego vino el thunderdome, un "campo de batalla virtual" por chat para "luchar" a favor o en contra de cada charla (generalmente divididas en grupos de a 3-4, por afinidad, donde se debía aceptar, separar y descartar las propuestas). En mi caso no pude seguir el rítmo (perdí la cuenta de la cantidad de reuniones por IRC, a veces dos por día) y no llegué a comprender del todo algunos argumentos (en ocasiones parecieran bastante intuitivos en los escasos minutos que había disponibles para tomar una decisión sobre cada charla).

    Por último, quedaron algunos espacios vacantes por lo que se resucitarón algunas charlas (aquellas separadas en el thunderdome) a criterio del coordinador de programa, que solicitó previamente algunos comentarios no vinculantes.
    En mi humilde opiñon, este sistema es bueno para conferencias científicas/académicas donde uno tiene el artículo (paper) por anticipado y realmente hay pares expertos. Para conferencias comunitarias, creo que es mejor un sistema de voto alternativo por preferencias ponderadas (similar al sistema de Python Brasil y PyConAr en las últimas ediciones, incluyendo en ciertos casos una consulta al público que en definitiva es el que va a ver las charlas, como en EuroPython y PyConAr). 

      Asistencia Financiera

      Una de las principales barreras para asistir a PyCon US es el costo de los pasajes, estadía y entrada al evento (no es gratuito). Si bien no es algo impagable, los importes y el tipo de cambio son considerables para ir desde Argentina (desde 300 dólares la inscripción individual, 190 dólares la noche de alojamiento, 150 dólares cada tutorial, 1400 dólares el pasaje de avión, sin contar los costos de tramites visa, seguros, etc.).

      El año pasado, luego de completar el formulario,  dado la gran cantidad de solicitantes, me ofrecieron la entrada sin costo y 1/5 del pasaje. Finalmente luego de algunos días de espera para ver si se podía conseguir fondos adicionales, lo decliné para dejarle lugar a otra persona a la que le cierren mejor los números.

      Este año me ofrecieron algo similar (esta vez incluyendo noches de alojamiento, pero solo 50% de descuento en la registración bonificada). Luego pudieron ampliar la beca un poco y gracias a que pude sacar el pasaje con anticipación (bajo una promoción) y una mejor situación financiera personal, decidí emprender el viaje.

      La Conferencia

      Tutoriales

      Tomé dos tutoriales:
      • Faster Python Programs through Optimization
      • How to get the most out of your PyPy
      Para decirlo en criollo, tuvieron gusto a poco. En el primero tuve que compilar una herramienta (otras directamente no estaban soportadas) y en lineas generales no tuvo la profundidad esperada. En el segundo, termine encontrando un bug (feature no implementado) que me imposibilitó seguir.

      Parece que no fue algo aislado, el día previo ayude a una señora que tenía problemas para instalar Qt en su Mac, y luego al cruzarmela en la registración habiendo tomado el tutorial, no lo pudo instalar ni con la ayuda del instructor (por el tiempo que requiere), por lo que lo tomo con humor decidiendo que no era para ella, a lo que le recomendé wxPython como alternativa antes de Tkinter, que estaba por empezar a ver.

      Seguramente tuve mala suerte al elegir tutoriales que no eran para mi, ya que luego hablando con Tatiana Alchueyr, me comento que había asistido a un tutorial que estuvo muy bueno.

      WebDev Summit

      De lo mejor que vi en la conferencia. Un día entero dedicado al desarrollo web, con varios paneles tratando las distintas problemáticas:

      Me tocó reemplazar a Massimo Di Pierro como disertante en el panel "Factoring Code for Reuse", ya que por tema de horario él no podía asistir. Espero haber cumplido, lamentablemente mi Inglés no es perfecto pero viendo al moderador y charla informal posterior, entiendo que el mensaje llegó satisfactoriamente.

      Lo interesante fue ver como web2py encara satisfactoriamente algunos temas planteados, que no fueron considerados (calculo por desconocimiento) en la mayoría de ocasiones, como el despliegue simil .WAR con un paquete todo-incluido; reuso de otros modelos/componentes intercambiable entre bibliotecas; y promoción de Python para la Web (windows, educación, diseñadores y no programadores, etc.).

      Afortunadamente Massimo llegó luego del almuerzo y pudo dar una charla relámpago mencionando el modo en que web2py esta afrontando estos temas, espero que sirva para hacer de Python realmente una comunidad más diversa...

      Más alla de esto, fue muy interesante la jornada, viendo un poco cual es la tendencia actual, cuales son los problemas que enfrentan otros frameworks y buscar formas de colaborar (que discutimos luego en los sprints).

      Backstage, Registración y Desayuno

      La noche del Jueves se realizó el armado de bolsas (todavía no entiendo como se llenaron 2000 bolsas en un par de horas, teniendo en cuenta que incluía bastantes materiales e incluso otra bolsa). No tengo la cuenta, pero todos fueron voluntarios, tanto disertantes como organizadores y participantes ayudaron por igual.


      Por la mañana del viernes fue el grueso de registración (pasabas el código de barras impreso en la hoja, te entregaban otra hoja troquelada para hacer origami y armar el identificador con el colgante, a lo que se le pegaban las cintas según el tipo de participación):


      Ayude en lo que pude en ambos, fue útil para conversar y conocer gente, por ej. le entregue la remera a Armin Ronacher, y de paso le pregunté si quería venir a Argentina.

      El desayuno en el lugar también fue útil para charlar con gente y aprovechar mejor el día, lo que se complementaba con el almuerzo también en el lugar, donde por ej. nos juntamos con Tatiana para conversar temas de PyConAr 2012 y PythonBrasil 2012, y de casualidad me sente en la misma mesa que Brett Cannon, asique aproveche para comentarle sobre PyConAr (Ricardo Kirkner había hablado algo con él previamente).

      Charlas 

      El Viernes, Sábado y Domingo fue el evento principal. Más de 100 charlas llenaron el cronograma:

      Apertura, Keynotes y Plenarias


      La apertura fue muy entretenido, con un show de robots comandados por python (hubo una mínima demora esperando que la mayoria apague sus notebooks por la interferencia). Luego en el stand se pudo apreciar de cerca (ver abajo).

      La primer keynote, Stormy Peters de Mozilla, no tuvo mucho que ver con Python pero si con la comunidad, el open source. Si mal no recuerdo, arrancó como la web influye hoy por hoy nuestras vidas, habló de no maltratar ni espantar a los nuevos usuarios, no imponer el software libre a toda costa, etc.
      Para la segunda keynote estaba ayudando en la registración, pero por lo que escuche, fue más orientada a startups.

      La plenaria del Sábado (David Beazley) fue mucho más interesante y orientada a python (anunciada como técnica y diabólica), pero me quedo un sabor agridulce al ver la conclusión final sobre el futuro (no quiero faltar a la verdad con mi mala memoria, les recomiendo que la vean ya que es muy llevadera, tiene el estilo de Roberto Alsina).
      La plenaria del Domingo (Guido) obviamente fue 100% python, con un mensaje sobre el GIL y Android para pensar. En general, los consejos fueron interesantes, y el panorama del mundo Python creo que lo dejo en claro.

      Charlas Programadas

      Hubo charlas muy interesantes para mí como la de Armin Ronacher ("Code Generation in Python: Dismantling Jinja") y en menor medida, "Stop Writing Classes", "Web Server Bottlenecks And Performance Tuning", "RESTful APIs With Tastypie", "How CherryPy supports Python 2 and 3", "Spatial data and web mapping with Python", "Deep Freeze: building better stand-alone apps with Python". 
      Si bien ninguna tuvo la verdad revelada (dificil para 30 o 40 minutos), me llevé consejos utiles de ellas para procesar luego con más tranquilidad (que todavía no tuve).

      A la de Raymond Hettinger ("The art of subclassing") no pude entrar porque estaba llenno, pero aparentemente también fue muy buena.
      Otras, como "Putting Python in PostgreSQL" y "web2py: ideas we stole and ideas we had", me fueron útiles desde otra perspectiva, mas que nada, el modo de presentación, la interacción y preguntas.


      Una frase que me quedo dando vuelta fue "For the questions I warn you: I'm an architect so I don't know the details". Me pareció raro en una conferencia de este tipo (dado el tipo y descripción de charla). En estos casos, creo que tener de antemano el borrador de la presentación o un articulo/paper ayudaría a que no haya malos entendidos. 

      También me llamó la atención que la mayoría de las charlas terminaban con un mensaje tipo "Tenemos un startup, estamos reclutando empleados!", algunas llegando al punto de sobrevolar los temas técnicos para directamente recomendar contratar la solución comercial que ofrecían. 
      No digo que este mal, de hecho me parece útil conocer todas las opciones, solo que algunas me tomaban desprevenido.

      En algunas charlas trate de ayudar como session runner, no sin los sobresaltos típicos (el disertante no aparecía en una charla, el session chair no aparecía en otra, el session runner -yo- llegaba tarde y temas menores), igualmente fue enriquecedor y sirvió para romper un poco la rutina. La "green room" donde se reunía a los disertantes antes de la charla y se los obligaba a terminar (grabar en el pendrive) y probar la charla en el proyector fue bastante útil. 

      Charlas Relampago

      Las charlas relámpago de 5 minutos que ví fueron muy interesante, lastima que el video de PyAr que habíamos hecho (JuanBC principalmente, con la colaboración de todos) no fue seleccionado...


      Este año cambiaron las reglas y la selección en vez de ser por orden de llegada fue aleatoria (y el cronograma era bastante rígido, al punto de no poder cambiar el contenido de los slots que fueron adjudicados a otros miembros de PyAr). De haberlo sabido, quizás hubiera armado un poster o pedido  un stand comunitario. 


      Particularmente no se si es el mejor método para elegir charlas relámpago, ya que las hojas se llenaban estando hasta dos días disponible sin limite práctico (o sea, se anotaron 2 o 3 veces más propuestas del tiempo disponible). Creo que de este modo se pierde un poco la mística, en cambio, limitar a 10 charlas + backups me parece que le da más entidad, obligando a preocuparse y negociar un poco más con otros disertantes y el coordinador  (salvo que falle la interfaz humana, como en este caso).

      De hecho, este tema (expresado en un email de "feedback" en la lista de organización por quien escribe), sumado a que se rechazaron la mayoría de charlas de comunidad, quizás dé nacimiento a un track "comunidad" valga la redundancia, para agrupar las charlas que no cumplen los criterios de "notoriedada" y "audiencia" necesarios para las charlas generales.

      Espacios Abiertos

      Prácticamente me los perdí, estaban un poco alejados y no estaba muy atento a los temas que se presentaron. 
      De hecho, con Massimo armamos un espacio abierto de web2py al que no asistí porque se me superpuso con una charla y al llegar ya era tarde (en realidad me olvidé...). 
      Todavía me arrepiento ya que la charla no estuvo muy buena y me perdí de hablar con Guido, que estaba interesado en el depurador web (si, leíste bien, aparentemente GvR fue al OpenSpace de web2py...).

      El Testing BOF lleno mucha gente, no me pude quedar porque ya estábamos cansados, pero tenían proyector y todo, también me queda como asignatura pendiente para la próxima.

      Salón de Exposición

      Expositores

      El Viernes y Sábado armaron los stands de los expositores (Sponsors) y comunidad (PyLadies, Women Who Code, Pyramid). Eran varios stands, la disposición se asemeja mas a una evento comercial de TI (a diferencia de los eventos de software libre que he visto regionalmente).

      Más allá del merchandising, no alcanzaban los intervalos para recorrerlo completamente e interiorizarse con cada Stand, lo que le aportaba mucho a la conferencia.   
      Incluso cada tanto en el stand de NAO, los robot bailaban bajo la influencia pythónica:

       

      (perdonen la calidad de la foto, la camara tenía problemas con poca luz, por suerte la perdí...)

      Posters y Feria de Empleos

      Los posters fueron otro punto fuerte de la conferencia a mi entender. Del hall de esposiciones levantaron los stands y cada uno armo su poster. Durante una hora y media la gente se mostró muy interesada en los más de 40 posters, incluso el mismo GvR recorrió algunos y converso con los expositores. 


      El pizarron con mi poster (en ocasiones, flanqueado por Massimo en el poster secundario de web2py)


      En el fondo se ubicó la  Feria de Empleos, un lugar con mesas para que los Sponsors pudieran realizar entrevistas laborales y hablar con los interesados.

      Sprints de desarrollo

      Las reuniones de desarrollo fueron otro punto considerable de la conferencia. Según los organizadores, se lograron juntar alrededor de 700 desarrolladores el primer día.

      Si bien había proyectos para todos los gustos, estuve organizando un sprint de web2py, con varios interesados, principalmente:
      • Discutiendo temas surgidos del summit como gluino (un mini web2py que corre sobre flask, bottle, e incluso django) 
      • Implementando nuevos features, como el editor Ace para web2py, soporte para toscawidgets, coffeescript, etc.
      • Resolviendo algunos bugs y recibiendo feedback de los usuarios
      El resultado fue positivo, si bien Massimo tuvo que partir temprano, estuvimos trabajando varios días y la interacción con otros desarrolladores fue muy buena, abriendo un camino para que el año que viene otro desarrollador de web2py tome la posta y continuemos expandiendo nuestra comunidad.


      web2py sprint

      Hallway track, cenas y Party Nights

      Los pasillos en los intervalos fueron el mejor lugar para conocer gente, charlar y coordinar otras actividades, como las cenas y salidas (por cierto, no había muchos lugares cerca y encima casi todos cerraban a las 8pm por ser zona comercial, y como el transporte público existe y es regular -cada 1 hora-, conviente alquilar un auto o quedarse en el hotel).

      También conversé con Josh Berkus (core de PostgreSQL) acerca de que quizás sea interesante armar un PgDay en paralelo/cerca de la PyCon y aprovechar speakers en común (me vino a la mente Hannu Krosing, quién fue DBAs de Skype y miembro del proyecto SkyTools: replicación + python, ha dado charlas en otras PyCons, etc).

      Me encontré con usuarios de web2py de diversas partes del mundo (España/Finlandia, Brasil, India, Canada y por supuesto de EEUU). También me cruzé y con gente de Reino Unido, Austria, Singapur y otros países que ya no recuerdo.


      Algunos días hubo fiesta, PyCon Party y PyLaydies. A la primera, si bien tenìa la entrada, no fui ya que estabamos reunidos con gente que no tenía entrada. A la segunda, fuimos y ahí con Massimo nos encontramos con Tatiana, donde lo invitamos a ambas conferencias.

      Cerrando la reseña, en el lobby del Hyatt había un Pizarrón para grafitis lleno de mensajes, como ejercicio se puede comparar el  antes y después (¿por que es la progamación tu pasión? qbasic rules!): 


      Yapa

      Santa Clara esta en el medio del Silicon Valley, asique había cerca varios museos, incluyendo el de Intel (con su frase inspiradora: "Don't be encumbered by history. Go off and do something wonderful") y el Museo de la Historia de la Computadora (donde se exhibe el libro "The Mythical Man Month", referencia inicial de mi tesis y del póster):


       

      También se puede observar el botón "Steal From Your Friends" de la comunidad DECUS, y un recordatorio sobre "Sharing Software and Advice", como muestras de cooperación de hace más de 50 años.

      Post-Conferencia

      Aprovechando que estabá alla, como mini vacaciones me tome unos días para recorrer San Francisco y los Parques Nacionales de la zona.

      En el Sprint conocí a Ramiro da Luz, miembro de Python Brasil y organizador de varios eventos, asique pasamos el fin de semana conociendo California y entre las sequoias conversamos sobre Python, web2py, PyConAr, PythonBrasil, PyAr, APyB, el trabajo y la familia.

       
       

      "La fiesta termino ... y todo sigue igual", es hora de arrancar con la organización de PyCon Argentina 2012, cualquier cosa nos vemos en la próxima reunión. Traje merchandizing para repartir!

      YMMV
      Viewing all 33 articles
      Browse latest View live