Cómo preparar las certificaciones Java (y probablemente el resto)

Estoy preparándome la certificación OCP Java SE 8. No preguntes por qué. Quizás porque soy adicto a coleccionarlas, tras tener el SCJP 1.5, 1.6, SCWCD 1.5 y SCBCD 1.3 y llevaba años sin presentarme a ninguna. O porque las que tengo ya son antiguas y quería tener una actualizada. O porque quería aprender Java 8 con cierta profundidad, ver todo lo nuevo que tiene que ofrecer (que es mucho, aunque quizás llega tarde) y compararlo con lo que he aprendido en otros lenguajes (Swift, te estoy mirando).

Además, he tenido la oportunidad de preparar a varios grupos para obtener esta certificación… que yo ahora mismo no tengo. Fraudismo at its best. Aunque en este caso no tengo tanto síndrome del impostor por una razón: puede que no tenga (aún) la certificación Java 8, y mis conocimientos de Java son muy mejorables, pero me autotitulo como el mayor experto mundial en aprobar estos exámenes. Y eso es gracias a mi sistema, el Sistema Freniche para aprobar las Certificaciones Java AKA sentido común.

El Sistema Freniche para aprobar las Certificaciones Java

Es un sistema muy probado, tanto personalmente como con montones de alumnos que he preparado para distintas certificaciones. Se basa en 9 pasos:

  1. Buscar un buen libro, que cubra todo el temario de la certificación. En este caso, he escogido el oficial de Oracle

  2. Leer el libro, saboreando cada capítulo. Aunque el objetivo último es aprobar el examen, hay mucho que podemos aprender aunque tengamos muchos años de experiencia con Java. Especialmente si tenemos muchos años de experiencia con Java trabajando siempre en proyectos similares, porque habrá montones de cosas que no hemos probado o visto por falta de tiempo.

  3. Escribe código. Mucho código. Haz pequeños ejemplos. Búscate las vueltas. Piensa retorcidamente. Prueba cosas extrañas (ver anexo Cosas Extrañas al final)

  4. Crea tus propios apuntes. O extiende los míos

  5. Escribe más código. Cuando te surjan dudas, vuelve a leer esa parte del libro. Y vuelve a escribir código probando todo.

  6. Cuando termines el libro, haz las preguntas de repaso de cada tema. Descubrirás que aún no has memorizado o te has fijado en partes. Goto 2

  7. Busca un simulador de exámenes. En mi caso siempre uso Enthuware porque me ha ido bien (no porque me paguen por hacerles publicidad, aunque ya podrían 🙂 )

  8. Haz exámenes de prueba. Falla. Vuelve a leer. Escribe código. Haz exámenes.

  9. Cuando en los exámenes del simulador estés llegando al 80% de aciertos, preséntate. Pasarás con nota.

¿Cuánto tiempo me va a llevar esto?

Pues depende. Leer el libro e ir probando pueden ser unas 30 h. Y luego hay que hacer los exámenes de prueba. Lo ideal es ponerse una fecha tope y en un par de meses power through it. Quitártelo de en medio, vamos.

Aunque recibir un excelente curso de formación, patrocinado por tu empresa e impartido por un profesional de prestigio siempre puede ayudarte bastante y

(interrumpimos este _shameless plug_ para continuar con lo que has venido a leer aquí)

Cómo presentarte al examen

Yo tengo mi ritual, pero lo ideal es que cada uno ejecute el suyo, porque lo normal es que estés nervioso/a ese día. Lo que yo hago es:

  • levantarme bastante temprano
  • comprobar que llevo algún documento, como el DNI en España que me identifique. Si no, no puedo hacer el exámen.
  • llegar con más de 1h de adelanto a los alrededores de donde tenga el Centro Prometric para presentarme.
  • desayunar o tomar café. Aunque el examen sea a las 13:00h en Sevilla en Agosto. Café. Para estar tranquilo.
  • llevar el libro de preparación de la certificación conmigo en la mochila, aunque no lo voy a leer mientras tomo café ni me van a dejar tenerlo conmigo durante el examen. Lo uso de talismán y porque no soy el más listo. Pero tengo que sentir que está cerca por si me ataca el pánico y alguna duda concreta en el último momento.
  • cargar con el portátil que no me van a dejar usar por las mismas razones que el punto anterior: porque no soy demasiado astuto.
  • llevar agua. Y caramelos. Para darte un premio según avance el exámen y beber para mantenerse hidratado.
  • ir al cuarto de baño justo antes de entrar, porque voy a estar bebiendo más agua que un caracol en el desierto durante la prueba.

¿Pero esto de las certificaciones sirve para algo?

Pues esto es un debate interesante, que puedes tener con quien quieras menos conmigo poque que en mi caso lo tengo bastante claro:

  • las certificaciones no demuestran que sepas más Java que nadie
  • demuestran que eres capaz de fijarte un objetivo, que te va a requerir un esfuerzo extra y cierto sacrificio y pasarlo
  • demuestran que tienes una base en el lenguaje Java
  • preparar esta certificación me ha supuesto toda una sorpresa, porque la he encontrado 100% útil: multihilo con Thread Pools y el paquete java.util.concurrent, programación funcional con Lambdas, map, reduce, streams, parallel streams, problemas de concurrencia y multihilo, acceso a BDs con JDBC (que hasta ahora era lo único que usaba en Android), uso de ficheros, excepciones, Opcionales,…
  • demuestran que eres capaz de estar 2 horas y media seguidas trabajando enfocado en una sola tarea, sin usar Internet ni mirar Twitter. Y eso es una rara cualidad hoy día, en los entornos multi-interrupción de que disfrutamos trabajando.

Esto último es probablente lo más difícil. Ser capaz de nuevo de estar haciendo una tarea durante 2 horas y media sin moverte de la silla. Esto se entrena con los exámenes del simulador. Y es duro, porque tú eres tu mayor enemigo.

Anexo: Cosas extrañas

Cosas que puedes hacer con Java, como escribir bucles así

Predicate<Integer> end = e -> e < 10; int i = 0; 
for (int j = 1; end.test(i) ; i++, j++, System.out.println("i " + i)) ;

// imprime i 1, i 2, i 3...

Usar bloques de código de instancia (NO usar en código real)

class Cat {
    String name;

    {
        System.out.println("I'm a Cat!");
        name = "Meow!";
    }

    Cat() {
        name = "Garfield";
    }
}

Programar «código encriptado» 😀

class _ {
    String _ = "Hello";
}

// más adelante...

_ _ = new _();
System.out.println(_._);   // imprime "Hello"

_ $ = _;
System.out.println($._);   // imprime "Hello"

Y otras muchas barbaridades que podría añadir…

j j j

Acelera el emulador de Android

«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

j j j

Cómo crear un entorno de desarrollo Android portable

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.

<

div class=»mceTemp mceIEcenter»>

<

dl id=»attachment_1707″ class=»wp-caption aligncenter» style=»width: 470px;»>

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 🙂