jQuery best practices

After some time working with C programming language in a *NIX like operating system, recently I came back again to Web Programming, mostly working with HTML, CSS and JavaScript in the client-side and other technologies in the backend area.

The current project I’ve been working on, heavily relies on jQuery and Highcharts/Highstock libraries, I must confess that at the beginning of the project my skills in the client-side were more than rusted, so, I began reading a lot of articles about new techniques and good practices to catch up very quickly, in the meantime, I start taking some notes about “best practices”¹ that promotes a better use of jQuery²

Please take this “best practices” with a grain of salt, do your research ↩
As a side note, besides jQuery nowadays are used by a large percentage of ↩

MongoDB University: M101P

A finales del año pasado finalice satisfactoriamente el curso en línea M101P: MongoDB for Python Developers de MongoDB University (otrora conocido como 10gen Education). Sin embargo, no me había tomado el tiempo para compartirles la experiencia, sino hasta ahora.

Cualquier persona sin práctica en el área puede tomar este curso, pues es un abreboca al mundo detrás de MongoDB y explora un buen número de temas relacionados a esta base de datos NoSQL. Aunque está orientado a desarrolladores en Python lo exigido por el curso es mínimo en este lenguaje, incluso dentro de los temas está contemplado una introducción a este lenguaje. Sin embargo, para aquellos que decidan explorar otros lenguajes de programación, MongoDB University ofrece alternativas para programadores en Java, Node.js y también para DBAs.

La duración del curso es de 7 semanas, en base al conocimiento previo que se maneje de las tecnologías puede necesitar de unas 4 a 6 horas semanales de dedicación. La estructura del curso permite ver inicialmente varios videos introductorios que hacen referencia a un tópico en particular, luego podrá reforzar lo visto con una serie de quizzes, en este punto siempre es recomendable contrastar lo visto con la documentación oficial en línea y no dejar de responder todas las tareas de cada semana pues tienen un peso total del 50%, el plazo de respuesta es más que aceptable, se da una semana de plazo para responder. En la última semana será el examen final, el cual consta de 10 preguntas, con ello se obtiene el otro 50%.

En mi caso aprovechaba el tiempo al ser trasladado hacia/desde el trabajo y veía fuera de línea los videos ofrecidos por MongoDB University. Luego, al retornar a casa en las noches o los fines de semana respondía los quizzes y las asignaciones, de ese modo me fue posible lograr aprobar sin problemas el curso, además, al final recibes un certificado de aprobación, aunque lo más importante para mi fue aprender algunas cuestiones que aún desconocía de MongoDB, las semanas podrían resumirse como siguen:

En la primera semana se ve una introducción a MongoDB, se compara en cierta medida con el esquema relacional y se plasma un bosquejo del desarrollo de aplicaciones con MongoDB. También se explora el shell y se introduce la notación JSON, a partir de acá se crean arrays, documentos y subdocumentos, entre otros detalles de la especificación. También se comienza a preparar el ambiente de trabajo futuro, es decir, se explica como instalar MongoDB en diversas plataformas, así como Python, Bottle (microframework para desarrollo Web en Python) y pymongo, éste último ofrece un conjunto de herramientas para interactuar con MongoDB desde Python. Ya para finalizar las sesiones de la semana, se da una introducción al lenguaje de programación Python y manejo básico del framework Bottle.

La segunda semana se tiene mayor interacción con el shell de MongoDB, se inicia el proceso de CRUD, se podrán ejecutar consultas por medio de find, findOne. Se comienza el uso de operadores de comparación de campos como $gt y $lt, operadores lógicos como $or, $and, uso de operadores $exists, $type, conteo de consultas sobre colecciones con el método count(), uso de expresiones regulares (compatibles a las usadas en Perl) a través del operador $regex¹, consultas sobre elementos dentro de arrays con los operadores $in y $all, actualizaciones de arrays a través de $push, $pop, $pull, $pullAll y $addToSet. Además, uso de operadores de actualización $set y $unset para establecer o eliminar campos de un documento respectivamente. Actualización de documentos existentes y la posibilidad de utilizar opciones como upsert (operación que permite hacer una actualización si el documento en cuestión existe, de lo contrario, se realiza una inserción automática) o multi (actualización múltiple). Ya para finalizar la segunda semana se deja de lado un poco el shell y se comienza el mismo proceso de interacción descrito previamente pero en esta ocasión desde pymongo.

La tercera semana nos podemos encontrar con temas enfocados al área de modelado de datos, pues MongoDB ofrece un esquema flexible, incluso cada documento puede manejar un esquema dinámico. Por lo tanto, resulta conveniente estudiar las posibilidades existentes en el modelaje de datos y que la escogencia de un esquema particular apunte a cubrir los requerimientos de la aplicación, explotación de las características propias del motor de base de datos y los mecanismos comunes de obtención de dichos datos. En el transcurso de la tercera semana, se contrasta como ejemplo el modelado de datos relacional de las tablas que pueden estar asociadas a un blog y como cambia dicho modelado desde la visión no relacional, también se cubren temas como las relaciones uno a uno, uno a muchos con referencias a otros documentos, uno a muchos con documentos embebidos, en qué casos puede ser beneficioso embeber datos. Finalmente se explora GridFS para el manejo de blobs, ficheros que normalmente superen el límite de tamaño de cada documento (16MB).

El tema principal de la cuarta semana es el rendimiento, lo cual puede estar influenciado por muchos factores, desde el sistema de gestión de ficheros, hasta la memoria, CPU, tipos de discos, entre otros. Sin embargo, en esta semana se concentrarán en explorar los algoritmos que dependiendo de la situación puede ejecutar rápidamente o no las consultas. Por lo tanto, es necesario explorar conceptos básicos como índices, su creación y descubrimiento, índices con múltiples claves hasta temas como la detección de posible cuellos de botella al no utilizar índices o mala utilización de los mismos. Al finalizar se comienza a explorar los shardings, básicamente es una técnica que permite dividir largas colecciones de datos en múltiples servidores.

La quinta semana se explora una de las funcionalidades mas atractivas de MongoDB: Aggregation framework. Para los que vienen del mundo SQL puede parecerles una respuesta a la agrupación de resultados por grupos, en donde se pueden obtener sumas ($sum), conteos ($count), promedios ($avg) y otras funciones sobre un conjunto de colecciones agrupadas por ciertos valores particulares.

La sexta semana se cubren interesantes temas como la replicación y sharding. La última semana se tiene acceso a 2 casos de estudio, en particular, la primera entrevista es con Jon Hoffman (@Hoffrocket) de Foursquare y la segunda con Ryan Bubinski (@ryanbubinski) de Codecademy.

Después de las entrevistas viene el examen final, el cual cubre el 50% del curso. ¡Éxitos! y recuerde siempre reforzar lo visto en el curso con la documentación oficial, también existen recursos adicionales² en la red que podrían servirles.

Ya para finalizar quisiera decirles que se animen a intentar unirse al curso que se ofrece de MongoDB, vale la pena intentarlo y verán que son semanas bien aprovechadas.

través del operador $regex, tenga en cuenta que solo podrá hacer uso eficiente del índice cuando la expresión regular incluye el ancla de inicio de cadena: ^ (acento cincunflejo) y sea case-sensitive.

MongoDB Book]the-little-mongodb-book de Karl Seguin, también existen guías y presentaciones adicionales que pueden ayudarle a comprender aún más MongoDB, por ejemplo, esta presentación sobre distintas consultas y uso del aggregation framework para explorar datos de resultados la NBA.

Resalto que de llegar a necesitar hacer uso de expresiones regulares a ↩
Puede encontrar material de apoyo introductorio en el libro [The Little ↩

Elixir: Primeras impresiones

NOTA: Este artículo originalmente lo escribí para La Cara Oscura del Software, un blog colectivo dedicado a desarrollo de software.

Durante el segundo hangout de @rubyVE escuché a @edgar comentar sobre Elixir y en verdad me llamó la atención lo que indicaba, siempre me inquieta conocer al menos un poco sobre otros lenguajes de programación, siempre terminas aprendiendo algo, una buena lección es seguro, sobre todo por aquello de la filosofía del programador pragmático y la necesidad de invertir regularmente en tu portafolio de conocimientos.

Ahora bien, después de leer un artículo de Joe Armstrong, padre de Erlang, en donde afirmaba que tras una semana de haber usado Elixir estaba completamente entusiasmado por lo visto. Con esto era claro que se estaba presentando para mi una gran oportunidad para retomar la programación funcional con Elixir, inicié con Haskell en la Universidad en la materia de Compiladores y la verdad es que no lo he vuelto a tocar.

José Valim es un brasileño, parte del equipo core committer de Rails. Después de sufrir RSI, en su afán por encontrar qué hacer en su reposo se puso a leer el libro: Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages y allí conoció Erlang y su EVM (Erlang Virtual Machine), cierto tiempo después creo este nuevo lenguaje llamado Elixir, en donde uno de sus mayores activos es la EVM, tanto es así que de hecho no existe un costo de conversión al invocar Erlang desde Elixir y viceversa. Todo esto es seguramente es la respuesta de Valim a las limitantes físicas actuales en los procesadores o lo que se conoce también como: “se nos acabó el almuerzo gratis”, sobre todo ahora con recientes anuncios de Parallella y de Intel con los procesadores Xeon Phi.

A pesar de la horrible sintaxis de Erlang, o al menos después de leer a Damien Katz, autor original de CouchDB en What Sucks About Erlang y a Tony Arcieri, autor de Reia (otro lenguaje basado en BEAM), en su artículo The Trouble with Erlang (or Erlang is a ghetto) es fácil concluir que la sintaxis no es la más amenas de todas. Sin embargo, las inmensas habilidades que brinda Erlang para establecer sistemas concurrentes (distribuidos, tolerantes a fallas y code swapping) ha permitido llegar a mantener hasta 2 millones de conexiones TCP en un solo nodo. Es por ello que compañías como Whatsapp, Facebook, Amazon, Ericsson, Motorola, Basho (Riak) y Heroku por mencionar algunas están usando Erlang para desarrollar sus sistemas.

Rápidamente quisiera compartirles mi felicidad por haber iniciado a explorar este lenguaje. Para iniciar tu proyecto tienes un magnífico utilitario llamado mix (inspirado en Leiningen de Clojure). Mix también permite manejar las tareas más comunes como administración de dependencias de tu proyecto, compilación, ejecución de pruebas, despliegue (pronto), entre otras. Incluso puedes programar nuevas tareas, simplemente asombroso, en fin, vamos a jugar:

$ mix help
mix                 # Run the default task (current: mix run)
mix archive         # Archive this project into a .ez file
mix clean           # Clean generated application files
mix cmd             # Executes the given command
mix compile         # Compile source files
mix deps            # List dependencies and their status
mix deps.clean      # Remove the given dependencies' files
mix deps.compile    # Compile dependencies
mix deps.get        # Get all out of date dependencies
mix deps.unlock     # Unlock the given dependencies
mix deps.update     # Update the given dependencies
mix do              # Executes the tasks separated by comma
mix escriptize      # Generates an escript for the project
mix help            # Print help information for tasks
mix local           # List local tasks
mix local.install   # Install a task or an archive locally
mix local.rebar     # Install rebar locally
mix local.uninstall # Uninstall local tasks or archives
mix new             # Creates a new Elixir project
mix run             # Run the given file or expression
mix test            # Run a project's tests

Procedamos con la creación de un nuevo proyecto:

$ mix new demo
* creating README.md
* creating .gitignore
* creating mix.exs
* creating lib
* creating lib/demo.ex
* creating test
* creating test/test_helper.exs
* creating test/demo_test.exs

Your mix project was created with success.
You can use mix to compile it, test it, and more:

    cd demo
    mix compile
    mix test

Run `mix help` for more information.

La estructura del proyecto creado por mix es como sigue:

$ cd demo
$ tree
.
|-- README.md
|-- lib
|   `-- demo.ex
|-- mix.exs
`-- test
    |-- demo_test.exs
    `-- test_helper.exs

2 directories, 5 files

En mix.exs encontramos la configuración del proyecto así como sus dependencias en caso de aplicar, en lib/demo.ex ubicamos la definición del módulo que nos ayudará a estructurar posteriormente nuestro código, en test/test_demo.exs encontramos un esqueleto base para los casos de pruebas asociadas al modulo. Finalmente en test/test_helper.exs radica inicialmente el arranque del framework ExUnit.

Creemos un par de pruebas sencillas primero:

$ vim test/demo_test.exs
defmodule DemoTest do
  use ExUnit.Case

  test "factorial base case" do
    assert Demo.factorial(0) == 1
  end

  test "factorial general case" do
    assert Demo.factorial(10) == 3628800
  end

  test "map factorial" do
    assert Demo.map([6, 8, 10], fn(n) -> Demo.factorial(n) end) == [720, 40320, 3628800]
  end
end

Evidentemente al hacer “mix test” todas las pruebas fallaran, vamos a comenzar a subsanar eso:

$ vim lib/demo.ex
defmodule Demo do

def factorial(0) do
    1
end

def factorial(n) when n > 0 do
    n * factorial(n - 1)
end

end

En el par de bloques de código mostrado previamente se cubren los dos casos posibles del factorial.

Volvamos a correr las pruebas:

$ mix test
..

  1) test map factorial (DemoTest)
     ** (UndefinedFunctionError) undefined function: Demo.map/2
     stacktrace:
       Demo.map([6, 8, 10], #Function<0.60019678 in DemoTest.test map factorial/1>)
       test/demo_test.exs:13: DemoTest."test map factorial"/1

Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
3 tests, 1 failures

De las 3 pruebas programadas hemos superado dos, nada mal, continuemos, volvamos a editar nuestro módulo:

$ vim lib/demo.ex
defmodule Demo do
    def factorial(0) do
        1
    end

    def factorial(n) when n > 0 do
        n * factorial(n - 1)
    end

    def map([], _func) do
        []
    end

    def map([head|tail], func) do
        [func.(head) | map(tail, func)]
    end
end

En esta última versión se ha agregado la función map, básicamente esta función recibe una colección de datos y una función que se aplicará sobre cada uno de los elementos de la colección, para nuestros efectos prácticos la función que será pasada a map será el factorial.

Como nota adicional, los bloques de código vistos en el ejemplo anterior prefiero expresarlos de manera sucinta así, cuestión que también es posible en Elixir:

$ vim lib/demo.ex
defmodule Demo do
    @moduledoc """
    Demo module documentation, Python *docstrings* inspired.
    """
    def factorial(0), do: 1

    def factorial(n) when n > 0, do: n * factorial(n - 1)

    def map([], _func), do: []

    def map([head|tail], func), do: [func.(head) | map(tail, func)]
end

Acá se pueden apreciar conceptos como pattern matching, guard clauses, manejo de listas y docstrings (inspirado en Python). Atención, los docstrings soportan MarkDown, junto a ExDoc es posible producir sitios estáticos que extraen los docstrings a partir del código fuente.

Comprobemos los casos desde la consola interactiva iex antes de pasar de nuevo al caso automatizado:

$ iex lib/demo.ex
Erlang R16B01 (erts-5.10.2) [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false]

Interactive Elixir (0.10.2-dev) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> import Demo
nil
iex(2)> h(Demo)
# Demo

Demo module documentation, Python *docstrings* inspired.

iex(3)> Demo.factorial(10)
3628800
iex(4)> Demo.map([6, 8, 10], Demo.factorial(&1))
[720, 40320, 3628800]

Lo previo es una consola interactiva, vimos la documentación e hicimos unas pruebas manuales.

Seguro notaron que al final del ejemplo previo, al hacer el map he cambiado la forma en la que invoco a la función anónima la cual originalmente fue definida en las pruebas como fn(n) -> Demo.factorial(n) end, solamente he recurrido a un modo que permite Elixir y otros lenguajes funcionales para expresar este tipo de funciones de manera concisa, se le conoce como Partials.

Ahora corramos las pruebas automatizadas de nuevo:

$ mix test
Compiled lib/demo.ex
Generated demo.app
...

Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
3 tests, 0 failures

Con eso hemos pasado los casos de pruebas.

En este caso particular, prefiero que las pruebas sean autocontenidas en el módulo, además, no recurrimos a fixtures ni nada por el estilo, así que vamos a cambiar el código para que soporte doctest

$ vim lib/demo.ex
defmodule Demo do
    @moduledoc """
    Demo module documentation, Python *docstrings* inspired.
    """

    @doc """
    Some examples

    iex> Demo.factorial(0)
    1

    iex> Demo.factorial(10)
    3628800

    iex> Demo.map([6, 8, 10], Demo.factorial(&1))
    [720, 40320, 3628800]
    """
    def factorial(0), do: 1

    def factorial(n) when n > 0, do: n * factorial(n - 1)

    def map([], _func), do: []

    def map([head|tail], func), do: [func.(head) | map(tail, func)]
end

Dado lo anterior ya no es necesario tener las pruebas aparte, por lo que reduzco:

$ vim test/demo_test.exs
defmodule DemoTest do
  use ExUnit.Case
  doctest Demo
end

Comprobamos la equivalencia:

$ mix test
...

Finished in 0.06 seconds (0.06s on load, 0.00s on tests)
3 tests, 0 failures

Simplemente hermoso, cabe resaltar que lo mencionado es solo rascar un poco la superficie de Elixir :-)

Ah, por cierto, ya para finalizar, José Valim está apuntando el desarrollo de Elixir y Dynamo (framework) a la Web, lo ha dejado claro, por eso he visto que algunos programadores Rails están “echándole un ojo” a Elixir, al menos eso es lo que concluyo de los elixir-issues en Github, el reciente screencast de Peepcode (vale la pena comprarlo) y los libros que se avecinan de Dave Thomas y Simon St. Laurent.

Quizá en una nueva oportunidad hablemos de Macros, pase de mensajes entre procesos, Protocolos (inspirados en Clojure protocols), Reducers (inspirados también en Clojure Reducers), HashDict, el hermoso y *nix like operador pipeline (|>), mejorar nuestra implementación de la función map para que haga los cálculos de manera concurrente, entre otros.

Espero hayan disfrutado la lectura, que este artículo sirva de abreboca y les anime a probar Elixir.

Python: ¿Cómo puedo comenzar a programar?

Hay mucha documentación sobre el lenguaje de programación Python, tal vez eso haya quedado claro en el artículo anterior.

Sin embargo, se puede iniciar revisando el tutorial oficial de Python. El libro Learn Python the Hard Way (LPTHW) de Zed Shaw está muy bueno para comenzar, tiene una buena cantidad de ejercicios. LPTHW no es el único libro de fácil o libre acceso, también podrá disponer de los siguientes:

Google también ofrece muy buen material a través de Google Python Class, no olvide revisarlo. Otros recursos muy interesantes son los del MIT Open Courseware A Gentle Introduction to Programming Using Python y Code Like a Pythonista: Idiomatic Python. Lamentablemente libros en español recuerdo pocos, el último que llegue a revisar fue Python para todos, también alcance a revisar un libro de la Universidad de Jaume, muestran una grata introducción a la programación con Python.

Considero que la mejor manera de engancharte con un lenguaje es trabajar en un proyecto personal o practicando, si no se te ocurre nada por el momento, puedes comenzar vía Learn Street, Code Academy, Python Challenge, Project Euler. Si quieres ver la ejecución paso a paso de tus programas en Python no dejes de revisar Python Tutor. El gran dilema: ¿Python 2 o 3? Si tienes un objetivo con Python y la versión 3 puede cubrirlo perfecto, pero ten claras las reglas del juego antes de escoger la versión 2.x o 3.x, este artículo te puede aclarar el panorama.

Python: El comienzo

¿Qué es Python?

Lenguaje de programación orientado a objetos, interactivo e interpretado.
Estructuras de datos alto nivel, dinámicamente tipado.
Aumenta la productividad de desarrollo en comparación con otros lenguajes estáticamente tipados.
Multiplataforma:
- El interprete CPython puede ejecutarse nativamente en muchas plataformas (esto incluye Windows, OS X, GNU/Linux, entre otras).
- Jython corre dentro de la Java Virtual Machine.
- IronPython está orientado a plataformas .NET y Mono.
- PyPy es una implementación enfocada en el rendimiento con un compilador Just In Time
- Stackless es una rama de CPython con soporte a microthreads

Python es un lenguaje dinámicamente tipado, esto quiere decir que el tipo de cada variable se conoce en tiempo de ejecución, a su vez, Python es un lenguaje fuertemente tipado, lo anterior implica que si usted posee una variable de tipo entero no puede tratarla como una cadena de texto a menos que usted realice la conversión de manera explícita previamente.

CPython es la primera implementación del lenguaje Python, también es la de mayor uso a nivel mundial, dicha implementación esta escrita en el lenguaje de programación C. Esta es la implementación que todos conocemos al referirnos al lenguaje de programación Python, pero en aquellos escenarios en donde es necesario distinguirla de otras implementaciones alternativas se le conoce como CPython.

¿Por qué usar Python?

En uno de los primeros libros que leí sobre Python, Mark Lutz resumía estos puntos de la siguiente manera:

Calidad del software

Para muchos, Python se enfoca en la legibilidad, coherencia, y la calidad del software en general. Al ofrecer un diseño legible, el proceso de mantenimiento se hace más fácil y rápido.

Incremento en la productividad del desarrollo

El código en Python regularmente es de 1/3 a 1/5 el tamaño de un código equivalente escrito en C++ o Java. Esto quiere decir que el desarrollador tendrá menos que escribir, menos que depurar, y menos que mantener después de todo. Además, los programas en Python pueden ejecutarse inmediatamente, sin tener que recurrir a los largos y tediosos pasos de compilación y enlazado.

Portabilidad

La mayoría de los programas en Python se pueden ejecutar indistintamente en la mayoría de las plataformas. Por otra parte, Python le ofrece múltiples opciones para desarrollar interfaces gráficas de usuario portables, entre ellas contamos con: TkInter, wxPython, PyGTK, PyQT, WxWidgets. Además, cuenta con módulos de accesos a base de datos, sistemas Web, entre otros.

Integración de componentes

Los scripts en Python fácilmente pueden comunicarse con otras partes de una aplicación, usando una variedad de mecanismos para la integración. Actualmente, Python puede invocar librerías en C y C++, puede ser llamado desde programas en C y C++, puede integrarse con componentes en Java, puede comunicarse sobre Corba y .NET, puede interactuar en la red con interfaces como SOAP, protocolo estándar que define cómo dos objetos en diferentes procesos puede comunicarse por medio del intercambio de datos en XML, REST y XML-RPC.

Diversión

Ya que Python es tan fácil de usar y le brinda un gran conjunto de herramientas, puede hacer el acto de programar una tarea muy placentera.

¿Qué es el Zen de Python?

A través de Zen de Python puede conocer los principios del diseño y la filosofía detrás del lenguaje de programación Python. También resulta útil para comprender y utilizar el lenguaje.


1
2

    >>>  import this
    The Zen of Python, por Tim Peters

Obtendrá por respuesta algo como:

Hermoso es mejor que Feo.
Explícito es mejor que Implícito.
Simple es mejor que Complejo.
Complejo es mejor que Complicado.
Lineal es mejor que Cruzado.
Escaso es mejor que Denso.
Poder leer el código, cuenta.
Los Casos Especiales no son tan especiales como para romper reglas.
Lo Práctico le gana a Lo Puro.
Los Errores no deben pasar desapercibidos.
A menos de que Explícitamente se silencien.
En la ambigüedad, rehusa el Adivinar.
Sólo debería haber una, y preferiblemente Una, manera
obvia de hacer las cosas.
Aunque esa manera no se obvia al principio, a menos que seas (Dutch).
Ahora es mejor que Nunca.
A pesar de que Nunca es mejor que Ahora Mismo.
Si la implementación es difícil de explicar, es probable
que sea una mala idea.
Si la implementación es fácil de explicar, es probable
que sea una buena idea.
Namespaces son una Gran idea — Hagamos mas de esas.

¿Qué tipos de aplicaciones puedo desarrollar en Python?

Python es un lenguaje multipropósito, basta darle una revisión al Python Package Index para ver una muestra de las aplicaciones desarrolladas con este hermoso lenguaje.

Sin embargo, podemos ubicar el dominio de las aplicaciones en Python en:

Herramientas y utilidades para la administración de sistemas

Python provee interfaces para servicios de Sistemas Operativos, desde un programa escrito en Python podemos buscar ficheros y árboles de directorios, cargar otros programas, realizar procesamiento paralelo, entre otras cosas muy interesantes.

GUI (Interfaz gráfica de usuario)

Python viene con una interfaz estándar orientada por objetos llamada TkInter, la cual permite a los programas escritos en Python implementar GUIs con una interfaz nativa del Sistema Operativo. Además, pueden encontrarse implementaciones más atractivas como: wxWidgets, GTK+, Qt (pyqt o pyside), entre otras.

Internet

Python viene con módulos estándar para Internet que permiten a los programas realizar una gran variedad de tareas en redes, tanto en el modo servidor como cliente. Los scripts en Python pueden comunicarse sobre sockets; transferir ficheros vía FTP; procesar ficheros XML, JSON, también permite establecer comunicaciones sobre XML-RPC, SOAP, telnet, [hermosas APIs para la interacción con HTTP y más.

En el ámbito Web se pueden encontrar variadas opciones, desde CGI básicos, pasando por avanzados manejadores de contenido hasta frameworks de desarrollo como Django, Flask y microframeworks como Bottle.

Bases de Datos

Python ofrece módulos para interactuar con la mayoría de las bases de datos relacionales, existen interfaces en Python: PostgreSQL, MySQL, Sybase, Oracle, Informix, ODBC, y más. También ofrece un API estándar para la interacción con Bases de Datos. Es claro entonces poder observar proyectos que brindan una interacción de alto nivel con bases de datos como los ORM SQLAlchemy o DAL.

También hay cabida para el mundo NoSQL en Python, donde hay soporte para: Cassandra, Riak, MongoDB, CouchDB y Redis por mencionar solo algunas.

Juegos, Imágenes, AI, XML

Se pueden realizar fácilmente gráficos y programación de juegos en Python con la librería pygame, PyKyra, pyglet, cocos2d y más, incluso puedes participar en el concurso PyWeek.

También se puede incluir en el largo listado el procesamiento de imágenes con el paquete PIL y otros. Programación de Inteligencia Artificial con simuladores de redes neuronales y Sistemas Expertos, análisis de ficheros XML con el paquete de bibliotecas xml. Python soporta a traves de extensiones Programación numérica avanzada, NumPy/SciPy vuelve a Python en una sofisticada herramienta de fácil uso para la programación numérica y científica. De manera adicional, Python puede soportar animaciones,visualización 2D y 3D, Biología Molecular, cálculo estadístico (RPy) y más.

¿Quienes usan Python?

La lista incluye a grandes en el mundo de tecnología, un excelente resumen se puede encontrar en el listado de casos de éxito y citas del portal oficial de Python.

¿Cómo puedo mantenerme al día?

Son muchas las fuentes de información sobre Python, algunas interesantes son las siguientes:

En el siguiente artículo de esta serie espero poder listar algunos recursos que pueden ser de ayuda a los principiantes en este fabuloso mundo de la programación con Python.