1. PyAfipWs: growing up a project & surviving 15+ years in Argentina 



    About:


    The project PyAfipWs is a library and tools for government web-services.

    I'm one of its creators & maintainer, being a python enthusiast since long time ago.


    Also I'm a software developer, tech leader and now architect, and studied a Master in Free and Open Source Software (CV).


    We formed a micro startup (Sistemas Ágiles: Agile Systems) to support the project and complement the community effort.


    Summary:


    Technology: 

    • Multiplatform library & end user tools (windows executables, interoperability & legacy interfaces, spin-offs: SOAP WS / PDF projects
    • Python 3 challenges, crypto/ssl issues
    • Useful GitHub actions for windows automation and test against external webservices.
    Community: 
    • Tips and lessons learned to sustain a non trivial user base and hundreds of customers.
    • Building a 2k user group & GSoC mentorship / contributions
    Resources: 

    • Commercial dual-license funding / tech support / maintenance
    • Alternatives to create sustainable open source projects for local or regional needs.

    ChatGPT intro experiment:


    As an alternative presentation, when asked the AI to give some information to the topic:

    Q: What are the Argentina major government webservices (AFIP, ANMAT and ARBA)? Q: And what Python open source library can I use to interact with them?


    The overall responses were interesting (and it mentions our library), although there are some wrong facts (strikethrough the wrong parts):
    The major government webservices in Argentina are: AFIP (Administración Federal de Ingresos Públicos) - This is the federal tax agency in Argentina responsible for collecting taxes and ensuring compliance with tax laws. ANMAT (Administración Nacional de Medicamentos, Alimentos y Tecnología Médica) - This is the national regulatory agency in Argentina responsible for ensuring the safety, efficacy, and quality of drugs, medical devices, and food products. ARBA (Agencia de Recaudación de la Provincia de Buenos Aires) - This is the tax agency for the province of Buenos Aires in Argentina, responsible for collecting taxes and ensuring compliance with tax laws in the province. To interact with these webservices, you can use the Python Requests library to make HTTP requests and retrieve data from their APIs. Additionally, you may need to use Python libraries specific to each webservice to handle authentication and data parsing. For AFIP, you can use the PyAFIP library, which provides a Python interface for interacting with AFIP's SOAP web services. 😀 For ANMAT, there is no specific Python library available, but you can use the Requests library to interact with their RESTful API. 😕 For ARBA, you can use the PyARBA library, which provides a Python interface for interacting with ARBA's SOAP web services. 😱

    Warning with AI hallucinations! 

    PyARBA project doesn’t seem to exist (as far I could search eg. PyPI nor Google nor GitHub). 

    In another question the AI also mentioned WSSRv1, a government webservice that seems to not exist either.


    In fact, our library (which its complete name is PyAfipWS) supports several webservices including  AFIP, ANMAT and ARBA.


    Probably it would be better to divide this project per gov agency PyARBA / PyANMAT etc. but that could be harder to maintain.


    Most of them are SOAP (Simple Object Access Protocol), a mixture of HTTP + XML.

    It is not really simple, except ARBA that uses something like a REST API with CSV request and XML response (so ChatGPT mixed a bit that or is referencing other webservices).


    It seems the AI is translating some concepts wrongly (method names?).

    Naming convention debate aside… Spanish is used in official webservice methods documentation, and some words doesn’t have a direct English translation.


    Finally, when asked "Please write a code snippet in Python to generate and authorize an Electronic Invoice for Argentina AFIP webservices using PyAfip library", the response was (edited):
    Sure, here is a code snippet in Python using the PyAfip library to generate and authorize an Electronic Invoice for Argentina AFIP webservices: … In this code snippet, we initialize a WSFEv1 instance with our AFIP credentials and set the invoice data. We then call the create_invoice method to generate the invoice and authorize it. Finally, we print the response.
    Note that you'll need to replace the placeholders with your actual AFIP credentials and certificate paths.  

    but after that there are some de


    The code snippet is not that bad, the first line written (from pyafipws.wsfev1 import WSFEv1) looked promising as it mention our library and correct webservice class, but after that there are some problems. It confuses the request and response, uses the version 0 fields instead version 1, misses some tax structures as we have different VAT tax percentages, and it doesn’t point out the major result (CAE: authorization code).

    Maybe ChatGPT is mixing other libraries/examples?


    The correct code could be found in the project examples directory: factura_electronica.py (and there are also programs and code fragments for other programming languages and webservices).

    A short fragment to illustrate and compare:

    import datetime from pyafipws.wsaa import WSAA from pyafipws.wsfev1 import WSFEv1

    # authentication (TA: access ticket) for testing # (creates the access request ticket and sign using certificate/private key):  
    wsaa = WSAA() ta = wsaa.Autenticar( "wsfe", "reingart.crt", "reingart.key", wsdl="https://wsaahomo.afip.gov.ar/ws/services/LoginCms", debug=True, )

    # electronic invoice webservice setup for testing: wsfev1 = WSFEv1() wsfev1.Token = wsaa.Token wsfev1.Sign = wsaa.Sign wsfev1.Cuit = "20267565393" ok = wsfev1.Conectar(wsdl="https://wswhomo.afip.gov.ar/wsfev1/service.asmx?WSDL") # get last invoice number: cbte_nro = int(wsfev1.CompUltimoAutorizado(1, 3)) or 0 # create the electronic invoice (header fields, simple case): wsfev1.CrearFactura( concepto=1, tipo_doc=80, nro_doc="30500010912", tipo_cbte=1, punto_vta=3, cbt_desde=cbte_nro+1, cbt_hasta=cbte_nro+1, imp_total=122.00, imp_tot_conc=0.00, imp_neto=100.00, imp_iva=21.00, imp_trib=1.00, imp_op_ex=0.00, fecha_cbte=datetime.datetime.now().strftime("%Y%m%d"), moneda_id="PES", moneda_ctz=1.000, ) # add subtotals per each VAT tax percentage (21% case): wsfev1.AgregarIva(iva_id=5, base_imp=100.00, importe=21.00) # add other taxes: wsfev1.AgregarTributo( tributo_id=99, desc = 'Impuesto Municipal', base_imp=None, alic=None, importe=1.00, ) # authorize the invoice: wsfev1.CAESolicitar() # Electronic Authorization Code (result): print("CAE", wsfev1.CAE)

    Anyway it is very interesting as it give a overall help on this topic (if you know the details).

    Probably we should use the Stack Overflow question/response style and provide more examples, so the information corpus about these topics increases and AI responses get more accurate.


    Quick Intro (real):


    After the ChatGPT experiment, that was interesting but probably there is no enought information for more correct responses (as documentation is in Spanish and very limited).


    Let's do a traditional quick introduction to these topics.


    AFIP is the country's main tax agency, like the "I.R.S." in the US (Internal revenue service)..


    Note that every invoice in Argentina must be sent to the government to get approval (including total amount, taxes plus item description, quantities and unit prices in some cases), or use a special printer with government software (fiscal controller).


    There are special regulations to use invoices for tax returns (industrial fiscal bonus), foreign trade commerce (exports), tourism or using credit invoices as checking-account to pay other invoices.

    There is a tax-payers registry to validate customers' VAT numbers and status. 

    And received invoices should be verified using a webservices to validate the amounts for tax porpouses.


    Also the primary sector is important in Argentina, so sales and shipments of cereal crops, flour, cattle, meat or milk production and derivatives should be informed to  Afip too, using several Agriculture or Livestock webservices.


    Customs and foreign exchange are also complicated, for example in the past needing authorization to buy or sell US dollars (via web service for companies/banks or online government website for taxpayers).


    Other related web services supported by the library are: 


    ARBA: Buenos Aires province tax agency

    • Freight transport Shipments code (COT), also for Córdoba & Santa Fe provinces.
    • Gross income tax withholdings (IIBB).

    National Traceability System web services: to track movements of

    • Medicines and medical equipment (ANMAT TrazaMed/ProdMed)
    • Controlled substances (SEDRONAR/RENPRE TrazaRenpre)
    • National Health and Food Quality (SENASA: TrazaVet/TrazaFito)

    No official python example, even in 2023!

    The official  AFIP Government website has general documentation about its web services: afip.gob.ar/ws
    The architecture is divided in two stages:

    The client calls WSAA (authentication and authorization webservice) to get a Token and Sign.

    A custom digital X509 certificate is used and requires signing a CMS (Cryptographic Message Syntax format). It is basically like a "Signed Multipart Email" (S/MIME). The result is an access ticket XML.

    Then the client uses that access ticket to consume the WSN (business webservice), sending the Token and Sign along business data. It can do several operations as long as the access ticket is valid (not expired).
    Business web services are Electronic Invoice Version 0, Version 1, Fiscal bonus, Exports, Tourism, etc..

    Developer Manuals are agnostic PDF with XML Request / Response templates and some minimal examples with test data (in the best cases).

    There are some programming examples for WSAA, sadly only for JAVA PH C#, VB.NET and PowerShell.
    Note that they don't have any official programming tech support.

    And some use cases are tricky or there are usage limits (for example, 5 minutes to request a new token, or non trivial error recovery procedures) that could be difficult to handle for newcomers.

    The full catalog includes more than 40 web services with many versions and regulations!. 

    They cover from invoicing to registry, agriculture/livestock, tax forms filing, payroll, customs, and more specific use cases.


    For these webservices there are some some official examples for PHP / Java .NET, but they are not supported and no Software Development Kit exists.

    And no, no python example, even in 2023 😞

    Official examples were a bit complex to setup (specially for legacy systems) and have many dependencies.

    There are now some command-line utilities to use WSAA and get an access ticket (token/sign) using powershell.

    Note that official docs point to OpenSSL / SoapUI and WireShark to implement / test / debug this web services (that could not be easy specially for newcomers)

    Motivation

    This library surges to build a community alternative as there were no free / open source Software Development Kit.

    A main goal of this project is to be easy to use, specially for developers of other languages.
    Requirements should be easy to install and eventually maintain or adapt.

    For example Python SOAP library at that time had some memory consumption issues and were not entirely compatible with the different XML dialects for Java or .NET (we tried but we couldn't adapt them).

    Also multi-platform and interoperability were a must, as many users had legacy operating systems or applications that cannot easily be extended to add JAVA or .NET requirements.

    This include old Windows versions (XP), Unix flavors (some no longer actively supported), and programming languages that do not have even a networking stack or XML / crypto services (COBOL, Visual Basic, Visual FoxPro, Pascal and dBase derivatives, etc.).

    Python offered these features, and also made possible desktop applications (PyRece / PyFactura): 
     

    Finally, user experience was important to bring new developers to the python world without hassle.
    Single file installers with no runtime or other dependencies were implemented.

    The origins:

    The project dates back to 2008, when we exchanged some mails in the Python Argentina users group. 
    We joined efforts and started working in a common library.

    Then freelance portals were used to offer the library to developers needing to implement electronic invoice for legacy applications in Cobol / FoxPro (DBF) and similar.
    There were also diffusion in forums & user groups of other languages (VB/VFP).

    Eventually even some Java, .NET and PHP users also started to look at this library, as we gave tech support (remember no official programming support was given from the government, just XML error issues)

    pywin32 is used to expose Python Objects to other modern languages (VB / VFP support CreateObject for automation) similar to an OCX control (COM: Component Object Model).
    py2exe is used to build EXE / DLL to host the object servers and command line tools.

    Current status

    The road so far includes around 25 webservices supported, 5 Electronic Invoice webservices (in 2 variants), 8 agriculture webservices and several other related agencies and systems.

    We added PDF generation, with barcode and QR, plus mailing features.

    File interchange formats include universal fixed-width text format (COBOL), XML, DBF tables, CSV/XLS spreadsheets and JSON.

    Additional command line tools were developed to create access tickets, authorize, retrieve and verify invoices, bulk processing (reading invoices from databases), etc. 

    Also two Visual desktop applications were created to overcome some limitations and issues of government old windows utilities and official website. 

    They are oriented to non-programmers (for example, accountants or small shop owners) with bulk processing features and customization/storage capabilities.

    We were invited to several meetings in AFIP offices and to participate in the related group of Argentine Software Industry Chamber.

    The User's Group

    We created pyafipws@googlegroups.com that over time attracted 2k members… (in comparison, Python Argentina telegram group has 2.4k members)

    It works as a public forum and is very active and used for several topics:
    Many users helps other users, contributing error corrections and minor examples.

    Topics exceeding this python library are included too:
    • Announcements & discussions about AFIP government news and regulations.
    • AFIP downtime and general scalability issues .
    There is some moderation to avoid political discussion and non-free software (spam).

    Sustainability

    To sustain development and maintenance we opted for a dual license model.
    Licensed under GPLv3 for free software projects, and a commercial exception for proprietary software.
    Now moving to LGPL and looking alternatives ways of funding; 
    GPL is great to raise awareness but there are grey areas and could be more hard to manage for small projects (for example contributor agreements)

    We offer commercial technical support with a small update fee (around 50 USD on average). 
    It is mainly for administrative, installation issues and first steps.

    This helps to do basic maintenance, and we have more advanced plans for releases of new webservices or major changes. 

    But there are periods without activity nor significant income (updates are optional), so major refactors are difficult.
    Only large companies are willing to pay monthly/yearly support plans, mainly to cover operation, regular maintenance and minor enhancements.

    This funding also was used initially to pay for AdWords campaigns in search engines.
    It complemented SEO and allowed new users to find the project when it was not widely known.

    Public forum also helped to communicate and generate synergy with users helping each other (even non commercial free riders).

    For SEO, a landing page was published with a lot of information and details on regulations.
    Also the full documentation is freely available.

    Over years some links and resources could get outdated, so special care must be taken to keep it updated (that is also included in the tech support fee)

    Documentation:

    Example documentation page (originally using trac), with a menu listing all webservices and tools (left).

    Contents include all AFIP government regulations, downloads / installation instructions, examples for different programming languages, pseudocode and sample files, use cases, common error and exceptions, webservices codes and parameter tables, etc.

    Python 3

    Crossing the chasm?

    Python 3 porting was not trivial and it depended on several third party libraries.

    Some, like m2crypto (openssl) was eventually ported but more difficult to install (replaced by cryptography)

    Others, like py2exe, were not ported initially or had limited functionality (until recently it didn’t supported some features we needed).

    Specially on Windows we faced issues with SSL protocol and support proxy (for example pycurl)

    We had to opt to keep a quick reaction to government changes and fixing bugs.
    User base is mostly in python 2, and they wouldn’t pay support just to port.

    We still need to keep compatibility with legacy users (old Windows or Unix installations)

    Spin-offs

    We started with simple modules for SOAP and PDF that over time become independent libraries.

    SOAP code was moved out to its own project (PySimpleSOAP), and eventually many contributors were interested in submitting changes and enhancements.
    It was later moved from a personal project to an organization and had active development, but over time interest stalled. 
    Some changes introduced by other maintainers were incompatible with our PyAfipWs library (or were untested in our scenarios), so at the end we’re using an older branch with custom changes (see py311).

    PyFPDF was born from a port of the fpdf PHP library (intended for simple generation of PDF), with many enhancements and also eventually attracted many contributors. 
    The project was forked to fpdf2, python 2 support was dropped and some changes are incompatible with upstream API (see #111).
    So we cannot use the latest branch now, hence we still keep working on our older branch.

    It is a bit strange to step down for your own libraries, but also it is understandable that the community needs to advance (especially if changes cannot be reviewed in a timely basis, or security/compatibility concerns arise).

    NOTE that sometimes priorities change, and original maintainers can lack enough time to work on the project (in my case, I had 3 jobs in some periods, so open source dedication was limited).

    Also, it could be needed to say no and reject contributions if those cannot be reviewed or tested, or introduce breaking changes or other issues.

    Integrations:

    This could be a major concern especially if the library is used in larger projects (in our case, Argentina localizations for OpenERP/Odoo and Tryton), as it could introduce bugs or security issues to them.

    Open Source never dies 😉
    Low maintenance mode is good

    If a project doesn't receives a lot of changes, it could just mean that it has no serious bugs or new features are not needed. And it can be forked if needed...

    A humble recommendation would be to accept new contributions but in a new branch (2.0 “next” or unstable), and use versioning to pin stable 1.0 branch.
    When the new 2.0 branch becomes stable, reviewed and security/compatibility issues solved, you can easily change to the new branch. 
    This balance could avoid friction and unnecessary forks, but will not be completely free/easy. Anyway it could be better that having unnecesary forks or different version in different projects.

    Modern Era:

    In the search for new contributors, we participated in Google Summer of Code 2019, 2021 and probably in 2023 (see PyAr ideas wiki page), under the Python Software Foundation umbrella.

    The students get a grant to learn and develop (around 1500 USD). 
    The PSF receives 500 USD that later are used in other grants programs.

    In our case, the students became mentors for the project, and in general this program helped us a lot to tackle big ideas / refactors like Python 3 port, dependency updates, testing improvements (VCR) and stabilization.

    In the last 5 years we moved from Travis to GitHub Actions.
    This helped to run the test with different python versions and operating systems (linux/windows)
    Now windows installers can be almost built in C.I., and it also can be tested in a fresh installation with some basic automation tests.

    This new Continuous Integration pipeline helps to review and approve pull request fasters, as they can be tested automatically in all scenarios.

    GitHub actions:

    Python package workflow has a build job for several python versions.
    The job has the standard steps to checkout, install dependencies, configure and run unit tests with pytest. 
    A test report is built and coverage report is uploaded to artifacts.

    The other Windows Installer workflow is run for 32 and 64 bits.
    It has several jobs (compile, test and pre-release).
    In the compile phase it builds the project and convert to an executable using py2exe.
    Then the test phase downloads the certificates (in secrets to avoid conflicts).
    After that it runs the executables for simple checks.
    And finally it registers the components and run some automation tests with pester (powershell).
    The final pre-release job upload the artifacts (dist archive with executables and python libraries)

    Testing

    Originally we had unit tests and end 2 end tests that had to be run manually.
    Some test were difficult to run as they depend on  AFIP webservers that can go down / raise timeouts or have limitations (certificate cannot be used once each 5 min).

    We use VCR to record requests and replay responses, stored in yaml “cassettes”, so flakiness due external services is reduced.
    In tandem, freezegun is used to keep the request reproducible (immutable date/time).

    For End 2 End tests we use pester PowerShell tests. 
    These tests are more difficult to mock as they are black-box processes, but a fake webservice simulator could be used in the future.

    In the test folder we have the cassettes folder with the recorded request/response.
    For example the login yaml has the webservice URL endpoint and the XML request & response, with all the flags.
    This is later used in test wsaa.py via the @pytest.vcr decorator.
    In test wsfev1.py we enable the pytest.vcr and pytest.freezegun plugin for all the tests.

    Finally, the powershell folder has the pester tests using windows automation.
    For test wsaa.ps1 there are some basic test to generate the xml access ticket.
    Then in test wsfe.ps1 we have a basic test for electronic invoice generation, checking the happy path and some corner cases / exceptions. 

    References:

    Thank you for reading!
    Fell free to contact me if you have any doubt

    This is a transcription (slides) with extended details of the talk presented for the PyCon US 2023 Maintainers Summit
    Publicado por
    Ubicación: PyCon US 2023 - Salt Lake City UT - U.S.A..


  2. Google Summer of Code

    El GSoC es un programa de Google para introducir a estudiantes universitarios en el desarrollo de software libre de código abierto.

    En 2014 participé como estudiante (Improve wxQt port and wxPython for Android proof of concept), y en 2017 como mentor (wxWebView JavaScript Integration).

    La idea de esta entrada es documentar brevemente estas experiencias, explicando y comentando las cuestiones aprendidas, especialmente para futuros estudiantes y mentores que puedan encontrarle utilidad.

    Intro al GSoC:

    Para empezar, las organizaciones interesadas en participar publican una página de ideas (por ej ver wxWidgets 2017 Project ideas), donde se listan al menos un par de mentores por cada proyecto.

    Los estudiantes interesados deberían ponerse en contacto con la organización, descargar el código del proyecto y resolver algún bug "simple", como práctica de "pre-calentamiento".
    Una vez elegido el proyecto, deben envían sus propuestas, y la organización hace una preselección de candidatos. 

    Finalmente, Google determina cuantos slots puede asignar a cada organización, y se eligen los estudiantes definitivos, asignándoles sus mentores.

    Luego de un período inicial de "aclimatación" (community bonding), los estudiantes comienzan a trabajar en su proyecto y existen tres evaluaciones que se deben superar para continuar participando.

    Al finalizar, se presentan los resultados y se realiza una reunión de mentores en Google.

    Proyecto GSoC 2014: mejoras wxQt y PoC Android

    En 2014 participé como estudiante, mientras estaba realizando la Maestría en Software Libre. La propuesta completa puede encontrarse en el Archivo de Internet 


    Como resumen general, la experiencia fue muy positiva, pudiendo lograr varios avances y principalmente que el código sea incorporado luego al proyecto principal.

    Además, la rama wxQt tuvo nueva difusión y atrajo desarrolladores adicionales que colaboraron con distintas contribuciones para poder hacer funcionar sus aplicaciones.

    Si bien quedaron algunos tickets abiertos y el último milestone resultó ser muy ambicioso, la mayoría fue solucionado (ver tickets cerrados incluyendo temas interesantes de segmentacions faults, memory leaks, Qt internals, diferentes API entre Linux / Android, etc.)

    Abstract

    wxWidgets es una biblioteca multiplataforma que permite incluir navegadores nativos en aplicaciones de escritorio (además de otras opciones para construir GUI: Interfaz Gráfica de Usuario).


    Un proyecto previo de GSoC creo las bases para un port de wxWidgets a Qt. 
    Este proyecto consistió en hacer el port usable y completar las partes faltantes, para poder desarrollar pequeñas aplicaciones, trayendo los standares actuales de wxWidgets a  wxQt, actualizando a Qt 5.2.
    Como prueba de concepto para explorar el desarrollo rápido de aplicaciones en ambientes móviles, la idea era construir un prototipo minimalista de wxPython usando wxQt para Andorid.

    Prueba de Concepto

    Repositorio: https://github.com/reingart/gsoc2014 (PoC wxQt + Android)


    Proyecto GSoC 2017: mejoras JavaScript a wxWebView

    En 2017 participe como mentor para un proyecto wxWidgets GSoC que consistió en extender el método RunScript para que pueda retornar el valor devuelto por JavaScript, de esta forma extendiendo la funcionalidad de la biblioteca en C++ y posibilitando una mejor integración con los distintos navegadores.

    wxWebView mostrando el ejemplo JS RunScript


    Diversidad: experiencia técnica e idioma

    Participé como mentor para un estudiante español, lo que por el lado del idioma, ayudo a discutir más fácilmente las cuestiones del día-a-día (especialmente), para luego presentar en la lista las cuestiones más elaboradas (en inglés).

    Igualmente hubieron problemas de comunicación y malos entendidos, "normales" para este tipo de proyecto (considerar que los desarrolladores están distribuidos alrededor del mundo, con distintas zonas horarias, usos y costumbres, etc.)

    Por el lado de las expectativas técnicas, es bueno recordar que el GSoC es un programa para introducir nuevos desarrolladores a proyectos de software libre / código abierto ya establecidos.
    Por lo tanto, puede haber distintas perspectivas y los estudiantes pueden no estar al tanto de la metodología de desarrollo (estilos, reglas para las revisiones de código, cobertura de pruebas), calidad esperada, balance entre costo/beneficio del esfuerzo, etc.

    Lecciones aprendidas:

    En este sentido, sería recomendable aprovechar el tiempo previo para entrenar a los potenciales estudiantes:
    • tratando de establecer las expectativas técnicas claramente con anterioridad
    • ejemplificando el proceso de desarrollo del proyecto (con un ticket / Pull Request simple)
    El tiempo es una cuestión fundamental: no todos los desarrolladores estan disponible siempre (por ej. para revisar el código), y pueden surgir imprevistos (tanto del lado del estudiante como para los mentores).

    La interacción inicial del estudiante candidato con los potenciales mentores es un muy buen indicador a futuro, y en base a eso es conveniente organizar bien el proyecto para no sumar stress innecesario a los participantes ni a la comunidad.

    Desafíos técnicos:

    wxWidgets, al ser una biblioteca GUI multiplataforma, implica levantar entornos de desarrollo para distintos sistemas operativos y navegadores web. Es recomendable tener todo preparado con tiempo.

    Cuestiones de bajo nivel y viejas vs nuevas API influyeron significativamente en el proyecto:
    • Linux: WebKit vs WebKit2 y GTK2 vs GTK3
    • Mac OS X: UIWebView vs WKWebView
    • Windows: IE (ActiveX) vs Edge
    Por el lado de tipos de datos, simplificar en JSON fue una alternativa para minimizar desarrollo requerido, considerando especialmente todas las variantes de objetos posibles a ser devueltos por JS y ser necesario de procesar en la capa C++.

    También hubo otras cuestiones, como llamadas sincrónica vs asincrónica (no soportadas por todas las plataformas / componentes), cuestiones de C++ (memory leaks, performance, "gotchas"), ejemplos y tests a adaptar, etc.

    Organización vía GitHub

    Para un mejor seguimiento, se decidió utilizar todas las características de GitHub (hitos, tickets, PR).
    En general fue una buena estrategia, pudiendo unificar la mayoría de los aspectos de organización, aunque la mayoría de las conversaciones del día a día fueron por chat, y muchas otras por la lista de correo.

    Para la planificación, se definieron varios hitos: uno por cada etapa de evaluación determinada por los deadlines de Google, más otros de "precalentamiento" (ticket inicial y community-bonding).

    Para estimar se cargaron tickets iniciales (Scrum), con una estimación aproximada considerando que cada etapa dura aproximadamente 1 mes. Varios de estos tickets tuvieron que ser reconsiderados, ya que se encontraron dificultades y diferentes acercamientos a medida que avanzaba el proyecto.

    No olvidar que algunas cuestiones, como la revisión del código, documentación y discusiones de características pueden tomar su tiempo. Es fundamental considerar el esfuerzo necesario + eventualidades, y no dejar todo para último momento.

    IMPORTANTE: no perder de vista que el GSoC esta pensado para las vacaciones de verano del hemisferio norte (para no interferir con los estudios / trabajo cotidiano); dado que en estas latitudes las vacaciones de invierno son mucho más cortas, la disponibilidad y fechas límites pueden no ser temas menores.

    Ficha del Proyecto:

    GSoC 2017 Mentor Summit

    Cada año Google lleva a cabo una desconferencia (un-conference), donde participan dos mentores de cada proyecto en diversos espacios abiertos: https://sites.google.com/view/2017gsocmentorsummit

    La idea es intercambiar experiencias, consejos y relacionarse con miembros de las distintas comunidades de software libre.

    En las diferentes salas se podría proponer varios espacios abiertos de discusión:

    Las tematicas fueron super variadas, desde juegos a hardware libre, incluyendo como motivar y preparar a futuros contribuidores (para proyectos como Chrome, el Kernel de Linux), licenciamiento, diversidad, arte, robótica, "nuevas tecnologías" como WebRTC, mobile, usabilidad etc.
    También algunas charlas eran propuestas por ingenieros de Google sobre iniciativas open source.   


    Por mi parte propuse una sesión sobre "Open Source Education" que tuvo bastante interesados, y luego de presentar algunas experiencias como disparadoras, se abrio una discusión muy productiva.

    En 2017 se realizó en los edificios Tech Corners 4 de Google (California):
    GSoC 2017 Mentor Summit (public photos)

    Tuve la oportunidad de conocer a Vadim Zeitlin, uno de los principales desarrolladores de wxWidgets, y mi mentor en el primer proyecto de GSoC:


    Publicado por
    Ubicación: Google Tech Corners, 809 11th Ave, Sunnyvale, CA 94089, EE. UU.


  3. El año pasado se inició la Diplomatura en Software Libre que impulsamos en la Universidad del Este (La Plata). La primer promoción de estudiantes ya completaron los cursos, destacándose académicamente los siguientes trabajos finales integradores:
    Felicitamos y agradecemos a todos los participantes (tanto estudiantes como docentes, tutores colaboradores, personal de la universidad y ONGs: SoLAr, CAdeSoL, FACTTIC) que hicieron posible la primer edición.
    Como contribución a la comunidad y para aquellos interesados, a continuación se detalla más información sobre la misma, incluyendo la Edición 2016 que está comenzando este mes (próximo encuentro 14/05).

    Organización

    La diplomatura son cursos de extensión universitaria orientados a un público en general (estudiantes, docentes, desarrolladores en empresas públicas o privadas y miembros de la comunidad), y no requiere experiencia previa en estas tecnologías. Por ello, abarca distintos módulos con contenidos para cada nivel (desde principiantes a usuarios intermedios/avanzados) y se distribuyen en una serie de 8 cursos a lo largo de un año para contemplar la dedicación mínima necesaria.

    Primer cuatrimestre (Mayo, Junio, Julio, Agosto):

    Seminario Sw. Libre
    (1 mes)
    Bases de Datos PostgreSQL
    (1 mes y medio)
    Redes de computadoras GNU/Linux (1 mes y medio)
    Programación I Python
    (4 meses)

    Segundo cuatrimestre (Septiembre, Octubre, Noviembre, Diciembre):

    Ingeniería de Sw. Libre (1 mes)
    Sistemas Operativos GNU/Linux
    (1 mes y medio)
    Desarrollo Web HTML web2py
    (1 mes y medio)
    Programación II C C++ Python
    (4 meses)

    Los temarios tentativos y planificaciones iniciales pueden descargarse desde nuestro portal, con información sobre los objetivos, unidades temáticas (generalmente una por semana), metodología, criterios de evaluación, actividades, referencias y bibliografía.

    Son 4 cursos por cuatrimestre, pero el único en paralelo es el de programación (contemplando los tiempos necesarios para presentar los contenidos y reforzar conocimientos de aquellos que no tengan una base en estos temas).
    Los encuentros presenciales son un sábado vez por mes (opcionales) y la mayor parte de los trabajos y prácticas se realizan a distancia por el campus virtual u otros medios.

    Los contenidos por el campus virtual son para una cursada completamente "asincrónica" según la disponibilidad del estudiante (documentos PDF de lectura, enlaces páginas, foros y actividades que no requieren un horario específico). Eventualmente se coordinan sesiones de chat o hangouts para tratar algún tema en particular.

    Académicamente, la carga horaria aproximada mínima es 4 hs de dedicación por semana por curso, más los encuentros presenciales y desarrollo de trabajos prácticos.

    Encuentros Presenciales:

    Se llevan a cabo 8 encuentros presenciales (optativos y recomendados), donde se dictan clases presenciales y talleres sobre los módulos de cada mes, generalmente en cuatro tramos (horario de 8.00 a 16.00):
    • Presentación expositiva de los temas teóricos
    • intervalo (café) 
    • Trabajo práctico individual y grupal en PC
    • almuerzo libre
    • Laboratorio de programación en PC
    • intervalo (café)
    • Actividad sobre el trabajo final integrador y cierre
    Frecuentemente las charlas en los intervalos y almuerzo complementan la parte académica con interesantes debates sobre temas de actualidad relacionados al software libre, aportando experiencias y reflexiones útiles sobre muchos de los contenidos teóricos, en un ambiente distendido, cordial y ameno.

    Materiales libres y abiertos:

    Todos los contenidos están fuertemente orientados al Lenguaje de Programación Python, por lo que se utiliza el material de Algoritmos y Programación I (Apunte FIUBA)

    También como referencias se pueden ver algunas presentaciones Universidad Carlos III de Madrid (OCW UC3M) y la documentación oficial / sitios de las comunidades locales, como Python Argentina, PostgreSQL Argentina, web2py, etc.
    Para los estudiantes más avanzados, se incluyen artículos optativos sobre el kernel de linux, optimización de consultas, firewalls, etc.

    Como complemento se recorren apuntes propios y trabajos académicos (desarrollados al cursar la Maestría de Software Libre de la UOC):
    Para el curso "Ingeniería del Software Libre" se presentan metodologías ágiles ("Scrum y XP desde las Trincheras"), el Proceso de Software Personal (materiales de estudio autodidacta), entre otros materiales y recursos.
    A modo de ejemplo, se utilizan como referencia varios de los temas investigados en mi tesis de la maestría: "Desarrollo rápido de software libre de alta calidad", entre otras lineas de trabajo.

    Actividades y Trabajos Prácticos:

    Para una cursada más dinámica y flexible, adaptamos la mayor parte de las actividades optativas para ser realizadas por el Campus Virtual de la Universidad, mediante los Foros y en ocasiones Wiki / Glosario. Este año planteamos incrementar el uso de las herramientas de Cuestionarios de Auto-Evaluación y Chats para mejorar las cuestiones de virtualidad y seguimiento.

    En el campus de la universidad se desarrollan debates diversos, por ej: "Licenciamiento de Software (Libre)", "Estructura y funcionamiento de internet", "Comparativas entre motores de bases de datos", etc. También aquellos estudiantes que lo crean conveniente, pueden publicar internamente sus exámenes resueltos para compartirlos y discutir las alternativas / correcciones, comentar dudas, etc.

    Se proveen ejercicios modelos y ejemplos concretos, como la Bases de Datos Dell DVD Store 2, tutoriales de programación, sitios y herramientas interactivas, etc.

    Estamos analizando materiales de estudios de reconocidos MOOCs y certificaciones, avanzando en contenidos comunes que permitan a los estudiantes certificarse luego en esas tecnologías.

    Para las prácticas más técnicas (programación, bases de datos, redes/sistemas operativos) hemos implementado un "Laboratorio Virtual de Software Libre" en un portal educativo abierto a la comunidad: www.softwarelibre.org.ar/moodle
    Utiliza el módulo "VPL" de Moodle para facilitar las entregas y corrección automatizada ágil, completamente online (con editor de texto, consola de ejecución y depuración completamente vía web, para poder experimentar libremente sin riesgos y sin necesidad de instalar las herramientas en la PC):


    En este sentido, estamos avanzando en un curso comunitario masivo y en linea para enseñar programación de computadoras ("Python para Zombis": documento de trabajo y presentación resumen), traducción al Español de materiales como Python Module of The Week, etc. Ver abajo los exámenes resueltos con más información al respecto.

    Obviamente al ser una diplomatura en Software Libre, el código fuente resultante de las prácticas es trabajado y se publica de manera abierta en el repositorio en GitHub:  https://github.com/UniversidadDelEste

    Exámenes:

    Las actividades de evaluación son mixtas, con estrategias tradicionales y alternativas más modernas (incluyendo multimedia), buscando un aprendizaje critico, constructivo y significativo. Se contemplan tanto el desarrollo y participación en el campus / encuentros, como el resultado final.
    Generalmente se realizan a distancia vía un examen domiciliario (con entrega por el Campus Virtual):
    1. Seminario de Software Libre: investigación-acción sobre Wikipedia (PDF)
    2. Bases de Datos PostgreSQL: desarrollar un mini-proyecto sobre datos abiertos (PDF)
    3. Redes de computadoras GNU/Linux: redactar un capítulo/sección de libro libre (PDF)
    4. Programación I Python: desarrollar una actividad de evaluación automatizada (PDF)
    5. Sistemas Operativos GNU/Linux: presentación multimedia sobre temas a elección (PDF)
    6. Desarrollo Web: trabajar sobre una aplicación web2py o similar (PDF)
    7. Programación II C+Python: analizar el proyecto hello de la Free Software Foundation  (PDF) 
    8. Ingeniería de Software Libre: trabajo final en forma de artículo (PDF)
    Si bien hay fechas limites, los estudiantes pueden determinar su propio ritmo de cursada y entrega de actividades, dentro de los limites razonables de cada curso (procurando trabajar en grupo y con acompañamiento docente adecuado).

    En la carpeta pública se encuentran ejemplo variados de exámenes de programación resueltos (Python), desde ejercicios simples (PDF, ODT), intermedios (ODT, ODT) y más avanzado (PDF). Además de servir como evaluación, documentan la configuración de una actividad automatizada en la plataforma Moodle (VPL: Laboratorio Virtual de Programación, ver arriba) que puede ser útil como tutorial para otros docentes.
    También se pueden mencionar exámenes resueltos de bases de datos PostgreSQL (sobre datos abiertos y públicos): "Encuesta Nacional de Gastos de los Hogares " (PDF), "Elecciones CABA 2013" (PDF), "Censo Hogares y Viviendas" (PDF), "Cajeros Automáticos CABA" (PDF) y "Trabajo Práctico" (ZIP), entre otros.

    Gracias a los alumnos por compartirlos dentro de los lineamientos de la dipolomatura para generar recursos educativos libres y abiertos.
    Recordar que son documentos académicos preliminares (pueden no estar realizadas las correcciones y observaciones realizadas por los docentes), y revisar la licencia de publicación.

    Edición 2016:


    Para 2016 esta abierta la inscripción

    http://ude.edu.ar/extension/diplomaturas/software-libre-combinada/

    También buscamos profesores y tutores que estén interesados en colaborar con el equipo docente (para más información ver propuesta académica completa)
    Proximamente se publicará un repositorio institucional con todos los trabajos académicos, y anunciaremos más novedades (invitados, eventos, etc.) vía @softlibre y en el portal.
    Desde ya se agradece difusión y toda sugerencia es bienvenida

    Publicado por
    Ubicación: Universidad del Este, Calle 2 684, La Plata, Buenos Aires, Argentina
    Etiquetas: educación linux postgresql python software libre

  4. Aprovechando el cierre del año, y a modo de resumen, a continuación transcribo una entrevista (traducida) que me realizó Mike Driscoll para su blog "Mouse vs Python":


    "Desarrollador Python" de la Semana: Mariano Reingart


    ¿Puedes contarme un poco sobre ti (hobbies, educación, etc)?:


    Soy programador independiente y docente, casado con dos hijos pequeños.

    Comencé a programar cuando era un chico y mi padre compró una ZX Spectrum TK-90 a fines de los '80.
    Para 1989, con sólo 11 años, tomé mi primer curso "formal" de programación "Basic I" usando computadoras MSX y "D.O.S." hacia 1991.
    Luego de terminar la primaria, en 1992 me anoté en un colegio con orientación de "Bachiller especializado en Informática"  (nivel secundario) donde se enseñaba Visual Basic y Visual Fox Pro en los cursos finales.

    Luego de egresar, trabajé en esa escuela como Ayudante de Laboratorio, instalando mi primer servidor Slackware Linux circa 1997 para la conexión de Internet, y programando los sistemas del colegio (usando inicialmente VB + Access).
    Mi primer experiencia "open source" fue desarrollando un modulo para el kernel de Linux y así usar la linea telefónica dedicada de 128Kps (incluso tuvimos que importar la placa de comunicaciones); y un controlador de kernel de ucLinux para PiCoTux (una micro-computadora embebida corriendo Linux).
    También, di mis primeros pasos en la migración de bases de datos a PostgreSQL y trabajando con los primeros dispositivos "WiFi".

    Luego, estudié Ingeniería Electrónica por varios años, pero me dí cuenta que mis habilidades iban más por el lado del software, por lo que me cambié de carrera a una Universidad local para Estudiar Licenciatura en Sistemas.
    Finalmente me gradué en 2011 luego de varios años "sabáticos" donde gané experiencia laboral desarrollando pequeños sistemas de gestión administrativa/contable para PyMEs, y una aplicación 911(en colaboración ad-honorem con un amigo de la radio-estación policial local).

    Actualmente estoy terminado la Maestría en Software Libre (Universidad Abierta de Cataluña), y el Profesorado en Disciplinas Industriales / Docencia Superior (UTN - INSPT).

    ¿Por qué comenzaste a utilizar Python?


    Empecé a usar python en los '00, buscando alternativas a Visual Basic.
    Lo elegí para mi tesis de grado en 2006 "Desarrollo Rápido de Aplicaciones bajo el Proceso de Software Personal"

    Desde 2009 enseño Python en un Instituto Terciario. Comenzó en un curso pero luego acordamos (con otros profesores) implementar un Proyecto Curricular Institucional orientado al software libre, principalmente en las siguientes materias:


    Basado en ello, con otro colega estamos preparando una "Diplomatura en Software Libre" (programa de cursos de formación profesional de 1 de año de duración con actividades de extensión universitaria, enfocados Python, PostgreSQL and GNU/Linux, para más información ver documento de trabajo y articulo).

    Felizmente, laboralmente hoy trabajo principalmente brindando planes de soporte comercial de código abierto gracias a Python, dado que desde 2008 el proyecto PyAfipWs: "factura electrónica", iniciado desde la lista de correo PyAr, la comunidad de Python Argentina, creció, siendo usado por una base de usuarios relativamente grande (incluyendo grandes empresas, PyMEs y profesionales)

    ¿Que otros lenguajes de programación conoces y cual es tu favorito?


    Obviamente Python es mi favorito, y tengo cierta experiencia en PHP, C/C++, Java y otros lenguajes.

    Lamentablemente aún tengo que usar Visual Basic Clásico (6.0) para algunos de mis sistemas ERP "legados" (son grandes, alrededor de cientos de miles de líneas de código, y no he tenido tiempo / recursos para migrarlos a Python por el momento)

    Ahora estoy investigando vb2py, un proyecto para convertir código VB a Python.
    Me intriga por qué  no llegó a juntar masa crítica / tracción (el desarrollo parece estancado desde 2004), teniendo en cuenta que hay mucho código VB dando vueltas...

    En el proyecto de factura electrónica, use pywin32 (de Mark Hammond et al) para hacer componentes Python usables desde lenguajes legados (VB, VFP), y bibliotecas como dbf (de Ethan Furman) para interactuar con lenguajes aún más antiguos (Clipper, xBase, etc.).
    Recientemente también comencé a experimentar con Jython, para usar proyectos Python desde Java.

    ¿En que proyectos estás trabajando ahora?


    Para mi tésis de grado, comencé a desarrollar rad2py, un entorno integrado de desarrollo (IDE) experimental y herramientas CASE de ayuda al desarrollador , previstas para ser usadas para propósitos comerciales, educativos y académicos.

    Ahora estoy terminando la invesigación para mi tesis de maestría "Desarrollo Rápido de Software Libre de Alta Calidad", tratando de facilitar la vida a los desarrolladores integrando enfoques modernos como interfaces basadas en tareas (Eclipse Mylyn) y Ágil ALM (gestión del ciclo de vida de las aplicaciones), con principios disciplinados de la ingeniería de software para aseguramiento de calidad y mejora continua.

    ¿Que bibliotecas Python son tus favoritas (del núcleo or de terceros)?


    Trato de usar solo la Biblioteca Estándar de Python + wxPython y web2py, y adicionalmente pywin32 y dbf para ciertos proyectos, como mencioné antes.

    Particularmente encuentro a web2py fascinante, dado que tiene prácticamente una curva de aprendizaje plana, permite prototipado rápido, una interfaz integrada de desarrollo en linea (web), etc.
    Sus enfoques no tradicionales también son interesantes para traer otras perspectivas y "pensamiento crítico", especialmente gracias al liderazgo abierto, cordial y reflexivo de Massimo Di Pierro, su creador, y por supuesto, su comunidad afable.
    Descargo: soy uno de los desarrolladores "principales", no muy activo estos días debido a la falta de tiempo, pero he contribuido un depurador en linea y otras mejoras, co-escribí el libro "web2py app development cookbook" de Packt, etc.

    wxPython también me merece una mención especial, el trabajo de Robin Dunn es grandioso (phoenix py3k!), los widgets agw widgets de Andrea Gavana en puro phyton son realmente impresionantes, solo para mencionar algunos desarrolladores de dicha comunidad.
    También veo a wxWidgets más ortogonal y fácil de usar que otras alternativas.
    Este año traté de colaborar más en profundidad con una variante experimental wxQt, como becario enmarcado en el Google Summer of Code 2014 (ahora es usable, incluso desde wxPython! y bajo Android al menos la parte C++ ...).

    Cuando necesito algo no cubierto por estas opciones, tiendo a mirar hacia soluciones simples (muchas veces influenciadas por extensiones PHP), iniciando, continuando o "forkeando" ("escindiendo") otros proyectos:
    • PySimpleSoap: interfaces ad-hoc livianas para construir clientes y servidores SOAP
    • PyFPDF: clase para la generación simple de PDF basada en FPDF de  PHP y derivados
    • gui2py: un fork (bifurcación) de PythonCard (conjunto de construcción GUI visual "rápido" & simple) para evolucionarlo y modernizarlo 
    Más allá de que ciertos desarrolladores los ven como esfuerzos "naif" (por decir lo más leve), la mayoría de los proyectos ha encontrado su nicho y hoy en día varias contribuciones son hechas por otros colaboradores que también los han encontrado útiles .
    También ayudan a entender las tecnologías subyacentes, a proveer alternativas implementadas en "puro Python" y a experimentar con la migración a Python 3.

    ¿Hay algo más que quieras decir?


    No, disculpas por las largas respuestas, pero la entrevista es irresistible :-) ...
    También, disculpas por mi Inglés (en la entrevista original), dado que hablo español es dificultoso a veces encontrar la traducción correcta.

    Gracias a vos Mike por tus esfuerzos y este proyecto sobre artículos de entrevistas, y ¡gracias a toda la comunidad Python!

    Publicado por
    Etiquetas: linux postgresql python software libre web2py wxpython



  5. 4ta Jornada intensiva sobre bases de datos PostgreSQL


    http://www.postgresql.org.ar/pgday2013



    El encuentro es de entrada libre y gratuita, y se realizarán el 14 de Noviembre en  el edificio de la Secretaría de Gestión y Coordinación Administrativa, Av. Roque Sáenz Peña 511 (Capital Federal), en el marco del Foro de la Agenda Digital Argentina.

    Entre los disertantes contará con ponencias de expertos internacionales, autoridades nacionales y funcionarios públicos, docentes y profesionales, entre otros, brindando más de 14 actividades confirmadas (ver agenda), tanto conferencias como talleres prácticos para todos los niveles de conocimiento sobre PostgreSQL, el líder mundial en sistemas de base de datos relacionales de código abierto y software libre.

    Para facilitar el ingreso y organización, recomendamos realizar la inscripción via web con anticipación:

    http://www.postgresql.org.ar/pgday2013/user/register

    Gacetilla de prensa con más información sobre el PgDay:


    http://www.postgresql.org.ar/pgday2013/static/gacetilla.pdf

    Dossier de Prensa de PostgerSQL 9.3:


    http://www.postgresql.org/about/press/presskit93/es/


    Desde ya agradecemos difusión por listas de correo, redes sociales o en carteleras de universidades/empresas.

    Por consultas, escribir a ar@postgresql.org (contacto regional de PostgreSQL para Argentina)
    Publicado por
    Ubicación: Avenida Pres. Roque Sáenz Pena 511, Buenos Aires, Ciudad Autónoma de Buenos Aires, Argentina
    Etiquetas: educación postgresql software libre

  6. El Jueves 31 de Octubre de 2013, se realizará de 18:00 a 21:30 en el Instituto Tecnológico Blaise Pascal (donde soy docente), una Jornada Anual de Informática, en la cual los alumnos compartirán experiencias y presentarán algunos proyectos trabajados en el año:

    • Domótica: Control de una vivienda con una computadora (raspberry pi) 
    • Control de asistencia con lector de códigos de barra (web2py) 
    • Monitor de Anuncios: aplicación web "TV Inteligente" (web2py) 
    • Software de manejo de matrices (python) 
    • Robótica: Robot N6 guiado para recorrer un camino / laberinto (python) 
    • Sistema de gestión académica orientado a web -trabajo final integrador- (web2py) 
    También se presentarán otros proyectos sobre análisis de un sistema de orientación vocacional, mercado laboral, idiomas y estadísticas.


    La mayoría de los trabajos están enmarcados en un proyecto curricular orientado al software libre que venimos trabajando desde 2009 (tecnicaturas en Análisis de Sistemas y Redes Informáticas).

    Para más información sobre el instituto y las carreras, ver: http://www.institutopascal.edu.ar

    Cualquier duda quedamos en contacto, desde ya todo aquel que esté interesado puede concurrir, la entrada es libre y gratuita.

    Próximamente se publicarán algunos vídeos sobre la jornada.

    Se agradece difusión,
    Publicado por
    Ubicación: Puerto Argentino 4238, González Catan, Buenos Aires, Argentina
    Etiquetas: educación linux python software libre web2py


  7. Recientemente he liberado una aplicación web, usada originalmente para el Recuento definitivo de las elecciones provinciales de Rio Negro 2011:


    En el Primer Hackaton de Datos Públicos,  que incluyó juegos de datos de elecciones pasadas, trabajé en dicha aplicación para armar y publicar el código de la misma, a modo de demostración que sirviera para procesar los resultados de distintas elecciones.

    La aplicación es básica y simple, permite consultar/cargar datos de las planillas (actas / telegramas de cada mesa) y tiene una página de resultados totalizados. Está escrita en el lenguaje de programación Python (framework web2py) y utiliza PostgreSQL como base de datos.

    El esquema de base de datos ha sido generalizado para que pueda ser utilizado en cualquier tipo de elección, ya que soporta diferentes cargos, listas internas / partidos, y un árbol jerárquico de ubicaciones (soportando clasificaciones variadas, por ej. en País, Provincia, Departamento, Circuito y Mesa).

    Mi idea de publicar el código fuente, fue más que nada por una cuestión educativa / experimental, para poder compartirlo con alumnos y otros interesados, ya que quizás sea de utilidad para tomarlo como base para analizar resultados de elecciones, hacer pruebas de carga y rendimiento, optimización de bases de datos, etc.

    Hasta el momento, se procesaron los datos públicos de dos elecciones nacionales:
    Esta subido a un repositorio público bajo licencia AGPLv3+ (licencia de software libre similar a la de Linux pero con consideraciones adicionales para aplicaciones web): https://github.com/MSA-Argentina/recuento_web2py

    Instalación Rápida:

    • Descargar web2py desde: http://www.web2py.com/ 
    • Descargar la aplicación en un archivo comprimido desde GitHub: master.zip
    • Descomprimir la aplicaión en la carpeta application de web2py (por ej. bajo el nombre recuento)
    • Crear una base de datos en PostgreSQL y ejecutar el esquema.sql para crear las tablas
    • Seguir los pasos siguientes de cada juego de datos (ver carga.sql y migracion.sql)
    • Configurar la cadena de conexión a la base de datos en el modelo app_settings.py

    Juegos de Datos Públicos


    Ultimamente trabajé en procesar los datos de las P.A.S.O. 2013 -elección primarias para senadores y diputados nacionales en las 24 provincias-, publicados en el Portal de Datos Públicos

    Para más información ver carpeta 2013-primarias:
    El juego de datos es bastante interesante ya que está a nivel de mesa (fuente de la información), por lo que incluye 88.463 mesas procesadas con 1.846.369 registros de resultado (votos por mesa, por cada lista para los cargos de diputados + sendadores).
    Recordar que es un recuento provisorio por lo que los datos no son definitivos y no están todas las planillas cargadas (90.670 mesas habilitadas en total). El total de electores habilitado fue de 30.573.183.
    Para ver los datos oficiales, dirigirse a http://www.elecciones.gov.ar/ (recuento definitivo) y http://www.resultados.gob.ar (recuento provisional).

    Manejo de Imágenes de actas de mesa (telegramas / faxes):


    La página de Consulta de Telegrama / Planilla permite revisar, cargar y corregir los votos por cargo por lista en cada mesa escrutada.
    Para el procesamiento de las imágenes se desarrollaron dos programas auxiliares (scripts):
    • faxes.sh: para extraer las imágenes del PDF y convertirlas al formato TIFF optimizado (CCITT grupo 4) se utilizaron las herramientas pdfimages y ppm2tiff
    • faxes.py: para incorporar las imágenes a PostgreSQL (campo BYTEA), usando python, psycopg2 (adaptador BINARY) y una consulta para determinar la mesa según el nombre de archivo.
    NOTA: si se utiliza una versión antigua de PIL (Python Imaging Library), es necesario convertir las imágenes a PNG, perdiendo un poco de eficiencia en la compresión, pero ganando compatibilidad.

    Para mostrar las imágenes, se obtiene la misma desde la base de datos y se genera una miniatura con PIL (ver thumbnail en definitivo.py) para ser descargada por el navegador web.

    El tamaño total de la base de datos, incluyendo las imágenes de las planillas, es de 6.4 GB

    Consultas no triviales con el "ORM" de web2py


    Gracias a características declarativas del framework web2py, se pueden realizar consultas relativamente complejas y arbitrarias, en este caso con agrupaciones, tablas anidadas y criterios de búsquedas particulares, de manera programada en Python, sin necesidad de recurrir a escribir SQL puro.
    A continuación se extrae un ejemplo de código para totalizar los votos dada una ubicación (por la URL se especifican los identificadores de ubicación, cargo y estado de las planillas):

    # constantes (jerarquía de ubicaciones)
    CLASES = ['Pais', 'Provincia', 'Departamento', 'Circuito', 'Mesa']

     # alias de tablas:       
    p = msa.planillas
    d = msa.planillas_det
    l = msa.listas

    # armo la consulta base con los criterios de búsqueda
    query = p.id_planilla == d.id_planilla
    query &= d.id_lista == l.id_lista
    query &= p.id_estado == request.args[3]
    query &= d.id_cargo == request.args[0]
    query &= l.positivo == True

     # armo la consulta "recursiva" (árbol) para tener las ubicaciones y planillas
    # (up -> ubicación padre, uh -> ubicación hija)
    # p/ el alias de cada tabla se usa el nombre de la clase (depto, mesa, etc.)
    up = msa.ubicaciones.with_alias(ubicacion.clase)
    query &= up.id_ubicacion == id_ubicacion
    for clase in CLASES[CLASES.index(ubicacion.clase)+1:]: 
          uh = msa.ubicaciones.with_alias(clase)
          query &= uh.id_ubicacion_padre == up.id_ubicacion
          up = uh
    query &= p.id_ubicacion == up.id_ubicacion
            
    # campo suma total:
    suma_votos = d.votos_definitivos.sum()
        
    # ejecuto la consulta:
    resultado = msa(query).select( 
                  d.id_lista.with_alias("id_lista"),
                  l.nro_lista.with_alias("nro_lista"), 
                  l.descripcion.with_alias("descripcion"), 
                  l.idx_fila.with_alias("idx_fila"), 
                  l.descripcion_corta.with_alias("descripcion_corta"),
                  l.color.with_alias("color"),
                  suma_votos.with_alias("suma_votos"),
                  groupby=(d.id_lista |
                            l.nro_lista | 
                            l.descripcion |
                            l.idx_fila |
                            l.descripcion_corta |
                            l.color),
                  orderby= ~suma_votos | l.idx_fila
                 )


    La salida puede observarse en la Página de Resultados por Ubicación  que permite obtener la suma total de votos agrupada por lista y cargo, para un País / Dpto / Mesa):
    Esta consulta en Python generará una consulta SQL similar a la siguiente:

     SELECT planillas_det.id_lista, listas.nro_lista, listas.descripcion, 
           SUM(planillas_det.votos_definitivos) AS suma_votos 
    FROM planillas, planillas_det, listas, 
         ubicaciones AS provincia, 
         ubicaciones AS departamento, 
         ubicaciones AS circuito, 
         ubicaciones AS mesa 
    WHERE planillas.id_planilla = planillas_det.id_planilla
      AND planillas_det.id_lista = listas.id_lista 
      AND planillas.id_estado = 'Publicada' 
      AND planillas_det.id_cargo = 1
      AND listas.positivo = 'T' 
      AND provincia.id_ubicacion = 1 
      AND departamento.id_ubicacion_padre = provincia.id_ubicacion
      AND circuito.id_ubicacion_padre = departamento.id_ubicacion 
      AND mesa.id_ubicacion_padre = circuito.id_ubicacion 
      AND planillas.id_ubicacion = mesa.id_ubicacion
    GROUP BY planillas_det.id_lista, listas.nro_lista, listas.descripcion 
    ORDER BY SUM(planillas_det.votos_definitivos) DESC, listas.nro_lista;

    Consultas Recursivas con PostgreSQL:


    La consulta anterior, podría escribirse de manera más flexible en PostgreSQL utilizando Expresiones de Tablas Comunes (CTE) para consultas recursivas (clausula WITH).
    En el siguiente ejemplo, se utiliza un termino no recursivo para obtener la ubicación base (id_ubicacion =1), unido luego con el termino recursivo que busca las ubicaciones hijas de cada padre:

    WITH RECURSIVE U(id_ubicacion, descripcion, clase) AS (
        SELECT UP.id_ubicacion, UP.descripcion, UP.clase 
          FROM ubicaciones UP 
         WHERE UP.id_ubicacion = 1
      UNION ALL
        SELECT UH.id_ubicacion, UH.descripcion, UH.clase
          FROM U, ubicaciones UH 
         WHERE UH.id_ubicacion_padre = U.id_ubicacion 
      )
    SELECT L.id_lista, P.id_partido, L.nro_lista, L.descripcion, P.descripcion,
           SUM(PD.votos_definitivos) AS suma_lista
    FROM U, planillas PL, planillas_det PD, listas L, partidos P
    WHERE PL.id_ubicacion = U.id_ubicacion
      AND PL.id_planilla = PD.id_planilla
      AND PD.id_lista = L.id_lista 
      AND L.id_partido = P.id_partido
      AND PD.id_cargo = 2
    GROUP BY P.id_partido, L.id_lista, L.nro_lista, L.descripcion, P.descripcion 
    ORDER BY 6 DESC;

    Si bien en este caso no cambia el rendimiento ni el resultado, podría ser útil para otras elecciones en que las jerarquías de ubicaciones no tengan los mismos niveles de agrupación (por ej., hay provincias que podrían estar divididas por secciones electorales, municipios, comunas, departamentos, con mayor o menor de detalle, generalmente hasta el establecimiento y mesa)

    Es interesante ver con el comando EXPLAIN el análisis del plan de ejecución de la consulta para detectar posibles optimizaciones , como podría ser agregar el siguiente indice:

    CREATE INDEX planillas_det_id_cargo_id_idx ON planillas_det(id_cargo, id_planilla)


    Funciones de Ventana con PostgreSQL:


    Otra característica de PostgreSQL que puede ser útil en estos casos, son las funciones que calculan en base a una partición de los datos (similar a un agrupamiento).
    Por ejemplo, para obtener la cantidad de votos por cada partido (además de la suma de cada lista interna), se puede agregar la expresión SUM(SUM(PD.votos_definitivos)) OVER (PARTITION BY L.id_partido) AS suma_partido  a la consulta anterior:

    WITH RECURSIVE U(id_ubicacion, descripcion, clase) AS (
        SELECT UP.id_ubicacion, UP.descripcion, UP.clase 
          FROM ubicaciones UP 
         WHERE UP.id_ubicacion = 1
      UNION ALL
        SELECT UH.id_ubicacion, UH.descripcion, UH.clase
          FROM U, ubicaciones UH 
         WHERE UH.id_ubicacion_padre = U.id_ubicacion 
      )
    SELECT L.id_lista, P.id_partido, L.nro_lista, L.descripcion, P.descripcion,
           SUM(PD.votos_definitivos) AS suma_lista,
           SUM(SUM(PD.votos_definitivos)) OVER (PARTITION BY L.id_partido) AS suma_partido
    FROM U, planillas PL, planillas_det PD, listas L, partidos P
    WHERE PL.id_ubicacion = U.id_ubicacion
      AND PL.id_planilla = PD.id_planilla
      AND PD.id_lista = L.id_lista 
      AND L.id_partido = P.id_partido
      AND PD.id_cargo = 2
    GROUP BY P.id_partido, L.id_lista, L.nro_lista, L.descripcion, P.descripcion 
    ORDER BY 7 DESC, 6 DESC;

    Cuyo resultado es:


    Agradecimientos y trabajo a futuro


    Esta aplicación fue posible gracias a la colaboración de la empresa MSA y al grupo de trabajo de datos públicos / software libre del foro de la Agenda Digital, por haber hecho posible la publicación del código fuente y el acceso a los datasets respectivamente.

    En el futuro posiblemente publicaremos un análisis más exhaustivo, extendiendo el apunte sobre optimización de consultas y estadísticas en el sitio del Grupo de Usuarios de PostgreSQL Argentina: http://www.postgresql.org.ar/trac/wiki/OptimizarRendimiento

    Seguramente se presentará el trabajo en la próxima jornada PostgreSQL: PgDay Argentina 2013, donde se preparará un taller para experimentar con los datos, analizar el rendimiento y proponer mejoras.

    Publicado por
    Ubicación: Buenos Aires, Argentina
    Etiquetas: educación postgresql python software libre web2py

  8. Asignaturas Ciclo Lectivo 2013

    Este año, en el Instituto Tecnológico Blaise Pascal estoy dando las siguientes materias, en las cuales usamos software libre como eje de los contenidos:
    • Bases de datos: Modelo Entidad Relación; Modelo Relacional; Lenguajes de de consulta (SQL y Algebra Relacional). Administración y Optimización. Herramientas: PostgreSQL
    • Sistemas Operativos: conceptos básicos e interprete (shell) GNU/Linux; Sistemas de Archivos. Procesos, sincronización e intercomunicación. Manejo de Memoria. Primitivas. Herramientas: Debian/Ubuntu y Python
    • Interconectividad (Redes):  Modelos de Referencia OSI. Ethernet. Pila de Protocolos TCP/IP. Sockets. Aplicaciones. Configuración y administración de routers y gateways. Herramientas: Debian/Ubuntu y Python (entre otras)
    • Práctica Profesional (proyecto final de carrera): Gestión de proyectos. Ingeniería de Software. Herramientas: Python, Mercurial, web2py, PostgreSQL
    En las páginas respectivas podrán encontrar la información completa, incluyendo un resumen de la planificación anual, programa de contenidos, referencias bibliográficas, prácticas y modelos de examen.

    Las materias corresponden a la "Tecnicatura Superior en Analisis de Sistemas" (Resolución Nº5817/03) y "Tecnicatura superior en Redes Informáticas" (Resolución Nº6164/03).
    Junto a otras como Programación I y II dictadas por otros profesores, se inscriben en el Proyecto Curricular Institucional orientado al software libre, en el cual venimos trabajando desde 2010 entre docentes y directivos para organizar y profundizar los contenidos teóricos y prácticos.

    "Bases de Datos" no ha sufrido modificaciones significativas desde 2009.
    La materia E.D.I. 3, que daba desde 2009 a 2012, se unificó en "Práctica Profesional".  Aquellos alumnos que vayan a rendir el final, por favor contactar con la nueva profesora ya que deben estudiar los contenidos de este año.

    Pueden ver algunos proyectos de "Práctica Profesional" del año anterior en el sitio de PyCon Argentina 2012 (Póster de trabajos estudiantiles) y en el repositorio público de la materia.

    Referencias bibliográficas libres

    La mayoría de los materiales de consulta utilizados son libre y abiertos, pudiendo citar principalmente:
    • Máster Universitario en Software Libre (Universitat Oberta de Catalunya): Si bien es una carrera de postgrado, los contenidos seleccionados son adecuados al nivel terciario y muy bien organizados. La modalidad "virtual" a distancia de la UOC ayuda a una estructura de los documentos simple y gradual, facilitando la lectura y práctica auto-dirigida por parte del alumno, para complementar y profundizar los temas presentados en clase. Además de los contenidos básicos, incluyen lecturas adicionales muy relevantes. Los materiales docentes y programas de estudio pueden consultarse en el sitio  UOC OpenCourseWare. Licencia del sitio: CC BY-NC-SA. Licencia de los documentos: GNU FDL.
    • Proyecto Alqua.org (editorial virtual libre): "Alqua es una comunidad dedicada a la recopilación de libros y material libre. En concreto, han publicado varios libros y manuales de física, matemáticas e informática, que se pueden descargar, modificar y copiar libremente". Los libros son más que nada apuntes de algunas materias, pero lamentablemente algunos han sido retirados por no estar terminados o corregidos. Licencia de los documentos: CC BY-NC-SA
    • Luis Miguel Armendáriz (Güimi): "Elaboración propia utilizando principalmente apuntes de trabajo, de distintas asignaturas universitarias, trabajos del profesor Montañana publicados en RedIRIS y artículos de la wikipedia (http://www.wikipedia.org)". Recopilaciones muy interesantes y completas para utilizar como material de consulta. Licencia del sitio y los documentos: CC BY-SA. Ver su página de documentación para el listado completo.
    • Latinux Press: "Consorcio de Cooperación Internacional que impulsa y desarrolla soluciones basadas en Software Libre y Tecnologías Abiertas". Traducción del libro de web2py al español.
    • Grupo de Usuarios de PostgreSQL Argentina: El sitio incluye una recopilación de articulos y traducciones del manual oficial, que fuí realizando en estos años para la materia Bases de Datos. Ver sección Documentación para más información.
    Adicionalmente, los siguientes recursos también han sido útiles (aunque no son usados directamente en estas materias):

    Temas a futuro

    • Traducción de la Documentación oficial al Español (Python y PostgreSQL principalmente, las man pages ya están traducidas -la mayoría...-): si bien el inglés es la "lingua franca" en estos temas de tecnología, sería importante tener los manuales oficiales traducidos, sobre todo porque las materias se dan al mismo tiempo que "Inglés Técnico" y por consiguiente puede llegar a ser una complicación, mas que nada si los alumnos usan la traducción automática de google que en la mayoría de las veces es muy imprecisa. En algún momento espero poder retomar la propuesta de internacionalización par Python como punto de partida, y volver a colaborar más activamente con las iniciativas de traducción existentes para PostgreSQL.
    • En el mismo sentido, sería interesante una adaptación de algunos materiales mencionados para el lenguaje Python, unificando los contenidos ya que actualmente estan basados en Java, C o Pascal. También sería útil completar algunos temas (como normalización de bases de datos), de los cuales todavía no se encuentra documentación libre y abierta en castellano. 
    • Python y PostgreSQL tienen herramientas y entornos de desarrollo simples como IDLE y PgAdmin3. Si bien son suficientes para presentar los contenidos de la tecnicatura, posiblemente sería conveniente mejorarlos aún más para que sean más simples y útiles para otros tipos de público. En este sentido, ver el proyecto rad2py en el que busco integrar de los temas de programación (y depuración y diseño de interfases), bases de datos y práctica profesional (repositorios, calidad, etc.). 
    • En paralelo, también estoy trabajando en proyectos como gui2py (fork renovado de PythonCard para desarrollo de interfases visuales), y en seguir mejorando web2py, ambos diseñados no solo para ser utilizados con fines educativos, sino también para brindar herramientas completas más amigables para aquellos que vienen desde otros lenguajes (PHP, Visual Basic, Delphi, etc.) y quieren dar sus primeros pasos con Python.

    Publicado por
    Etiquetas: educación linux postgresql python software libre ubuntu web2py wxpython

  9. AFIP:


    Liquidación Primaria Electrónica de Granos:


    Esta en desarrollo la interfaz para el webservice WSLPG (Liquidación Primaria de Granos):
    Operaciones de compraventa de granos no destinados a la siembra.
    Régimen de emisión de comprobantes.
    Norma conjunta Resolución General Nº 1.593 (AFIP) y Resolución Nº 456
    (ex SAGPyA), Resoluciones Generales Nº 1.415, Nº 2.205 y Nº 2.485, sus respectivas modificatorias y complementarias.
    Para más información ver:
    Proximamente liberaremos un instalador y la documentación actualizada  (actualmente el servidor de AFIP parece no estar completamente funcional ya que devuelve '500: Error General de Aplicacion.') 

    Certificados de seguridad:


    Afip ha cambiado los certificados de seguridad de los servidores de producción (webservices):

    Según la Especificación Técnica WSAA 1.2.2, la aplicación que consuma los webservices debe verificar el canal de comunicación seguro usando los CA (Certifiado de las Autoridades Certificantes).
    Para ello se puede usar el transporte (wrapper) pycurl, usando el archivo de informacion provisto: afip_ca_info.crt (recientemente actualizado por este cambio). Más info en la documentación.

    ANMAT:


    Trazabilidad de Medicamentos: Especificación Técnica v2


    Desde hace algunos días tenemos conocimiento y estamos trabajando en  una nueva versión del webservice de trazabilidad de medicamentos (TrazaMed), que  incluye los siguientes métodos (capacidades) nuevos:
    • SendConfirmaTransacc(..., p_ids_transac, f_operacion): Confirma la  recepción de un medicamento 
    • SendAlertaTransacc(..., p_ids_transac_ws): Alerta un medicamento,  acción contraria a “confirmar la transacción”. 
    • GetTransaccionesNoConfirmadas(...): Trae un listado de las  transacciones que no están confirmadas 
    Esto se suma a SendCancelacTransacc, SendMedicamentosDHSerie y  SendMedicamentosFraccion que se habían agregado con anterioridad.

    Pueden ver los nuevos cambios en la documentación:

    http://www.sistemasagiles.com.ar/trac/wiki/TrazabilidadMedicamentos

    Los ajustes iniciales al código fuente ya están publicados:

    https://code.google.com/p/pyafipws/source/browse/trazamed.py

    Según comentarios, esta nueva operatoria sería obligatoria a partir  del 1 de Marzo de 2013.

    La próxima semana estaremos publicando una nueva versión de los  instaladores y ejemplos.
    En cuanto tengamos más información ampliaremos comunicandolo por la lista de correo

    Publicado por
    Etiquetas: factura electrónica pyafipws python sistemas agiles software libre webservices

  10. Cerrando la organización de PyCon Argentina 2012, escribo esta entrada principalmente para sintetizar mis comentarios personales a las sedes que se han postulado para el 2013, y espero que sirva como resumen a modo de guía, por si alguno quiere organizar un evento similar (recordar que existe el reporte final y balance de la conferencia para mayor información, y pueden ver una entrada en mi blog previa sobre pyconus2012 para una perspectiva más detallada).

    Objetivos: ¿PyDay o PyCon?

    El principal punto es definir: ¿para que organizar una conferencia? ¿cual va a ser el público?

    En principio, se puede organizar un evento "chico" por ej. un PyDay (jornada de Python de 1 día, usualmente de carácter local, sin invitados internacionales ni mucha más complicación). Esto es lo más recomendable para aquellos que nunca organizaron un evento, ya que es más informal, con menos responsabilidades y ayuda a afianzar una comunidad local con perspectivas a realizar un evento más grande.

    Si bien los PyDays son muy interesantes, a mi criterio tienen ciertas limitaciones en cuanto a los recursos y posibilidades. Suelen ser una buena opción para los principiantes y aquellos que ya tienen una experiencia intermedia en el lenguaje, pero pueden no ofrecer la profundidad necesaria para los usuarios más avanzados. Por lo general, tampoco logran reunir participantes a nivel regional o nacional, siendo su ámbito de acción y posibilidades de difusión mucho más acotadas. Como además  generalmente son de 1 solo día, pueden no justificar el viaje para personas que viven lejos del evento.

    Para ir un poco más allá, creo que se necesitan eventos más "grandes": por ej una PyCon (usualmente varios días de conferencias, entrenamientos y reuniones de desarrollo, para todos los niveles, desde nuevos usuarios hasta desarrolladores del lenguaje). Este tipo de evento tiene en general un carácter nacional, regional o internacional, usualmente nucleando un público más diverso (incluyendo disertantes internacionales), con mayor posibilidades y recursos. Las actividades técnicas se complementan con eventos sociales y turísticos (happy hour, fiestas, city tours, etc.)

    Incluso armar eventos especiales en paralelo ayuda a traer disertantes, participantes y facilitar la organización. Por ej., este año, se armó una Jornada de PostgreSQL en paralelo a los Sprints: PgDay Argentina 2012. No solo se compartieron disertantes, sino que también un 25% de los participantes aproximadamente asistieron a ambos eventos.
    Creo que es una idea bastante buena, sobre todo viendo que este año en PyCon US 2013 se organizan varios eventos en paralelo, como un PyPgDay y PyData. 
    Tampoco habría que descartar participar en eventos mayores (conferencias de software libre o similares).

    ¿Por que se necesitan conferencias y entrenamientos más avanzados?


    En diciembre pasado estuve en las de Jornadas de Agenda Digital, donde se planteó en un panel "Debate abierto sobre Software Libre en el Estado".
    Uno de los disertantes, Jorge Linskens – Consultor quien fuera encargado de modernizar los sistemas informáticos de AFIP  – comentó que le fue posible implementar software libre porque tenia 4 "gurues de java". También señaló un caso negativo, donde la falta de soporte local hizo fracasar un proyecto, cuestionando que las ventajas del software libre se pierden si para solucionar un problema se debe contratar y traer un experto desde el exterior (con un costo de cientos de miles de dólares).
    En el ámbito privado, se puede citar una búsqueda laboral de Intel, donde uno de los requisitos era la participación activa en Django, web2py, cherrypy o web.py (además de otros temas avanzados).

    Esto no es algo nuevo o específico, recuerdo que en 2009, en la reunión informal luego de la conferencia PgCon Brasil 2009, comentaban sobre que las empresas estatales brasileñas solo contrataban "expertos" que hubieran contribuido fehacientemente al proyecto (o sea, haber enviado correcciones o mejoras que fuesen aceptados y listados en el historial de cambios).
    Siguiendo esa linea, en dicha conferencia hubo varias charlas para fomentar nuevos desarrolladores, con una Sala VIP dedicada a estos temas avanzados, tratando como hacer extensiones o lograr que te aprueben un parche (esta última, muy motivadora, sobre todo la parte de experiencia personal del autor, remarcando que el esfuerzo de contribuir al software libre al principio puede ser abrumador, pero que a la larga se aprecian sus beneficios).

    Además de fomentar el crecimiento de nuevos colaboradores, eventos de capacitación más avanzados posibilitan acercar la experiencia completa relacionada al software libre a mayor numero de interesados, quienes de otra forma tendrían que ir a los países centrales para conocer, capacitarse y conectarse con la comunidad internacional (cosa que, al menos desde Argentina, es algo económicamente costoso y hasta burocrático por el tema de visas y similares).

    Por último, no olvidar que eventos más abarcativos posibilitan encontrarse con personas de distintos orígenes e intereses, y se generan interesantes discusiones, charlas, talleres o reuniones de trabajo no programadas que de otra forma serían dificil de concretar.
    Esto se conoce como "Hallway track" (charlas de pasillo durante los intervalos),  y es uno de las mejores oportunidades que brindan estos eventos para socializar y conocer otros pythonistas.
    Tampoco olvidar otras actividades menos formales como los espacios abiertos, sala de exposición, etc., que también ayudan a conectarte con disertantes, auspiciantes y público en general.

    Disertantes Internacionales


    Retomando el tema anterior, en Python Brasil 2012 (y por consiguiente, en parte también para PyCon Argentina 2012), se buscaron disertantes internacionales para facilitar la formación de nuevos "core developers". Con un eje avanzado y charlas en inglés, se buscaba atraer a la conferencia a otros disertantes y participantes internacionales. 

    En general, los disertantes reconocidos pueden llegar a solicitar a su empleador que les cubra el costo del pasaje (uno de los gastos principales de este tipo de eventos). Esto hay que sugerirlo con tiempo, ya que sus jefes deben evaluarlo y hacer los tramites necesarios. En estos casos debe ofrecerse un reconocimiento como sponsor o similar, y garantizar que las actividades a desarrollar van a ser relevantes y justificarán el viaje.
    Puede ofrecerseles alojamiento sin cargo, sobre todo para facilitarle la jornada a a aquellos disertantes con varias actividades, pero recordar que usalmente las grandes compañias también cubren la estancia en hoteles de mayor categoría a las que puede cubrir un evento de software libre en estas latitudes, por lo que se les puede recomendar un hotel oficial al que pueden cambiarse a su cargo si asi lo desean.
    Si no se consigue cubrir estos gastos, se pueden solicitar fondos a la PSF para cubrir pasajes de avión de los invitados internacionales, y se evita el papeleo para recibir la transferencia internacional (ver Financiación y Sponsors abajo).

    Recordar aclarar estos temas para que no haya malos entendidos, por ej. recibimos una contestación de un posible invitado que solicitaba le cubrieramos el pasaje, estadía y comida (esto es usual en otras conferencias, pero puede ser complicado en nuestro caso). 
    También aclarar que la participación es ad-honorem, o sea, no se paga por las capacitaciones (a diferencia de, por ej. PyCon US, que paga alrededor de USD $1500 por presentar un tutorial).

    Los disertantes internacionales pueden llegar a pedir sus vacaciones para poder venir (incluso con sus parejas), por lo que también debería ofrecerse alternativas turísticas para hacer más atractiva y amena su estadía.

    También se puede explorar un "Tour" o gira de los disertantes internacionales, que recorran los diversos países de la región, como por ej. se hizo en "Gira Ruby Sur 2011". Proyectos similares para Python incluyen el "Python African Tour"

    Por último, es recomendable contestar los emails en tiempo y forma (máximo 24hs), y proveer por anticipado detalles sobre la organización general (duración de charlas, slots, alojamiento y transporte, gastos aproximados -comida, bebida, etc.-). Estas son cosas que tienen en cuenta los disertantes internacionales, y la sola falta de respuesta puede afectar la seriedad del evento y hacer que desistan de viajar hacia la conferencia.

    Revisión y Selección de charlas - Diversidad 


    En principio, debe armarse un Llamado a ponencias, detallando las actividades que pueden ser propuestas. En general, luego se forma  un comité de selección de charlas que evalua las propuestas, pide aprueba/rechaza las propuestas y asigna los horarios (ver Llamado a Revisores)

    El problema es que generalmente se reciben más charlas de las que pueden ser ubicadas en la grilla y surgen los inconvenientes. Lo fundamental es mantener la transparencia del proceso (para evitar decisiones que pueden ser consideradas "arbitrarias"), y posibilitar a los autores que realicen las correcciones necesarias antes de que sea demasiado tarde.
    Lo ideal sería recibir un paper tentativo (documento usualmente de entre 10 y 25 hojas) para asignarle expertos y evaluarlo en profundidad, pero la realidad es que esto es bastante difícil para este tipo de conferencias de software, y lamentablemente la disponibilidad de expertos es limitada. 

    Por eso, creo que una buena opción seguir abriendo la selección de charlas a la comunidad (y así también aumentar la participación de los futuros asistentes al evento). Para PyCon Argentina 2012 el público pudo votar sus preferencias, pero se limito la cantidad de revisores por temor a que el proceso se salga de control (sobre todo en las reuniones). 
    Quizás se debería incluso simplificar aún más el proceso de revisión, para que más gente pueda revisar las charlas y así poder mejorar la calidad antes de la votación y selección final. 
    Tanto EuroPython como PythonBrasil usan un sistema de votación totalmente abierto a la comunidad.

    También debe balancearse las posibilidades de la organización, recursos, disertantes internacionales, etc. Por ejemplo, en EuroPython combinan las charlas de invitados internacionales y sponsors, en adición a las propuestas seleccionadas por la comunidad.

    En este sentido creo que es fundamentar seguir políticas de diversidad que aseguren la participación de los distintos grupos y proyectos, generalmente minoritarios o emergentes, para que tengan cierta visibilidad, ya que si simplemente se evalúa su popularidad, quedarían excluidos por no ser "mainstream". Esta pluralidad favorece las interconexiones y compartir experiencias para enriquecer el software libre con otros casos de uso, soluciones y puntos de vista.

    Además, recordar que en general se termina decidiendo en unos pocos minutos basado en un párrafo de texto y la experiencia del autor, por lo que los autores conocidos tienen más posibilidades. Por eso puede ser interesante reservar lugares para fomentar la diversidad, por ej en PHP tek13 comentan que: "el proceso de selección es altamente competitivo. Pero También, tenemos una política para asegurar que varias de nuestras charlas sean de nuevos disertantes, o al menos sobre nuevos temas, así que no dejes que la competencia te desanime."

    Una medida para 2012 fue la de limitar a una charla por autor por track -eje- (en PyCon US se limita a dos charlas en total por cada autor), buscando mayor diversidad de temas y mejor calidad (ya que preparar más de una charla o repetirla la otros años puede ser contraproducente para el autor y la conferencia).
    También se deben dejar algunas charlas de respaldo, ya que a último momento puede que algunos disertantes desistan de participar, y es útil tener un pack de charlas para reemplazar los espacios vacantes. Es recomendable que estas charlas de backup sean preferentemente de disertantes locales o conocidos para que la confirmación sea rápida y evitar mayores complicaciones y demoras.

    Para resumir, cito a Diana Clarke -coordinadora general de PyCon CA 2012, y creo próxima de PyCon Norteamerica 2014-: "No necesitas apegarte a un sistema de votación estricto (que usualmente refuerza el status quo). ... Si quieres que el 20% de las disertantes sean mujeres: haz que ocurra! ... Si queres que el 20% de las charlas sean academicas: haz que ocurra! ... Si haces tu tarea, buscando grandes disertantes de grupos que de otro modo son poco representados, ninguno de esos disertantes seran "indignos". Obviamente, no debes solo poner tus amigos y auspiciantes sobre el escenario,  pero debes decidir como un equipo cuales son tus metas y trabajar hacia ellas" (ver mensaje completo en la lista de Conferencias)

    Financiación y Sponsors

    Para aquellos que quieran organizar una evento relacionado a Python, la Python Software Fundation tiene un Programa de Subvenciones, usualmente de 5.50 dólares por participante (aunque el importe final puede ser menor). Cabe aclarar que a partir de este año, la PSF requiere que la conferencia tenga un código de conducta.

    Es recomendable hacer la solicitud los antes posible, recordar que estos tramites demoran por la transferencia internacional (hicimos el pedido el 4 de abril, lo aprobaron el 30 de abril, nos notificaron el 5 de mayo, lo depositaron el 11 de septiembre y se acreditó en la cuenta el 21 de noviembre, 4 días después de la conferencia...). Incluso hubo que presentar varios comprobantes en el banco para que habiliten los fondos. Otro auspicio internacional que se inició en Agosto, termino acreditándose el 22 de enero de este año (dos meses después de la conferencia).

    Para este año se usó una propuesta de auspicio segmentada y diferenciada, siguiendo las bases del llamado a sponsors de PyCon US que distingue entre empresas grandes y pequeñas (menos de 25 empleados) con un descuento del 50%. Para sponsors previos se mantuvo el precio del año anterior, con un ajuste del 25% por el aumento de costos.

    Viendo las dificultades que tuvimos para cobrar los fondos de los sponsors internacionales (incluyendo comisiones bancarias importantes, gastos de notarios por certificaciones y hasta una posible retención del 35% por impuestos de EEUU), quizás sería conveniente mantener la propuesta pero limitar los descuentos solo a empresas locales, excluyendo a las multinacionales que tienen otras posibilidades y generalmente contemplan los importes internacionales para este tipo de conferencias.
    La mayoría de los sponsors fueron locales (empresas de desarrollo de software buscando programadores) y hubo varios por "canje" de productos o servicios.

    Si bien haber tenido varias fuentes de ingreso ayudó a tener un flujo de caja más predecible,  igualmente hubo que cubrir algunos gastos (adelanto de la filmación y hotel) con dinero propio de los organizadores, hasta que se iban acreditando los ingresos.

    Organización Formal


    Es un tema para tener en cuenta, sobre todo si no se tiene una organización formal (asociación, fundación o similar) para manejar los fondos y se depende de terceros.
    Armar una ONG o similar también ayudaría a los temas administrativos, con metas y responsabilidades más claras, facilitando armar planes de acción más concretos y perdurables.
    Se debe encontrar un balance entre las necesidades y sugerencias de la comunidad, contrastándolo con las posibilidades reales, sobre todo si se arman debates o discusiones  que pueden ser constructivos pero si no aportan recursos para llevarlo a cabo (voluntarios, tiempo, fondos, etc.), suelen convertirse en un ruido no deseable.

    Se pueden explorar otras formas, ver el manual de Big Kahuna (Python Brasil) para más información sobre modelos de organización comunitario, mixto o profesional (comercial). Se puede mencionar también que PyCon US es una conferencia comunitaria producida por la Python Software Fundation (ONG sin fines de lucro), pero también hay otras como DjangoCon que son producidas por empresas privadas, pero llevadas a cabo por la comunidad.
    Si para organizar se colaborará con una ONG existente dedicada a promover el software libre, ver por anticipado que no haya problemas con los posibles sponsors (PyConUS, PSF).

    Entrada Gratuita, Bono contribución y Becas

    La mayoría de los PyDays son de entrada gratuita, pero la mayoría de las PyCons son pagas. 

    Por ej., PyCon US cuesta desde USD $100 para estudiantes, aprox. USD $350 para individuos, y hasta USD $750 para empleados corporativos (entre $500 y $3750 pesos argentinos, sin contar adicionales como los tutoriales, que se pagan aparte). 
    Otros eventos más cercanos como Latinoware cuestan entre R$ 70 y R$ 110 (alrededor de $300 pesos argentinos al día de hoy).  PythonBrasil[8] costó entre R$150 y R$450 (de $400 a $1200 pesos argentinos al día de hoy). Los aranceles de las 41 Jornadas Argentinas de Informática arrancaron en $160 para estudiantes, $260 para docentes y $430 para los no-socios (realizadas por una ONG sin fines de lucro y en una Universidad Pública).

    PyCon Argentina 2012 fue de entrada gratuita (costo = $0) para posibilitarle el acceso a la mayor cantidad de interesados, y se implementó un bono contribución opcional que tenía importes sugeridos entre $75 y $250 pesos argentinos (USD $15 a USD $50 dependiendo del tipo de cambio), principalmente para cubrir el costo de remeras, artículos promocionales y catering.
    Si bien el logramos cubrir varios temas, faltó contemplar el almuerzo de los días de tutoriales y conferencias (jueves, viernes y sábado), lo que hubiera significado incrementar el costo en $150.- (el catering es uno de los temas más caros y complicados para organizar, pero es muy beneficioso para no dispersar a los participantes y facilitarles las actividades, sin estirar los horarios de almuerzo como nos ha pasado).

    Para disertantes, hubo un descuento especial del 50% (por debajo de los costos) y los sponsors obtenían acreditaciones sin cargo dependiendo del importe de patrocinio pagado.

    La categoría más económica de patrocinio, alrededor de $1000 para empresas grandes y $500 para empresas pequeñas, no tuvo ningún interesado y directamente fue eliminada. Por el contrario, hubo varias cooperativas y trabajadores particulares que aportaron con el bono contribución profesional (incluso más que el importe básico sugerido).

    El bono contribución no solo ayudo a poder mejorar algunos aspectos de la conferencia, sino que también brindó efectivo para poder pagar las becas y otros gastos (parte de la filmación y temas menores) mientras estábamos esperando que se acrediten los importes de los sponsors internacionales.

    Respecto a las becas, para ayudar a aquellos que no podían cubrir los costos de viaje, se simplificó el trámite (ver instrucciones), con un tope de $1500. El proceso de análisis y otorgamiento se simplificó para hacerlo más rápido y expeditivo.

    Para cerrar este tema, dejo una cita mencionada en un artículo periodístico: "Universidad para algunos"  Revista Veintitres del 31-1-2012: “Quienes abogan dogmáticamente por la tradicional gratuidad generalizada no están aportando efectivamente a la vigencia de una nueva situación con más igualdad en la acumulación del capital humano, por la sencilla razón de que bloquean la posibilidad de un financiamiento solidario”

    Sitio web

    Sobre este tema no voy a profundizar, ya que pueden leer lo escrito en el reporte final (postmortem) y en el blog ("Historia y como colaborar").
    Solo voy a agregar que no es un tema menor, pueden ver que el sitio de PyCon US 2011 costó en principio USD 15.000 (ver http://www.python.org/psf/records/board/resolutions/) y tampoco fue exento de inconvenientes, luego de haber intentado un primer desarrollo comunitario, para pasar a uno más comercial.
    Un consejo en este punto sería tratar de balancear los requerimientos, con un diseño más profesional, pero un desarrollo comunitario perdurable en el tiempo y reutilizable en otras conferencias.
    Ver nuevamente el mail de Diana Clarke (que recomienda no construir algo nuevo solo por diversión), aunque recomienda el software web symposion basado en pinax, que creo es más complejo que web2conf, hecho en web2py y más facil de usar y mantener, el cual recomiendo ya que lo venimos usando estos años  ;-)

    YMMV


    Publicado por
    Etiquetas: educación python software libre
Licencia y Aviso Legal
Licencia y Aviso Legal

CC BY-SACopyright (C) 2009 - 2013 Mariano Reingart reingart@gmail.com - Visite el sitio http://reingart.blogspot.com/ para novedades. Salvo indicación contraria, el texto de esta página está disponible bajo la Licencia Creative Commons Atribución Compartir Igual 3.0 Unported; podrían ser aplicables cláusulas adicionales.

Se solicita mantener el aviso de copyright (enlazando al texto original), compartir las obras derivadas bajo la misma licencia, y si es, posible comunicando al autor cualquier mejora. No utilizar logotipos ni marcas sin la debida autorización de sus titulares.

Toda información es proporcionada a Titulo Informativo y se entrega como está, sin garantías explícitas ni implicitas de ningún tipo, incluyendo sin limitación, pérdida de ganancias, interrupción de negocios, pérdida de programas u otros datos en sistemas de computación o cualquier otro reclamo. Al usarla acepta hacerlo bajo su propia responsabilidad, conociendo la normativa y reglamentaciones existentes. En caso de controversias respecto del presente, usted acepta presentarlas y resolverlas exclusivamente en la jurisdicción de los Tribunales Ordinarios Civiles y Comerciales del Departamento Judicial de Morón, Provincia de Buenos Aires, Argentina, renunciando expresamente a cualquier otro fuero que pudiere corresponder.


Enlaces
Enlaces
Laboral
Laboral
Laboral
Grupo de desarrolladores independientes
Docente en
Docente en
Docente en
Instituto Superior Blaise Pascal
Diplomatura
Diplomatura
Diplomatura
Universidad del Este
Proyecto PyAfipWs
Proyecto PyAfipWs
Proyecto PyAfipWs
Interfáz libre a los servicios web de AFIP
Etiquetas
Etiquetas
Datos personales
Datos personales
Mi foto
Suscribirse
Suscribirse
Archivo del blog
Archivo del blog
Cargando