ES KAsi UN blog

Blog de Unkasoft, donde hablamos de programación de juegos para móviles, advergaming, marketing móvil, la industria de los videojuegos, metodologías ágiles y todos aquellos temas que nos preocupan en nuestro día a día

25 junio 2009

El desarrollador de software y la tesorería

La tesorería es a la empresa casi lo que el oxígeno al cuerpo humano. Tenemos que respirar aire con oxígeno y siempre tiene que haber oxígeno en el sistema porque se gasta de manera natural. Aunque el simil puede que no sea perfecto, la tesorería nos indica que tal andamos de "oxígeno" en la empresa y nos permite hacer más o menos esfuerzo y tomar algunas decisiones. Si se acaba el oxígeno, esto se acaba porque nos axfisiamos.
El desarrollo de software como actividad, puede llevar dos líneas diferentes, la de la prestación de servicios a terceros en desarrollo de software y/o el desarrollo de productos sin encargo de un tercero que luego se venden o licencian a terceros. En ambas líneas, la fuerza motriz es el ser humano (actualmente), es decir, que necesitas personal especializado para las tareas de analizar, diseñar, implementar, probar y dar soporte. Todo esto implica un coste importante mensual que se debe cubrir por adelantado en la mayoría de los casos. En el caso de la prestación de servicios, acuerdas unas fechas de entrega intermedias o finales y unas fechas de pago. En el caso del desarrollo de producto, adelantas todo el coste de la creación del producto y luego buscas compradores.
Uniendo ambos conceptos, veremos que el control de la tesorería es esencial en una empresa que desarrolle software y tenga un equipo de desarrolladores en plantilla. Los desarrolladores deben ser pagados mensualmente (al menos por estos lares) y para eso tienes que tener mucho dinero.
En caso de que no quieras tener tu propio super equipo técnico y tener "el control" y prefieras encargar el desarrollo a un tercero, entonces el coste humano se traslada a tu proveedor. Seríamos un intermediario que subcontrata. Una variable más a la ecuación o una capa más al diseño.
Si a todo este cuadro le sumamos la crisis y que se está imponiendo la terrible manía del "te pago cuando me pague mi cliente", entonces observamos claramente que la tesorería en el eslabon más debil, es el que tiene en plantilla a los desarrolladores, será la llave de la desgracia o la felicidad. Si el cliente del cliente del cliente (...) no puede, no quiere o simplemente decide retrasar el pago, el riesgo soportado por el eslabón más debil es increible.
Más claro, quiero decir que si eres un desarrollador de software y hay crisis económica, es que estás bien jorobado porque vas a asumir todo el riesgo de las operaciones. Un ejemplo medio: A contrata a B un software para pintar florecitas en una pantalla, B decide subcontratar a C el desarrollo del software y le obliga (es el cliente) a pagar cuando A pague a B. ¿Quién tiene el riesgo? C porque ha adelantado el pago de todo el desarrollo de software y encima tiene que dar soporte a A (B no es capaz). A recibe producto y paga cuando puede, B es un intermediario que paga cuando le pagan y C se come el marrón de desarrollar un proceso complejo y caro (hay que tener especial cuidado calculando los márgenes).
Después de esto, si tienes una empresa de desarrollo de software con personal especializado, lo mejor es que tengas un gran control de la tesorería y que elijas bien a tus clientes. Que no te de miedo rechazar algunos que no te inspiren confianza y negocia bien el cobro del trabajo independientemente de lo que hagan con ese trabajo en la cadena de contratantes.
Lo más fácil (que no lo mejor) en estos tiempos, sería subcontratar el desarrollo a un tercero y hacerte un mero intermediario inutil para el sistema.
Lo más necesario para nuestra economía, sería tener más empresas de desarrollo de producto con personal especializado con capacidad tecnológica para innovar y con capacidad comercial para venderlo fuera de España. Algo poco habitual en este país por el momento.
¿Y tú qué eres? ¿Desarrollador, inetermediario o cliente final?. Seas lo que seas, ten siempre en cuenta a los demás agentes de la cadena y trátalos cómo te gustaría que te tratasen a tí.

Etiquetas: , , , ,


11 julio 2008

Meme de desarrollo de software

He visto en el blog de Javier Santana (psé) un meme acerca de desarrollo de software y su petición de continuidad en otros blogs como este. Mis respuestas son:


- ¿Cuántos años tenías cuando empezate a programar?

Mi primer código lo hice con unos 11 o 12 años (año 1984 o 1985).

- ¿Cómo empezaste a programar?

Tenía una consola Philips muy primitiva (Videopac+ G7400) y mis padres me regalaron un cartucho con un módulo enorme (tan grande como la consola) que no era más que un BASIC muy primitivo (2KB?) y con una entrada para conectar un radiocassete para grabar los programas hechos en cinta y que aún poseo :).



- ¿Cual fue el primer lenguaje que usaste?

BASIC con mi super consola con módulo :)

- ¿Cual fue el primer programa real que programaste?

Una aplicación de base de datos que guardaba datos personales, tipo agenda. Los datos se grababan en cinta de cassete de manera secuencial y la aplicación permitía crear, borrar, editar, buscar y listar.

- ¿Qué lenguajes has usado desde que empezaste a programar?

Lenguajes que he llegado controlar son Basic, Pascal, Clipper, asm x86, C, C++, VB, java, y varios de tipos de script y sublenguajes que o ya no existen o son del tipo JavaScript. Luego están los típicos del shell de los sistemas operativos. He probado muchos lenguajes que no he llagado a dominar, pero actualmente llevo más de 6 meses sin programar por temas de dirección y creo que podría perder mi toque como programador.

- ¿Cual fue tu primera experiencia profesional?

Una empresa que montaba ordenadores (clónicos) en Salamanca. Yo hacía de todo, y programaba en clipper aplicaciones de gestión.

- ¿Si tú hubieras sabido lo que sabes ahora cuando empezaste a programar, hubieras empezado a hacerlo?

Sí, sería el amo del cotarro :), imaginate saber de arquitecturas distribuidas en el año 1984 o 1985. Bueno, dejando las bromas aparte, creo que hacer programas puede compararse con el simil de ser un mago que hace hechizos. No lo habría cambiado por nada.

- Si tuvieras que decir una sola cosa de las que has aprendido a lo largo de los años a un nuevo programador, ¿qué le dirías?

Vivelo con fuerza, no desistas, sólo hay barreras psicológicas.


- ¿Qué es lo más divertido que has programado?

Prefiero explicarlo como lo que más me ha llenado. Lo que más me ha llenado ha sido ver funcionar el motor isométrico de Battlewizard, tanto en el editor del PC como en los móviles Nokia S40. No era perfecto, pero verlo funcionando me satisfazo muchisimo.

- ¿A quién le pasas el meme?

A todo programador que se tercie en aparecer por este blog :).

Etiquetas: , , ,


10 junio 2008

El tamaño importa

En los juegos para móvil el tamaño importa, sobretodo cuando se trabaja con dispositivos como nokia 3220 y familia donde el tamaño máximo de un juego ronda los 128kb como máximo. Los días de cierre de juego nos pasamos sufriendo pensando en si entrará o no en estos dispositivos... :(

Al final hay un montón de artimañas para que en los juegos se pueda meter más con menos, por ejemplo usando pngout para sacar información de los png (hace muchas cosas más que tienen que ver con lo que explicaré ahora), eliminando colores de las imágenes, etc. Al final todo va empaquetado en un jar, que no deja de ser un zip, con lo cual se comprimen los datos y te salva un poco los muebles ya que normalmente las cadenas de texto de somprimem muy bien.

Pero se puede hacer más para conseguir más espacio, y no se trata de quitar contenido, si no de ordenador adecuadamente. Un ejemplo: poganmos que queremos guardar unas paletas de colores en un fichero, lo primero que pensamos es:

- guardo los colores uno tras otro:
si la paleta tiene 200 colores (3 componentes por color r,g,b) finalmente ocupará en "disco" 600 bytes. Aparte luego se puede comprimir, sin embargo puede que no se comprima. Por ejemplo, en un fichero típico no se comprime prácticamente nada.

- Si pensamos que la compresión lo que hace es quitar redundancia, podemos intentar añadir redundancia a los datos. Si echamos un ojo a los datos es fácil que en una paleta el rojo de un color se parezca más a el rojo de otro color que al verde que escribimos justo a su lado.

Esto en "disco" ocupa exactamente lo mismo que el anterior, 600 bytes, pero no hay que pensar en este tamaño si no en el que tendremos cuando esté comprimido. Lo comprimimos usando zip y obtenemos una mejora de un 36% más o menos.

- Pero pensando un poco más, se puede sacar más redundancia aún, si codificamos en deltas, esto es, guardamos la diferencia de un color al siguiente. Con esto se obtiene más o menos una mejora del 57% una vez comprimido.



Está claro que no es mucho ahorro para un solo fichero, pero si juntas todos los pequeños datos que tienes en un juego (tiles, sprites, fuentes...) se sacan esos pocos kb que hacen que el juego termine funcionando. En resumen, no es más que hacer lo mismo que hace el formato PNG para comprimir... quizás estaría bien meter todos los datos en imágenes y comprimirlos en png .... :)

otro cantar es lo que ocupe en la memoria en ejecución, pero eso es para otro post :)

Etiquetas: ,


04 junio 2008

Metas

Es hora de hacer una parada técnica, una parada en Boxes, cambiar neumáticos y afinar el motor, y después volver a arrancar el coche pero despacio, haciendo el rodaje, que me de tiempo a mirar a los lados para ver el paisaje.

Después de unos meses un poco perdido, después de muchos cambios, sin tener demasiado claro una meta profesional o mejor dicho con demasiadas metas en mente, es hora de que me pare a pensar, de centrarme en una o dos metas y concentrar mis esfuerzos en esa dirección. Demasiadas metas te hacen querer correr mucho para alcanzar alguna de ellas demasiado pronto, pero al ser varias nunca acaban de llegar y lo que llega es la frustración.
Las metas pueden no dejarte ver ni disfrutar del presente, ten claro que son tú futuro pero que se llega allí trabajando el presente.

Es importante también que no dejes que las metas te alcancen a ti (eso significará que no estás preparado aún), tienes que alcanzar tú la meta preparándote para ello, de lo contrario perderás ese objetivo para siempre.

No se puede saber todo, conocer todo y aprender de todos, mejor dicho puedes aprender algo de todos pero no todo lo que los demás saben. Si abres muchos frentes casi seguro que los descuidarás y no los terminarás nunca.
Por eso este verano no voy a proponerme 15 metas aprovechando la jornada intensiva, sino que voy a centrarme en la meta profesional que después de titubear mucho sé que quiero alcanzar: gestión de proyectos con perfil técnico. ¿Esto significa que quiero dejar de programar? NO. Solo significa que quiero invertir los porcentajes, ahora dedico un 85% a programar y un 15% a algún tipo de gestión, voy a intentar que se equilibren más, de forma paulatina, y evidentemente primero como piloto de pruebas, pues habrá que demostrar que valgo para ese trabajo, a mi modo de ver empiezo la carrera con un buen coche y con un buen bagaje:

- A lo largo de toda mi carrera profesional he llevado algunas de las tareas de la gestión del proyecto, sin bien es cierto que casi siempre del lado más técnico.

- Tengo conocimientos.

- Me gusta.

- Tengo ganas.

¿Es un buen coche para empezar la carrera?. Yo creo que sí.

Esto tampoco significará grandes cambios ahora mismo, pues desde hace ya bastante tiempo, todo lo que leo esta relacionado con este tema, el mayor cambio será mi forma de ver las cosas. Intentado disfrutar del presente, sin permitir que el futuro me vende los ojos y con en ello algunas veces el humor, y sobre todo intentaré andar, no correr.

Hasta ahora tenía muchos frentes, muchos, demasiados:


- Cada día aprender más sobre gestión de proyectos.

- Aprender Ruby

- Aprender Groovy

- Volver a tocar ensamblador

- Conocer la maquina virtual de java al dedillo.

- Y además tengo la mala costumbre de que cada vez que cambio de tecnología me gusta conocerla al dedillo, explorarla, que está bien pero en el momento en el que nos encontramos, el paso por una tecnología en un proyecto puede ser de 3 semanas y en ese tiempo es imposible conocerla en profundidad (al menos para mi)

Todas estás metas están ahí por que me interesan, la mayoría son algo más que metas profesionales, simplemente quiero hacerlas como hobby pero oye es que yo trabajo como programador y eso significa que el tiempo libre que tengo lo ocupo aprendiendo otra cosa, pero no 5 cosas y si trato de ir a por las 5 cosas me quedaré con un 5% de cada una. Así que ahora solo me centraré en una "ir a más en gestión de proyectos", y el resto de cosas irán viniendo en mi carrera teniendo en cuenta que me gusta programar y me gusta descubrir. Después de todo no hay mejor forma de aprender algo que trabajar en ello y si tenemos en cuenta como se trabaja en Unkasoft no tengo ninguna duda que acabaré conociendo todo esto, un ejemplo de por donde nos movemos hoy en día en Unkasoft, tenemos proyectos trabajando en (Mezclo tools, testing, programación, metodologías…):

RubyOnRails, ByteCode Java, J2SE, J2ME, J2EE, Python, Selenium, Marathon, Maven, Ant, Flex, Trac, Svn, Hudson, Scrum, CMMI…..

Etiquetas: , ,


08 mayo 2008

Hola mundo en 366 lenguajes

Es verdad que cuando te enfrentas a un nuevo lenguaje de programación que no has visto con anterioridad sueles buscar el ejemplo más sencillo para ir tomando contacto: 'Hola mundo'.
Realmente lo más importante al enfrentarse a un lenguaje ajeno es que comprendamos la sintaxis y el ciclo de vida de la aplicación, sea cual sea el lenguaje.
Vía The Inquirer me paso Rodi un enlace más que curioso, una recopilación de 'Hola mundo' en más de 360 lenguajes distintos (58 lenguajes humano). Alguno son lenguajes bastante inútiles, pero la mayoría son los que más utilizamos o de los que más hemos oído hablar.
Aceptan sugerencias, así que si conoces un lenguaje que no tienen, enviarlo.

Etiquetas: ,


24 septiembre 2007

Test Unitarios en J2ME

En el desarrollo de proyectos es muy importante el mantenimiento y más aun las tareas de debug asociadas tanto a la creación como al mantenimiento de cualquier proyecto. Siempre debemos crear buenos casos de prueba que permitan comprobar la validez de nuestro código según lo vamos creando, para facilitar el mantenimiento del mismo y para simplificar radicalmente la cantidad de problemas y fallos que pueda dar.

Cuando programamos en Java podemos comprobar nuestras clases utilizando JUnit; es un conjunto de clases que permite realizar la ejecución de clases Java de manera controlada, para poder evaluar si el funcionamiento de cada uno de los métodos de la clase se comporta como se espera. También se utiliza en pruebas de regresión, para comprobar que el nuevo código no afecta al funcionamiento del código anterior. Este framework permite que el programador se centre en la realización de los test y en los resultados que debe obtener, gestionando los test de forma sencilla y permitiendo su ejecución automática.

Normalmente, la ejecución de test unitarios es necesaria para poder asumir la mantenibilidad de un proyecto, pues con ellos, cualquier desarrollador puede conocer cuando los cambios que está realizando afectan al resto de código del proyecto. En otras ocasiones, los test unitarios sirven como guía a otros programadores, y a uno mismo, de cómo funciona un código específico, pues un test, además de salvarnos de bugs, permite conocer qué estructura y usos tiene el propio código que se prueba.

El framework de JUnit utiliza las capacidades de reflexión en tiempo de ejecución para encontrar y ejecutar todos los test sin necesitar un test case. Sin embargo, los entornos basados en CLDC pierden la reflexión, con lo que no es posible descubrir los métodos en tiempo de ejecución, por ello, necesitamos distintas soluciones que permitan realizan test unitarios de forma sencilla para el programador.

El problema que tiene testear estas aplicaciones es que Java ME es básicamente un JDK 1.0. Hasta JUnit 3.8.X el mecanismo que usaba este framework para identificar los métodos que debía ejecutar como parte del test era la reflexión, característica que se añadió en Java 1.2 y que no está presente en Java ME. Menos esperanzas hay todavía de usar anotaciones, el mecanismo que emplean las versiones 4.0 y posteriores de JUnit, en Java ME.

La siguiente tabla resume las capacidades y características de las distintas soluciones para utilizar toda la potencia posible de JUnit sobre J2ME, a continuación se comenta brevemente cada alternativa:

Ejemplos / Complejidad

¿Ant? / ¿Maven?

¿Open source?

¿Ejecución en dispositivo?

Requerimientos

Peso (Kb)

MoMEUnit

Pocos / sencillo

Si

Si

Si

CLDC1.1

26

SonyEricsson JUnit

Muchos / complejo

Si

NO

NO. Solo con Debug-on-device

CLDC 1.0

20

J2MEUnit

Muchos / medio

Si

Si

Si

CLDC 1.1

17

JMUnit

Varios / medio

NO

Si

Si

CLDC1.0
CLDC 1.1

12,5
12,8

CLDCUnit

Pocos / sencillo?

Si / Si

Si

Si?

CLDC 1.1

?

J2MEUnit

Solo dispone de una versión del framework, compatible con CLDC11.
Parecido a JMUnit, para crear una suite de test necesitamos sobrecargar el metodo suite() utilizando la librería TestMethod. Esto hace que la creación de testsuites sea un poco más compleja

Alternativamente, como en MoMEUnit, J2MEUnit permite añadir los test o testSuites como propiedades del MIDlet para así ejecutarlos directamente sin tener que crearnos una MIDlet programaticamente. El TestRunnner MIDlet no proporciona resultados tan sencillos gráficamente, fáciles de ver, como JMUnit o MoMEUnit, pero sin embargo, en la consola proporciona más información que éstos.

MoME Unit

MoMEUnit es una herramienta muy similar a JUnit pero orientada a aplicaciones Java ME. Emplea tres métodos estandarizados en cada test, uno para preparar el test, otro para ejecutarlo y otro para realizar "limpieza". De este modo los test se hacen por clase más que por método. Aunque no es la solución óptima, los desarrolladores del framework afirman que es el mejor balance que se puede obtener.

MoME permite crear TestSuites con todos los test que queramos para ejecutaros a la vez; pero para que un Test comparta la fixture con otros es necesasrio que creemos una clase por test a ejecutar. El problema es tener tantas clases para todos los test.
La creación de los test es muy sencilla, es decir, es más fácil añadir test desde MoME que desde J2MEUnit.

SE Junit

La API de Sony Ericsson para ejecutar JUnit sobre J2ME. Dispone de mucha documentación y varios ejemplos de test. Permite utilizar directamente los test creados para JUnit 3.8.x.

SE JUnit requiere, para ejecutar los test, el emulador de SonyEricsson o cualquier otro compatible con WTK. lo más cercano a la ejecución en un dispositivo real es utilizar DebugOnDevice de SE que solo es compatible con algunos móviles SonyEricsson

El uso de SE Mobile Unit no es muy apropiado en casos específicos en los que se necesita añadir funcionalidades al código fuente que se está utilizando. Al no ser open-source puede que en ocasiones no se ajuste a las necesidades existentes.

JMUnit

Este framework es parecido a J2MEUnit en cuanto al uso que se hace de los test y cómo éstos se ejecutan. Principal problema de este framework es que no soporta Ant.

Para contruir una suite, cada clase que contenga los test deberá sobrecargar el método test() que contendrá un case para cada método (test) a ejecutar.Las clases abstractas TestCase y TestSuite heredan directamente de MIDlet, con lo que fácilmente se pueden ejecutar en el emulador o en un dispositivo real.

CLDCUnit

Parte de MicroEmulator, un emulador de J2ME basado en WTK. Permite ejecutar aplicaciones J2ME como aplicaciones stand-alone de J2SE o como applets java en el navegador Web. Es decir, permite hacer que nuestro navegador se comporte como un móvil y ejecute aplicaciones J2ME.

CLDCUnit es muy parecido a J2MEUnit y parte de su código fuente; conservando una interfaz muy semejante.

CONCLUSIÓN

Comparando las distintas APIs, las posibilidades que ofrecen y las necesidades que se requieren, pienso que destacan dos de las comentadas.:

MoMEUnit Ofrece mucha información muy usable de los test realizados. Se porta fácilmente al móvil y es compatible con Ant. Desventaja (o no), necesita que cada clase de test contenga un solo método de test utilizando mucha herencia entre clases.

JMEUnit. (futura unión entre J2MEUnit y JMUnit) JMUnit no soporta Ant pero la interfaz es parecida a la de MoMEUnit. J2MEUnit no ofrece información muy usable. Ambas framework requieren creación de test un poco compleja. J2MEUnit sí soporta Ant; es por esto que la fusión de ambas frameworks sería muy interesante (en ello estan trabajando desde hace un año más o menos).

REFERENCIAS

J2MEUnit http://j2meunit.sourceforge.net/doc.html

Unit de SonyEricsson http://developer.sonyericsson.com/getDocument.do?docId=85608

JMUnit http://sourceforge.net/projects/jmunit/

MoMEUnit http://momeunit.sourceforge.net/

CLDCUnit http://pyx4me.com/snapshot/pyx4me/pyx4me-cldcunit/index.html

Etiquetas: , , , , , ,


17 agosto 2007

Las cualidades de un programador

Últimamente estoy leyendo muchos post sobre cualidades del programador como Humildad ,disciplina. Y es que estás características están por encima de lenguajes, arquitecturas, etc.

Voluntad, sacrificio, tenacidad, disciplina, humildad, compromiso son las cualidades que debería tener un buen programador.

Un programador de vocación no busca cumplir, solo sacar el trabajo adelante, sino que quiere hacerlo bien, le gusta programar y por tanto aprender, aprender de cada línea que escribe, quiere aprender a hacer hoy mejor lo que hizo ayer, aprender de cada compañero. Tiene objetivos claros y la voluntad y tenacidad necesarias para lograrlos, le gustan los retos, espíritu I+D+I y sabe lo suficiente para darse cuenta de que tiene que mejorar(Humildad); No tiene limites solo es cuestión de tiempo superarlos; depende de sus propias inquietudes y capacidad de asimilar nuevos conceptos, aplicarlos y mejorarlos continuamente.

Estás cualidades podrían formar parte de los CV, al igual que por ejemplo "Capacidad de trabajo en grupo" o alguien cree sin disciplina, sacrificio, humildad, etc una persona puede trabajar en grupo, o qué quiere aprender? o que sin estás cualidades una persona querrá afrontar retos, I+D+I, etc.

Quizá solo son las cualidades que a mi me gustaría tener y no las necesarias, en cualquier caso, UN BUEN PROGRAMADOR NO DEPENDE DE UNA ARQUITECTURA O DE UN LENGUAJE, depende más de cualidades humanas que tecnológicas.

Etiquetas: , ,


26 julio 2007

¿Alguien sabe la formula?

No sé a vosotros pero a mi 24 horas me parecen pocas, ¿quién decidió que un día tiene 24 horas? ¿No sé puede cambiar? ¿seguro?
ya se que es una estupidez, pero vamos que yo con 24 horas al día no hago nada!! o soy muy lento o no lo entiendo.

Este verano aprovechando el cambio de horario me propuse aprovechar las tardes:

- hacer un minijuego con Blender y C++ con el fin de aprender ambas cosas y de exprimir a Javi y sacarle toda la info que tiene en su cabeza.
- Terminar mi I+D de detección de movimiento con la cámara del móvil.
- Ponerme al día en Compiladores, leyendo algún libro.
- Ponerme al día en metodologías (otro libro).
- Leer algún libro sobre programación, proyectos, etc...
- Escuchar una hora de radio en inglés para mejorar mi paupérrimo inglés.

Si lo sé, imposible, y si a esto le unimos lo que ya venía haciendo:
- Sacar a mis dos perros (7:00)
- Trabajar (8:00 a 15:00)
- Sacar a mis dos perros ( 15:30)
- Hacer 30 minutos de ejercicio (16:30 a 17:00)
- Estudiar inglés (17:20 a 18:20 ).
- Sacar a mis dos perros ( 19:00)
- Picar algo de código, generalmente algún juego (1 hora, aunque cada vez menos)
- Y mi vida social se lleva el resto, lo poquito que queda porque toy reventado y a las 22:00 ya no soy persona).

De lo que me propuse estoy cumpliendo:

- Escuchar radio en inglés, solo media hora y aprovecho para hacerlo cuando saco a los perros.
- Leer un libro "The Pragmatic Programmer", cuando me voy a la cama y como mucho 20-30 minutos.
- De vez en cuando programo un poco, cuando digo poco es muy poco, no será la primera vez que escribo 3 líneas y uf... qué he quedado!!


Y francamente estoy reventado. ¿Cómo se hace? Porque hay gente que es capaz de trabajar, de escribir en un blog a diario, de leer, de tener vida social...

Quizá lo suyo es centrarse solo en una cosa y cuando terminas, empezar con otra, pero es que es el mundo de la informática y aquí
¿cuándo terminas con algo? porque la formación es continua y con el inglés pasa lo mismo, no es algo con lo que uno termine en un verano (uy ya me gustaría).

Si todo fuese tan fácil como programar:

Person flopez = new Person();
Language language = Knowledge.getKnowledge(Knowledge.LANGUAGE);
flopez.addKnowledge(language);
Programming prog = Knowledge.getKnowledge(Knowledge.PROGRAMMING);
flopez.addKnowledge(prog);
...
..
.


Si alguien conoce la formula que me avise, que yo me piro a sacar a los perros (que ya voy mal de tiempo por escribir este post).

Etiquetas: , ,


11 julio 2007

Unkasoft daily WTF

Suele ser común la tendencia a despotricar del código ajeno, sobretodo cuando estás atascado, hasta arriba de trabajo y va el programita de turno y te saca un mensaje estúpido, sin descripción alguna de lo que está pasando y por arte de magia deja de funcionar, se cierra el programa y si tienes suerte te deja todo el trabajo intacto.

Cuando además eres programador te solidarizas con el compañero de profesión, piensas: "pobre hombre, seguro que estaba pillado de tiempo y no tuvo tiempo a poner un mensaje descriptivo", aunque lo cierto es que muchas veces las cosas de dejan por vaguería...

Una buena recopilación de esto es daily WTF en la que entras y te regocijas de lo malos que son los demás programadores... JAJAJA!... hasta el día en el que estás tranquilamente sentado en tu puesto y te sale lo siguiente:



:_(

Etiquetas: ,


04 abril 2007

Test unitarios en grupos de trabajo

No es la primera vez que en este blog se habla de test unitarios y seguramente esta no será la última, pero en este caso voy a dejar un poco al lado la teoría y hablaré de la práctica, del uso diario que se le puede dar a los test unitarios y que tratamos de aplicar en Unkasoft.

Una de los desarrollos actuales de Unkasoft es Unkasoft Platform, una herramienta para atajar el problema de la fragmentación en el mundo de los móviles y que permite, de una forma cómoda, crear todos los contenidos para desarrollar un juego en una amplia gama de móviles. Aunque estemos acostumbrados a ver multitud de herramientas gráficas para todo (grabar un CD con Nero, crear imágenes con photoshop), muchas veces es difícil darse cuenta de la complejidad que hay por debajo.

En el desarrollo de Unkasoft Platform trabajamos un grupo de personas, cada cual hace y deshace parte del código, corrige bugs, incluye nuevas características, pero es imposible que en un proyecto con cierta complejidad, como es UP, una sola persona esté al tanto de todos los posibles efectos colaterales del cambio de una clase o un método. Por ello la existencia de unos test unitarios impide (bueno, hace más difícil :) que un error cometido en una parte de código se propague a las demás. Si alguien hace un cambio que afecta al código de un miembro del equipo (que puede ser él mismo) ,cuando pase los test unitarios verá con facilidad que y donde la está liando.

La cosa no termina ahí. Las aplicaciones con un entorno gráfico suelen tener una curiosa inercia hacia el caos. Es habitual ver como el modelo vista controlador se convierte en un modelo de "controlo desde la vista", donde, por ejemplo, se ve como la gestión de los datos se implementa en un callback de un botón o similar. El uso de test unitarios te obliga a tener que separar lo más posible la parte controlador del resto ya que solo de esa forma es posible programarlos.

Como conclusión es fácil ver que "gastar" un poco de tiempo en realizar las pruebas unitarias te puede ahorrar horas de debug corrigiendo problemas que han incluído los demás o peor, tú mismo, o intentando refactorizar código distribuido por callbacks de botones.

Etiquetas: , ,


09 junio 2006

MIDP 3 ¿Realmente necesario?


¿Cómo estáis? desde hace algún tiempo se lleva hablando de MIDP 3 , parece que ha tomado finalmente velocidad y que se cerraría en Mayo 2006.

Estoy viendo si se ha cerrado ya finalmente. Lo primero que me preguntaba era, ¿Qué trae esta versión?

Pues lo más destacable es:


Cuando empecé a analizar la lista me gustaron especialmente algunas cosas. Por ejemplo, la posibilidad de soportar varias aplicaciones en ejecución. Creo que en breve usaremos aplicaciones de mensajería instantánea o música, a la vez estaremos disfrutando de nuestro juego favorito.

La mejora de las formas de provisionamiento también será esencial, es el principal caballo de batalla hasta el momento. Haceros a la idea de lo tomentoso que es ahora enviar 5 mensajes para poder descargar un juego en nuestro móvil - y que no tengas problemas con su ejecución porque alguien equivoco los paquetes-,

¿Alguien ha sentido la necesidad de matar a alguien en esos momentos?

Creo que me podría extender más pero espero vuestros comentarios y seguimos profundizando en el tema. ;-)

Etiquetas: ,


25 mayo 2006

TDD y Eclipse

En nuestro trabajo diario intentamos desarrollar siguiendo las prácticas de eXtreme Programming, y entre ellas en especial el desarrollo guiado por pruebas o TDD. Y digo "intentamos" porque a veces no es fácil aplicar TDD para corregir bugs o trabajar con código que ya está escrito. Sin embargo, TDD funciona extraordinariamente bien para desarrollar nuevas clases, sobretodo si trabajas con Eclipse.

Vamos a poner un ejemplo tonto: tenemos que desarrollar la clase "Device", que entre otras cosas, tiene un identificador, una descripción, un constructor de copia y un método que nos dice si el dispositivo soporta un formato específico de audio (basándonos en una base de datos en UAProf o WURLF).
Podemos abordar este problema de tres formas distintas:Bien, el caso que nos ocupa es que Eclipse nos ofrece una serie de herramientas que nos ayudarán a usar el TDD de forma poco traumática.


Empezamos codificando el esqueleto típico de la clase de pruebas con JUnit, y vemos como Eclipse nos marca una serie de errores de compilación. Como vemos en la imagen de la derecha, nos dice que la clase "Device" no se ha encontrado (logicamente, porque todavía no existe :). Haciendo clic sobre la marca de error del margen izquierdo, nos aparece una lista con posibles soluciones al error, y entre ellas: crear la clase. Así que dejamos que Eclipse cree el esqueleto de la clase "Device", y seguimos con nuestras pruebas.


Después de codificar dos métodos de pruebas estamos en las mismas: tenemos varios errores de compilación, ya que estamos llamando a métodos que todavía no existen.
Por ejemplo, en el test que prueba el constructor de copia, estamos llamando a un constructor que todavía no existe (además de un par de los getter), así que hacemos clic sobre la marca de error, y seleccionamos la opción "Create constructor Device(Device)". Con el resto de errores de compilación podemos hacer lo mismo, aunque habrá casos en que tendremos que completar o cambiar el tipo a ciertos parámetros que Eclipse no es capaz de deducir.

De este modo, casi podemos hacer que Eclipse nos vaya generando el esqueleto de nuestra clase de lógica basándose en las llamadas que hacemos desde la clase de pruebas.

Esto nos puede ahorrar bastante tiempo que dedicamos sólo a tareas de códificación zombie (la que se hace sin pensar, sólo para que los compiladores nos dejen vivir en paz).

Una vez que tenemos la prueba completa y el esqueleto de la lógica, podemos seguir codificando la lógica de la clase, hasta que todos los test pasen correctamente (aunque creo que Eclipse no puede ayudarnos demasiado en esto).

Etiquetas: , , ,


16 mayo 2006

Esconder los “bugs” es peligroso

Dentro de las prisas por desarrollar un videojuego o por cerrar una entrega, algunos desarrolladores se encuentran que no han podido solucionar algunos bugs y deciden encubrir dichos bugs controlando las excepciones inesperadas o errores no controlados. Esta práctica que debería ser a ojos de cualquier desarrollador con experiencia una grave práctica, está extendida entre algunas comunidades de desarrolladores.

Es verdad que existe la posibilidad de evitar algunos errores no controlados de una tecnología no desarrollada por nosotros, por ejemplo swing de Java o una implementación de la KVM (J2ME) de algún fabricante de teléfonos, puede ser capturar dichas excepciones y evitar el problema. A veces no hay más remedio si no tenemos control sobre la plataforma que estamos usando. Pero cuando lo que estamos manejando es nuestra lógica y nuestro código, el capturar excepciones genéricas en todos los métodos de forma incontrolada puede llegar a ser una broma de mal gusto e inclusive una pesadilla:

/**
 * Controls "key pressed" events
 * @param key Key that has been pressed
 */
public void processKeyPressed(int key) {
    try {
        // Toda la lógica aquí
        // …
    } catch (Exception ex) {
        // No hacer nada
    }
}

Una pesadilla porque el tiempo de proceso de dichos bloques de excepciones es muy alto e implica que la detección de teclas, el proceso de la IA, los cambios de estado, el control de movimiento, la carga de recursos, el pintado de algunos elementos, la creación y construcción de personajes, el control de eventos y acciones, y en general todo aquello que se ejecuta en cada ciclo del juego, harán que vaya mucho más lento.

Poca potencia en los móviles, puede ser, pero normalmente deberemos vigilar las malas prácticas que a veces cometemos y que los equipos de desarrollo no deberían cometer.

Si en vuestros equipos de desarrollo detectáis esta práctica, normalmente usada por desarrolladores de poca experiencia o que no se preocupan por el resultado de su trabajo, deberéis atajarla de inmediato o podréis encontraros con problema de potencia a ultima hora. Mi recomendación es que hagáis revisiones de código con frecuencia haciendo que desarrolladores que no conozcan un código lo analicen y detecten estos tipos de mala práctica. Algunos desarrolladores se tomarán estas revisiones como algo personal, pero simplemente habrá que hacerles ver que es un tema meramente profesional y que hay prácticas que hacen que se complique mucho el desarrollo de un producto.

Etiquetas: ,


22 abril 2006

Piensa en perfiles y capacidades en vez de dispositivos

Hace tiempo iniciamos un cambio de arquitectura de nuestras herramientas y en nuestra forma de pensar hacia las plataformas para las que desarrollamos. Pasamos de pensar en dispositivos a empezar a pensar en perfiles y capacidades.

Nuestro dolor de cabeza comienza cuando nuestros desarrollos orientados a una serie de dispositivos tienen que ser actualizados para nuevos dispositivos que salen al mercado y nuestras herramientas empiezan a ser más complejas de usar y menos intuitivas. Poco a poco y con nuestra experiencia anterior en sistemas como UAProf, empezamos a cambiar nuestra forma de pensar para ser más ágiles y que nuestras herramientas resulten naturales.

El mercado cambia de dispositivos muy rápido y las propiedades de estos dispositivos, aunque estables, cambian de valor bastante a menudo. Por ejemplo, Nokia decide con frecuencia el cambio de tamaño de pantalla en su Serie 40, el cambio de memoria de HEAP y de RMS. Si esto lo llevamos al número de marcas del mercado de móviles, nos obliga a actualizar nuestra base de datos de dispositivos con demasiada frecuencia y no disponemos de tiempo y recursos infinitos.

Nuestra problemática nos lleva a pensar en la comunidad de desarrolladores y en las decisiones que está tomado al respecto y nos encontramos que hay comunidades orientadas a J2ME como J2ME Polish que han creado una base de datos de dispositivos J2ME especialmente diseñada para conocer las diferencias entre los diferentes dispositivos; también nos encontramos otras comunidades, como la de los desarrolladores de WAP que llevan más tiempo luchando con esta problemática y que basándose en sistemas como UAProf , han creado bases de datos orientadas a capacidades, por ejemplo WURFL .

Esto nos lleva a pensar como ya lo hacíamos antiguamente con los problemas de WAP, ya que al final nuestro objetivo es el mismo, presentar contenidos en un dispositivo móvil: PIENSA EN CAPACIDADES.

Usar capacidades consiste en no saber de marcas, modelos y cosas así, sino más bien en tamaños de pantallas, formatos de audio y vídeo, características J2ME, memoria disponible, etc. De esta manera creamos el concepto de perfil, que al final no es más que agrupar una serie de capacidades.

Ahora por fin, nuestros contenidos pueden ser manejados de manera independiente de la base de datos de dispositivos. Nuestra base de datos crecerá y nuestros contenidos se ajustarán a dichos dispositivos según sus capacidades.

Por ejemplo, si creo un perfil que sea “Medio-Bajo” donde apunto que las pantallas van desde 128x128 a 128x160, que soporto PNG como formato de imágenes, que mi HEAP máximo de memoria es de 500 KB, que mi JAR máximo es de 125 KB y que soporto MIDI como formato de audio, es seguro que un grupo de dispositivos de diferentes marcas coincidirá con estas características ahora y dentro de un año.

Nuestra manera de afrontar la problemática de la fragmentación de los teléfonos móviles es pensar en perfiles y capacidades. El objetivo del desarrollo hacia dispositivos no se puede mantener en pequeñas y medianas empresas y tendrá que ser abolido en las grandes compañías en cuanto decidan ahorrar costes de producción.

Etiquetas: ,


05 abril 2006

Integración continua y gestión de la configuración

Como decíamos "ayer", una de las tareas propias de las metodologías ágiles es la llamada "integración continua".
Esta práctica consiste en llevar al límite el proceso de construcción automática y diaria. Si conseguimos automatizar este proceso ¿porqué no lanzarlo cada vez que hagamos algún cambio, por pequeño que sea?
Pues precisamente esa es la clave de la integración continua, pero como es lógico, no todo es tan fácil como puede parecer a simple vista.

El primer paso para la integración continua es, como ya hemos dicho, automatizar el proceso de construcción. Para ello nos basamos en herramientas como Ant, Maven, el antiguo MAKE, Jam, etc., que nos permiten ir lanzando distintas tareas de forma secuencial y sin nuestra intervención.
Una vez que hemos logrado ejecutar todos los pasos necesarios, tenemos que conseguir que ese proceso se lance automaticamente, cada vez que algún cambio de código se integra en el repositorio. Lo podemos conseguir facilmente gracias a un montón de herramientas para ello, que nos ayudan a programar las construcciones, aunque también podríamos habilitar una máquina dedicada y conseguir que todo el equipo se comprometa a lanzar una compilación después registrar cada cambio. Ummmm, creo que va a ser mejor instalarse alguna herramienta ¿no?
Empresas que manejan proyectos muy grandes dan a este aspecto una importancia vital. Por ejemplo: Microsoft, en su equipo de desarrollo de Windows, tiene todo un laboratorio de construcciones diarias: un montón de servidores y personas responsables de que la compilación y las pruebas se ejecuten correctamente todos los días.

Bien, el modelo de integración continua, si no se hace con cabeza, puede traernos más problemas que ventajas.
Pongamos el caso en que tenemos un repositorio con nuestro código fuente. Nosotros usamos Subversion, pero valdrían otros como CVS, Source Safe, Perforce, etc. Cada vez que integramos un cambio en el repositorio, existe alguna posibilidad de que el programa deje de compilar (por ejemplo si hemos olvidado subir un archivo nuevo), o que hayamos generado algún bug, así que podemos decir que en ese momento, y hasta que se valide de nuevo, el repositorio está en estado inestable. Si hacemos que se lance una construcción cada vez que integramos algo en el repositorio, muchas de esas construcciones fallarán. Por ejemplo: todas las tardes, antes de irnos a casa, registramos nuestro trabajo, aunque no esté terminado, y muchas veces la construcción resultante no es válida. Pensad que esto lo hacemos todos los desarrolladores, así que a la mañana siguiente tenemos el repositorio lleno de bugs y en un estado caótico, y si ese mismo día necesitásemos entregar una versión, estaremos en apuros.

A continuación podéis ver el diagrama que representa esta situación:


Cada flecha es un cambio hecho en el repositorio, y como véis, algunos cambios desestabilizan el producto, bien introduciendo bugs o errores de compilación.

Para conseguir que la integración continua tenga su efecto beneficioso, tenemos que organizar el desarrollo en distintas ramas, o branches.
Para este modelo de gestión de la configuración tenemos varias opciones, aunque las más habituales son las siguientes:

Cada desarrollador tiene su propia rama de código, donde trabaja a diario, hace sus cambios, registra código, etc. Esa rama es privada, y podrá hacer lo que quiera con ella y mantenerla en cualquier estado. Lo habitual es que esa rama esté muy inestable al comenzar con una nueva tarea, y vaya ganando estabilidad conforme avance en el desarrollo.
En el momento en que el desarrollador termina con su trabajo, se compila una versión de esa rama y se pasa a pruebas. El departamente de pruebas validará la funcionalidad sobre la que ha estado trabajando el desarrollador, se reportarán los bugs oportunos, y cuando se de por correcta, se etiquetará esa rama y se integrará en el repositorio principal. En ese momento se lanza una construcción del producto de la rama principal, y se vuelve a pasar a QA el producto ya integrado, para validar que la integración ha sido correcta.
En este caso, hemos pasado a tener una funcionalidad más, reduciendo al máximo los tiempos de inestabilidad de la rama principal. Una vez que la rama principal se da por buena desde el departamento de QA, se etiqueta y se continua con la siguiente funcionalidad.
Podemos verlo representado aquí, y fijaros que la rama principal tiene muchas menos zonas en rojo:


Existe todavía otro modelo, muy parecido al anterior, y que consiste en tener una rama de desarrollo para cada nueva funcionalidad. El esquema es el mismo que hemos visto, donde los desarrolladores que trabajan en una misma funcionalidad lo hacen sobre una rama separada. La diferencia es que cuando la funcionalidad se da por terminada, se integra en la rama principal y esa rama queda muerta, teniendo que crear otra nueva para la siguientes funcionalidad.

Bien, como véis, es tema no es sencillo de gestionar, y requiere algo de infraestructura de por medio.
Yo os recomendaría que, al igual que se automatiza el proceso de construcción, intentéis hacer lo más automático posible la gestión de la configuración, teniendo scripts para la creación de ramas para desarrolladores, para funcionalidades, de integración en el principal etc.

Pero... ¿donde queda la integración continua en este jaleo de ramas? Pues en la rama principal, que es donde se registrarán los cambios definitivos y estables. No tiene sentido que intentemos compilar el producto cada vez que se cambie algo en una rama secundaria, ya que habrá muchos momento de inestabilidad. Así que cada vez que una tarea es dada por buena, se integrará en el repositorio principal y se construirá el producto final.

Y ya para poner la guinda al pastel, puedes poner un "ambient orb" en la oficina, para que todo el mundo vea el estado de la rama principal.

Automated Continuous Integration and the Ambient Orb
Using an Ambient Orb to show continuous integration build status
The Build Indicator Lamp

Nosotros no llegamos tan lejos, ¿y tú?

Etiquetas: ,


30 marzo 2006

El proceso de construcción

Hace ya varios años, leí un artículo en Joel on Software que hablaba de las compilaciones diarias. En aquellos tiempos me sonó a chino, cuando pensaba que la compilación de un programa no era más que seleccionar la opción "Project - Build" de mi IDE.
Sin embargo, con el tiempo me he ido dando cuenta de que no tiene nada que ver la "compilación del programa" con la "construcción del producto", aunque los dos deberían hacerse con un único paso.
Compilar un programa no es más que transformar código fuente en código ejecutable, y eso es un trabajo repetitivo y mecánico (aunque bastante complejo) resuelto por el compilador, que para eso se inventó.
Sin embargo, contruir un producto supone mucho más. Por ejemplo, en nuestro caso, para construir El Cuarto Sello tenemos las siguientes tareas:
  1. Compilar el motor abstracto de Battlewizard.
  2. Compilar la implementación específica para el móvil que queremos utilizar: MIDP 2.0, nokia, etc. (Por cierto, tenemos pendiente hablar en detalle de Battlewizard y de su arquitectura).
  3. Incrementar la versión actual y crear el archivo de manifest
  4. Empaquetar todo eso en un archivo JAR.
  5. Compilar el código fuente del juego, utilizando los recursos (gráficos, sonido, cadenas de textos, etc) específicos para el dispositivo e idiomas destino.
  6. Lanzar las pruebas unitarias de todo el código (con JUnit y J2MEUnit)
  7. Ofuscar todo (con ProGuard o RetroGuard, dependiendo del caso).
  8. Optimizar y comprimir el bytecode (con librerías específicas para ello)
  9. Crear el archivo JAD, indicando el tamaño del archivo JAR, nombre del MIDlet, etc.
Casi nada.
Por otro lado tenemos la construcción de Battlewizard, que tiene sus propios pasos, bastante distintos, sobre todo porque Battlewizard tiene una aplicación de escritorio con su propio instalador, generación del archivo ejecutable, etc.
No sé si me dejo algo, pero más o menos nos hacemos a la idea.

Todos estos pasos que hemos descrito forman el proceso de construcción de nuestro producto, sin embargo, nos falta algo importante: automatizarlo. Pues sí, la gracia de todo esto está en que el proceso de construcción sea:
¿Y porqué todo esto? Pues muy sencillo: porque cuando más automaticemos nuestro proceso de construcción, más preparados estaremos para sacar nuevas versiones, en un solo paso, y asegurándonos que son realmente nuevas, y no "medio nuevas".

Otro beneficio es que, construyendo completamente el producto y de forma periodica, conseguimos detectar código erróneo muy pronto. Supongamos que una de nuestras librerías lleva sin modificarse meses, y cuando vamos a compilarla y lanzar sus pruebas unitarias, falla por todos los lados. Si todos los días o semanas hubieramos compilado y probado esa librería (junto con el resto del producto), ese error lo habríamos detectado muy pronto, pocas horas o días después de que alguien lo hubiera cometido, y sería mucho más sencillo corregirlo.

Y por último, haciendo construcciones automáticas conseguimos que cualquier persona, incluso aunque sólo lleve unos días en el equipo, sea capaz de generar el producto. El proceso ya se encargará de obtener los ficheros de donde sea, de hacer las copias necesarias, modificar nosequé librerías, etc. pero de cara al usuario, todo se hace en un sencillo paso.

Bueno, mañana hablaremos de la famosa "integración continua" que recomiendan las metodologías ágiles como eXtreme Programming.

Mientras tanto, podéis leer más sobre el tema en estos artículos que no tienen desperdicio:

Etiquetas:


24 marzo 2006

El tamaño no importa

Esta semana nos ha tocado ir de conferencias: el martes en los Tech Days de Sun y ayer en la presentación de un nuevo producto para la gestión de la configuración.
El caso es que, mientras los distintos ponentes contaban sus historias, presentaban sus productos y demás, yo me iba dando cuenta de lo difícil y distinto que es programar juegos para móviles. Que si bases de datos relacionales, que si frameworks de mapeado R/O, arquitecturas basadas en servicios web, AJAX, OpenGL... y mientras tanto nosotros pegándonos con los desplazamientos de bits, o haciendo malabarismos para evitar esos dichosos arrays de 3 dimensiones que hacen que el heap explote.
Y es que, como bien decía Joel, aunque todos los programadores nos dediquemos a programar, los mundos en los que nos movemos son radicalmente distintos.

Os voy a contar un caso nuestro, que ya ha comentado Jaime por encima: nuestros juegos son bastante grandes, sobre todo teniendo en cuenta las capacidades de algunos móviles que soportamos. Por poneros en situación, El Cuarto Sello tiene 12 niveles y 9 tipos distintos de enemigos. Esto lo pone al nivel de muchos juegos de PC, pero metido en un móvil con 500 KB de memoria. Esto nos obliga a exprimir al máximo la memoria del teléfono, y como decía Jaime, hay muchas cosas que están en el heap cuando no estaba previsto que estuvieran.

Si te dedicas a programar aplicaciones de escritorio o servidor, seguramente no te habrás parado a pensar si estás desperdiciando espacio en la memoria. Te bastará con que no haya memory leaks y que el consumo de memoria no se dispare, pero da un poco igual si es posible ahorrar algunos KB, o si tenemos más cosas en el heap de las estrictamente necesarias.
Sin embargo, en nuestro caso sí que importa, y mucho.

Una de las cosas que teníamos en memoria y nos estorbaba eran las instrucciones ejecutables (bytecodes) de algunos métodos. Tenemos mucho código de preproceso, que se encarga de crear imágenes en memoria, leer datos de disco, ordenar listas, descomprimir datos, etc. y todo ese código sólo se ejecuta una vez, en el arranque del juego, por lo que nos lo queríamos quitar de encima una vez que se había ejecutado.
Pero... ¿cómo? Java (y mucho menos J2ME) no ofrece mecanismos para descargar de memoria cierta parte del código... bueno, no hay mecanismos directos, aunque no está todo perdido.

La solución que usamos pasaba por juntar todo ese código "de usar y tirar" en una única clase. Cuando se crea la primera instancia de esa clase, se meterá en el heap todos los bytecodes, y cuando se libere el último objeto de esa clase (y el recolector de basura entre en acción) todos esos bytecodes desaparecerán del heap. Sencillo, y lo mejor de todo es que funciona. Sacando gráficas de consumo de memoria de la aplicación (como la imagen de más arriba), se puede ver un par de descensos bruscos en el consumo de memoria. Se trata del momento justo en el que liberamos la última instancia de la clase de carga y forzamos la llamada al recolector.

Y es que, como se suele decir, el tamaño no importa, ¡¡excepto si programas juegos para móviles!!

Etiquetas: ,


23 marzo 2006

Circulo vicioso

Una vez más el problema de la memoria del HEAP y del tamaño del paquete JAR (J2ME) con los recursos. Uno de los mayores problema que tenemos cada día con los teléfonos móviles más pequeños es que no nos vale comprimir al máximo los archivos que se instalan, porque aunque eliminemos la problemática del límite de tamaño de instalación, nos chocamos con el límite de memoria RAM (heap) disponible.

El verdadero problema con la memoria en los teléfonos móviles es que nunca dispones de lo que esperas. Te dicen que tienes n KB para usar de heap, pero nunca cuentas con que tus imágenes comprimidas (PNG…) se tienen que descomprimir y ocupan como un bitmap, que tu archivo JAR se descomprime también, que tus clases java se tienen que cargar en memoria y claro, cuando ejecutas, te comes mucha más memoria de la esperada.

Al final, la solución es cuestión de equilibrio. Si bajas el tamaño del paquete JAR comprimiendo al máximo, y no controlas el contenido, al descomprimirse te encontrarás con una limitación de HEAP. Lo mejor es pensarlo desde el principio, con todos los recursos y el orden en que los vas a manejar en memoria y a destruirlos.

Voy a enumerar una serie de reglas, creo que importantes, que usamos a la hora de evaluar el HEAP que estamos usando con los recursos y que nos están dando buenos resultados:

1 – Nunca pienses en el tope de memoria de HEAP especificado por el fabricante. Siempre tendrás menos en el móvil, ya sea por bugs del firmware o por usos internos de la implementación del fabricante.


2 – Tus imágenes preparadas para pintar ocuparán en memoria siempre la formula:

Imagen (KB) = (ANCHO (pixels) x ALTO (pixels) x COLORES (bytes)) / 1024

Para una imagen de 64 x 64 en una pantalla de 65.535 colores (16 bits = 2 bytes) tendremos = (64 x 64 x 2) / 1024 = 8 KB de HEAP.

Intenta optimizar los tamaños siempre que puedas de cara a tu memoria de HEAP y el número de colores de cara al tamaño de tu archivo JAR.


3 – El código de tus clases podrían tener que vivir en el HEAP. Recuerda que el uso de una clase necesita de su bytecode en algún sitio, y ese sitio seguramente sea tu querido HEAP. Piensa que las clases descomprimidas irán usando el HEAP cuando las vayas usando. Una buena solución puede ser tener una clase con métodos de un solo uso como cargas y preparaciones, y cuando se finalice de usar, poner todos sus objetos a null para que, en algunos móviles, te saque su código del HEAP por no estar en uso.


4 – Si crees que tu archivo JAR no puede descomprimirse en tu HEAP, estás muy equivocado. Algunos móviles descomprimirán tu archivo JAR en tu HEAP y si has comprimido a tope, te encontrarás con poco HEAP disponible. Intenta equilibrar el contenido de tu JAR con el HEAP que necesitas. Si no lo equilibras, entrarás en el círculo vicioso entre HEAP y JAR. Otra opción es implementarte un pequeño descompresor para tus recursos (no clases, ni imágenes o sonidos comprimidos) que permita mantenerlos comprimidos. Equilibrar es básico.


5 – La mayoría de los recursos y clases tienen cabeceras que ocupan espacio de HEAP y de JAR. Cuantos menos archivos de clases y recursos tengas, menos espacio ocuparás. Cuidado con meter todo en una clase o una imagen, cuando los uses podrá desbordar tu HEAP si son muy grandes. Equilibra el número de clases y recursos con su uso en memoria. No es fácil porque hay que analizar la lógica de tu juego para hacer una correcta división, pero te facilitará entrar en móviles pequeños.


6 – Adapta la disposición de tus gráficos dentro de las imágenes. No ocupa lo mismo en memoria una imagen más vertical que horizontal o cuadrada. Desde hace mucho tiempo se sabe que la forma de crear las imágenes con tus gráficos puede consumir más o menos memoria de HEAP. A veces, poner en vertical los frames de tus sprites puede que mejoren tu uso de memoria. Experimenta hasta encontrar la mejor combinación y únelo a tu equilibrio entre el número las imágenes de recursos.


7 – Usa herramientas de optimización de imágenes como PNGOUT, herramientas de optimización de archivos JAR como JARG (Java Archive Grinder) o KZIP. Con esto conseguirás mejorar el tamaño de tu archivo JAR, pero recuerda equilibrarlo con tu espacio de HEAP. El uso de ofuscadores es obligatorio tanto para reducir el tamaño del JAR como el espacio ocupado por el Bytecode en el HEAP. Algunos ofuscadores optimizan más que otros, pero también algunos móviles no aceptan bien grandes clases con ciertos tipos de ofuscado, usa el ofuscador más adecuado en cada caso si puedes.


8 – La precarga de imágenes y sonidos puede acelerar la ejecución de tus juegos, pero también puede limitar el tamaño de tu lógica dentro del HEAP. Equilibra tus recursos cacheados en memoria con la lógica de tu juego. Aunque no todos los recursos estén cacheados, puedes hacer algunos efectos durante el juego para que el jugador no se de cuenta de los momentos de carga y preparación. Carga y descarga recursos en memoria de HEAP y usa trucos durante el juego para que el jugador no se de cuenta. Cargar desde el archivo JAR es lento y tener las imágenes preparadas para pintar es caro de cara al HEAP; una buena idea consiste en tener algunos archivos de imágenes (PNG, …) en arrays en memoria como si tuvieras una cache y cuando los necesites, prepararlos como imagen bitmap y pintarlos. Esto es mucho más rápido que ir directamente al jar a buscarlos y son recursos que ocupan poco en el HEAP al estar comprimidos en su formato original (PNG, …). Lo mismo puedes hacer con algunos recursos de audio.


9 – Tu teléfono dispone de una memoria persistente y en caso de J2ME puedes grabar datos en sus Record Store. En algunos casos, si tus recursos y lógica no caben por la limitación de archivo JAR, puedes intentar meter la lógica en el JAR y que al iniciar el juego, el propio juego se descargue los recursos que le falten y los guarde en Record Store. Usamos teléfonos móviles y se pueden conectar a la red, debemos usar estas capacidades para mejorar nuestros juegos. Poco a poco los jugadores irán asimilando que las aplicaciones móviles necesitan conectarse a la red para actualizarse. La creación y acceso a varios Record Store puede ser lenta, pero el acceso y grabación de registros de un Record Store es bastante rápida. Organiza tus contenidos de tal manera que puedas leerlos sin que el usuario note retrasos durante el juego. Podrás crear juegos bastante impactantes en teléfonos limitados. Recuerda que también hay límites para los Record Store de una MIDlet.


10 – Equilibrio y diseño. Todo es cuestión de equilibrio y depende de cómo diseñemos nuestro videojuego. Si somos capaces de diseñarlo basándonos en el equilibrio entre JAR y HEAP, conseguiremos meter una gran cantidad de contenidos y crearemos pantallas y niveles muy completos para el jugador. Cuando vayas a hacer un videojuego para el móvil, piensa siempre en este equilibrio para evitarte dolores de cabeza posteriores. Esta regla también vale para otras plataformas porque al final a más capacidad, más contenidos metemos y siempre necesitamos un equilibrio.

Etiquetas: ,


17 marzo 2006

Aquí empezamos la casa por el tejado

...y estamos orgullosos!!

Cómo no...empezaré por el principio, creo que era mi segundo día cuando JM comenzó a explicarme nuestra metodología, empezando por XP llegamos a las pruebas unitarias..

eh??? ¿qué son las pruebas unitarias? (uff que vergüenza reconocer que no las conocía).

A pesar de que es una práctica altamente recomendable y condición sine qua non con el software de calidad, por las empresas por las que he pasado no conocíamos ni el termino.
Después de explicarme su sentido(a grosso modo "las pruebas unitarias prueban que cada modulo de código funcione correctamente por separado", lo vi todo clarísimo (os recomiendo leerlos el artículo de Jm sobre este tema), a partir de ahora siempre usaría pruebas unitarias, hasta que JM siguió explicando y de nuevo consiguió darle la vuelta a mi "claridad"...
ahora decía que hiciera las pruebas unitarias antes que el código!!!,

Pero éste está loco!!! ¿qué empiece la casa por el tejado?..."sí hombre y ahora me dirá que primero programe y luego diseñe" :).


Quería que probase métodos que no existían, clases que no existían...en fin loco!! jejeje, puede parecer una locura pero tiene mucho sentido, esta técnica se conoce como TDD(Test Driven Development), si haces las pruebas primero te estás anticipando a posibles fallos, las pruebas te harán modelar tu diseño de la clase, del método, tendrás una visión muy clara del comportamiento que esperas que tenga un método, clase, etc..
si queréis más información sobre esto nos perdáis el articulo completo de JM.

Etiquetas: ,


This page is powered by Blogger. Isn't yours?