Generación de paquetes de la aplicación

El siguiente paso es generar un paquete que englobe toda la aplicación para el usuario el final.

Primeramente me baso en Linux para crear el paquete .deb

Para crear un paquete .deb únicamente hay que definir un archivo control y hacer una estructura idéntica de carpetas donde queramos instalar el paquete (p.e si queremos instalar el paquete en /opt/electron-node-java pues crear esa misma estructura en el tar.gz y luego ejecutar el comando dpkg-deb con la opción build).

El siguiente paso, sería generar una build que incluya todos los elementos (Electron, JVM y el código de la aplicación). Me he basado en un proyecto aprovechando bastante interesante que empaqueta Electron en los tres diferentes SO (Windows, Linux, Mac).

Este es el proyecto : https://github.com/szwacz/electron-boilerplate

Me he basado porque tiene bastantes cosas que no nos interesan de momento (Less, testing...).
He dejado lo básico y además he añadido la tarea en gulp para que se ejecute maven y haga el .jar de los fuentes cuando se inicia la aplicación con npm start.

Para incluir la JVM y no depender de la del usuario, la JRE la instalo con un script postinstal.sh, que es la forma que tiene dpkg de ejecutar comandos después de instalar el paquete.

Para Linux el paquete con electron-java-node funciona, el paquete se instala y la aplicación funciona correctamente.

En Windows como de costumbre, tenemos un error: Parece que ahora hay problemas al integrar java-node con electron, por lo que queda pendiente que se arregle en las siguientes releases de los proyectos.

El siguiente paso es introducir Angular2 junto con Typescript.

Sustitución de thrust + thrust-java por electron + node-java

Sustituimos la librería creada en las semanas pasadas, thrust-java, por Electron y node-java

Thrust-java se realizó para usar la librería nativa de thrust creada para levantar un browser e interactuar con él. Sin embargo esta librería nativa de Thrust lleva aproximadamente un año sin actualizarse, y en el mundo de la informática eso puede implicar que en poco tiempo ocurran errores de versiones... por ejemplo de los navegadores.

Es por ello por lo que se ha sustituido la librería nativa thrust por electron. Electron es una librería que actualmente está con recientes desarrollos y una comunidad más activa que Thrust.

Electron permite desarrollar aplicaciones de escritorio multiplataforma usando Javascript y está basado en Node.js y Chromium.

http://electron.atom.io/

Como he comentado, Electron está basado en Javascript, por lo que usaremos la librería node-java que permite llamar a código de un proyecto Java desde código Javascript.

https://github.com/joeferner/node-java

Ventajas del cambio

- Librerías electron y node-java con un desarrollo más activo en la comunidad. 

- Node-java permite comunicación directa entre Java y Javascript sin usar un servidor web embebido como teníamos con thrust -> Reducción de tiempo en el arranque de la aplicación. 

- Existe un proyecto llamado node-java-maven desarrollado por la misma comunidad de node-java para poder usar maven desde node-java.

https://github.com/joeferner/node-java-maven

Desventajas

- Librería thrust-java no aprovechable en el proyecto.

Estado actual

Se ha creado un proyecto uniendo Electron + node-java con una aplicación de ejemplo.

- Parte Java: se ha desarrollado una aplicación usando una dependencia en maven de una base de datos H2 para persistir datos en una BBDD embebida. 

- Parte JS+HTML+CSS: se ha desarrollado un GUI para interactuar con la aplicación Java. Desde el GUI se llaman a los métodos de la parte Java para listar y añadir elementos que son persistidos en la BBDD H2.

Conclusión

- Se ha cambiado el core del proyecto por unas librerías con más actividad en la comunidad.

- Ahora el proyecto se basa en Node.js, Javascript y Java en lugar de C++ (Thrust), SpringBoot y Java.

- Se ha creado un ejemplo de aplicación básica y su tutorial para cualquier desarrollador.


El nuevo repositorio de la aplicación es https://github.com/DanielGarciaMandillo/electron-node-java

Hasta la próxima!

Aclarando dudas sobre Java 8

La versión final de la aplicación thrust_java ya está en el repo desde ayer, quiero aclarar algunos conceptos técnicos, ya que me he encontrado con cosas con las que nunca me había encontrado y he tenido que programarlas, algunas nuevas de Java 8 y otras no.

• CompletableFuture: la forma de tratar los futuros, en Java 8 es muy similar a la forma que tiene Scala para tratarlos

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html http://19drops.com/blog/2014/10/09/future-in-scala-java/ https://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/changes8.html 

• Métodos sobre colecciones:
• forEach: es un nuevo método en Java 8 para recorrer colecciones.

https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html

• Clase Optional: una clase que puede o no puede tener valor, tiene muchos métodos, algunos de los usados en el proyecto han sido:
• empty() : devuelve un opcional vacío
• of(valor) : devuelve un opcional con el valor indicado
• ofNullable(valor) : devuelve un opcional describiendo el valor especificado, si este es nulo devuelve un opcional vacío
• orElse(valor) : devuelve el valor si la clase desde la que se invoca no es nula

https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html

• Métodos sobre Arrays: se han usado algunos nuevos métodos de Java 8 sobre Arrays como:

• emptyList() : devuelve una lista vacía
• asList(valores) : genera una lista con los valores indicados

https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html

• Librerías: se han usado la librería Gson y Typesafe:
• Gson : librería de Google para tratar los json en Java 

https://github.com/google/gson

• Typesafe: librería para leer archivos de configuración

https://github.com/typesafehub/config

• Streams: extensión de Java Collections para procesar colecciones de forma que tenga un estilo funcional. Algunas operaciones que se pueden encontrar en el proyecto sobre Streams : filter, findFirst, orElseThrow

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/

• Consumer: esta interfaz acepta un solo argumento y no devuelve ningún valor, son usadas ya que este tipo de comportamiento en el lenguaje Scala viene implícito.

http://baddotrobot.com/blog/2015/07/14/scala-implicit-functions/
https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html
https://blog.idrsolutions.com/2015/03/java-8-consumer-supplier-explained-in-5-minutes/

El repositorio en github es el siguiente: https://github.com/DanielGarciaMandillo/java-thrust 

Hasta la próxima!

Desarrollo en Java 8

Después de prácticamente dos meses, retomo el blog, que no quiere decir que no haya estado trabajando en el proyecto, en concreto en la traducción de aquel proyecto Scala del que hable en la anterior entrada y que había que traducir.

Si estuviese aplicando metodologías ágiles y tuviera que realizar una planificación del sprint, a este le hubiese titulado en grande y con mayúsculas "Traducir en Java 8" para hacer saber que el objetivo no es más que ese.

Me encontré con varios problemas en el proyecto de Scala que se hacían casi imposibles para desarrollarlos en Java (campos opcionales, funciones como parámetro, los nuevos métodos en estructuras de datos, streams y sus filtros...) pero..se encendió la luz con Java 8.

Lo primero que hice fue ponerme un poco al día de todas las novedades de Java 8, en estas páginas encontré buena información:

https://docs.oracle.com/javase/8/docs/api
http://openjdk.java.net/projects/jdk8/features
http://www.oracle.com/technetwork/es/articles/java/expresiones-lambda-api-stream-java-2633852-esa.html
http://www.javahispano.org/portada/2014/3/22/novedades-y-nuevas-caracteristicas-de-java-8.html
http://www.dosideas.com/noticias/java/983-java-8-mas-alla-de-los-lambdas.html

Después, aprovechando el código que tenía ya desarrollado hice un refactor a Java 8, prácticamente tenía la mayor parte de clases cubiertas ya con Java 7, y me faltaban los métodos que incluían operaciones con promesas, estructuras de datos con tuplas o funciones como parámetro, para los streams los filtros... en definitiva las cosas que con Java 8 se hacen más sencillas que con la versión anterior.

Para manejar los JSON el proyecto de Scala usa la librería Argonaut. Para manejar los JSON en el proyecto Java opté por la librería Gson de Google:

https://github.com/google/gson
http://www.blog.teraswap.com/gson-introduccion

A falta de organizar un poco mejor los paquetes y hacer pequeños cambios, la librería thrust_java está funcionando, para muestra una foto:

En la siguiente entrada entraré un poco más en detalle de la parte técnica de la librería thrust_java y espero tener ya en github la librería completa.

Desarrollando la librería THRUST para Java

Después de casi un mes, retomo el blog.

El objetivo del proyecto digamos que es que una aplicación web corra en un ordenador, por lo que necesitaremos un navegador. Por esto es por lo que usaremos Thrust.

Pero...¿qué es Thrust?.

Chromium-based cross-platform / cross-language application framework

Thrust is require/import-able, it lets you distribute NodeJS, Go or Python GUI apps directly through their native package managers.

Thrust is based on Chromium's Content Module and is supported on Linux, MacOSX and Windows

Thrust nos ofrece una estructura para poder usar un navegador en cualquiera de los tres sistemas operativos más usados.

La idea es traducir el proyecto de Thrust en Scala (https://github.com/eklavya/scala-thrust/) a Java.

[Thrust Architecture]

          (Platform)           [stdio]      (Your Implementation)

                                  #
               +--------------+   #       +-----------------------+
               | Cocoa / Aura |   #   +---|    win3: (HTML/JS)    |
               +-------+------+   #   |  +-----------------------++ 
                       |          #   +--|    win2: (HTML/JS)    |
+------------+ +-------+------+   #   | +-----------------------++
|            +-+ thrust (C++) +-------+-+    win1: (HTML/JS)    |
| ContentAPI | +-------+------+   #     +-----------------------+ 
|            |         |          #                | (TCP/FS)      
| (Blink/v8) | +-------+------+   #     +-----------------------+ 
|            | + JSON RPC srv +---------+ Client App (JAVA) |    |
+------------+ +--------------+   #     +-----------------------+ 
                                  #

Actualmente estoy por la mitad de las clases, en principio no tiene mucha complicación ya que la mayoría es definición de clases y atributos, aunque hay algunas cosas que tengo que revisar en profundidad como son las promesas y futuros en Java y los típicos problemas que vayan surgiendo..

Otro de los problemas que me han surgido es como podría resolver las duplas y pasar funciones como parámetro, (un TrieMap que tiene como clave (Int - String) y como parámetro una función) quizá use un Array bidimensional para las duplas y las nuevas expresiones Lambda de Java8.

Primera toma de contacto - Trauma post-vacacional

El verano para mí acabó la semana pasada, el día 7 de septiembre empecé a trabajar en MediaNet Software después de estar un mes de vacaciones y dejar atrás Everis.

He esperado un par de días para habituarme al horario y la rutina y hoy ha llegado el día de, por lo menos, poner la primera piedra a mi culminación en la carrera.

Hace 3 años, en septiembre de 2012 decidí empezar la Ingeniería de Computadores ya que por aquella época no había muchas salidas con un FP superior. Entre medias han estado exámenes y prácticas, unas mas largas que otras y otras más fáciles, pero bueno, el caso es que estamos en septiembre del 2015 y el único impedimento que tengo para que me den el papelito es el TFG.

Micael Gallego será mi tutor en este TFG y el me recomendó escribir un blog, Supongo que para que el día que haya que ir elaborando una memoria decente no se nos olvide nada.

Mi TFG consistirá en la implementación de una librería para facilitar a desarrolladores Java la implementación de aplicaciones web (HTML, CSS y Javascript) con un interfaz de usuario. Algo parecido a Cordova, pero para aplicaciones de escritorio.

En las siguientes entradas se profundizará más sobre el tema y todos nos enteraremos mejor (pero la idea es usar Maven, Spring, Websockets, HTML, CSS, Javascript, Java, GIT....)

PD: Cuenta en GIT que se me olvidaba!! DanielGarciaMandillo.


Hasta la próxima!