Skip to content

El tour de Corey “Tour de Programacion en parejas”

diciembre 23, 2008

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 on Rails, antes de ello paso 5 años desarrollando con C#. Y durante los ultimos 4 años ha estado dirigiendo e implementando tecnicas de desarrollo agil, como la programacion en parejas, BDD y TDD.

Actualmente se encuentra sin empleo, pero con algunos ahorros en el bolsillo y con la ayuda de sponsors, ahora lleva adelante este evento, que tambien es parte de lo que pretendia hacer como uno de sus siguientes pasos en su carrera profesional. Obviamente cuando acabe el tour quedara sin dinero practicamente y necesitara conseguir un empleo.

Mas datos del evento:

Core Haines ha creado un blog exclusivo para el evento, Corey Haines’ Pair Programming Tour.

A continuacion una breve lista de las entrevistas con los personajes que tuvo la oportunidad de trabajar en pareja:

Fue todo un tour el que lleve adelante en el blog de Corey y fueron muchas las horas que me tomo para ver cada una de las entrevistas, pero sin duda estas experiencias son las que nos enriquecen y las que dificilmente encontraremos en libros, blogs, etc.

Anuncios

Hoy es el ultimo dia de Pownce

diciembre 15, 2008
tags: ,

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 y puedan traernos sorpresas para la gran comunidad de django.

Si quieres seguirlos en esta nueva proeza, podemos encontrar sus blogs en vox:
leahculver.vox.com, Mike en mjmalone.vox.com, y Ariel en arielwaldman.vox.com.

Anuncio oficial de Six Apart, dando la bienvenida al equipo de pownce:
http://www.sixapart.com/blog/2008/12/welcome-pownce-team.html

Creando modelos y registrandolos en la interfaz de administracion en Django

diciembre 14, 2008

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 llamada 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  ahora crearemos una nueva aplicacion que se llame todo:

#./admin.py start-app todo

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

Abrimos el models.py y a continuacion definimos los modelos de nuestra aplicacion:

(archivo: models.py)

from django.db import models
from django.utils.translation import ugettext_lazy as _

# ugettext_lazy es parte de la aplicacion de internacionalizacion de django y viene junto al core de django, el objetivo es que podamos mostrar tanto el contenido como las funcionalidades en varios idiomas, para añadir esta caracteristica usaremos textos traducibles de la forma _(‘texto a ser traducido’).

from django.contrib.auth.models import User 
#django nos provee otra aplicacion que maneja la autenticacion, en el todo el modelo User nos servira para representar al dueño.

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’))
)

A continuacion escribimos los campos que tendra nuestro modelo, django nos provee unos tipos basicos de fields, entre ellos tenemos el foreignkey que nos permitira relacionar nuestra entidad debil con una fuerte. En nuestro caso un User sera dueño de uno o mas todos.

owner = models.ForeignKey(User, related_name=’owner_group’, verbose_name=_(‘owner’))

#  el atributo related se usa para indentificar desde el Usr al conjunto de “todos” que le pertenecen, mientras que el verbose name es la cadena que se usara para representar a ese campo.

name = models.CharField(_(‘name’), max_length=32)

# el tipo Charfield tiene como atributo obligatorio definir un maximo de letras de contenido, que sera un entero mayor a 1

created_date=models.DateTimeField(default=datetime.now)

# el atributo default lo usamos para definir valores por defecto, el valor por defecto sera la fecha de hoy, now la pasamos como callbak (se ejecutara la funcion now cada vez que se la requiera)

priority = models.IntegerField(_(‘priority’), choices=CHOICES_PRIORITY)
status = models.IntegerField(_(‘status’), choices=CHOICES_STATUS)

# El atributo choices nos permite pasarle una lista de valores validos para dicho campo

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’
order_with_respect_to=’owner’

# Estas son algunas de las opciones que tenemos para definir los metadatos de nuestro modelo, estos se definen definiendo la clase interna Meta. (En otro post veremos con mas detalle las difrentes opciones, aunque muchas de elas son faciles de predecir)

def __unicode__(self):
return self.name

# el unicode django automaticamente nos proveera el metodo __str__() que llamara a nuestro metodo _unicode__ y entonces convertira el resultado del mismo a una codificaciion de cadena de objetos UTF-8 correctamente. Para versiones mayores de django 1.0 es aconsejable usar unicode y no asi str.

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

(archivo: admin.py)

from django.contrib import admin

from models import Todo

admin.site.register(Todo)  # aca registramos nuestro modelo con el admin de django

Ahora nos toca generar la base de datos:

./admin.py syncdb

Simepre la primera vez que sincronizamos 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.

Sin duda esta caracteristica de django es la que atrae a muchos, ya que en la mayoria de las aplicaciones que realizamos siempre 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.

Scaffolding en Grails

diciembre 12, 2008

Grails,

Es un framework que hereda y mejora muchas cosas de rails, esta basado en el lenguaje groovy (un lenguaje de tipeado dinamico), su estructura esta basada en las clases del dominio, las vistas y los controladores.

En esta oportunidad veremos una de las propiedades basicas que nos ofrece Grails.

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 (Para esto grails realiza una introspeccion a nuestros modelos mediante la cual determina la interfaz apropiada a ser renderizada para dicho modelo, esto lo hace en tiempo de ejecucion)
  • 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.