http://sergiohinojosa.wordpress.com/2008/12/23/el-tour-de-corey-tour-de-pro

Realmente fantastico, Corey Haines lleva adelante su tour denominado “Pair-Programming Tour 2008″, lleno de nuevas experiencias y donde hace prevalecer que la experiencia de trabajar en parejas te lleva a aprender y compartir mucho mas que del modo simple y solitario. Quien es Core Haynes? Corney Haines, paso el ultimo año casi exclusivamente desarrallonado con Ruby [...]

http://sergiohinojosa.wordpress.com/2008/12/15/hoy-es-el-ultimo-dia-de-pown

Goodbye Pownce, Hello Six Apart, es asi como titula el post que nos recuerda que hoy es el ultimo dia de esta gran aplicacion echa en django, y tal cual lo refleja su creadora leah, ahora junto a mike, seran parte del equipo de ingenieros de Six Apart. Esperemos que pronto tengan nuevas noticias [...]

Django viene con muchas aplicaciones reutilizables directamente añadidas al core o a la version de distribucion, entre una de ellas, de echo la mas utilizada, es la de administracion "django.contrib.admin".

El admin de django te permite tener una interfaz administrativa para tus modelos, el unico requisito es que las registres,a continuacion recrearemos una pequeña aplicacion un todo manager.

Para habilitar el admin, debemos añadirlo a nuestro settings.py

 INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.admin',
    'todomanager', # nuestra aplicacion que vamos a crear mas adelante
)

Sobre el proyecto hola mundo ahora crearemos una nueva aplicacion que se llame todomanager:

#./admin.py start-app todomanager

Django nos crea el models.py y views.py por defecto en el nuevo directorio de nuestra aplicacion que lleva el mismo nombre.

Abrimos el models.py y editamos creando nuestros modelos, nuestro models.py deberia quedar algo asi:

from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import User  #django nos provee otra aplicacion que maneja la autenticacion, de el usaremos el modelo User

from datetime import datetime

class Todo(models.Model):
    HIGH = 3
    MEDIUM = 2
    LOW = 1
    CHOICES_PRIORITY =(
        (HIGH, _('High')),
        (MEDIUM, _('Medium')),
        (LOW, _('Low'))
    )
    COMPLETED = 1
    TBD =2
    CHOICES_STATUS=(
        (COMPLETED, _('Completed')),
        (TBD, _('To be Done'))
    )
    owner = models.ForeignKey(User, related_name='owner_group', verbose_name=_('owner'))
    name = models.CharField(_('name'), max_length=32)
    created_date=models.DateTimeField(default=datetime.now)
    priority = models.IntegerField(_('priority'), choices=CHOICES_PRIORITY)
    status = models.IntegerField(_('status'), choices=CHOICES_STATUS)
    description = models.TextField(_('description'))
    due_date = models.DateField(_('due_date'),blank=True,null=True,)
    completed_date = models.DateField(_('completed_date'),blank=True,null=True)
    
    class Meta:
        ordering = ('created_date','priority')
        verbose_name = _('Todo')
        verbose_name_plural = _('Todo List')
        unique_together = ("owner", "name")
        get_latest_by = 'created_date'

    def __unicode__(self):
        return self.name

Para que nuestro modelo pueda ser tomado en cuenta por el admin de django debemos registrarlo, dentro de nuestra aplicacion creamos el archivo admin.py y lo minimo requerido para registrarlo seria tener lo siguiente en nuestro archivo:

from django.contrib import admin

from models import Todo

admin.site.register(Todo)  # aca registramosnuestro modelo

 Ahora nos toca generar la base de datos:

./admin.py syncdb

Como es la primera vez nos pedira registremos las credenciales de nuestro usuario administrador (dile yes :P).

Para habilitar completamente las interfaz administrativa debemos editar el urls.py de nuestro proyecto y tener algo como sigue:

from django.conf.urls.defaults import *
from django.contrib import admin

admin.autodiscover()

urlpatterns = patterns('',
    (r'^admin/(.*)', admin.site.root),
)

Ahora podemos hacer correr nuestro proyecto con:

#./manage.py runserver 0.0.0.0:8000

Ahora nos vamos al browser y colocamos:

http://127.0.0.1:8000/admin

Usando las credenciales que registramos al realizar el sync de bd ingresamos al sitio de administracion de djano.

En un siguiente post veremos como poder hacer mas rica y como tambien veremos como se puede sobreescribir y darle mas funcionalidad a esta interfaz que nos provee django.

Sin duda esta caracteristica de django es la que atrae a muchos, ya que en la mayoria de las aplicaciones que realizamos siempr necesitamos tener esta interfaz administrativa, aunque existen muchas cosas que se estan mejorando aun, no cabe duda que el admin de django nos ahorrara mucho trabajo.

Heroku, es una increible plataforma echa para Ruby on Rails que te permite poder desarrollar y desplegar tus aplicaciones webs online, viene integrado con git y ademas tienes acceso al API, utiliza tecnologias como EC2, tienes todo el ambiente listo para correr tus aplicaciones y ademas tambien puedes editar en tu browser o trabajar con un cliente de git.

Porfavor solo dejen su mail para que les mande invitaciones.

 

Scaffolding en Grails

Que es?
Se llama al proceso de auto generar toda la aplicacion para una clase de nuestro dominio, el scaffold nos:

• Crea las vistas necesarias
• Crea las acciones del controlador para realizar operaciones de Crear/leer/actualizar/eliminar “CRUD” en ingles
• Y tambien puede crear el esquema de base de datos y las relaciones para nuestras clases de dominio

Empezemos con un ejemplo basico:

Creamos nuestra clase de dominio:

grails create-domain-class

Y le damos el nombre de Client

Bajo el directorio de domain clases encontraremos nuestro Client.groovy lo editamos como sigue:

class Client {
String first_name
String last_name
String email
}

En Grails para habilitar el scaffolding de una clase de dominio, editamos la clase controlador de la clase del dominio:

#grails create-controller –le damos el nombre de client

class ClientController{
def scaffold = Client
}

Ahora solo necesitaremos hacer correr nuestra aplicacion, grails run-app
y todo lo necesario sera auto generado en tiempo de ejecucion

Para verlo debemos ir a nuestro browser http://localhost:8080/miproyecto/ y tendremos el CRUD listo para usarlo.

"The Spring Framework really pioneered simplified development on the Java platform. A philosophy that is the very essence of Grails. Both frameworks aggressively try to makes the lives of developers easier. The Spring Framework provides an abstraction layer of common Java enterprise APIs, whilst Grails uses the Groovy dynamic language to further simplify Spring and Java. In this sense Grails fits perfectly into SpringSource’s philosophy." read more

Es bueno conocer la historia y el por que se tomaron algunas desiciones en cierta tecnologia, framework. En este relato se ven diferentes aspectos como: - Por que se opto por que Django sea un Open Source - Por que tiene licencia BSD - Por que no usa TDD :( como definieron su Arquitectura - Pythp, BDFL y mucho mas cosas muy interesantes. Articulo: http://toys.jacobian.org/presentations/2008/softwaresummit/desig

http://softwarelibre.org.bo/sha/weblog/3446.html

Jacob Kaplan Mos uno de los pricnipales Devs de Django nos dice por que ellos decidieron que Django fuera open source:

"My name is Jacob Kaplan-Moss; I’m one of the lead developers of Django and the former lead developer at the Lawrence Journal-World, where Django originated. This is a bit of a new topic for me: instead of talking about how Django works, I’ll be looking at why Django’s built the way it is. I'll look at the history of Django, the philosophies guiding its development, and dissect the choices we made as we developed Django."

 "The first big decision was simply the choice to release Django as Open Source, instead of trying to sell it as commercial software."

"First, Open Source code is higher quality. This is mostly because you’ve got all these people looking at your code and using it in ways you couldn’t anticipate; they find lots and lots of bugs."

"Gievn enough eyeballs, all bugs are shallow" That’s Linus Torvalds, creator of Linux, as formulated by Eric S. Raymond in The Cathedral and the Bazaar.

Peer Pressure

"There’s also a related effect of Open Source: it’s major impetus to get your code right, because you don’t want to be shamed in front of your peers."

Hiring

 Hiring

"Hiring has also been made much, much easier. This is a shot of some of the folks working over at the J-W these days; the awesome thing is that each of them came to the J-W already knowing Django, which means the “start up cost” (training, etc.) of new employees is dramatically lower."

"Django is an examplary  example of a good open source project, run by people who really understand community involvement" by Guido van Rossum

Lamentablemente creo que para poder llegar a  entender como se desarrolla una comunidad tenemos que dejar de lado muchos tabues que por lo general en nuestro pais los tenemos muy arraigados.

Fuente del articulo: http://toys.jacobian.org/presentations/2008/softwaresummit/desig donde tambien nos explica la desicion tomada en el tipo de licencia, arquitectura y mucho mas.

Escrito por Linus Torvalds (usado para el dev de linux) y actualmente mantenido por Junio C Hamano. Primos, hermanos de git: Mercurial o Bazaar. Producto open source con licencia GNU, mas detalles en su web: http://git.or.cz/

Instalacion: #sudo apt-get install git-core

Para este primer post solo mostraremos su uso localmente:

Primero nos identificamos:

$ git config --global user.name "ajayu espiritu de la red"
$ git config --global user.email admin@ajayu.memi.umss.edu.bo

Crear un repositorio git en mi carpeta django-ajayurespaldo

$cd django-ajayurespaldo
$git init

Empezamos a crear nuestros archivos

$sudo touch README

Ahora añadimos nuestro nuevo archivo, si creamos sobre un directorio con archivos, solo colocamos "git add ." para añadir todo a nuestro proximo commit.

$ git add README   *$ git add folder/ Añade toda la carpeta
$ git commit   *nos sale un editor en mi caso vim ahi escribimos toda la info del commit

Modifiquemos el README y creemos nuevos files test1.py y test2.py

$ git status   *nos muestra que archivos estan en el commit, que archivos modificamos pero 
aun no los añadimos al proximo commit   
$ git commit -a  *añade todos los archivos cambiados pero no asi los nuevos
$ git status   *podemos ver que solo nos quedan por subir lo nuevos archivos
$ git add test1.py test2.py 

Viendo los cambios en varias formas

$ git dif –cached * nos muestra los cambios antes de hacer commit
$ git log  * nos muestra la historia del repo
$ git log -p  * nos muestra la historia del repo mas los cambios efectuados
$ git log --stat --summary  * un resumen corto 

Muchas veces cuando desarrollamos se nos ocurren ideas o alternativas pero que por lo general son cosas arriegadas, entonces es buen momento para crear un nuevo branch (podemos verlo como un hilo de desarrollo de un proyecto). Por defecto en git al crear un repo se crea el branch master.

$ git branch prueba

Si usamos git status, podremos ver al principio en que branch nos ubicamos. Para cambiar al nuevo branch lo c¡hacemos con: 

$ git checkout prueba

Empezamos a probar nuestros experimentos locos, para ello repetiremos ya los pasos de git recientemente aprendidos: add, coomit. 
Si nuestro experimento en el branch prueba nos slio bien, entonces lo tenemos que juntar con el master :), para eso nos posicionamos en el branch master y realizamos el merge:

$ git checkout master
$ git merge prueba

A continuacion nos saldra la info del resultado.

Bueno con esto ya podemos empezar a jugar y experimentar con git. ah me olvidaba, podemos usar gitk nos muestra graficamente todo lo echo en el repo.

Grails es otr framework que sigue el fenomeno rails, grails esta basado en groovy, y groovy es un lenguaje dinamico script basado en java. Al estar basado en java podemos utilizar todas las librerias o codigo realizado anteriormente en sole java.

grails create-app holamundo

cd holamundo

grails create-controller hola

vim grails-app/controllers/HolaController.groovy

#colocar lo que sigue:

class HolaController {
    def mundo = {
        render "Hola Mundo!"
    }
}

grails run-app  # listo!! vemos en el navegador en localhost:8080/holamundo