Vaadin, Spring Boot, GORM y GRADLE para soluciones interesantes

Hoy día podemos usar GRAILS desde cualquier sistema de automático de construcción (GRADLE, MAVEN, IVY), pero aveces queremos realizar pequeños proyectos con solo ciertas herramientas y con un desarrollo web rápido debido al entorno y necesidad generados por el proyecto. Por que perder a un gran ORM como GORM?, Tengo que usar GRAILS para usar a GORM?

Para los amantes de Micro Frameworks Spring Boot es una gran opción ante otros (Spark Java, NodeJS) si lo que se quiere es mantener un lenguaje alto con altas herramientas para soluciones sencillas, pero que necesitan un poco (Incluso son viables si el proyecto es de tamaño medio) del elemento de programación.

Para el ejemplo usé el Plugin de Grails para las Grid y Tables Lazy que anteriormente mostré como usar y crear para enseñar que sí funciona! :V

Usando nuestro IDE favorito creamos un proyecto GRADLE limpio y procedemos a adicionar los siguientes repositorios a nuestra configuración.

• maven { url "https://repo.spring.io/libs-release" } // Spring repo
• maven { url "http://maven.vaadin.com/vaadin-addons" } // Vaadin Add-ON
• maven { url "http://dl.bintray.com/johndevs/maven" } // Vaadin on Gradle

Nota: Se deben poner en

buildscript {     repositories {         // Aqui     } }

repositories { // Aqui }

Una vez con todos los repositorios están en su lugar procedemos a usar los componentes para crear nuestro primer proyecto.

Declaramos las siguientes variables para controlar las versiones (intentamos usar las últimas, no confundan las de GORM [4.0.1.RELEASE que es vieja]):

def vaadinVersion = '7.5.7' def vaadinSpringVersion = "1.0.0" def springBootVersion = "1.2.7.RELEASE" def gormGrailsVersion = "1.1.0.RELEASE"

Luego activamos los plugins necesarios:

apply plugin: 'groovy' apply plugin: 'java' apply plugin: 'spring-boot' apply plugin: 'war' apply plugin: fi.jasoft.plugin.GradleVaadinGroovyPlugin

Adicionar al ClassPath lo siguiente para configurar el proyecto.

classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.7.RELEASE") classpath "fi.jasoft.plugin:gradle-vaadin-plugin:0.10.2"

Adicionamos al final lo siguiente para determinar la versión de VAADIN y evitar problemas con Hibernate con una librería que VAADIN usa en una versión diferente.

jar {     from sourceSets.main.allJava } configurations {     //noinspection GroovyAssignabilityCheck     'vaadin-client' {         resolutionStrategy.force "javax.validation:validation-api:1.0.0.GA"         exclude module: 'spring-boot-starter-web'         exclude module: 'spring-boot-vaadin'     } } vaadin {     //noinspection GroovyAssignabilityCheck     version "$vaadinVersion"     widgetset 'AppWidgetSet' }

Por último adicionamos las librerías a usar.

compile 'org.codehaus.groovy:groovy-all:2.4.5'     // Activo a Spring Boot     compile "org.springframework.boot:spring-boot-starter:$springBootVersion"     // Con esto activo el web, pero es posible compilar el JAR.     compile "org.springframework.boot:spring-boot-starter-web:$springBootVersion"     compile "org.springframework.boot:spring-boot-parent:$springBootVersion"     providedRuntime "org.springframework.boot:spring-boot-starter-tomcat:$springBootVersion"     // Activo a GORM     compile("org.grails:gorm-hibernate4-spring-boot:$gormGrailsVersion") {         exclude module: 'groovy-all'     }     // Permite que GORM y Vaadin Existan juntos     compile 'javax.validation:validation-api:1.0.0.GA'     // Permite el uso de la DB y es obligatorio para que funcione la DB con o sin GORM     compile 'commons-dbcp:commons-dbcp:1.4'     // Activo el vaadin Official     compile "com.vaadin:vaadin-spring:$vaadinSpringVersion"     compile "com.vaadin:vaadin-spring-boot:$vaadinSpringVersion"     compile "com.vaadin:vaadin-spring-boot-starter:$vaadinSpringVersion"     // DB Driver     compile 'com.h2database:h2:1.4.190'     // Vaadin Add-On     compile("org.vaadin.addons.lazyquerycontainer:vaadin-lazyquerycontainer:7.4.0.1") {         // Evita que me descargue dependencias no necesarias para mi caso.         // Trae consigo una versión de VAADIN vieja.         transitive = false     }     testCompile group: 'junit', name: 'junit', version: '4.12'

Una vez completado esto podemos refrescar el GRADLE y esperamos que las dependencias descarguen.

Ya con todo esto incluido en nuestro proyecto podemos crear nuestras primeras UI con vaadin, al igual que crear nuestros servicios, domains y utilerías.

Nota:

• Usar un installApp permite correr la aplicación sin necesidad de un server, puesto usa el mismo tomcat que se especificó. Esto nos permite mostrar la APP a clientes sin necesidad de tener una PC configurada.

Todo esto podrán verlo directamente en el código fuente anexo.

Más información aquí
Example build.gradle
Source GIT Example TestGrailsVaadinSpringBoot

Punteros y arreglos en C que se unen.

Cuando trabajamos en C/C++ usamos punteros debido a que son una herramienta muy buena para facilitarnos la vida, pero un detalle interesante de estos que no siempre funcionan como uno quiere.

Como sabemos los punteros son direcciones de memoria y utilizar estos puede ocasionar que la aplicación colapse por acceso de memoria no autorizado, pero los utilizamos porque reducen el código y nos ayudan muchísimo.

Aquí un ejemplo de punteros que nos dan problemas cuando iniciamos y no sabemos por que. Para sorpresa del profesor se encuentra raro cuando nos revelamos a utilizar C y optamos por un lenguaje de alto nivel.


#include <stdio.h>

int *a, *b, *c;

void f(int x) {
  int i[3];
  i[0] = x;
  i[1] = x + 1;
  i[2] = x + 2;
  a = i;
}

void g(int x) {
  int i[3];
  i[0] = x;
  i[1] = x + 1;
  i[2] = x + 2;
  b = i;
}

void h(int x) {
  int i[3];
  i[0] = x;
  i[1] = x + 1;
  i[2] = x + 2;
  c = i;
}

int main() {
  f(1);
  printf("a = {%d,%d,%d}\n", a[0], a[1], a[2]);
  g(2);
  printf("a = {%d,%d,%d}\n", a[0], a[1], a[2]);
  h(3);
  printf("a = {%d,%d,%d}\n", a[0], a[1], a[2]);
}

Noten que imprimo siempre a[0], a[1] y a[2] siempre, pero después de llamar a una de mis funciones para asignar valores a otro puntero.

Una función que retorna FALSE, pero es TRUE

Muchas veces en la programación habituamos a usar los booleanos y por alguna razón aveces empleamos el sistema de ellos en base a lo que necesitamos, dígase "1" para verdadero y "0" para falso y según nos acostumbramos a hacer estas asociaciones ligamos dicha sintaxis a nuestros software principalmente en ciclos que ejecutan una determinada acción u/o ciclos que son servicios o demonios que escuchan en espera de un evento específico.

Algunos ejemplos de estos son en los juegos con el ciclo principal, hilos que escuchan puertos en espera de conexiones u otro caso similar y se ven linea como "while(1)" en vez de "while(true)" y de vez en cuando cuando tenemos una función que retorna un booleano le ponemos al final "return 0" o "return 1" y el lenguaje no los acepta, ya que simbólicamente para el lenguaje estos representan lo mismo, pero ¿es en su totalidad cierto?

Aquí les muestro un código que rompe con cualquier lógica de aquellos que trabajamos con booleanos:

#include <stdio.h>

#define TRUE  1
#define FALSE 0

int function_returning_false() {
  return FALSE;
}

int main() {
    if(function_returning_false) {
printf("La funcion retorna True.\n");
    }else {
        printf("La funcion retorna false.\n");
    }
}

Más adelante seguiré publicando más comportamientos extraños de los código, cualquier pregunta o sugerencia no dudar en preguntar.

Que tan perfectos son los cálculos matemáticos en la Computación?

Nota: El código se puede compilar y ver su salida en linea usando uno de los links en http://aluismarte.blogspot.com/p/herramientas-en-linea.html

Cuando empezamos a programar utilizamos los tipos de datos numéricos  con los cuales se nos enseñan las lógicas básicas para crear algoritmos y tener una mente ordenada, pero aveces aparecen casos muy particulares cuando trabajamos con los números; dígase cuando aplicamos un algoritmo de redondeo a números flotantes o cuando necesitamos más precisión en los cálculos de lo normal, pero a que me refiero explícitamente , es simple, cuando usamos datos numéricos flotantes estos carecen en sí mismos de precisión, aunque suene algo ilógico estos los usamos para tener más precisión, pero que hace que un numero flotante carezca de precisión?

Para responder a esa pregunta solo tenemos que entender que la computación es un gran puñado de bits (no bytes) en orden secuencial y lógico ordenado que permite tener diferentes opciones, pero recordando que estos bits solo pueden tener 2 estados consistentes y 1 no consistente, dígase 0 o 1 y en el estado no consistente sería que este carezca de existencia.

Como ya sabemos los bits tienen solo 2 valores, por lo que si no es 1 es cero, y los datos se guardan con una agrupación de estos, pero en los números tenemos singularidades en los flotantes, ya que estos tienen datos de 1 entero y datos para precisión (serían los números después del punto), por lo que entenderíamos que estos no tendrían un margen de error, pero si lo tienen!, si trabajamos con números que no son potencias de 2 estos generan un residuo importante lo cual puede hacer fallar un programa con una lógica impecable, pero me dejo de explicaciones y les muestro un ejemplo:

Este ejemplo es aplicable a todos los lenguajes que trabajo (C, C++, Java, C#, Python), aunque seguiré buscando aprender más lenguajes para probar estos casos.

#include <iostream>
using namespace std;

int main() {
    for(double i = 0.0 ; i < 2.0 ; i+=0.1) {
        if(i == 1.0) {
            cout << "Se supone que termino aqui." << endl;
            break;
        }
        cout << i << endl;
    }
    return 0;
}


Cuando corran este programa observaran algo curioso, pero si cambian el factor de suma de la variable i verán un efecto diferente, aunque este efecto es un caso raro, pero nos ayuda a hacer conciencia para que cada vez que trabajemos con flotantes usemos rango y no igualdades.

#include <iostream>
using namespace std;

int main() {
    for(double i = 0.0 ; i < 2.0 ; i+=0.125) {
        if(i == 1.0) {
            cout << "Se supone que termino aqui." << endl;
            break;
        }
        cout << i << endl;
    }
    return 0;
}

Aquí vemos el comportamiento de los flotantes, pero existen casos en los cuales se hallan perdido recursos debido a este error que no se contempla?, pues aquí hay unos ligeros ejemplos.

MIM-104 Patriot (1991): Es un misil antiaéreo que se utilizan también para la intercepción de misiles balísticos a modo de defensa. Durante la Guerra del Golfo en 1991 un Scud iraquí mató a 28 soldados al alcanzar un cuartel norteamericano ya que estos misiles fallaron. Se dictaminó que fue un error de software en el reloj del sistema que se había retrasado un tercio de segundo por haber estado activado 100 horas.

Ariane-5 (1996): Esta fue una misión ESA en el que el vuelo 501 la lanzadera se desvió y se partió durando únicamente 40 segundos en vuelo. El problema fue que el sistema de referencia inercial tratado con datos de punto flotante de 64 bits lo convertía a 16 bits con valores enteros. En una de esas operaciones el valor era demasiado grande provocando un desbordamiento aritmético en el hardware.

Chips Pentium (1994): Un error en el juego de instrucciones en los chip Pentium repercutió en la empresa $475 millones de dólares de costes en recogida y reenvío de procesadores. El error se reproducía al realizar una división con coma flotante en el que a partir del cuarto dígito decimal no daba valores correctos. Este fallo empezó a llamarse “bug de FDIV“.

Este ultimo caso fue un error de el chip, pero el problema fue que no controlaba correctamente un margen de precisión aceptable, lo cual provocó un error crítico y perdidas de dinero enormes.

Como conclusión, podemos afirmar que los números flotantes tienen error, pero que estos son controlados hasta un cierto punto para evitar problemas, y que si no se tiene conciencia de ello podemos crear un error lógico.

Descarga de código

Un solo link, con todos los códigos de los 5 lenguajes que trabajo.
http://adf.ly/FQO9f

Un arreglo curioso de tamaño cero.

Arreglo [0]

Nota: El código se puede compilar y ver su salida en linea usando uno de los links en http://aluismarte.blogspot.com/p/herramientas-en-linea.html

Como programadores siempre haremos uso de los arreglos para manejar datos, pero que pasa cuando rompemos la lógica y buscamos crear algo con dimensiones cero?.

Pues verá que los compiladores de C, C++, Python y Java permiten la creación de arreglos declarados en 0, así como su manipulación pero en C# esto solo permite su creación, pero no da la posibilidad de entrar 1 datos sin que de error de indice. La manipulación de este arreglo es curiosa y varía según el lenguaje al igual que su comportamiento.

Por ejemplo en C++ la salida de este arreglo singular da números que no son siquiera cercanos a los insertados en el mismo. Estos números sin sentido que nos ofrece la salida del programa podríamos buscarle algo de lógica si nos hacemos la idea de que eso sería acceso a ram del programa. Aunque esto no lo he podido probar, pero es una posibilidad existente que intentaré probar más adelante.


#include <iostream>
using namespace std;

int main() {
int arr[0];
int i,j, p;
cout << "Inserte el numero de datos a introducir en el arreglo" << endl;
cin >> p;
//Introducimos algunos datos en nuestro arreglo.
for(i = 0 ; i < p ; i++) {
arr[i] = i + 10;
}
cout << "Imprimimos a ver que sale" << endl;
//Imprimimos nuestros valores guardados.
for(j = 0 ; j < p ; j++) {
cout << arr[j] << endl;
}
return 0;
}


Después de correr este curioso programa, podría interesarle ver como se comportan estos en otros lenguajes y con el fin de facilitar la prueba podrán descargar los códigos para sus respectivos lenguajes a probar.

Links de descarga del código.

Lenguaje C
http://adf.ly/FL2Bh

Lenguaje C++
http://adf.ly/FL2Hp

Lenguaje C#
http://adf.ly/FL2J5

Lenguaje Python
http://adf.ly/FL2Mg

Lenguaje Java
http://adf.ly/FL2Ka