lunes, 15 de septiembre de 2014

De Nano a Emacs, cambiando una resortera por una piedra filosofal.




Hace un tiempo ya que publique un articulo para empezar a usar Vim, en esta entrada y gracias a Jonathan Sandoval puedo tomar un articulo de su blog y adaptarlo para así traer ante ustedes una nueva herramienta, Emacs.

¿Qué es Emacs?
La GNU define a emacs como el editor extensible y [altamente] personalizable. Esta descripción podría perfectamente aplicarse a muchos otros editores si es que no se conoce de emacs, o nunca se ha trabajado en él.
Comenzaré por mencionar que Emacs fue desarrollador por Richard Stallman, un desarrollador de C y de Lisp, que llegó a ser usuario de máquinas Lisp, y emacs, en esencia, es una máquina virtual de Lisp enfocada a la implementación de un potente editor. Emacs es, por tanto, extensible en Emacs Lisp. La naturaleza altamente dinámica de [Emacs] Lisp, le permite modificar (y por tanto, personalizar) virtualmente cualquier parte Lisp. Esto lo diferencia de otros editores que, a pesar de poderse extender a través de otros lenguajes de programación, lo permiten de una manera muy limitada a lo que puede llegar a permitir emacs.
Si en su tutorial de Vim, Oscar llama a este editor un “cañón de neutrones” (lo que sea que esto quiera decir), Emacs vendría a ser algo así como la “piedra filosofal” de los editores de texto (manteniendo la proporción de las metáforas ;)).

Funcionalidades
Veamos entonces, qué se puede realizar con GNU Emacs:


  • Corrector ortográfico (hace uso del que venga instalado en el sistema, aspell o hunspell por ejemplo).
  • Autocompletado de texto.
  • Múltiples archivos pueden ser visibles al tiempo, dividiendo el marco de trabajo.
  • Resaltado de sintaxis, dependiendo del lenguaje de programación que se utilice. 
  • Deshacer, “rehacer” (para emacs, rehacer es una forma de “deshacer”. Esto es bastante poderoso, aunque sea diferente a los demás editores).
  • Emacs soporta una cantidad impresionante de lenguajes de programación y modos de resaltado. 
  • En su administrador de paquetes (SI, emacs tiene un administrador de paquetes al más puro estilo de apt-get o yum) es posible encontrar sintaxis tan exóticas como las de los archivos de configuración de Asterisk.
  • Extensible en Emacs Lisp. (Hay proyectos como Pymacs que permiten que emacs pueda ser extensible en Python).
  • Completado de comandos, palabras y uris de archivos. (Es posible instalar complementes como Ido y Helm, los cuales pueden funcionar juntos, que a su vez expanden enormemente las capacidades de autocompletado y búsqueda de emacs).
  • Compresión y descompresión de ficheros a la hora de ser editados. Puede también trabajar con ficheros cifrados a través de gpg. Soporte para múltiples codificaciones de ficheros, y conversión entre los mismos.
  • Historial de comandos ejecutados recientemente. 
  • Igualmente, es posible instalar extensiones que facilitan que recuerdan los comandos más utilizados. Grabación y reproducción de macros. (Las ediciones de código más complejas se pueden realizar en emacs lisp). 
  • Guardado de la configuración entre sesiones. 
  • Plegado (folding) de bloques de código. 
  • Interfaz gráfica opcional (e innecesaria y poco recomendada). 
  • Probablemente es el editor más configurable y personalizable que hay (alguien me indica uno más personalizable?.
  • Es capaz de emular a Vim con Evil, pero con la potencia de seguir en Emacs :).
  • Compilación y depuración desde el mismo editor. 
En esta lista traté de listar lo mismo que en el artículo de Vim fue listado. Ahora haré un breve repaso de características de Emacs que son únicamente fáciles gracias a su diseño altamente extensible: 
  • Cliente de correo electrónico (rmail, gnus).
  • Lector de noticias. Cliente de IRC (ERC). 
  • Organizador personal (org-mode). Esta es probablemente una de las extensiones más impresionantes que tiene emacs, y por las que muchos usuarios deciden iniciar la carrera de aprendizaje de este editor. Yo lo uso como mi agenda personal, administrador de proyectos, y ofrece, por ahí derecho, la posibilidad de editar textos complejos que pueden ser exportados a formatos como HTML, LaTeX (y por tanto, a PDF), texto, plano, entre otros. Con org-mode es posible realizar programación literata e investigación reproducible. 
  • Interfaces a las aplicaciones de control de revisiones con VC (subversion, git, bazaar, mercurial, etc.). 
  • Administrador de procesos (Proced). 
  • Administrador de archivos (Dired). Este modo es especialmente interesante para realizar ciertas operaciones con archivos. 
  • Administrador de paquetes (package.el).


Utilizando emacs

Dado que esta es una [no tan] corta introducción, solo indicaré el uso básico de emacs. A diferencia de Vim, que hace uso de distintos modos para trabajar, emacs utiliza complejas combinaciones de teclas con Control, Alt, y otras (yo por ejemplo tengo configurada la tecla Win). La convención es que C-x quiere decir control junto con x, y C-x a quiere decir, primero Control-x, y posteriormente solo la tecla a. Igualmente, Alt se denota con M- por lo que M-x quiere decir, Alt junto con la tecla x (M quiere decir Meta, y se refiere a una tecla que tenían viejos teclados). Para abrir emacs basta con ejecutar lo siguiente en la linea de comandos:
emacs
Una vez en el editor, pueden presionar C-x C-f para abrir o crear un nuevo archivo. Una vez realicen cambios, pueden presionar C-x C-s para guardar los cambios. Ahora, para salirse de emacs basta con que presionen C-x C-c .

Otros comandos

  • C-SPC (Control + la barra espaciadora). Inicia la selección de texto.
  • C-w : Cortar.
  • M-w : Copiar.
  • C-y : Pegar.
  • C-a : Va al principio de la linea.
  • C-k : Corta desde la ubicación del cursor hasta el final de la linea.
  • M-7 C-k : Corta siete veces la linea.
  • C-u 5 0 C-y : Pega cincuenta veces lo recientemente copiado.
  • TAB: Tabula la linea actual.
  • C-_ : Deshacer.
  • C-x o : Cambia a la siguiente ventana.
Espero que aprendan mucho de este articulo y si quieren profundizar en Emacs pueden ir directamente a el articulo de donde se extrajo la información.


Si te gusto el post
compartelo... :D

miércoles, 13 de agosto de 2014

Tutorial de Backbone.js (III)

En las entradas anteriores hablamos sobre las Vistas en Backbone.js y la interacción con el usuario, y en el primer post de esta serie hablamos sobre la capa de datos de Backbone.js, en esta oportunidad veremos como usar los enrutadores de Backbone.js en una aplicación para hacer el proceso de navegación.

Navegando en el portal
Una de las cosas que hacen de la web de hoy en día algo tan especial es la facilidad de encontrar mucha información agolpada en un solo lugar pero organizada de una manera jerárquica y lógica, justamente este es el caso en que los enrutadores de backbone brillan, pero para entenderlo veamos primero que es un enrutador.
Un enrutador (Router) es una herramienta que permite manejar los hashtags (#) de las URLs de la aplicación como disparadores de eventos. A continuación veamos un ejemplo:
<script>
    var AppRouter = Backbone.Router.extend({
        routes: {
            "posts/:id": "getPost",
            "search/*search": "searchBook"
        }
    });
    var app_router = new AppRouter;
    app_router.on('route:getPost', function (id) {
        alert( "Obtener el número de post " + id );
    });
    app_router.on('route:searchBook', function (search) {
        alert( search );
    });
    Backbone.history.start();
</script>



Como vemos en el ejemplo se define la clase AppRouter, que hereda de la clase Router de Backbone y luego ésta se instancia, despues se utiliza el método on de la variable creada para definir que acciones ejecuta en que momento. El proceso de ruteo dinamico que realiza Backbone.js inicia cuando se invoca la accion start del objeto history de backbone en la linea 15.

Otra de las cosas que hacen interesantes los procesos de ruteo en Backbone.js es que cuando se definen las rutas se pueden extraer datos de las mismas que son pasados al callback como parametros, un ejemplo de esto es la ruta "posts/:id", la cual llama la funcion getPost con un parametro que sera extraido de la URL.

Otra de las herramientas es el uso de splats, que son expresiones que permiten tomar de un segmento de la URL y enviarlo como parametro al callback, un ejemplo de esto es la ruta "search/*search", que puede ser aplicado a la ruta "http://www.miserver.co/search/el-nombre-de-la-rosa", el cual invocara la función searchBook y enviara el parametro "el-nombre-de-la-rosa".

Teniendo en cuenta lo anterior podemos concluir que con la herramienta Router de Backbone.js es posible traer mucha información del servidor y mostrarla solo cuando sea necesario sintener que realizar más peticiones al servidor o haciendolas unicamente cuando se ejecuta un evento especifico, además de poder interactuar con datos extraidos de la URL.

Espero que les haya gustado el post.

Por favor
Comparte este post. 
:D

lunes, 4 de agosto de 2014

Tutorial de NodeJS I, llevando la potencia de V8 al servidor


Es verdad que hace algún tiempo Brendan Eich tuvo como labor crear un lenguaje que enriqueciera los navegadores y éste uso una poca de sus poderes magicos y entrego al mundo Javascript, tiempo después Google entrego al mundo de la mano de Lars Bak V8, una de las mejores maquinas virtuales que interpretan Javascript, y luego Ryan Dahl , un muchacho inquieto decidió portar V8 para que funcionara independientemente, y esto fue llamado Node.js.


Node.js es un entorno de programación para servidor basado en el lenguaje de programación Javascript, con I/O de datos en una arquitectura orientada a eventos y basado en el motor Javascript V8. Fue creado con el enfoque de ser útil en la creación de programas de red altamente escalables, como por ejemplo, servidores web.

Instalando NodeJS

El la pagina oficial del proyecto pueden descargar el instalador, para Windows y Mac es muy sencillo, solo basta bajar el instalador y ejecutarlo como se hace comúnmente en cada plataforma, para sistemas linux por otro lado es necesario descargar el código fuente, para instalarlo en distribuciones debian o basadas en debian debemos:

1. Descargar los fuentes
wget -c http://nodejs.org/dist/v0.10.30/node-v0.10.30.tar.gz
2. Instalar dependencias
apt-get install GCC make libssl-dev
3. descomprimir el paquete
tar -zxf node-v0.10.30.tar.gz
4. Entrar a la carpeta
cd node-v0.10.30
5. configurar
./configure
6. compilar (y tomar una buena tasa de café por que se toma su tiempo)
make
7. Instalar
sudo make install
Muy bien, esto deberia instalar nodejs y otra herramienta fabulosa llamada npm, la cual permite gestionar paquetes de nodejs y manejar dependencias, entonces para probar que se instalo correctamente ejecutamos:
node --version
npm --version
de esta manera tendremos las versiones de nodejs y npm respectiva mente.
Espero que esta primera parte sea util para ustedes.


Por favor
Comparte este post. 
:D

jueves, 3 de abril de 2014

SQLiteDbManager, una herramienta para SQLite3 en IOS


Desde hace un tiempo he estado trabajando en una librería para manejo de SQLite3 en IOS, ésta herramienta permite hacer operaciones con bases de datos de manera secuencial y no bloqueante para poder hacer consultas de la manera más simple, esta se llama SQLiteDBManager, pueden encontrarla en Github y esta disponible para la comunidad, está abierta a sugerencias y cambios pueden hacer un fork y mejorarla.

Espero que les sea de utilidad.

Por favor
Comparte este post.
:D

viernes, 21 de marzo de 2014

Tutorial de Backbone.js (II)


Backbone.js es una herramienta que permite separar el trabajo con datos, el trabajo de la capa visual y las acciones de navegación, lo cual hace de ésta una herramienta muy versátil a la hora de trabajar proyectos muy grandes. En la entrada anterior escribí acerca de la potencia de esta herramienta con respecto al manejo que le da a la capa de datos, en esta oportunidad veremos la manera en que se gestiona la interacción con el usuario mediante sus vistas.

Interacción con el usuario
Cuando hablamos de interacción con el usuario hacemos referencia explícita a a las vistas (Views) y a los Enrutadores (routers), en esta ocasión sólo hablaremos de las vistas. Las vistas en Backbone.js son elementos muy importantes puesto que son los encargados de presentar la información que llega del backend del servidor y permitir que los usuarios interactúen con ésta. Para esta labor se extiende la clase Backbone.View, veamos un ejemplo.

var ViewLibro = Backbone.View.extend({
    events:{
        "click a#delete" : "eliminar",
    },
    initialize : function () {
        this.template = _.template(
                 $('#templatelibro').html()
                 );
    },
    render : function() {
        var data = this.model.toJSON();
        var html = this.template(data);
        this.$el.append( html );
    },
    eliminar: function(e) {
        this.model.url = this.model.url+this.model.id;
        this.model.destroy();
        var libro = $(e.currentTarget).parent().parent();
        libro.remove();
        e.stopPropagation();
    }
});

Además hacemos unos pequeños cambios a la función listarLibros
function listarLibros () {
    $(".datos").html("")
    var coleccion_libros = new Libros();
    coleccion_libros.on("add", function(model){
        console.log("Agregado", model.toJSON());
        var vl = new ViewLibro({el:$("ul.datos"),model:model});
        vl.render();
    });
    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();
            libroNuevo.attributes.id = 1;
            coleccion_libros.add(libroNuevo);
        }
        console.log("0k");
    });

}

Y finalmente agregamos el template respectivo
<script type="text/template" id="templatelibro">
    <div id="libro-<%= id %>" class="libro">
        <strong>Nombre:</strong> <%= nombre %> <br/>
        <strong>Editorial:</strong> <%= editorial %><br/>
        <strong>Genero:</strong> <%= genero %><br/><br/>
        <div class="actions">
            <a href="#" id="delete">Eliminar Libro</a>
        </div>
    </div>
</script>
Muy bien, pero ¿Qué hace todo esto? Primero construimos la vista, para esto hacemos una clase que hereda de Backbone.View, esta tiene una serie de elementos que hacen posible toda la "magia" que hace internamente, el primero es el objeto events, el cual almacena el tipo de evento (por ejemplo click) y sobre que elemento del DOM se aplica, para esto usamos "." (punto) para especificar clases y y "#" para especificar los identificadores. Asociado a esto se encuentra el nombre del método que se ejecutará cuando el evento sea llevado a cabo.
Luego encontramos el método initialize, que inicializa la vista, adentro de este creamos el template de la vista, debemos tener en cuenta que el carácter "_" hace referencia a la librería Underscore.js, también creada por Jeremy Ashkenas, creador de Backbone.js, la cual tiene una serie de herramientas muy útiles y una de estas es un sistema de templates. Cabe aclarar que no es obligatorio usar el sistema de templates de underscore, su puede usar el que se desee (swig, mustache, etc).
Después encontramos el método render, que toma los datos del modelo y los renderiza con el template creado en el método initialize para finalmente mostrarlo al usuario en el lugar de destino, referido por la variable de clase $el.
Como último elemento de la vista encontramos el método eliminar, que actualiza la url del modelo, llama el método eliminar y retira el HTML asociado al modelo del DOM.

Dentro de la función listar libros encontramos que ya no creamos el código HTML necesario para incrustar en el DOM, en cambio creamos una instancia de la vista y la renderizamos y al crear en nuevo libro especificamos como atributo el id de ese nuevo objeto.

Finalmente esta el código del template asociado a la vista, notese que éste se guarda en un tag script de tipo text/template y tiene un identificador para poder recuperarlo con Javascript.

jueves, 20 de marzo de 2014

Tutorial de QtCreator


Hace algunos años hice un tutorial de QtCreator, espero que les guste.


Por favor comparte este articulo. 
:D

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


jueves, 12 de diciembre de 2013

Ponte la Armadura, Java y las Clases Abstractas

Como mencionaba en un artículo anterior Una de las cosas más complejas de entender en el mundo de Java son las clases abstractas, en ésta entrada vamos a hablar de ellas.
¿Una armadura?, es extraño mencionar una armadura cuando de código se trata, pero veamos esto:
  • Una armadura es un conjunto de piezas  que vienen listas para permitir que hagamos algo.
  • Para poder portar la armadura es necesario tener (o implementar) ciertas aptitudes físicas para poder usarla.
Así mismo es una clase abstracta, en ésta existen un conjunto de elementos que ya están listos para ser usados y que fueron implementados como se implementan comúnmente métodos en Java, sin embargo hay otros que debemos hacer nosotros mismos antes de poder usar la clase y los hacemos declarando el método abstracto y removiendo el cuerpo del método.

Veamos un ejemplo:

public abstract class Ficha{
    private String nombre = "Ficha";
    public abstract void mover(String destino);
    public abstract void atacar(String destino);
    public String getNombre(){
        return nombre
    }
    public void setNombre(String nombre){
        this.nombre = nombre
    }
}

En el ejemplo anterior vemos la clase abstracta Ficha, que tiene dos métodos comunes (getNombre, SetNombre) y dos métodos abstractos (mover, atacar). Ahora bien, esta clase existe y tiene ciertas cosas que podemos usar (ya está la armadura), pero hay otras que debemos hacer nosotros (Trabajo físico para usar la armadura), para esto podríamos:
  • Crear una nueva clase que implemente la clase abstracta
  • Crear una instancia de la clase abstracta y definir los métodos ahí mismo (Se ve muy feo pero funciona)
Veamos un ejemplo de cada una:

Primera Forma
public class Peon implements Ficha {
    public Peon() {
        setNombre("Peon");
    }
    @Override
    public void mover(String destino){
        System.out.println(String.format("Me estoy moviendo a %s", destino));
    }
    @Override
    public void atacar(String destino){
        System.out.println(String.format("Estoy atacando %s", destino));
    }
}

Como vemos en el ejemplo anterior se ha creado una nueva clase, la cuál implementa la clase abstracta Ficha, es posible observar que podemos usar el método setNombre que había sido definido en la clase Ficha y que se han reescrito los métodos abstractos agregando lógica a  éstos. Es muy importante tener en cuenta que a los métodos reescritos se les ha puesto la anotación @Override, la cual especifica que lo que queremos hacer es reescribir el método.

Segunda Forma
public class Main {
    public static void main(String []argv) {
        Ficha f = new Ficha(){
            @Override
            public void mover(String destino){
                System.out.println(
                    String.format("Me estoy moviendo a %s", destino)
                );
            }
            @Override
            public void atacar(String destino){
                System.out.println(String.format("Estoy atacando %s", destino));
            }
        };
        f.setNombre("Peon");
    }
}

Como vemos en el ejemplo instanciamos la clase Ficha, pero debemos llenar de alguna manera los lugares faltantes.

¿Y para qué usar armadura?
Las clases abstractas son elementos que permitirían hacer código que luego sea extendido en situaciones específicas, por ejemplo, si se tiene un tablero de ajedrez y hay que implementar el movimiento de las fichas seria bueno usar clases abstractas, puesto que a pesar de que todas las fichas son iguales no se mueven igual, por lo tanto hay que reescribir el método de movimiento en cada clase.

Espero que sea útil.
Si te gusto el post
compartelo... :D


lunes, 25 de noviembre de 2013

Puesta en producción de una aplicación web con Django y Nginx


Cuando se usan frameworks para desarrollo web todo se hace más fácil, excepto la puesta en producción, una muestra clara de esto es django, un framework que permite que cosas como hacer un entorno de administración parezca juego de niños y que realizar consultas que parecen concebidas en la maligna mente del mismo Satanás sea una tarde de picnic. Desafortunadamente a la hora de poner en producción un proyecto empezamos a ver dificultades. Este post tiene como objetivo mostrar una sencilla manera de poner en producción nuestros proyectos con Django mediante el servidor Nginx.

Nota: Todo el proceso de configuración esta preparado para Linux Debian y derivados, si usas una distribución diferente es probable que cambien las rutas de los archivos de configuración.

Primero que todo, ¿Qué es Nginx?

Nginx es un servidor web y proxy inverso ligero de muy alto rendimiento, es software libre de código abierto y multiplataforma, tiene las siguientes características:
  • Servidor de archivos estáticos, índices y autoindexado.
  • Proxy inverso con opciones de caché.
  • Permite realizar balanceo de carga.
  • Tolerancia a fallos.
  • Soporte de HTTP sobre SSL.
  • Soporte para FastCGI con opciones de caché.
  • Servidores virtuales basados en nombre y/o en dirección IP.
  • Streaming de archivos FLV y MP4.
  • Soporte para autenticación.
  • Compatible con IPv6.
  • Soporte para protocolo SPDY.
  • Soporte para compresión gzip de paquetes.
  • Habilitado para soportar más de 10.000 conexiones simultáneas.
Muy bien, pero ¿Qué pasa con lo clásico?
Muchos se preguntaran ¿Por qué Nginx y no Apache2?, pienso que hay varias cosas al respecto:
  • La cantidad de recursos que demanda Apache2 son mucho mayores que los demandados por Nginx.
  • La velocidad alcanzada por Nginx es mucho mayor que la de Apache2 a la hora de responder peticiones.
  • Nginx es muchisimo más fácil de configurar que Apache2 puesto que Apache2 usa engorrosos XMLs, Nginx no.
La información mencionada la obtuve de aquí, aquí y aquí.

Muy bien, entonces, manos a la obra
En este momento me parece adecuado explicar cómo funciona la conexión entre django y Nginx:

Nginx es el encargado de atender las peticiones externas por el puerto 80 (protocolo HTTP), éste a su vez envía los datos de la petición a uWSGI mediante un puerto auxiliar, quien hace de intermediario en el proceso de comunicación y finalmente uWSGI entrega los datos de petición a nuestro proyecto django para que éste ejecute la acción correspondiente e inicie el proceso inverso para responder a la petición. Escogí uWSGI porque me pareció muy fácil de usar y en éste enlace hay una comparativa de rendimiento en la cual el tiempo de respuesta es mejor que el de Gunicorn.

Configuremos Nginx
Debemos crear el archivo de configuración para nuestro proyecto, recuerda que si el puerto 80 está siendo usado por Apache2, por alguna otra aplicación o por el mismo Nginx por otra configuración debes liberar primero el puerto, en caso de ser Apache2 debes editar el archivo /etc/apache2/ports.conf y cambiar el puerto 80 por uno diferente, luego reiniciar el servicio Apache2 así:
$ service apache2 restart
Después de esto debes crear el archivo de configuración en la carpeta /etc/nginx/sites-avaliable, el nombre del archivo lo eliges tú, yo elegí como nombre archivo.conf. El contenido del archivo debe ser el siguiente:
# archivo.conf
server {
    listen      80; # puerto por el que escucha la aplicación
    server_name midominio.co; # nombre o ip del servidor
    charset     utf-8;

    # tamaño maximo de subida
    client_max_body_size 75M;

    # Ruta de la carpeta media
    location /media  {
        alias /var/www/proyecto/media; # reemplace por su ruta a media
    }

    # Ruta de la carpeta static
    location /static {
        alias /var/www/proyecto/static; # reemplace por su ruta a media
    }

    # Configuración de las peticiones que no son resueltas con las
    # reglas anteriores. Estas son reenviadas al servidor django
    location / {
        uwsgi_pass 127.0.0.1:8001; # 127.0.0.1:PUERTO_AUXILIAR
        include     uwsgi_params;
    }
}
Cabe resaltar que el puerto auxiliar seleccionado es el 8001, este dato es importante puesto que debemos tenerlo en cuenta para iniciar la labor de uWSGI.
Después de esto es necesario habilitar la nueva configuración creando un enlace simbólico del archivo en la carpeta sites-avaliable de Nginx así:
$ cd /etc/nginx/sites-enabled
$ ln -s ../sites-avaliable/archivo.conf .
Finalmente reiniciamos el servidor Nginx
$ service nginx restart

Configuremos nuestro entorno
Primero es necesario crear un entorno para el proyecto con la orden mkvirtualenv vista en el post anterior y luego activamos el entorno creado con la orden workon:
$ mkvirtualenv entorno
$ workon entorno
después de ésto es necesario instalar las dependencias de nuestro proyecto django, personalmente pienso que es bueno trabajar con django 1.5 o superior, puesto que aasi tendremos muchas de las nuevas características, además django 1.6 fue liberado hace un par de semanas.
$ pip install django
$ pip install ....
$ pip install ....
Ahora necesitamos instalar uWSGI:
$ pip install uwsgi
Nota: Para instalar uWSGI es necesario tener instalados en el sistema el compilador gcc y los paquetes de desarrollo de python, para el caso de linux debian y derivados con python2.7 deben instalarse como superusuario así:
$ apt-get install gcc-4.5 python2.7-dev
Finalmente creamos el archivo para iniciar el proceso de conexión entre Nginx y django, este archivo es un script bash al que yo llame start.sh, este debe tener el siguiente contenido:
#!/bin/bash
uwsgi --socket :8001 --wsgi-file wsgi.py -d mensajes.log

Aquí viene la parte importante, cuando django genera un proyecto él crea una carpeta de proyecto, dentro de ésta hay una carpeta con los archivos de configuración, éstos son settings.py, urls.py, __init__.py y wsgi.py


debe hacer una copia del archivo wsgi.py a la raíz del proyecto y en éste mismo lugar poner el archivo start.sh así:

Después es necesario permitir la ejecución de este archivo mediante la orden:
$ chmod +x start.sh
Luego podemos iniciar el proceso así:
$ ./start.sh
Si tienes alguna duda o comentario puedes hacerla en la sección de comentarios, espero que sea útil.

Si te gusto el post
compartelo... :D

sábado, 23 de noviembre de 2013

Virtualenv II, yendo más allá con virtualenvwrapper


En una entrada anterior vimos algo de Virtualenv, ahora vamos a ver cómo usar una herramienta que facilita un tanto su uso, Virtualenvwraper.

¿Qué es Virtualenvwrapper?
Virtualenvwrapper es un conjunto de herramientas para extender Virtualenv. Éstas herramientas incluyen wrappers o contenedores para la creación y eliminación de entornos virtuales y la gestión del flujo de trabajo para desarrollo, facilitando trabajar en más de un proyecto a la vez sin generar conflictos entre dependencias.

Características de Virtualenvwrapper
  • Organiza todos sus entornos virtuales en un solo lugar.
  • Wrappers para la gestión de sus entornos virtuales (crear, borrar, copiar).
  • Facilita cambiar entre entornos con un solo comando.
  • Implementa el uso de la tecla de tabulación (tab) para los argumentos de las ordenes de los entornos virtuales (no válido para el CMD de Windows, para esto es necesario tener una shell Cygwin).
  • Posibilidad para que el usuario cree hooks (ganchos) en todas las operaciones para ejecutar acciones propias. 
  • Sistema de plug-ins para la creación de extensiones.
Instalación
Luego de tener instalado Virtualenv instalamos Virtualenvwrapper mediante la orden
easy_install virtualenvwrapper
o
pip install virtualenvwrapper
Luego de esto es necesario configurarlo, para esto debemos seleccionar la carpeta en la cual quedarán almacenados los entornos, para este caso la carpeta de entornos quedará en el directorio del usuaio y se llamará .entornos (Para los sistemas *nix el punto al principio oculta los entornos) .  Entonces debemos establecer una variable al sistema (para Windows también es necesario agregar una ruta al path del sistema), esto se hace así:

Para sistemas *nix (Linux, MacOSX)
Buscar un archivo en la carpeta de usuario llamado .bashrc o .bash_profile, ábrelo con tu editor preferido y pones las siguientes líneas:
export WORKON_HOME=$HOME/.entornos
source /usr/local/bin/virtualenvwrapper.sh
En estas dos líneas lo que hacemos es definir cuál es el directorio donde vamos a guardar los entornos y en la que sigue estamos ejecutando el script de inicialización de virtualenvwrapper. Recuerda que podrías poner cualquier ruta del sistema por ejemplo:
export WORKON_HOME=/tmp/entornos
o
export WORKON_HOME=/home/andres/proyectos/entornos
Después de esto es necesario recargar las variables de entorno, si editamos el archivo .bashrc lo hacemos así:
source ~/.bashrc
si editamos el archivo .bash_history lo hacemos así:
source ~/.bash_history
Nota: También podrías simplemente cerrar y reabrir la consola, así se recargaría automáticamente.

Para Sistemas Windows:
Después de tener instalado Virtualenv en Windows (recuerda el post anterior) debes instalar desde la linea de comandos (CMD) virtualenvwrapper mediante la orden:
pip install virtualenvwrapper-win
después debes crear la carpeta para los entornos así:
mkdir %USERPROFILE%\entornos
y luego debes establecer las variables en el entorno así:
  • Entra al menú de propiedades:
    • Accede al menú de Inicio, click derecho al botón Equipo, y click al botón de propiedades.
    • Click al botón de configuración avanzada del sistema.
    • Click a el botón variables de entorno.
    • En la sección de Variables de entorno agregamos una variable llamada WORKON_HOME con el valor %USERPROFILE%\entornos.
La próxima vez que abramos una consola ya podremos usar virtualenvwrapper.

Nota: Si estás en Windows debes instalar virtualenvwrapper-win y si quieres y tienes Powershell virtualenvwrapper-powershell porque el paquete virtualenvwrapper es exclusivo de sistemas *nix.

Nota: El paquete virtualenvwrapper-win tiene como ruta por defecto de los entornos la carpeta %USERPROFILE%\Envs, por tanto si quieres obviar la configuración de la variable de entorno podrías hacerlo.

Nota: En ocasiones la instalación de virtualenvwrapper-win mediante pip no establece los ejecutables necesarios en la carpeta de scripts de python, por lo cual deberá instalarse descargando el código fuente mediante Git así:
git clone git://github.com/davidmarble/virtualenvwrapper-win.git
cd virtualenvwrapper-win
python setup.py install

Nota: es probable que al usar la orden mkvirtualenv salga el mensaje:
"El sistema no puede encontrar la ruta especificada."
no te preocupes por eso, el entorno se crea de todas maneras.


Modo de empleo:
Para crear entornos nuevos usamos:
mkvirtualenv <entorno> # entorno estandar
mkvirtualenv <entorno1> --no-site-packages # entorno totalmente aislado
Para activar el entorno:
workon <entorno>
Para desactivarlo:
deactivate
Para listar los entornos existentes:
lsvirtualenv
Para eliminar un entorno (recuerde que no puede estar usándolo en el momento de eliminarlo)
rmvirtualenv <entorno>
Para copiar un entorno:
cpvirtualenv <entorno> <nombre-copia>
Para ejecutar un comando en todos los entornos:
allvirtualenv <comando>
# un ejemplo sería:
allvirtualenv pip install django
Este es un listado de comandos básicos para la gestión de entornos y en este enlace queda la documentación de los comando de virtualenvwrapper.

Espero que les sirva de ayuda.
Si te gusto el post
compartelo... :D

jueves, 21 de noviembre de 2013

Git, qué, por qué y cómo


Carpetas, carpetas y más carpetas, eso es lo que uno encuentra en su disco duro cuando aún se es joven en el mundo de la informática ( todos lo hemos sido y en lo personal yo aún me siento así), pero es algo que todos empezamos a mejorar, clasificando la información de mejor manera y usando herramientas para esto. Los desarrolladores de software no son la excepción a esta regla, pero los problemas son un tanto más complejos ahora, puesto que no es solo guardar las carpetas con cientos o miles de líneas, además deben poder usarse comentarios específicos de cada carpeta o archivo, sin contar el hecho de que en cualquier momento podría fallar el disco duro y todo el trabajo se iría al mismísimo infierno (y muchos desarrolladores también pues sus jefes los deportarían). Para solucionar esto se crearon sistemas de control de versiones, en esta ocasión vamos a hablar de uno algo reciente pero muy potente, Git.

¿Qué es Git?
Git es un sistema de control de versiones distribuido, creado por Linus Torvalds con el fin de obtener la mayor eficiencia y la mejor confiabilidad posible. Se dice que es distribuido porque a diferencia de otros como SVN no hay un repositorio central contra el cual otros cargan y descargan actualizaciones,  por el contrario hay múltiples repositorios, unos se configuran como maestros y otros como esclavos y existe la posibilidad de cambiar la configuración en cualquier momento.

svn
Sistema de versiones Centralizado


git
Sistema de versiones distribuido
Como vemos en el gráfico 1 en sistemas centralizados de control de versiones como SVN todas las máquinas se sincronizan con una única máquina servidor, por el contrario en sistemas distribuidos como GIT cada una de las máquinas se pueden sincronizar con otras, y a su vez cada una de estas puede ser el repositorio maestro de otras.

Cuando existe un repositorio Git este tiene un repositorio local, el cual puede tener varias versiones de nuestro proyecto, a esto se le conocen como ramas (branches), de esta manera en un proyecto puede haber una rama estable, una de pruebas, una de desarrollo y demás.

¿Por qué?
Si quieres motivos para usar Git aquí los tienes:
  • Es distribuido. Gracias a esto obtienes:
    • Independencia. Tú eres un repositorio, no necesitas ninguna información de ningún otro lugar para ninguna operación. Es decir, no necesitas para nada red.
    • Mejor integración y comunicación en grupos de desarrollo grandes, de esta manera cada desarrollador puede compartir cambios con el resto sin depender de un servidor central.
  • Rapidez: Una de las principales características de Git es la velocidad que tiene para hacer todo lo que hace.
    • Manejo simple e intuitivo de las ramas de desarrollo:
    • Git permite mezclar varias ramas a la vez en una tercera (merge octopus).
    • Git permite mezclar eficientemente ramas que tenían como punto en común es un antiguo padre.
  • Git guarda contenido, más no ficheros, esto permite mayor eficiencia la hora de almacenar cambios pero obliga a que en el repositorio no hayan carpetas vacías (no tiene contenido alguno).
  • Permite trabajar en un punto intermedio entre nuestros ficheros reales y el repositorio, lo cual permite hacer modificaciones y más antes de que los cambios sean replicados.
  • Soporta múltiples protocolos de conexión a la hora de hacer publicación (HTTP, FTP, SSH, rsync).
  • Es compatible con otros sistemas de versiones como CVS y SVN.
  • Podrías pagar  por un servidor exclusivo para un proyecto y este te daría información relevante acerca del ritmo de trabajo, Github
¿Cómo?
A continuación pondré una lista de comando que pueden ser muy útiles.

Inicializar Repositorio
$ git init .
Agregar archivos
$ git add <file>
$ git add .
Actualizar archivos modificados
$ git add -u
Crear revisión inicial | Crear nueva revisión
$ git commit -m "mensaje de revisión"
Listar cambios realizados
$ git status
Listar los cambios del formato de parche
$ git diff
Ver historial de cambios
$ git log
$ git log -nX   #=> muestra las ultimas X revisiones
$ git log --stat --summary
Descartar todos los cambios hechos desde la última revisión
$ git reset --hard
Cargar archivo desde la última revisión
$ git checkout 
Corregir descripcion del último commit
$ git commit --amend
Incluir algo que faltó en la última revisión
$ git reset --soft HEAD^
$ git add arch1 arch2 ...
$ git commit
Crear un clon de un repositorio remoto
$ git clone <url del repositorio>
# por ejemplo
git clone ssh://usuario@mi.servidor.algo/ruta/interna/del/repositorio
Agregar origen remoto
$ git remote add origin <url del repositorio>
Sincronizar cambios con el repositorio remoto
$ git push origin master
Configurar usuario y correo para tener información de los commits
$ git config --global user.email "you@example.com"
$ git config --global user.name "Your Name"
Actualizar repositorio local
$ git pull origin master

Mostrar mensajes a color
$ git config --global color.ui auto
Evitar que nuestro servidor rachase commits externos
! [remote rejected] master -> master (branch is currently checked out)
$ git config receive.denyCurrentBranch ignore


Espero que les sirva de ayuda.

Si te gusto el post
compartelo... :D