jueves, 13 de marzo de 2014

Tutorial de Backbone.js (I)


Hoy en día hay una nueva tendencia a la hora de hacer sitios web,  ésta es usar el patrón MVC en los clientes para lograr una mejor experiencia, es por esto que se han creado frameworks como Backbone.js o Angular.js, los cuales permiten usar MVC en el cliente y permiten sacarle todo el jugo a JavaScript. Una vez dicho esto entremos en materia.

¿Qué es Backbone.js?
Backbone.js es un framework que permite al desarrollador estructurar su aplicación, delegando ciertas labores a elementos específicos con el fin de hacer aplicaciones escalables, robustas y que brinden al usuario una gran experiencia de uso.

Entendiendo Backbone
Antes habíamos hablado de una serie de elementos que estructuran una aplicación, éstos elementos son los modelos (Models) y colecciones (Collections), que manejan la capa de datos, vistas (Views) para gestionar el contenido que interactúa con los usuarios y enrutadores (Routers) que permiten realizar los procesos de navegación en la aplicación. Una de las cosas más interesantes de este framework es que en la mayoría de los objetos se pueden definir una serie de eventos que permiten responder a las acciones del usuario. Otro punto a favor es que la capa de datos puede conectarse con varios tipos de fuentes de datos como REST, local storage y otros más.

Capa de Datos
Como ya mencione antes la capa de datos esta compuesta por modelos (Model) y colecciones (Collection), es necesario entender que un modelo es un elemento asociado a una fuente específica de datos y que un una instancia de un modelo es una unidad de datos, es decir, lo equivalente a un registro en una base de datos. En comparación una colección es es un elemento asociado a una fuente específica de datos y a un modelo específico y una instancia de una colección es un grupo de instancias de un modelo.
Tanto los modelos como las colecciones pueden responder a eventos como un nuevo dato agregado, el cambio de un dato existente y más, respondiendo a estos eventos con acciones asignadas por el programador.
Veamos un ejemplo:
// Ejemplo de modelos y colecciones
var Libro = Backbone.Model.extend({
    url : '/api/libros/',
    initialize: function(){
       // TODO: acciones de inicialización del modelo
    }
});

var Libros = Backbone.Collection.extend({
    model: Libro,
    url: '/api/libros/',
    initialize: function(){
       // TODO: acciones de inicialización del colección
    }
});


Como vemos en el código anterior se definen un modelo y una colección, los cuales tienen como fuente común de datos una api REST que provee los datos. Además la colección tiene asociado un modelo.
Sin embargo el código anterior no permitirá usar ningún dato hasta que se descarguen de manera explicita. Ahora miremos cómo usar modelos y colecciones:
// Ejemplo de modelos y colecciones, como cargar datos del servidor

    function listarLibros () {
        $("ul.datos").html("")
        var coleccion_libros = new Libros();
        coleccion_libros.on("add", function(model){
            console.log("Agregado", model.toJSON());
            $(".datos").append("<li>"+
                JSON.stringify(model.toJSON())+
                "</li>"
                );
        });
        var xhr = coleccion_libros.fetch()
        xhr.done(function () {
            console.log('Libros descargados...');
            var llibros = coleccion_libros.filter(function (model) {
                var libro = model.toJSON();
                return libro.nombre === "El Principito";
            });
            if(llibros.length==0){
                var libroNuevo = new Libro({
                    "nombre":"El Principito",
                    "editorial":"Panamericana",
                    "genero":"Infantil",
                    "autor":"1"
                });
                libroNuevo.save();
                coleccion_libros.add(libroNuevo);
            }
            console.log("0k");
        });

    }


En el último ejemplo vemos una función en la cual se cargan los datos desde el servidor con la instrucción fetch y se agregan a una lista (ul.datos) y si no hay ningún libro con nombre "El Principito" este se agrega.
Como vemos en el ejemplo se crea un objeto de tipo colección (coleccion_libros) y éste gestiona la carga de datos del servidor, además se pueden hacer bindings entre eventos y funciones, de esta manera se muestran los datos en la pagina web dentro de una lista cada vez que se agrega un nuevo elemento a la colección.

Pueden encontrar el código de ejemplo en Github. espero que les sea de ayuda.

Por favor comparte éste post... 
:D

miércoles, 19 de febrero de 2014

Tutorial ¿Cómo compilar Python3 en Linux Debian?


Muchos ya lo han dicho, hay que dejar de lado Python2.X y aunque aun falta para ello he aquí un tutorial para compilar en nuestra maquina linux (debian para ser exactos) Python3.3.

Instalación de dependencias
Como super usuario (root) ejecutamos la siguiente instrucción en la linea de comandos:
apt-get install make build-essential  zlib1g-dev  libbz2-dev  libncurses5-dev  libreadline6-dev  libsqlite3-dev  libssl-dev  libgdbm-dev liblzma-dev tk8.5-dev

Descarga y compilación
Ahora bien, debemos descargar el código fuente y compilarlo, para ello ejecutamos las siguientes instrucciones:
wget -c http://python.org/ftp/python/3.3.4/Python-3.3.4.tgz
tar -zxf Python-3.3.4.tgz
cd Python-3.3.4
# Proceso de compilación
# primero se configuran los makefile para el sistema
./configure
# inicia compilación
make
# se hacen pruebas para saber que todo salió bien, 
# es recomendable pero no obligatorio.
make test
# instalación de los binarios en el sistema
make install

Finalmente solo queda probarlo ejecutando python3.3.

Espero que les haya gustado.

Si te gusto el post
compartelo... :D

martes, 4 de febrero de 2014

Django y las class based views


Cuando se trabaja en django resulta claro que hay muchas labores que son mas y mas fáciles, pero manejar la lógica de una petición mediante una función puede ser perjudicial a la hora de manejar muchas vistas. Es por eso que en este post vamos a ver cómo usar class bases views, una forma mas ordenada de encapsular la lógica.

¿Qué son?
Class-Based-Views (CBV en adelante) es una forma alternativa para crear vistas en django, no pretende reemplazar  las Function-Based-Views (FBV en adelante) , pero si tienen como objetivo permitir al desarrollador:
  • Organización del código relacionado con metodos HTTP específicos (GET, POST, PUT, etc) y que el router pueda acceder a estos sin tener que usar condicionales específicas.
  • Técnicas orientadas a objetos (Como los Mixins) para solucionar ciertos problemas.
¿Por qué usarlas?
La pregunta clave es ¿por qué? y ante esto hay varias cosas que la respaldan:

  • Orden.
  • Estética del Código.
  • Reciclaje del Código.
  • Uso de herramientas de OOP.
  • Simpleza.
  • Estructura bien definida (definición de acciones para cada protocolo, definición de respuestas para casos de éxito y falla con métodos como get_success_url).
¿Cómo funcionan?
Para entender mejor ciertos aspectos de cómo funcionan las CBV debemos ver un poco de FBV

# views.py
from django.shortcuts import render

def index(request):
    if request.method == 'GET':
        # TODO: GET ACTIONS
        return render(request,"template_get.html")
    elif request.method == 'POST':
        # TODO: POST ACTIONS
        return render(request,"template_POST.html")
    elif request.method == 'PUT':
        # TODO: PUT ACTIONS
        return render(request,"template_put.html")
    elif request.method == 'DELETE':
        # TODO: DELETE ACTIONS
        return render(request,"template_del.html")

# end views.py
# ----------------------
# urls.py

from django.conf.urls import patterns

urlpatterns = patterns('',
    (r'^$', "myapp.views.index"),
)
# end urls.py

Como vemos en el código anterior en una sola función la lógica de múltiples ti pos de respuestas, y esto no es adecuado porque restara mantenibilidad y escalabilidad a nuestra aplicación, para evitar eso están las CBV, veamos a continuación cómo sería esto:
# views.py
from django.views.generic.base import View
from django.shortcuts import render

class IndexView(View):

    def get(self, request):
        # TODO: GET ACTIONS
        return render(request,"template_get.html")

    def post(self, request):
        # TODO: POST ACTIONS
        return render(request,"template_POST.html")

    def put(self, request):
        # TODO: PUT ACTIONS
        return render(request,"template_put.html")

    def delete(self, request):
        # TODO: DELETE ACTIONS
        return render(request,"template_del.html")

# end views.py
# ----------------------
# urls.py

from django.conf.urls import patterns
from myapp.views import IndexView

urlpatterns = patterns('',
    (r'^$', IndexView.as_view()),
)

# end urls.py

Como vemos en el código anterior la legibilidad del código mejoraría en caso de que existiesen muchas líneas de código por cada método, además de que ya sería posible usar ciertas técnicas de programación orientada a objetos como los mixins.

Espero que les sea de utilidad.

Si te gusto el post 
compartelo... :D

miércoles, 29 de enero de 2014

Haciendo una API REST en 20 minutos con Python y Django


Hace poco vi en uno de los blogs que leo un muy interesante artículo acerca de cómo hacer una API REST en una hora, pero ¿Por qué no hacer una en 15 minutos? Para esto vamos a usar python, dajngo y dajngo-rest-framework.

Instalando los componentes
En un artículo pasado habíamos hablado de virtualenv y pip, en este caso usaremos virtualenvwrapper para crear un nuevo entorno y pip para instalar lo necesario:

mkvirtualenv entorno_rest --no-site-packages
workon entorno_rest
pip install django djangorestframework
django-admin.py startproject test_rest
cd test_rest
django-admin.py startapp apprest

Hora de codificar
Primero que todo es necesario configurar las preferencias del proyecto, es decir, editar el archivo settings dentro de la carpeta test_rest
En éste archivo es necesario incluir en las aplicaciones instaladas nuestra aplicación rest y el framework así:

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'apprest',
)
Además de esto si quieren que la aplicación solicite usuario y contraseña (mediante Basic Auth) agregamos al archivo:

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',
    ),
}

Muy bien, luego creamos los modelos de nuestra aplicación, para ello editamos el archivo models.py de la carpeta apprest y definimos lo necesario, yo solo voy a definir dos modelos, pero podrían ser cuantos quisieran:
class Autor(models.Model):
    nombre = models.TextField(max_length=100)
    apellido = models.TextField(max_length=100)
    
class Libro(models.Model):
    nombre = models.TextField(max_length=100)
    editorial = models.TextField(max_length=100)
    genero = models.TextField(max_length=100)
    autor = models.ForeignKey(Autor)

Ahora bien, es necesario crear 3 elementos auxiliares,  serializadores, que convierten los datos recuperados de la base de datos en json, viewsets, que son los elementos que de acuerdo al tipo de petición renderizan los datos y un router, el cual se encarga de indicar al proyecto django cuáles son las URLs de nuestra API. El serializer se creará en un nuevo archivo que está destinado para todos los serializers, estará dentro de apprest y se llamará serializers.py, veamos:

from rest_framework import serializers
from .models import Libro, Autor

class LibroSerializer(serializers.ModelSerializer):
    class Meta:
        model = Libro
        fields = ('id', 'nombre', 'editorial', 'genero', 'autor',)

class AutorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Autor
        fields = ('id', 'nombre', 'apellido',)

Ahora es necesario definir los viewsets, esto se hace en un archivo llamado viewsets.py, que esta ubicado en apprest. A continuación su contenido:

from .models import Libro, Autor
from .serializers import LibroSerializer, AutorSerializer
from rest_framework import viewsets

class LibroViewSet(viewsets.ModelViewSet):
 
    serializer_class = LibroSerializer
    queryset = Libro.objects.all()

class AutorViewSet(viewsets.ModelViewSet):
 
    serializer_class = AutorSerializer
    queryset = Autor.objects.all()
    
Finalmente es necesario crear el router y enlazarlo a nuestro proyecto, en esta oportunidad lo haremos directamente en el archivo urls.py del proyecto, ubicado en test_rest, en este definiremos un router, el cual tendrá referencias a los elementos creados anteriormente. Esto se hará así:

from apprest.viewsets import LibroViewSet, AutorViewSet
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register(r'libros', LibroViewSet)
router.register(r'autores', AutorViewSet)
   
y en la tupla urlpatterns agregamos:
    ...
    url(r'^', include(router.urls)),
    url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
    ...
para obtener finalmente algo así:
from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()

from apprest.viewsets import LibroViewSet, AutorViewSet
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register(r'libros', LibroViewSet)
router.register(r'autores', AutorViewSet)

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'test_rest.views.home', name='home'),
    # url(r'^blog/', include('blog.urls')),
    url(r'^', include(router.urls)),
    url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),

    url(r'^admin/', include(admin.site.urls)),
)

para obtener finalmente:
Pueden encontrar el código fuente en github, espero que les sirva de ayuda.

Si te gusto el post
compartelo... :D

domingo, 26 de enero de 2014

De Nano a Vim, cambiando la resortera por un cañón de neutrones

Hoy en día uno de los grandes problemas en el momento de utilizar un servidor es tener que usar una consola para hacer ciertas labores, éstas labores son más tediosas que complicadas y una de las mayores habilidades de un administrador de servidores es poder crear él mismo herramientas para automatizar aquellas labores que no le gusta hacer. Desafortunadamente, y por lo general un administrador debe hacer sus labores "al vuelo", es decir, directamente en el servidor. En general cuando alguien se está iniciando en el mundo de los servidores usa nano como editor de texto por su simpleza, puesto que es muy fácil de usar. Pero ésta búsqueda de comodidad causa que sean dejadas de lado herramientas como Emacs o Vim, aun cuando éstas últimas son mucho más potentes y robustas. Por eso es que en éste artículo voy a hablar de Vim, un poderoso editor de texto ideal para éstas labores.

Algo de historia
Vim (Vi Improved) es un editor de texto creado por Bram Moolenaar y cuya primera versión se presentó en 1991. Está basado en Vi (el clásico editor de Bill Joy creado en 1976), y al igual que Vi, Vim es un editor de texto orientado a modos, de esta manera separa por así decirlo en diferentes "secciones" sus funcionalidades, pero comparado con Vi es mucho más fácil de usar.

Funcionalidades
Las siguientes características están o pueden estar activadas en Vim:
  • Corrector ortográfico integrado
  • Autocompletado de texto
  • Navegación por pestañas
  • Ventanas múltiples, que dividen el área de edición horizontal o verticalmente.
  • Resaltado de sintaxis dependiente del lenguaje de programación o de etiquetas utilizado
  • Órdenes deshacer y rehacer
  • Comprensión de más de 200 sintaxis diferentes
  • Lenguaje de scripting para programar extensiones
  • Completado de órdenes, palabras y nombres de ficheros
  • Compresión y descompresión de ficheros, que posibilita editar ficheros comprimidos
  • Reconocimiento de formatos de fichero y conversión entre los mismos.
  • Historial de órdenes ejecutadas
  • Grabación y reproducción de macros
  • Guardado de la configuración entre sesiones
  • Plegado automático y manual de código
  • Interfaz gráfica opcional
  • Altamente configurable y personalizable
  • Casi 100% compatible con vi, pero sin muchos de sus defectos
Entendiendo los modos
Como mencioné anteriormente Vim esta basado en modos. Ésta precisamente es la característica que provoca que la curva de aprendizaje de Vim sea tan inclinada, Vim posee 3 modos básicos:
  • Modo Comando: Es el modo por defecto y sirve precisamente para introducir comandos (instrucciones basadas en combinaciones de teclas ). Para regresar a este modo se oprime la tecla escape (ESC) hasta que en la parte inferior izquierda de la consola solo se vea la ruta del archivo o que no se vea nada.
    Los comandos son sucesiones de teclas oprimidas, tal vez el comando más importante es el que se activa cuando se escribe el caracter (:), el cual da inicio a comandos como guardar y salir.
  • Modo Inserción: Es el modo mediante el cual podemos crear nuevo texto en un archivo. Para pasar a modo de inserción se oprime la tecla (i) mientras se está en modo de comandos, se sabe que se está en modo inserción por que en la parte inferior izquierda aparece como indicador el banner "-- INSERTAR --".

  • Modo Visual: Es el modo mediante el cual se seleccionan varios caracteres del contenido del documento para que los mismos sean copiados, movidos o modificados. Para pasar a modo visual se oprime la tecla (v) mientras se está en modo de comandos, se sabe que se está en modo visual por que en la parte inferior izquierda aparece como indicador el banner "-- VISUAL --".

¿Cómo lo uso?
para iniciar el programa basta con escribir su nombre en la línea de comandos de esta manera:
vim
y para editar un archivo (para este caso miarchivo.py) usamos:
vim miarchivo.py

El gran misterio (Cómo Salir de Vim)
la primer experiencia con Vim es traumática porque cuando alguien no es consciente de los modos no puede acceder al modo de inserción, que es el que permite modificar el contenido de un archivo, y el usuario intenta salir pero generalmente no sabe cuál es el comando para salir. Para terminar la aplicación debemos:
pasar a modo de comandos oprimiendo la tecla escape (ESC)
escribir :q
oprimir ENTER


¿Cómo Guardar modificaciones?
esta acción también se ejecuta mediante el modo de comandos, el comando (:) y w, así:
pasar a modo de comandos oprimiendo la tecla escape (ESC)
escribir :w
oprimir ENTER

Otros comandos
A continuación un breve listado de ordenes que se ejecutan en el modo de comandos y que pueden ser muy útiles:
NOTA: lo que hay antes de →es el comando, lo que hay después es la explicación.

  • yy     →  copia la línea actual y lo almacena en el buffer.
  • dd     →  corta la línea actual y lo almacena en el buffer.
  • Xyy  →  copia X cantidad de líneas y las almacena en el buffer, por ejempo:
    • 10yy  →  copia 10 líneas incluyendo la línea actual y las almacena en el buffer.
  • Xdd  →  corta X cantidad de líneas y las almacena en el buffer, por ejempo:
    • 10dd  →  corta 10 líneas incluyendo la línea actual y las almacena en el buffer.
  • p       →  pega el contenido del buffer.
  • >>    →  Tabula la línea actual.
  • <<    →  Lo contrario de la anterior.
  • X>> →  Tabula X cantidad de líneas, incluyendo la línea actual.
    • 10>>  → Tabula 10 líneas, incluyendo la actual.
  • X<< →  Lo contrario de la anterior.
  • U      → Deshace la última acción (como Ctrl+Z)
  • Ctrl+R  → Rehace la última acción
  • :split /ruta/de/archivo   →   Crea una subventana y ahí abre el archivo especificado para editarlo.
  • Ctrl+W+↓   →   Pasa a la subventana de abajo.
  • Ctrl+W+↑   →   Pasa a la subventana de arriba.

  • :tabnew /ruta/de/archivo   →  Crea una pestaña y ahí abre el archivo especificado para editarlo.
  • gt   →   Pasa a la pestaña siguiente.
  • gT   →   Pasa a la pestaña anterior.
  • Xgt   →   Pasa a la pestaña en la posición X.
  • :syntax on   →   Activa los colores (resaltado de sintaxis) de acuerdo al lenguaje de programación del archivo.
  • :syntax off   →   Desactiva los colores (resaltado de sintaxis) de acuerdo al lenguaje de programación del archivo.



Autocompletado
Vim permite usar autocompletado, por defecto el solo autocompleta con las palabras que ya existen en nuestro documento pero con plugins puede autocompletar palabras reservadas de múltiples lenguajes de programación. funciona en modo de inserción y se activa por defecto con la combinación de teclas Ctrl+N.

Espero que les sirva de ayuda.

Si te gusto el post
compartelo... :D