Adaptándose al Equipo

Desde que estoy trabajando en este nuevo trabajo sin dudas hay muchas cosas nuevas que estuve aprendiendo. Por supuesto que en cada anterior trabajo aprendí muchísimo y también en mis proyectos propios, pero estos últimos meses fueron muy intensos y de grandes desafíos.

Una de las cosas que más observé, es la necesidad de adaptarte al entorno. Es algo medianamente sabido. Pero he visto gente en este entorno con enormes resistencias al cambio.

El mundo del develop e informática en general, es un ambiente de cambio frenéticos. Muchos se casan con cual o tal tecnología o metodología y se ponen camisetas (vaya uno a saber por qué)… que en el fondo le terminan cagando la vida.

Así vi pasar gente, algunos despedidos, otros atascados profesionalmente ,etc, solo por no querer adaptarse. Por ejemplo, no dejar de usar un lenguaje de programación por otro, una plataforma por otro, un IDE por otro y hasta un Software de Control de Versiones por otro.

Adaptarse no es importante, es vital. Muchos reniegan porque no quieren salir de lo que conocen y no quieren enfrentar el miedo y la incertidumbre de sentir que no saben. No saben, es una realidad, pero todos estamos en la misma. Nadie sabe algo que no conoce, pero para crecer y también para  no estancarte, es un desafío que hay que enfrentar día a día.

Git Apesta

Git es el mejor nombre para esta aplicación.  Aunque podriamos reemplazar la  «G» por «Sh». ^^

Clases Dinámicas con Python

Esto es un tutorial sumamente simple. Pero nunca está de más.

Acá tenemos un ejemplo de como instanciar un objeto guardando el nombre de la clase en una variable:

>>class A():
     def __init__(self):
        print "New Object of Class A"
>>>class B():
     def __init__(self):
        print "New Object of Class B"
>>> aClass = B
>>> newObject = aClass()
"New Object of Class B"
>>> aClass = A
>>> newObject = aClass()
"New Object of Class A"

También podemos hacer exactamente lo mismo pero usando el nombre de las clases con un string. Suponiendo que ya tenemos definidas las dos clases del ejemplo anterior (Clase A y Clase B):

>>> nombreA = "A"
>>> nombreB = "B"
>>> newObject = eval(nombreB)()
"New Object of Class B"
>>> newObject = eval(nombreA)()
"New Object of Class A"

Como vemos, la magia se encuentra en la funcion eval de Python,

 

Espero que les sirva!

Configurar MySql con Django Ubuntu Server y Windows

Asumiendo que ya tengan el Django y el MySlq instalados (igual seguro me hago un tiempito y armo un post), es muy probable que, tras configurar el settings.py de algún proyecto, y colocar

'ENGINE': 'django.db.backends.mysql'

y luego intentar ejecutar cualquier comando con django, nos salga algo como:

Error loading MySQLdb module: No module named MySQLdb

Bien, es algo sumamente fácil de solucionar. Este error simplemente significa que nos está faltando MySqldb, que no es más que un paquete de Python para usar MySql. Dado que ni python, ni django lo traen consigo, a veces podemos sufrir un poco hasta que entendemos que pasa (sobre todo si recién se empieza en esto de instalar entornos).

Si nos encontramos en Ubuntu, la solución es tan simple como abrir una consola y tipear:

sudo apt-get install python-mysqldb

y si nos encontramos en windows, debemos bajar el conector, de este sitio: http://sourceforge.net/projects/mysql-python/. Asegurense de bajarse el binario para la versión que tienen de python, sino también van a tener dolores de cabeza.

Si no saben que version de python tienen, abran una consola de windows (el cmd), y escriban python. Lo primero que les aparece es un encabezado seguido de la consola de python. en dicho encabezado se encuentra la versión de python:

Python 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

Si todo funciona fue bien, ya no deberíamos tener más problemas al respecto. Espero sirva!
 

 

 

ShortCuts Flash Builder 4

Usar un buen IDE siempre es bueno, pero usarlo bien es todavía mejor. La comodidad y la fluidez para trabajar son indispensables para aumentar la productividad y, sobre todo, sentirse menos frustrado haciendo cosas molestas.

Les voy a dejar una serie de shortcuts y tips para FlashBuilder 4, sin duda muy cómodos.

Si sos usuario de MacOs solo reemplazá la tecla Control por Command, como seguro ya sabés.

Asistente (Control + Space): Un viejo conocido de muchos desarrolladores, más si vienen de cualquier Eclipse o derivado. Nos muestra el asistente según donde estemos posicionados y nos da una guía de como seguir (completando variables, métodos, etc).

Comentario en bloque (Control + Shift + C):  Sumamente útil, cuando lo descubrí fui muy feliz. Básicamente comenta (/* */) el sector de código que tengas seleccionado.  Si ya está comentado, lo descomenta.

Organizar Imports(Control + Shift + O): Se encarga de organizar los statement de los import, eliminando los no usados y acomodando por package si hace falta. No es un comando que vivas usando pero es realmente util.

Rapido acceso al Outline (Control + O): Amo este tipo de Shortcuts. Nos permite visualizar y dirigirnos rápidamente las variables y métodos del archivo que tengamos abierto. He visto algunos (incluyendome a mí tiempo atrás), hacés Control + f (find-search) buscando el método o variable en cuestión y navegando entre comments y demás. Este shortcut es indudablemente más práctico y veloz.

Abrir recurso (Control + Shift + R): Como el anterior, un shortcut para amar. Nos permite buscar rápidamente por nombre cualquier clase o recurso de nuestro proyecto. Se puede incluir caracteres ? y * en la búsqueda (la ventanita explica para que sirven). Un tip interesante es que podemos buscar escribiendo solo las mayúsculas. Por ejemplo, si tenemos una clase ResourceLoader, podemos escribir RL y la encontrará.

Encontrar la llave Perdida (Control + Shift + P): Suena a una aventura de Indiana Jones, y, a veces, es medio parecido encontrar donde cierra una llave ({ y }). Con este shortcut se soluciona facilmante 🙂

Encontrar Declaraciones (Control + G): autoexplicativo

Encontrar Referencias (Control + Shift +G):  idem

Ir a la declaración (F3): sumamente práctico. Si tenemos una variable que estamos usando, o un metodo al que estamos incvocando, un objeto creando, etc, con colocarnos encima y tocar f3 accedemos a la declaración del mismo.

Volver a la última posición de edición (Control + Q): A veces nos emocionamos tocando f3 o buscando cosas o abriendo recursos y nos olvidamos dondes estabamos o hay que ir buscando entre archivos cuál era el punto del que partimos. Con este shortcut podemos retroceder en dicha cadena de movimiento y búsqueda.

 

Hay varios shortcuts más, pero estos son los que más uso y realmente agilizan mucho el trabajo. Si me doy cuenta alguno más lo sumo!

 

 

 

Instalando SVN en Aptana Studio 3

Como es sabido, Aptana es un IDE basado en Eclipse para PhP, Python, etc. Por defecto trae la posibilidad de usar cvs como control de versiones, pero si usás SVN es muy fácil instalarle la funcionalidad para integrarlo.

Vincular el repositorio al proyecto

1. En Aptana, ir al menú “Help” -> “Install new software”.
2. Ingresar “http://subclipse.tigris.org/update_1.6.x”.
3. Instalar Subclipse.
4. Abrir el menú desplegable del proyecto a vincular, seleccionar “Team -> Share Project -> SVN”

Recibir (update)

1. Abrir la perspectiva “Team Synchronizing”
2. En la vista “Synchronize”, ir al botón “Synchronize”
3. Seleccionar el proyecto a sincronizar y seleccionar “Finalizar”.
4. Si hay actualizaciones, seleccionar “Update All Incoming Changes”

Enviar (commit)

Luego de realizar cambios en los archivos, repetir los pasos anteriores, pero seleccionar “Update All Outgoing Changes”

Usando Debuggers

Si venis de hacer aplicaciones de escritorio o bien Application Servers con lenguajes como Java, probablemente te suene mucho el tema de breakpoints y demás.

Conozco mucha gente que programa sin utilizar las bondades de un buen debugger (o de un debugger cualquiera).

Cuando se encuentran con bugs o problemas, suelen usar prueba y error o muchos prints (o trace, o echo, lo que lo quieras) para poder ir siguiendo la información que tienen los objetos y variables.

¿Por qué usar un debugger?

BreakPoints: Un breakpoint es una interrupción en la ejecución del código, una pausa, que te permite ver el estado del programa en ese punto y luego te permite continuar la ejecución.
De esta manera, podemos evitar que «pinche» el programa antes del legar al punto conflictivo e ir avanzando paso a paso en el código hasta determinar qué linea o sector de código no está generando el problema.

Por otro lado, tenemos la ventaja de revisar el estado en memoria de las variables y objetos que fueron utilizados, sin necesidad de prints raros ni nada por el estilo. En un buen IDE, podemos hacer dropdowns de dichos objetos de manera clara, navegando entre sus propiedades y elementos, por ejemplo si es un Array o Collection.

Además, según el tipo de plataforma que corras, el debbuger ayuda a capturar ciertos errores y excepciones sin que se rompa todo el entorno de trabajo.

Conclusión:

Usar debugger, es bueno. Fue un post muy simple, pero estos días estuve viendo mucha gente no usar debugger y programar en cuasi block de notas creyendose hackers por hacerlo, pero nada mas lejos de la realidad.

Object Pooling

Hace un tiempito estaba haciendo un juego en Flash, en el cual iban apareciendo enemigos cada vez en mayor cantidad y llegaba un momento en que la perdida de rendimiento era muy fuerte.

Una solución (o al menos un enfoque para mejorar la situación) a este tipo de situaciones es lo que se conoce como Object Pooling.

El término pool significa literalmente pileta, pero para conceptos como este, no se me ocurre una traducción correcta, pero basicamente hace referencia a un conjunto de recursos a los que se puede acceder para ser usados en algo (se usa no solo en la informática).

Object Pooling es un Design Pattern en concepto muy simple. Se trata de mantener un pool de objectos constantemente instanciados e ir accediendo a ellos según los necesitemos en vez de ir instanciandolos y disposiandolos de memoria on demand. Cada vez que accedemos a un objeto, sin duda, necesitamos resetearlo, así que que también hay que «limpiar» los objetos una vez liberados.

¿Cuándo usar Object Pooling?

La idea de object pooling es ahorrar memoria y tiempo de cpu en la instanciación y liberación de objetos, además de prevenir memory leaks y la fluctuante situación del garbage collector (supiendo que usemos un lenguaje que lo tenga). Por lo tanto, esta técnica es ideal para cuando instanciamos mucho una clase  y/o el costo de instanciación es muy alto.

Tomemos el ejemplo de un survival mini game. Si, de esos que empiezan a venir chobis y chobis y chobis. Digamos, zombies (todos amamos los zombies). Con el paso del tiempo, la cantidad de zombies es cada vez más grande.

Bien, acá tenemos  un buen caso para usar (casi seguro) Object Pooling.

Vamos a usar ActionScript3 para los ejemplos. Y el objecto  que vamos a poolear es,claramente, un Zombie.

Zombie.as

public class Zombie extends Sprite{
        public static const OUT_SCREEN_X   : Number  = -2000;
        public static const OUT_SCREEN_Y   : Number  = -2000;
        // -- Class Constructor
        public function Zombie(){
        }
        public function reset():void{
             this.x=OUT_SCREEN_X;
             this.y=OUT_SCREEN_Y;
        }
}

Como vemos,es una clase muy básica. Simplemente estamos hablando de herencia de Sprite. Ahora nos ocuparemos del pool:

ZombiePool.as

public class ZombiePool {
        public static const MIN_ZOMBIE_QTY    : int  = 50;
        private m_pool : Vector.<Zombie>;
        public function ZombiePool(){
            m_pool = new Vector.<Zombie>();
            var i:int =MIN_ZOMBIE_QTY   ;
            while (i-->0){
                m_pool.push(new Zombie());
            }
        }
        public function getAZombie():Zombie{
              if(m_pool.length==0)
                   m_pool.push(new Zombie());
              return (m_pool.pop()).reset();
        }
        public function freeZombie(_zombie:Zombie):void{
                m_pool.push(_zombie);
       }
}

Revisemos rapidamente el código. Como podemos ver,  la pool propiamente dicha es un Vector de Zombies. Esta pileta es inicializada con cierta cantidad de zombies definida en la constante MIN_ZOMBIE_QTY. Por supuesto que podria haber sido inicializada por inyección en el constructor o
seteada en algun init del ZombiePool, es indistinto.
Entonces, el uso es sumamente simple. Cuando un cliente (por ejemplo.. una clase Level, o GameManager
o Map,etc) necesite crear un zombie, en lugar del clásico

var zombie:Zombie = new Zombie();

deberá utilizar:

var zombie:Zombie = ZombiePool.getAZombie();

Tras eso, lo inicializa como desee, siempre que el zombie tenga un metodo para inicializar
e inyectar valores o bien estos sean públicos.
De esta manera evitamos crear y eliminar de memoria constantemente (y esto, en un juego como este,
puede ser muy constantemente) Zombies, evitamos el mal uso del garbage collector, memory leaks
y el costo de una instanciación.
En este ejemplo simple usamos un pool incremental, es decir, si la pool se encuentra vacía,
automaticamente crece. Existen otros enfoques (pool limitada, pool que empieza vacía, etc),
pero son básicamente lo mismo.

Cuando no Usarlo , el Anti-Pattern
Aunque no me pasó, existen casos donde aparentemente es copado usar Object Pooling pero,
la realidad, termina siendo muy distinta (lo que se conoce como Anti-Pattern, es decir,
usar un patrón creyendo que es la mejor solución pero que termine teniendo un efecto contraproducente.)
Se trata de casos en los que limpiar el objecto (resetearlo) es más costoso que instanciarlo
o casos donde las referencias al objecto del pool pueden ser conflictivas y al liberarlo
al pool puede generarse problemas con los punteros y demás. Pero no creo que sea para
alarmarse, la mayoría de los mortales no tenemos ese problema.

Así que, a llenarse de zombies!

Desacomplando Código y Buenas Prácticas , parte I

Si estudiás informática en algún lugar académico (facu o similar), seguro escuchaste hablar que una buena práctica es buscar que el código que hagas esté lo más desacoplado posible (decoupled). Por supuesto me refiero a una práctica que POO permite (quizás otros paradigmas no dan tanta libertad, pero no puedo hablar mucho al respecto).

Una mala costumbre que tienen muchos programadores, sobre todo aquellos que ignoran buenas prácticas de la ingenieria de software (design patterns y demás), es justamente acomplarlo todo. ¿Qué significa que nuestro código esté acoplado?

El término coupled (acoplado) es bastante autoexplicativo. Hace referencia a tener distintos sectores del código tan unidos que no podemos independizarlos, generando dependencias muy fuertes entre objetos, métodos, etc. Esto, indudablemente, es un problema.

Como una de  mis especialidades es la programación de videojuegos, mis ejemplos van a ser medio juegos. Pero creo que también son ejemplos más didácticos, ya que las abstracciones hechas en los juegos suelen ser bastante claras. Por el mismo motivo voy a usar ActionScript 3 como ejemplo de código, pero no se queden en eso.

Imaginemos que tenemos las clases Auto, Conductor. Implementemoslas de una «mala manera» (no soy experto en autos y motores asi que no creo qeu sea un buen modelo de la vida real, pero ignoren mi ignorancia):

Emepecemos por Auto:

public class Auto{
        public var funcionando : Boolean;
        public var velocidad   : Number;
        public var direccionRuedas : int; // -1,0,1 (izq, neutro, der)
        public var cantCombustible : Number;
        public function Auto(){
                cantCombustible = 20;
                direccionRuedas = 0;
                velocidad       = 0;
                funcionando     = false;
        }
}

Y ahora la clase Conductor:

public class Conductor{
        public var miAuto : Auto;
        public var nombre : String;
        public function Conductor(){
             nombre = "Juan Perez";
             miAuto = new Auto();
        }
        public function comenzarAManejar():void{
             miAuto.funcionando= true;
        }
        public function doblarDerecha():void{
            miAuto.direccionRuedas= 1;
        }
        public function doblarIzquierda():void{
            miAuto.direccionRuedas= 1;
       }
        public function update():void{
                 miAuto.cantCombustible-=5;
                 if (miAuto.cantCombustible <= 0) {
                     miAuto.funcionando= false;
                 }
        }

}

Bien. Sí. Disculpen si el código es sumamente feo, aquellos que tengan algo de conocimiento y práctica.
Estoy enfocando el artículo principamente a quienes no la tiene, al menos desde el comienzo y además,
Intentando ser sumamente explícito, así que mejor que sea bien feo.

Asumamos que el método update de Conductor se llama cada X cantidad de tiempo (por ejemplo en un OnEnterFrame) y que en ese delta de tiempo, el Auto consume 5 de combustible. Bien. Un programador inexperto diría «bueno.. el código es correcto, funciona» . FUNCIONA. Tenemos que tener un increíble cuidado con ese término. Puede funcionar.. pero.. ¿A qué costo?

Supongamos que deseamos cambiar el consumo de combustible, y supongamos que Conductor no es la única clase que utiliza el auto… deberíamos cambiar todas esas clases a su vez, y .. muy probablemente nos pasemos de alto cosas. En este ejemplo parece algo pequeño, pero en grandes aplicaciones… te vas a querer matar.

Una buena manera de desacoplar este comportamiento (el gasto de combustible), es simplemente delegar la responsabilidad del gasto de combustible al auto. Al fin y al cabo.. uno no le dice a su auto «che, coche, gastá tu combustible», él lo gasta solito, él sabe como hacerlo.

Lo mismo sucede con la siguiente línea, donde se controla si el auto debe detenerse al quedarse sin combustible.

Así que simplemente podemos agregar el siguiente método a Auto:

public function update():void{
   cantidadCombustible-=5;
   if (cantCombustible <= 0) {
                     funcionando= false;
    }
}

y reemplazar el update del Conductor por algo como:

public function update():void{
       miAuto.update();
}

Sumamente básico, pero muchísimo mejor. Existen otros enfoques ya un poco menos básicos (para que no se quejen) para desacoplar este comportamiento, pero pienso comentarlos en el siguiente artículo de la serie.

Bitnami Stacks: enlatados de lo que quieras (free!)

Bitnami[1] es un sitio desde el cual se pueden descargar stack completos de muchos sistemas open source gratuitamente.

Los stack se distribuyen de tres maneras:

• Instalador nativo para Windows, Linux y OSX.
• Imágenes para VMWare (incluyen un linux minimal como base)
• Imágenes para las VM de Amazon (sí! para hacer deploy en la nube facilmente)

Entre ellos están:

• SugarCRM
• Moodle
• MediaWiki
• DokuWiki
• RedMine
• Joomla
• Drupal
• WordPress
• y muchos más!

[1]http://bitnami.org/