Posts Tagged ‘Programación’

Notación Húngara: contrapost

¿A quién no le gusta una buena polémica?

Polémica Tuitera

Esta semana en Twitter Sendoa Portuondo planteó una conversación bastante interesante sobre si era conveniente (o estaba de moda) usar prefijos en las variables de nuestros programas Objective-C. Mi respuesta fue que, a veces los usaba. Especialmente uso los prefijos para los IBOutlets, de forma que puedo completar el código rápidamente (o encontrar un Outlet sin tener que hacer un viaje al@interface correspondiente.

Fernando Rodríguez (Cocoa Mental, Big Nerd Ranch, super Bad-Ass Master of the Universe) argumentaba totalmente en contra y ha escrito un artículo en Cocoa Mental al respecto. Normalmente estoy de acuerdo con las cosas que publica Fernando, más que nada porque voy al blog a leer para aprender y puedo aportar poco. Pero en este tema concreto (el uso o no de prefijos para identificar qué es una variable), no estoy de acuerdo.

Sus argumentos, que he visto esgrimidos en muchos sitios, se basan en la horrenda interpretación que se hizo de la Notación Húngara propuesta por Charles Simonyi. Nadie lo explica mejor que Joel Spolsky en el artículo Doing it wrong, pero por si no tenéis ganas de leerlo (mal!, dejad en este momento todo esto y leed el blog de Joel de cabo a rabo), voy a intentar explicarlo.

Notación Húngara

Si lees el paper original de Simonyi, encontrarás que la idea que presenta es: “pongamos el qué es de una variable en el prefijo, de forma que sepamos de qué estamos hablando al usarlo luego”. Probablemente por no ser el Inglés su lengua materna Simonyi usó la palabra type. Pero no se refiere al tipo que el compilador asigna a una variable, sino a su forma, características, esencia, chi o como lo llames. Su Kind. En un párrafo hablando de cómo prefijar cantidades (índices, filas, etc.) podemos leer:

Quantities are named by their type possibly followed by a qualifier. A convenient (and legal) punctuation is recommended to separate the type and qualifier part of a name. (In C, we use a capital initial for the qualifier as in rowFirst: row is the type; First is the qualifier.)

Si os fijáis atentamente, para dar nombre aquí a una variable que representa una fila, la llama *row_First, y no longFirst o intFirst. Es decir, usa _qué_ es esa variable y no el _tipo_ de nuestro lenguaje elegido para representar a ese elemento. Los grandes detractores de la notación húngara han visto código escritos por otros que no la han entendido y que les obligaban a hacer tonterías como:

int *ptrFirstNumber;        // ¡ya sabemos que el tipo es un puntero a int!
char *strName;              // con leer la declaración, basta...
NSString stringAddress;     // esto es de nota

Apple Will Never Do That

Por cierto y como nota inocente. Dado que esto lo extendió Microsoft y dado que Apple nunca se equivoca, Cocoa es elegante, etc. etc. en Cocoa no encontraremos nunca esta horrible notación, ¿no?. Bueno, no esta, sino notación húngara a la inversa (HungarianNotation^-1): usando sufijos en los tipos. Por ejemplo estas cositas:

AboutViewController *vc;    // ¡ejem! Ya sabemos que vc es de tipo "Pantalla About". 

¿Pero realmente es necesario poner “ViewController” al final de un tipo que extiende de UIViewController? Ya puesto así, que se llame AboutViewControllerUIResponderNSObject, y vemos todas las clases de las que hereda, ¿no?. ¡Error!.

Aquí Apple está marcando en el nombre de la clase qué es, y no su tipo. Para Apple, un ViewController es una pantalla en un programa iOS. Fijáos que el sufijo no es UIViewController, que sería el tipo. Además, sólo leyendo AboutViewController no sabes si es un UIViewController, un UITableViewController, … lo que sí entiendes es que es una pantalla.

Hungarian Notation at its best!

Un ejemplo, que me duermo

Quiero cerrar con un pequeño ejemplo. Supongamos que tenemos una clase que nos devuelve Usuarios (de un servicio web o una BD). Es la clase Users. Esta clase dispone de dos métodos:

+ (NSDictionary *)allUsers;
+ (NSDictionary *)allUsersOrderedByName;

Los nombres de los métodos son autoexplicativos. Usamos un diccionario en el que buscaremos usando una clave (en este caso, el nº de usuario).

Si en mi código, más adelante, quiero guardar estos dos diccionarios (uno está ordenado por los valores de sus claves, que ya que estamos es la forma de ordenar un diccionario, el otro no) podría usar Hungarian Notation Dark Side Style, la criticada por Fernando:

NSDictionary *dictionaryAllUsers = [Users allUsers];
NSDictionary *dictionaryAllUsersOrdered = [Users allUsersOrderedByName];

Aquí, el ver que son un NSDictionary no me aporta nada. Es una tontería redundante poner estos prefijos. Mucho mejor usando Hungarian Notation Luke Style:

NSDictionary *listUsers;
NSDictionary *orderedListUsers;

Aquí usamos qué es para nosotros estas variables, qué representan en el flujo del programa. Son listas de usuarios. Que utilizaremos para mostrar en pantalla, buscar o lo que sea. Me da igual su tipo. Pueden ser NSDictionary, NSArray, un tipo propio, un B-Tree… Lo que me interesa es comprender de un vistazo que a) son listas y b) una de ellas viene ordenada.

Conclusión

Así que, sí, estoy de acuerdo con Fernando en que poner el tipo del compilador al identificador de una variable es una chorrada. Pero eso no es Notación Húngara. Es la mala interpretación que se hizo de ella. La Notación Húngara tal y como se definió es valiosa.

Vale, pero al final, ¿tú lo usas?

Pues creo que sí. Pero no de una manera consciente. Este tipo de discusiones, que algunos obsesionados por “hacer que funcione” verán como una pérdida de tiempo son las que nos permiten aprender y entender por qué hacemos las cosas como las hacemos. Es lo que nos hace Informáticos. Que no Ingenieros. Los Ingenieros no entenderían esto :-D. Pero esta polémica la dejo para otro post.

Borrar un AVD que se niega a morir

Al intentar borrar un AVD (la configuración de un emulador de Android, conocido como Android Virtual Device) me he encontrado con este mensaje:

AVD no se puede borrar

En este caso, he tenido claro desde el principio cual era el problema sin consultar con StackOverflow. Había lanzado ese AVD antes y se había colgado. Y pensé que seguramente había dejado algún fichero indicando que el emulador estaba en marcha, y por eso ahora al intentar borrarlo pensaba que seguía encendido.

Nada que un poco de Terminal no pueda arreglar. Debemos ir, en una terminal, a la carpeta .android/avd que está dentro de nuestra carpeta $HOME. En mi caso, como mi usuario es dfreniche, la carpeta está en la ruta:

/Users/dfreniche/.android/avd/

Para llegar a ella, usamos a nuestro viejo amigo cd:

cd /Users/dfreniche/.android/avd

Una vez allí, veremos una carpeta por cada AVD que tengamos creado en Eclipse. Si hacemos ls:

Tesla:avd dfreniche$ ls -al
total 24
drwxr-xr-x   8 dfreniche  staff  272 22 ago 12:58 .
drwxr-xr-x  17 dfreniche  staff  578 19 ago 19:41 ..
drwxr-xr-x  12 dfreniche  staff  408 22 ago 12:58 Intel.avd
-rw-r--r--   1 dfreniche  staff  114 22 ago 12:58 Intel.ini
drwxr-xr-x  11 dfreniche  staff  374 20 ago 06:48 Nexus4.avd
-rw-r--r--   1 dfreniche  staff  116 19 ago 19:32 Nexus4.ini
drwxr-xr-x  10 dfreniche  staff  340 22 ago 11:22 Nexus4_API4.3.avd
-rw-r--r--   1 dfreniche  staff  130 20 ago 06:47 Nexus4_API4.3.ini

Podemos ver que los terminados en .avd son carpetas (en los atributos empiezan con una d de directory) mientras que los .ini son ficheros normales.

Si entramos en el AVD problemático (en este caso, Intel.avd) con un cd Intel.avd y hacemos ls veremos unos cuantos ficheros sospechosos acabados en .lock.

Tesla:Intel.avd dfreniche$ ls
cache.img       hardware-qemu.ini.lock  userdata-qemu.img.lock
cache.img.lock  sdcard.img      userdata.img
config.ini      sdcard.img.lock
hardware-qemu.ini   userdata-qemu.img

Con borrar estos ficheros, basta: rm *.lock

Tras esto, Eclipse nos dejará borrar tranquilamente el AVD desde su interfaz:

AVD arreglado para ser borrado

AVD arreglado para ser borrado

La NSSpain

NSSpain logo

La NSSpain es una conferencia dirigida a programadores Cocoa, tanto iOS como Mac. Al final, todo lo que empieza por NS* viene a ser un aviso del estilo de esto va de programar con el lenguaje ese raro de los corchetes. Por cierto, la insistencia en el prefijo NS (como las NSCoder Night) viene del S.O. NextStep donde se gestó el framework Cocoa y donde estuvo mantenido en crio sueño hasta su popularización, primero en el mundo Mac y luego definitivamente gracias al iPhone.

La NSSpain va a tener lugar en Logroño (La Rioja – España), aunque es una conferencia internacional. Viene gente de diferentes países y los ponentes son nacionales (los menos) y muchos extranjeros. La lista de ponentes es excepcional (dado que yo soy la excepción que confirma la regla) y van maestros como Fernando Rodríguez, de AGBO (el gran Jedi Master Cocoa) o Alfonso Alba (mi maestro Git, que me hizo abrir los ojos y cuyo curso de Git no deberías perderte si en 12 h quieres enterarte al fin de qué va Git). Por el precio que tiene la NSSpain es un regalo, viendo la gente que viene.

Se desarrolla íntegra en Inglés (por aquello de que es internacional).

<English-fear-rant>

Acabo de sentir una conmoción en la parte cateta de la fuerza “¡oh, Dios, mi Inglés no es lo suficientemente bueno para enterarme de las ponencias! Es más, todos se van a dar cuenta y se van reír de mi. Me sacarán al escenario desnudo a leer trabalenguas, y finalmente vendrá Godzilla y me arrancará la cabeza”. Vamos a ver, que se va a estar hablando de punteros, bucles, bloques, objetos… que nadie se va a poner a declamar a Shakespeare. Que con un vocabulario mínimo puedes perfectamente seguir una de estas charlas. Hay que perderle definitivamente el miedo al Inglés: es el primer lenguaje que debes aprender si quieres programar.

</English-fear-rant>

Así que este Septiembre nos veremos allí (del 16 al 19). Yo acudo como ponente (tras varios intercambios de correo, logré engañarles y hacerles creer que podía impartir una charla con cierto criterio; ahora lo malo es que hay que impartirla). En mi caso, voy a actuar dos veces: el día previo a la conferencia, con un taller de Core Data fundamentos, para explicar lo necesario (y algo más) para funcionar con Core Data. El primer día de la conferencia, vuelvo hablando de Core Data con algunos trucos avanzados, librerías y utilidades que suelo usar para mis proyectos.

Y claro, como en toda conferencia, además de los ponentes lo mejor suele ser la gente, la comunidad Cocoa. Gente que conozco físicamente o sólo por Twitter, pero que aprecio y respeto, de la que siempre aprendes y con la que quieres estar. No me voy a poner a nombrarlos uno a uno, porque sería una pesadez y de todas formas les voy a ver allí.

Lo que me lleva al último punto: que nunca he estado en Logroño. Así que este viaje me va a permitir ver algo (supongo que no mucho, que yo se cómo son estas cosas luego) pero al menos darme un paseo por la ciudad y tomarme un café en el centro, que es lo que me gusta.

Ya sabes: Logroño está cerca de todos lados (al menos, más cerca que Cupertino para muchos), el precio es de risa comparado con lo que vas a aprender, conocerás a gente alucinante y te lo pasarás pipa con personas que te entienden cuando les hablas excitado de programación. No como tu pareja, que te escucha y asiente, pero que realmente no sabe de qué le hablas.

Nos vemos en la NSSpain.

Volver a empezar

No, no me refiero al hecho de que dijera que tenía que escribir más y leer menos, y luego no he escrito desde hace meses. Me refiero a que tengo que volver a empezar a programar, después de tres semanas largas de vacaciones totalmente desconectado de un teclado. Y me cuesta.

Programar es como cualquier otro trabajo / afición. Es igual que correr, o escribir en tu blog (si lo haces, claro, no como yo ahora) y supongo que será como tocar un instrumento. Cuanto más practiques, mejor sabes hacerlo. Y más sencillo te resulta, con lo que tienes más ganas de volver a ello. Y practicas otro montón. Se crea ese círculo virtuoso que habrá sentido todo el que, tras tres semanas de correr de forma regular, siente la adicción a las endorfinas. Por cierto, que esa es otra cosa que tengo que volver a empezar a hacer…

Recientemente he leído varios artículos sobre cómo aprender a hacer cosas mucho más rápido. Todos estos artículos tienen una idea común: practica mucho, “comprime” en el mínimo tiempo posible la práctica de un año de formación normal y obtendrás los resultados de un año de experiencia. Siempre he sido reacio a esta idea, y he pensado que aprender las cosas lleva su tiempo. Pero, ¿y si estoy equivocado, y con una forma distinta de ver las cosas puedo aprender un lenguaje nuevo de programación, tocar un instrumento, correr mejor o aprender un idioma más rápido? Este verano, voy a hacer algunos experimentos sobre la forma en que hasta ahora he tratado de aprender las cosas. A ver cómo me va.

Y eso me devuelve a la idea inicial: que tengo que ponerme de nuevo a programar. Pese a lo que puedan pensar los que quieren aprender a programar, a todos nos cuesta, a los que empiezan o a los que llevamos algo más de tiempo. Siempre cuesta empezar. Lo bueno, es que como dijo Pitágoras de Samos, “el principio es la mitad del todo”.

¡Así que, menos llorar, y más programar! (Empecemos procastrinando viendo vídeos de la WWDC 2013, cuando vuelva a estar operativo el portal de Apple para Desarrolladores, claro :-) )

Acelera el emulador de Android

Creando un AVD con CPU Intel seleccionada

“El Emulador de Android es lento”. Mucho. Es una de las quejas recurrentes que tenemos los que tenemos que desarrollar para Android, bien sea por afición, devoción u obligación. Comparado con el simulador de iOS, el Emulador de Android es una tortuga. Pero claro, la comparación no es justa: Android emula un teléfono completo, con su CPU, GPU, memoria, tarjeta SD, etc. Está ejecutando código real que podríamos instalar en un teléfono, compilado para una CPU de una arquitectura que no tenemos en el escritorio (como es ARM p.ej.). El simulador de iOS crea un ejecutable x86 que “simula” comportarse dentro de un teléfono, pero realmente es un programa de Mac “travesti”. La fidelidad no es la misma.

Por eso, en teoría el desarrollo con el Emulador de Android debe ser más sencillo, al tener una mejor herramienta con la que probar. Eso, si eres capaz de aguantar el tiempo insoportable que tarda en arrancar. Y si no se desconecta de adb (Android Debugger Bridge) y tienes que reiniciarlo.

HAXM

Para mejorar esto, Intel pone a nuestra disposición HAXM (Hardware Accelerated Execution Manager). Gracias a este programa, instalaremos una capa de aceleración para el Emulador de Android, que realmente se ejecuta en como una máquina virtual qEmu. qEmu es un emulador de CPUs, es decir, nos permite ejecutar en nuestros equipos basados en Intel x86 (como un Core i5 por ejemplo) S.O. que corren en Intel (como Windows, Linux, Mac) o bien otros S.O. que necesitan otras CPUs y arquitecturas (como es el caso de Android con ARM).

HAXM es un driver (o un módulo del kernel en Linux / extensión del kernel en Mac) que concede a qEmu acceso directo al hardware en el que se ejecuta. Eso sí, como es un programa de Intel, sólo funciona con las CPUs Intel. Vamos, que si tu máquina tiene una CPU AMD ya puedes ir cerrando el post. Además, la CPU debe soportar VT-x (las modernas lo soportan, no pruebes con un Pentium II). Puedes consultar los requisitos en la página detallada de Intel sobre cómo instalar HAXM.

Instalación de HAXM

Si estás usando el nuevo ADT Bundle (es decir, el Eclipse + plugin ADT + SDK Android que ha sacado hace poco Google, que ya era hora por cierto) y abres el Android SDK Manager, al final encontrarás un grupo llamado “Extras” en el que está el Intel x86 HAXM Emulator Accelerator. Si estás en Windows / Linux, bájatelo desde aquí. Si estás en OS X Mountain Lion 10.8.2 no te lo bajes desde aquí, debes ir a la página de descargas de HAXM, ya que existe un bug que hará que tu querido Mac se cuelgue. Sí, has leído bien: los Macs también se cuelgan. Cuando te lo bajes, ya sea desde el SDK Manager o a mano (por cierto, en el enlace anterior están las versiones de Linux y Windows de HAXM) debes instalarlo.

En el caso del Mac, bajas un DMG que al montar te muestra un programa de instalación. Tras instalarlo (no exige reiniciar) podemos confirmar que está en funcionamiento escribiendo en una Terminal:

$ kextstat | grep haxm

Debe aparecer algo como esto:

Tesla:~ dfreniche$ kextstat | grep haxm
115  0 0xffffff7f81e29000 0x13000 0x13000  com.intel.kext.intelhaxm (1.0.4)

Si te has bajado el paquete usando el SDK manager, puedes encontrar el programa de instalación en $SDK_HOME/extras/intel/

Uso de HAXM

Una vez instalado HAXM, debemos descargar las imágenes de Android que también nos proporciona Intel. La idea es que en lugar de acelerar un emulador ARM (que sería muy complicado) Intel nos da Android para Intel Atom. De esta manera, cuando qEmu ejecuta instrucciones en el Intel Atom emulado realmente se pasan a nuestra CPU directamente, con la consiguiente mejora en rendimiento.

Estas imágenes aparecen como “Intel x86 Atom System Image” en el SDK Manager. A bajarlas. No las tenemos para todos los API levels, pero sí para los más usados (API 10, 15 y 17 y supongo que en breve sacarán para el 18).

SDK Manager mostrando las imágenes Intel ya instaladas

Ahora tendremos que crear una definición de AVD que utilice esta imagen de Intel. En lugar de un emulador con CPU ARM, vamos a escoger uno con CPU Intel Atom. De cara a nuestros programas da igual, ya que a fin de cuentas se van a ejecutar en la máquina virtual Dalvik. Si vamos a probar código Android nativo (escrito en C con el NDK) entonces lo mejor es leer la documentación de HAXM.

Creando un AVD con CPU Intel seleccionada

Cuando arranquemos nuestro AVD notaremos dos cosas. En la consola debe aparecer un mensaje que indique que “HAX is working” y casi sin darnos cuenta nuestro Emulador estará operativo. Se acabó el arrastrarse. Yo ni marco que arranque de un snapshot porque es tan rápido que no me merece la pena.

Bonus level

Si usas API level 15 ó 17 puedes usar la aceleración de hardware de la GPU, lo que hará que todavía sea más rápido. Avisado quedas de que puede no funcionar (el emulador se vería en negro y tendrías que cerrarlo). Consulta el apartado de aceleración de la GPU de la documentación Emulador para más detalles. Para activarla, marca el checkbox “Use host GPU” en la definición del AVD.

Ultra bonus level

Y si necesitas un emulador de Android “en la nube”, para probar algo o mostrar en una visita a un cliente, y no tienes tu máquina pero te puedes bajar el APK de Dropbox, mira Manymo. Si con esto no te pones palote

BlackBerry Jam en Barcelona

Reunión de cracks

El pasado Jueves 31 de Mayo estuve en la BlackBerry Jam que se celebró en Barcelona. Un evento en el que RIM está mostrando a los desarrolladores de todo el mundo su nueva plataforma, BlackBerry 10. Me invitaron a ir y no pude evitar aparecer. Encima, como bonus a todo un día viendo esta nueva tecnología, a los desarrolladores que nos registrábamos nos entregaban un dispositivo para hacer pruebas, un prototipo. El BlackBerry 10 Alpha Device.

Entre lo poco que dormí la noche anterior, el viaje ida y vuelta desde Sevilla a Barcelona, la alergia y alimentarme casi exclusivamente de azúcar y cafeína (dieta sana) la experiencia fue extenuante, pero muy, muy interesante. En el MWC acudí a las presentaciones del App Planet, que estuvieron bien. Pero aquí pude ver y probar código. Y preguntar cosas. Y eso sube el nivel de adicción de la sesión muchos puntos (al menos para mí).

Estuve con un montón de gente muy interesante. A algunos, como a Serantes, ya lo conocía del EBE. Con Hernán, de Aecomo he trabajado y da gusto tener un jefe que sabe tanto de programar como tú. Pude conocer fugazmente a NeuroFlip. La rabia es que, con el atontamiento que tenía encima no pude hablar con él de lo que de verdad me interesa: los Amiga :-).  Y otro montón de gente como @rallat, @jorgecasar, @ClaraCorretge, Pilar Bernat…

Reunión de cracks

Reunión de cracks

El día comenzó con las típicas charlas para mostrarte lo comprometida que está RIM, y cómo se está volcando con los desarrolladores. Y debo decir que me ha sorprendido mucho su cambio de actitud. Cualquiera que me halla escuchado en los últimos años sabe que no tengo demasiado cariño por BB7. Incluso me mofé de la PlayBook antes de que saliera, llamándola en el evento eTic “PlaySmoke”. No me gusta que se hable de algo que no se puede tocar, y compararlo con un producto que se puede comprar en una tienda me parece ridículo. Toda idea que no se ha llevado a cabo tiene una posibilidad no finita de no hacerse nunca. Y luego estaba la actitud de RIM hacia los desarrolladores: o eras una gran empresa, o eras escoria. Ningún cariño hacia los desarrolladores indies e independientes. ¿Quieres un certificado para subir Apps a su tienda? ¡Paga 20 $ por él!. ¿Lo pierdes?. Pagas otros 20 $. Y el SDK ni te cuento… Muchas barreras puestas a los programadores. La guinda es que encima sólo se podía programar en Java… No demasiado excitante, vamos.

Pero el 2007 lo cambió todo. Y ahora lo importante de una plataforma no es su hardware, ni la marca. Lo importante es lo que las personas pueden hacer con ella. Y para ello, se usan Apps. Luego es algo central en la estrategia de cualquier plataforma el tener a cuantos más desarrolladores de tu parte, en tu ecosistema. Cierto es que todas quieren a los Rovio (Angry Birds) de turno, a los desarrolladores RockStar. Pero también hace falta crear comunidad, y tener a los menos importantes y torpes como yo, porque hacemos preguntas en StackOverflow, o subimos código a GitHub, o usamos la plataforma porque nos gusta y hablamos de ella. Todas las gotas cuentan para llenar un vaso.

Y debo decir que RIM se ha dado cuenta. Y ha creado una plataforma, usando QNX como base, que tiene una pinta increíble, tanto para el usuario como para el programador. Para el usuario, espero que BB10 sea la primera plataforma móvil mainstream que lleve los gestos de webOS o Meego a las masas. La multitarea real de QNX funciona muy bien, y el cambio de tareas mediante gestos (copiado de webOS) hace que sea muy sencillo e intuitivo. Y es algo que engancha, además de ser algo distinto: al final acabas haciendo gestos en el iPad. Al que esté aburrido de iOS o Android y de ver las filas de iconos típicas en la pantalla, BB10 le va a encantar. Luego está el teclado predictivo, que te permite rellenar las palabras según escribes con un swipe del dedo. O las notificaciones, implementadas de manera muy visual y sencilla de usar.

Y para los programadores, BB10 es una maravilla. Es la plataforma para el desarrollador inquieto. Puedes hacer aplicaciones nativas con C/C++. Si quieres construir los interfaces de usuario de manera más rápida, puedes usar Qt y Qml/Cascades, una implementación propia de RIM de Qt. O puedes desarrollar en HTML5 usando WebWorks, el framework HTML5 de BB10. Yo, por ejemplo, he portado las Apps que hice para webOS de manera muy rápida y sencilla. O si vienes de Android puedes empaquetar tu App para BB10 sin tocar una línea de código. Lo que va a permitir que muchas Apps de Android aparezcan en BB10. RIM se ha volcado y ha puesto los diferentes SDKs al alcance de la mano. Ya no te cobra por nada. Y hay montones de ejemplos de código fuente en su repositorio de GitHub.

Pero todo no puede ser de color de rosa, por desgracia. Como programador y geek, la plataforma me atrae y me tiene genuinamente excitado ante las cosas que se pueden hacer. Eso de volver a C++ para el desarrollo nativo, y poder escribir JavaScript dentro de los ficheros Qml que describen las vistas de los programas me encanta. Pero aprender cualquier plataforma supone una inversión. En tiempo, esfuerzo y, lo más importante, en ilusión. El año pasado empecé con webOS y, gracias a mi aura gafe, la plataforma se hundió, por mucho que Enyo siga avanzando como proyecto Software Libre. Ahora RIM dispone de la tecnología adecuada, y la usabilidad correcta. Y puede disponer de aplicaciones para su ecosistema, ya que BB10 va a correr casi cualquier cosa. La pregunta es ¿demasiado tarde?. Los primeros dispositivos BB10 aparecerán en el mercado probablemente para la campaña navideña. Y se van a encontrar con nuevos Android Nexus, creados por Google y Motorola mobile, ahora que ya autorizaron la compra. Y con Windows Phone 8 y las nuevas tabletas con Windows 8. Y, claro, el nuevo iPhone con iOS 6… Va a ser muy duro. Muy, muy complicado. Por eso mismo me gusta. Por lo mismo que sigo usando un Amiga 1200 o intento programar para MorphOS.

Porque me gustan las causas perdidas.

Aquí o consigues triunfar, o te hundes. Sin riesgo no hay gloria. Steve tampoco lo tenía fácil en el 97 cuando volvió a Apple, ¿no?. Nadie daba un duro por Apple. Así que yo voy a usar las plataformas que más me atraigan. Porque esto es cuestión de conocimiento y vocación. Y porque soy gilipollas.

 Actualización 4 de Junio

Otras reacciones a la BBJam que he leído son las de Serantes y Pilar Bernat.  Y en el lado más técnico, las de Android.es y Jorge del Casar.

Cómo crear un entorno de desarrollo Android portable

Logo de Android
Logo de Android

Logo de Android

Algún día me tenía que pasar. Después de ver tanto backend Java en cursos de todos los colores y de coleccionar certificaciones Java, después de desarrollar para iOS y webOS, alguna vez me tenía que poner en serio con Android. De hecho, siempre me han preguntado que por qué no era esta mi plataforma de desarrollo móvil “de cabecera”. Quizás porque estaba saturado de Java. O porque, como comentaba en We.Developers, Java es un lenguaje que no me genera excesivas alegrías (sobre todo cuando lees la mayoría del código que hay por ahí, que es bastante feo, fruto del desconocimiento del lenguaje).

El caso es que estoy actualmente desarrollando una App para Android (de la que daré más datos cuando se suba a Google Play) y me ha surgido la oportunidad de impartir un curso a los programadores de RTVA. Como en todo curso, me gusta instalar el entorno de desarrollo. Y si vas a desarrollar para Android, sabes que tienes que instalarte:

  • un JDK para poder compilar todo el código Java que escribimos como parte de nuestras Apps Android
  • un JRE, necesario para ejecutar Eclipse
  • Eclipse, como IDE para escribir nuestros programas
  • el SDK de Android, que pone a nuestra disposición las bibliotecas necesarias para crear los programas Android, así como el Emulador, herramientas e imágenes para ejecutar ese emulador.
  • el plug-in ADT para Eclipse, que nos permite gestionar el SDK cómodamente desde Eclipse

Este curso se imparte en dos semanas, dejando varios días por medio. Y el tiempo que se tarda en descargar las distintas partes del SDK de Android y el plugin ADT (ambos hay que descargarlos para instalarlos) no es despreciable cuando lo intentamos hacer con 10 portátiles todos conectados a la misma Wifi. Además de la limitación inherente a compartir la conexión HTTP, el medio físico (el canal de radio usado por el punto de acceso WiFi) es el mismo para todos los portátiles. Luego hay colisiones. Y cuantos más portátiles, peor para todos.

En una primera opción, llevaba el JDK, Eclipse y el paquete de instalación del SDK en un pendrive, para irlo instalando todo. Pero de estas dos últimas descargas no me podía librar… ¿o si? Y mi miedo es volver la segunda semana y encontrarme los portátiles formateados…

Cómo crear un entorno de desarrollo Android Portable

En este caso, me centro en cómo crear el entorno portable para Windows 32 bits, que corre en XP y Windows 7. Al final comento las diferencias con Mac.

  • Lo primero es bajar todo lo que necesitamos a una carpeta:
  • Java JDK para Windows es un ejecutable, y escogeremos, de la versión 6, el saber que nos interese: 32 bits (i586) o 64 (x64).
  • De Eclipse nos interesa la última versión de la distribución Eclipse IDE for Java developers. No la versión para Java EE, ya que no vamos a usar servets ni nada de eso. A fecha de escritura de este post, la última versión es la Indigo.
  • La última versión del SDK de Android. Nos bajamos la versión en ZIP, no la instalable.
  • Una vez que tenemos todo esto bajado, debemos instalar el JDK en la máquina. Realmente queremos las carpetas que van dentro, pero al no disponer de un ZIP no tenemos más remedio que instalar. Lo dejará en C:\Archivos de Programa\Java
  • Una vez termine la instalación del JDK, nos crearemos una carpeta en el escritorio que podemos llamar Android-Portable, o como más nos guste.
  • Debemos descomprimir dentro de esta carpeta el ZIP de Eclipse.
  • Ahora, copiaremos la carpeta JRE que está en C:\Archivos de Programa\Java\Jre6\ dentro de la carpeta de Eclipse, justo donde está Elipse.exe. Así, al arrancar Eclipse usará ese JRE que le hemos instalado “tan a mano”
  • Igualmente descomprimiremos el SDK de Android dentro de Android-Portable.
  • Como necesitaremos el JDK para compilar, vamos a copiarnos en Android-portable la carpeta C:\Archivos de programa\Java\jdk1.6.0_31
  • Ahora debemos tener dentro de Android-Portable: una carpeta con Eclipse, otra con el JDK y el SDK de Android.
  • Ya podemos arrancar Eclipse. Necesitamos instalar el plugin ADT, para lo cual iremos a Help > Install Software e instalaremos ADT indicando como repositorio https://dl-ssl.google.com/android/eclipse/
  • Tras reiniciar Eclipse, nos pedirá que instalemos un SDK de Android, o que le indiquemos dónde tenemos uno instalado. Le indicamos que dentro de Android-Portable tenemos uno. Nos muestra el Android SDK Manager para descargar las imágenes de los emuladores para las versiones de Android que nos interesen, así como los SDKs propiamente dichos. Yo me los bajaría todos.
Eclipse nos pide un SDK de Android (click para agrandar)

Eclipse nos pide un SDK de Android (click para agrandar)

  • ¡Listo! Ahora podemos copiar la carpeta Android-Portable y todo lo que necesitamos lo llevamos dentro. Para arrancar Eclipse bastará con entrar en su carpeta y hacer doble click en Eclipse.exe. Si quieres, siempre te puedes crear un acceso directo, pero que sepas que al mover la carpeta tendrás que volver a crearlo.
Así debe quedar la carpeta Android-Portable

Así debe quedar la carpeta Android-Portable

Esta carpeta ya la podemos poner en un pendrive, comprimirla, copiarla de un equipo a otro, etc. Funcionará con los distintos Windows.

Si tienes un Mac el proceso es el mismo, salvo que:

  • no tienes que instalarte Java, ya que el JDK viene instalado con OS X (es una instalación opcional del S.O.). No puedes “bajarlo” de la página de Oracle.
  • debes bajar el Eclipse de Mac
  • debes bajar el SDK de Android de Mac

Ahora, a ver alguien compra las Apps que hagamos :-)

We.Developers

Logo de We.Developers
Logo de We.Developers

Logo de We.Developers

Que soy gran fan y seguidor de José Antonio Blanco (y de su otra mitad, Valen) del podcast Macniacos no es ningún secreto. Desde que Juaco me comentara que escuchaba a dos pesados hablando dos horas seguidas sobre Mac y lo mucho que le servía, empecé a escucharles y me aficioné a su podcast. Cuando en el EBE 09 pude grabar su episodio en directo, junto con TaZZiTo, Serantes y Berto Pena (vaya lujo de equipo) lo pasé como un enano.

Por eso, cuando Jose me comentó que tenía ganas de empezar un podcast en paralelo con Macnicacos, pero más hardcore, más orientado a informáticos / programadores, donde poder hablar sin tapujos de frikadas de las que no puedes contarle a tus amigos no informáticos no lo dudé ni un segundo y dije que cuando y donde fuera, pero que yo quería participar. Y así ha nacido We.Developers, un podcast coral (Jose será el hilo conductor, e irán desfilando distintas personas que irán hablando de temas diversos de programación) sólo apto para programadores. Un sitio donde comentar que te gusta hacerlo todo con void * en C sin que nadie te mire raro. O en el que defiendas a COBOL y su espíritu de hacer un código que se autodocumente, escribiendo sentencias muy, muy largas. Mira, justo como se hace en Cocoa hoy en día… :-D

De momento se ha grabado el episodio piloto, pero como hay ganas seguiremos. Por culpa de esto (y de Café y Cocoa) me he comprado un micrófono Blue SnowBall, para sonar algo mejor en las grabaciones. En el podcast, en su web y en el logo se nota (mucho) la mano y el cariño que Jose le pone a sus proyectos.

Así que ya sabes: si te gusta programar, escúchalo y anímate a proponer temas. De cualquier lenguaje y plataforma. Ver el mundo desde distintos puntos de vista ayuda mucho a comprenderlo mejor.

:wq *

* he robado hoy el cierre del post a otro maestro.

La NSConf11 de Vilanova i La Geltrú

Este pasado fin de semana tuve el placer de asistir a la primera Conferencia que ha organizado a nivel nacional la Asociación NSCoders España. Asociación a la que pertenezco y, la verdad, y no es por ser nosotros los organizadores, pero nos ha salido casi redondo. Y encima no sólo iba a escuchar. Cometieron el error de dejarme hablar. Y claro, me dediqué a desvariar un rato y, entre chiste y chiste, contaba cómo hacer un cliente RSS para iPhone.

Aún no se si realmente alguien aprendió algo de mi charla. Yo me lo pasé muy bien, aunque no las tenía todas conmigo. El Viernes anterior había estado toda la mañana programando con JavaScript y el framework Enyo para la HP TouchPad. Y por la tarde había estado viendo detalles intrincados de Java en un curso de preparación para el OCP Java SE 6 que estoy impartiendo. Y Cocoa ya no me cabía en mis maltrechas neuronas. Al final parece que Cocoa fluyó (con ayuda de muchos cafés) y me pude escapar sin demasiados tomatazos. Y aquí es donde empezó realmente lo bueno.

Este año he ido a otra conferencia, el iOSDevUK en Gales, que me encantó. Pero comparando ambas, en la NSConf11 he escrito código. No sólo he escuchado, aprendido y charlado de código. He trabajado el código. Como en el increíble taller de TDD que impartió Pedro Santos, tras su charla sobre Behaviour Driven Development. Aquí tuve el privilegio de picar código mientras hacíamos pair programming aplicando el proceso paso a paso de TDD. O la charla sobre Chipmunk de Óscar Cardona, que nos dejó a todos atontados y pensando “esto no puede ser así de simple, o hay más código o este tío explica muy bien esto”. O el taller de Core Plot, donde vimos cómo hacer gráficas complejas con esta librería, gracias a la demo de Víctor Jalencas. Y tantas y tantas ponencias interesantes. La única pena: las que me perdí mientras yo hablaba, y las que tuve que elegir, perdiendo la que se presentaba en paralelo.

Lo mejor, la gente que he conocido. Gente con muchas ganas de aprender, compartir y enseñar. Gente encantadora y que, como los miembros de la NSCoder_bcn que han organizado el evento, se han matado para que todo estuviera perfecto, como al final ha sido. Creo que nadie pensaba que en una primera conferencia íbamos a tener tanto público. Esto puede llegar a ser una WWDC hispana. Trabajaremos por ello. Gracias a José Juan, nuestro presidente, o a Guillem o Leandro, o Xabi, o… por la paliza enorme que se han dado.

He podido conocer en persona (yo no “desvirtualizo” a las personas: las conozco) a José Lobato, ídolo de masas Geeks y gran bebedor de cerveza :-D. El tío en persona es para comérselo, y gran parte de la “culpa” de que todo esto se originara es la semilla plantada desde 85% Cocoa con las NSCoder Nights. Otro que me ha impresionado y he podido escuchar con respeto reverencial es Iván Leider. Él es un Maestro Jedi del desarrollo. Yo, ni Padawan…

Y demostrando que el mundo geek también es un pañuelo, conocí a Daniel García, el programador de la App de Minube para la TouchPad. Creo que allí estábamos los dos únicos programadores Enyo de toda España :-). Bueno, alguno más habrá, pero no creo que más de 10…

Y claro, me he hinchado a comer, he visto algo de Vilanova i La Geltrú (principalmente de noche) y no he parado de hablar. La experiencia no merece la pena: es imprescindible si desarrollas en Cocoa. Yo el año que viene, repito. Espero que alguien recapacite y no me dejen hablar.

Os dejo con un Vídeo de Vilanova Digital en la que “el presi” de la Asociación explica (en Catalán, pero se entiende perfectamente) qué es la NSConf11

Y el que quiera el código del RSS Reader que utilicé de ejemplo, lo tiene en: https://github.com/dfreniche/SimpleRSSReader