Iniciando con Hyperledger Fabric y Composer

Blockchain

El Blockchain (o cadena de bloques) es una base de datos compartida que funciona como un libro para el registro de operaciones de compra-venta o cualquier otra transacción. Es la base tecnológica del funcionamiento del bitcoin.

Sobre el tema, staba leyendo este artículo https://www.bbva.com/es/busca-talento-blockchain-mucho-mas-programadores/ y doy fe que pasanto también en Perú. Justo participe en mi último trabajo en TSS sobre un proyecto al respecto y fue mi primer acercamiento sobre el tema. Asimismo en mi actual trabajo en Everis me han comentado que ya se tienen varios proyectos de blockchain en la Banca.


Volviendo al portal del BBVA, encontre otro articulo donde BBVA se une al consorcio HyperLedger como se detalla en este link https://www.bbva.com/es/bbva-se-une-hyperledger-la-principal-comunidad-open-source-blockchain/

Extracto:

BBVA se ha convertido hoy en miembro oficial de Hyperledger, el consorcio colaborativo de código abierto (open source) destinado a impulsar el uso de blockchain en diferentes sectores económicos y empresariales. Esta iniciativa internacional, que cuenta con el apoyo de la Fundación Linux, reúne a un nutrido grupo de empresas del mundo financiero, tecnológico, manufacturero o Internet de las Cosas. Mediante su incorporación en Hyperledger, BBVA también se convierte en miembro de la Fundación Linux.

Hyperledger es un proyecto de código abierto especializado en blockchain que intenta compatibilizar las diferentes tecnologías desarrolladas en torno a blockchain para asegurar su interoperabilidad sin fricciones. Como parte de la Fundación Linux, el proyecto destaca por una sólida política de gobernanza y una gran cantidad de proyectos internacionales con diversas aplicaciones. Algunos de sus socios más destacados incluyen a American Express, el Banco de Inglaterra, Airbus, SAP, Wells Fargo o Thomson Reuters.

Hyperledger-Composer

Justo para empezar con el tema encontré un framework denominado Hyperledger-composer que simplifica la creación de aplicaciones blockchain basado en Hyperledger fabric. Así que decidí probar al respecto para crear mi primer aplicación blockchain y para ello hice un vídeo explicativo. Espero les sea util.  Lo bueno es que este framework tiene integrada varios framewoks para crear tu api rest y tu cliente angular. Los invito a verlo.

Enjoy!

Read More

JoeTip #005 - Trabajar con Jetty y HikariCP en Spring Boot

Jetty

Cuando trabajas con spring boot por defecto si agregas la dependencia web esta viene con el contenedor de servlets tomcat. Si tu quieres trabajar con Jetty debes excluir el tomcat y agregar la dependencia de Jetty:

dependencies {
  // Kotlin Dependencies
  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
  compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"

  // Spring Dependencies
  compile("org.springframework.boot:spring-boot-starter-web") {
    exclude module: "spring-boot-starter-tomcat"
  }
  compile "org.springframework.boot:spring-boot-starter-jetty"
  compile "org.springframework.boot:spring-boot-starter-actuator"

HikariCP

HikariCP es un pool de conexiones de JDBC de alta performance. Un pool de conexiones es un cache de conexiones de base de datos de manera que las conexiones puedan ser reutilizadas cuando futuros requests a la base de datos sean requeridos. Los pools de conexiones son utilizados para mejorar la performance de comandos ejecutados en la base de datos.

compile "com.zaxxer:HikariCP:2.6.1"

Luego en el application.properties se debe añadir la siguiente configuración:

spring.datasource.type=com.zaxxer.hikari.HikariDataSource

De manera que si ejecutamos la aplicación veremos en la consola que el cambio fue aceptado:

2017-07-26 07:57:26.345  INFO 1015 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2017-07-26 07:57:26.505  INFO 1015 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.

Enjoy!

Read More

Usando CrudRepository con Kotlin

Ahora vamos a ver si podemos aplicar lo aprendido con Spring Boot y cambiar nuestro código con Kotlin.

Esta vez seguimos con Gradle

Nos aseguramos de tener las siguientes dependencias en buildScript:

buildscript {
 ext {
  kotlinVersion = '1.1.3-2'
  springBootVersion = '1.5.6.RELEASE'
 }
 repositories {
  mavenCentral()
 }
 dependencies {
  classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("org.jetbrains.kotlin:kotlin-noarg:$kotlinVersion")
  classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
  classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
 }
}

El compiler plugin allopen nos evitara estar colocando la palabra reservada open. El compiler plugin noarg agrega un constructor sin argumento donde se encuentre la anotación específica.

// Or "kotlin-jpa" for the Java Persistence API support
apply plugin: "kotlin-noarg"

En nuestro caso usaremos kotlin-jpa para tener un constructor sin argumento en nuestras entidades. Los plugins finalmente serán:

apply {
    plugin("kotlin")
    plugin("kotlin-spring")
    plugin("kotlin-jpa")
    plugin("org.springframework.boot")
}

El plugin kotlin-spring es para poder usar todas las anotaciones de Spring.

Las dependencias del proyecto serán:

dependencies {
 compile('org.springframework.boot:spring-boot-starter-data-jpa')
 compile('org.springframework.boot:spring-boot-starter-web')
 compile("org.jetbrains.kotlin:kotlin-stdlib-jre8:${kotlinVersion}")
 compile("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
 compile("com.h2database:h2")
 compile("com.fasterxml.jackson.module:jackson-module-kotlin")
 testCompile('org.springframework.boot:spring-boot-starter-test')
}

Nuestra Entidad Alumno

Esta será una entidad JPA. El código es el siguiente:

package com.example.demoCrudRepository

import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id

/**
 * Created by josediaz on 7/27/17.
 */
@Entity
class Alumno(
        val firstName: String,
        val lastName: String,
        @Id @GeneratedValue(strategy = GenerationType.AUTO)
        val id: Long = -1) {

    override fun toString(): String {
        return "Alumno(id=$id, firstName='$firstName', lastName='$lastName')"
    }
}

Sobreescribimos el método toString para poder generar un log mas humano. Luego creamos una interface que herede de CrudRepository.


CrudRepository de Spring Data

package com.example.demoCrudRepository

import org.springframework.data.repository.CrudRepository

/**
 * Created by josediaz on 7/27/17.
 */
interface AlumnoRepository : CrudRepository{

    fun findByLastName(lastName: String): Iterable
}

Application con CommandLineRunner

Luego en la clase Application creamos algunos Alumnos y probamos los métodos que Spring Data nos provee con CrudRepository.

package com.example.demoCrudRepository


import org.slf4j.LoggerFactory
import org.springframework.boot.CommandLineRunner
import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.context.annotation.Bean

@SpringBootApplication
class DemoCrudRepositoryApplication{



        private val log = LoggerFactory.getLogger(DemoCrudRepositoryApplication::class.java)

        @Bean
        fun init(repository: AlumnoRepository) = CommandLineRunner {
            // save a couple of alumnos
            repository.save(Alumno("Elias", "Diaz"))
            repository.save(Alumno("Felipe", "Diaz"))
            repository.save(Alumno("Deborah", "Diaz"))
            repository.save(Alumno("Maria", "Diaz"))
            repository.save(Alumno("Daniel", "Diaz"))

            // fetch all alumnos
            log.info("Alumnos found with findAll():")
            log.info("-------------------------------")
            for (alumno in repository.findAll()) {
                log.info(alumno.toString())
            }
            log.info("")

            // fetch an individual alumno by ID
            val alumno = repository.findOne(1L)
            log.info("Alumno found with findOne(1L):")
            log.info("--------------------------------")
            log.info(alumno.toString())
            log.info("")

            // fetch alumnos by last name
            log.info("Alumno found with findByLastName('Bauer'):")
            log.info("--------------------------------------------")
            for (diaz in repository.findByLastName("Diaz")) {
                log.info(diaz.toString())
            }
            log.info("")
        }


}

fun main(args: Array) {
    SpringApplication.run(DemoCrudRepositoryApplication::class.java, *args)
}

Controller

Finalmente, si queremos usarlo en un Controller.

package com.example.demoCrudRepository;

import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.RestController

@RestController
class AlumnoController(val repository: AlumnoRepository) {

    @GetMapping("/")
    fun findAll() = repository.findAll()

    @GetMapping("/{lastName}")
    fun findByLastName(@PathVariable lastName:String)
            = repository.findByLastName(lastName)


}

Si probamos el resultado es:

SOURCE CODE

Read More

Primeros pasos con Spring y Kotlin

Ahora ya podemos crear nuestros proyectos Spring Boot y escoger como lenguaje Kotlin.

Con Maven

Las dependencias seran:

Se puede especificar la ubicación de tu código fuente y tus tests:

  ${project.basedir}/src/main/kotlin
  ${project.basedir}/src/test/kotlin

Para compilar módulos kotlin, código fuente se usa un plugin de maven para kotlin:

La clase DemoApplication es la que inicia todo, tiene la anotación @SpringBootApplication. Por defecto en Kotlin todas las clases son públicas y se puede declarar sin {}.

@SpringBootApplication
class DemoApplication

fun main(args: Array) {
    SpringApplication.run(DemoApplication::class.java, *args)
}

Como se puede observar, se omite el public porque es dado por defecto, si no hay tipo de retorno se omite el void, asimismo, como se declara la función fuera del cuerpo de la clase por defecto es static.

Si ejecutamos la aplicación dentro del IDE o con mvn spring-boot:run la aplicación iniciará en el puerto 8080.


El HelloController, lucirá así:

@RestController
class HelloController (val helloService: HelloService) {

    @GetMapping("/hello")
    fun helloKotlin(): String {
        return "hello world"
    }

    @GetMapping("/hello-service")
    fun helloKotlinService(): String {
        return helloService.getHello()
    }

    @GetMapping("/hello-dto")
    fun helloDto(): HelloDto {
        return HelloDto("Hello from the dto")
    }
}

Como se ve se tiene un constructor donde se dará la inyección sin usar @Autowired y con val para que sea inmutable. Tenemos 3 casos. El primero devuelve un String, el segunDo también pero usando un Service y el tercer caso devuelve un DTO. El service sería de esta manera:

@Service
class HelloService{

    fun getHello(): String {
        return "hello service"
    }
}

El DTO sería un data class:

data class HelloDto(val greeting: String)

Este tipo de data class automáticamente crea equals/hashcode, toString, y una función copy. Pero, no nos da un constructor por defecto, el cual es requerido por librerías como Jackson. Si se quiere soportar esto se puede usar esta nueva dependencia en tu pom.

Finalmente el testing sería de la siguiente manera:

@RunWith(SpringRunner::class)
@SpringBootTest(classes = arrayOf(DemoApplication::class),
  webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class DemoApplicationTests {

 @Autowired
 lateinit var testRestTemplate: TestRestTemplate

 @Test
 fun whenCalled_shouldReturnHello() {
  val result = testRestTemplate
    // ...
    .getForEntity("/hello", String::class.java)

  assertNotNull(result)
  assertEquals(result?.statusCode, HttpStatus.OK)
  assertEquals(result?.body, "hello world")
 }

 @Test
 fun whenCalled_shouldReturnHelloService() {
  var result = testRestTemplate
    // ...
    .getForEntity("/hello-service", String::class.java)

  assertNotNull(result)
  assertEquals(result?.statusCode, HttpStatus.OK)
  assertEquals(result?.body, "hello service")
 }


 @Test
 fun whenCalled_shoudlReturnJSON() {
  val result = testRestTemplate
    // ...
    ?.getForEntity("/hello-dto", HelloDto::class.java)

  assertNotNull(result)
  assertEquals(result?.statusCode, HttpStatus.OK)
  assertEquals(result?.body, HelloDto("Hello from the dto"))
 }
}

De esto último se puede rescatar el null safety "?". Cuando una variable puede ser null debe ser declarada usando '?'.

Con Gradle

 Escogemos para esta otra versión la opción con Gradle.

A continuación veamos el build.gradle, los plugins y dependencias a usar.

buildscript {
 ext {
  kotlinVersion = '1.1.3-2'
  springBootVersion = '1.5.6.RELEASE'
 }
 repositories {
  mavenCentral()
 }
 dependencies {
  classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
  classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
  classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
 }
}

apply plugin: 'kotlin'
apply plugin: 'kotlin-spring'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
compileKotlin {
 kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
 kotlinOptions.jvmTarget = "1.8"
}

repositories {
 mavenCentral()
}


dependencies {

 compile('org.springframework.boot:spring-boot-starter-web')
 compile("org.jetbrains.kotlin:kotlin-stdlib-jre8:${kotlinVersion}")
 compile("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
 testCompile('org.springframework.boot:spring-boot-starter-test')
}

Luego todo lo explicado anteriormente aplica. Así que para tener una pequeña demo creamos esta clase Greeting y luego su Controller. Greeting.kt

package com.example.demogradle

/**
 * Created by josediaz on 7/27/17.
 */


data class Greeting(val id: Long, val content: String)

Y su controller:

@RestController
class GreetingController {

    val counter = AtomicLong()

    @GetMapping("/greeting")
    fun greeting(@RequestParam(value = "name", defaultValue = "World") name: String) =
            Greeting(counter.incrementAndGet(), "Hello, $name")

}

El resultado final es:

Enjoy! y los animo a empezar a utilizar kotlin en sus proyectos.

SOURCE CODE

Read More

El nuevo HttpClientModule

HttpClientModule  

Se ha escrito un nuevo HttpClientModule en reemplazo del HttpModule. Este nuevo módulo soluciona ya no exige extraer el JSON de la respuesta de cada request y trea mejoras para hacer nuestro testing al API de forma menos verbosa.

Cambiar tu import de:

import { HttpModule } from '@angular/http';

a:

import { HttpClientModule } from '@angular/common/http';

De un código como este:

import { Injectable } from '@angular/core';
import { Http } from '@angular/http';
import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/map';
import { UserModel } from './user.model';

@Injectable()
export class UserService {

  constructor(private http: Http) {}

  list(): Observable {
    return this.http.get('/api/users')
      .map(response => response.json())
  }
}

Lo puedes cambiar a:

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs/Observable';
import { UserModel } from './user.model';

@Injectable()
export class UserService {

  constructor(private http: HttpClient) {}

  list(): Observable {
    return this.http.get('/api/users');
  }
}

Testing

Ahora nuestros tests serán menos verbosos:

describe('UserService', () => {

  beforeEach(() => TestBed.configureTestingModule({
    imports: [HttpClientTestingModule],
    providers: [UserService]
  }));

  it('should list the users', () => {
    const userService = TestBed.get(UserService);
    const http = TestBed.get(HttpTestingController);
    // fake response
    const expectedUsers = [{ name: 'Pepito' }];

    let actualUsers = [];
    userService.list().subscribe((users: Array) => {
      actualUsers = users;
    });

    http.expectOne('/api/users').flush(expectedUsers);

    expect(actualUsers).toEqual(expectedUsers);
  });
});

También podemos añadir headers y parámetros a nuestros requests. Por ejemplo:

const params = new HttpParams().set('page', '1');
this.http.get('/api/users', { params });

const headers = new HttpHeaders().set('Authorization', `Bearer ${token}`);
this.http.get('/api/users', { headers });

El ejemplo anterior es muy útil cuando necesitas establecer el header Authorization cuando trabajas con JWT.

Interceptors

Ahora podemos usar interceptors por cada request y response y así podemos añadir un header a un request o manejar un error de una forma centralizada.

Por ejemplo, agregar un OAUTH Token a cada request de forma centralizada:

@Injectable()
export class BackendAPIInterceptor implements HttpInterceptor {

  intercept(req: HttpRequest, next: HttpHandler): Observable> {

    // if it is a Github API request
    if (req.url.includes('api.backend.com')) {
      // we need to add an OAUTH token as a header to access the Github API
      const clone = req.clone({ setHeaders: { 'Authorization': `token ${OAUTH_TOKEN}` } });
      return next.handle(clone);
    }
    // if it's not a Backend API request, we just handle it to the next handler
    return next.handle(req);
  }

}

Y esas son las novedades por ahora. Enjoy!

Read More

Ejecutar Stored Procedures con JPA 2.1

Hoy generamos en mi trabajo una nueva versión para UAT (User Acceptance Test) y nos dimos con este problema.

Problema

Teníamos que llamar a dos stored procedures usando SimpleJdbcCall.

SimpleJdbcCall jdbcCall = new SimpleJdbcCall(spJdbcTemplate).withProcedureName(“DELETE_LANE”);
Map in = new HashMap<>();
in.put(“V_LANE_ID”, laneId);
Map out = jdbcCall.execute(in);

El Stored procedure solo recibe un parámetro y no retorna nada, pero, si ejecuta varias operaciones intermedias que omito para este post.

Si bien en nuestro entorno de desarrollo trabajo muy bien, en UAT nos dio este problema:

 

Que se resume en: “Unable to determine the correct call signature - no procedure/function/signature for ‘DELETE_LANE'”.

Solución

Deduje que no resolvía bien el tipo del parámetro de entrada y que debía ser más explícito. Por suerte, ya sabía que en la versión de JPA 2.1 había soporte para stored procedures, así que procedí a implementarlo:
En la entidad Lane.java añadí el nuevo @NamedStoredProcedureQuery. El atributo name es el nombre interno que usarás en tu aplicación, el valor en procedureName es el nombre real del procedimiento almacenado y luego vienen los parameters donde debes indicar si es IN o OUT , tipo y nombre. Lo cual ya “adivinaba” me ayudaría a resolver mi problema.

 

Luego tocaba dejar de usar SimpleJdbcCall y usar esta nueva forma de ejecución de stored procedure:

Con 3 simples líneas:
StoredProcedureQuery query = this.em.createNamedStoredProcedureQuery(“deleteLane”);
query.setParameter(“V_LANE_ID”, laneId);
query.execute();
Eso sí como ven necesitan el EntityManager.  Pero en proyectos con Spring Boot es muy sencillo basta un @PersistenceContext private EntityManager em y eso es todo.

 

Y bueno eso es todo, se volvió a probar, desplegar en UAT y está funcionando muy bien.
Enjoy!

Read More

Mis primeros pasos con Angular 2

En el mes de noviembre iniciamos un proyecto con Angular 2 para construir un sistema para recursos humanos. En este post voy a contarles lo que a mi parecer han sido las mejores referencias que hemos podido encontrar con mi equipo y que nos ha dado resultados. Agradeceré de antemano el aporte que hagan sobre este post si omití, hable tonterías o debí añadir algo al respecto.

Frontend

• Si bien se puede programar con JavaScript, Dart, la elección que encontramos en la red es usar TypeScript, así que decidimos ir por esta opción.
• La mejor documentación la puedes encontrar en la misma página web de https://angular.io
• De todas las presentaciones que encontramos nos encanto la de John Papa. Ver el vídeo de su presentación. 
• En el sitio web de Angular encontrarán una guía de programación inspirada en el trabajo de John Papa 
• Decidimos crear el proyecto y seguir el soporte que nos da Angular CLI.
• El IDE que decidimos usar si fue de elección del programador, pero, el primer lugar se lo llevo WebStorm (que es comercial) seguido de Visual Studio Code (que es free).
• Para el diseño puedes usar  https://material.angular.io/ o comprar un template. En nuestro caso adquirimos SmartAdmin que tenía soporte para Angular 2. Esta plantilla nos mostró una arquitectura básica con componentes personalizados creados por el autor que nos ayudo mucho para empezar a crear nuestras pantallas.
• Enterados de que Kendo UI ya tiene soporte beta para Angular 2, decidimos usar los componentes liberados. Uno de los que decidimos usar fue el de la grilla porque nos pareció más sofisticado que el de la plantilla SmartAdmin. Ojo es comercial, pero, por ahora se puede usar libremente por andar en beta.
• Para el tema de seguridad en un principio quisimos usar Keycloak, pero, al final decidimos ir por Autenticación JWT y nos sirvió mucho este artículo . Curiosamente hablando del tema con un amigo me entero que existe Satellizer, así que ahí se los dejo para que lo revisen.
• Sobre cursos hay uno gratuito en http://courses.angularclass.com/p/angular-2-fundamentals y otros comerciales.
• El curso anterior viene acompañado de un gran starter https://github.com/AngularClass/angular2-webpack-starter
• Sobre libros recomiendo en https://www.ng-book.com/2/
• En mi canal de youtube les comparto una lista de reproducción de angular 2
• O sigan a Kara que ya tiene fans enamorados en mi trabajo porque es una experta en angular 2. Aquí un vídeo sobre Angular Material 2 y otro sobre Angular 2 forms que ha expuesto Kara Erickson.
• Bueno en otros post ya les contare que otras cosas vamos descubriendo

Backend

• El backend se baso en Spring Boot donde creamos nuestras entidades, repositorios JPA y/o Spring JDBC, controladoras REST para exponer la data en JSON.
• Usamos Gradle como Build Tool.
• La BD en esta oportunidad fue SQL Server y no hemos tenido ningún problema al respecto.
• En general el proyecto backend se parece mucho a https://github.com/joedayz/campusbackend
• Se configuro Spring Security para trabajar con JWT basado en http://www.svlada.com/jwt-token-authentication-with-spring-boot/.

Docker

Creamos tanto para el backend y frontend un Dockerfile para poder crear las imagenes correspondientes. El Dockerfile para el backend lo pueden ver aquí. El Dockerfile para el frontend por ahora lo hemos trabajado así:

FROM nginx
COPY dist /usr/share/nginx/html
EXPOSE 80

Bueno por ahora es lo que les puedo contar en post sucesivos ire publicando los tips respectivos que nos han servido
Enjoy!

Read More

Fundamentos de Programación para niños, jóvenes y adultos

Este mes de abril del 2016 iniciamos un curso de fundamentos de programación, ideal para quienes nunca han llevado un curso de algoritmos o de lenguaje de programación.
Todo nació debido a la iniciativa de mis hijos y cuñado de 14 que querían aprender ya a programar. Mi esposa Miryan complice de ellos me dio la gran idea de abrirlo al público y como siempre ha sido una gran idea de su parte.
Se registraron alrededor de 40 personas. De las cuales 16 son menores de edad, 4 jóvenes y el resto adultos. Al final, muchos de los adultos que participan me han comentado que lo hacen para luego explicarle con paciencia a su(s) hijo(s). Entiendo que guardan la privacidad o por decisión personal no quieren exponerlo.

¿Y como fue la primera clase?

Como la mayoría de participantes son niños tuve que apoyarme en code.org para realizar las primeras clases.
El primer reto fue desarrollar “la hora del código minecraft” juntos y hacer que todos participen. Manejar un grupo de niños me resulto super complicado, todos quieren hablar al mismo tiempo, mostrar su cámara web, pero, algo positivo es que preguntan de todo, y nunca dejan de preguntar. Al final nos divertimos e hicimos juntos los primeros 5 retos y luego ellos en dos semanas terminaron el resto enviándome sus certificados digitales como consecuencia de terminar todos los retos.
Aquí les paso el primer vídeo que ya esta en nuestro canal de youtube.

Y algunos de los certificados que me llegaron a mi correo electrónico:

 

Super, no?

Segunda Clase

En la segunda clase ya hicimos el segundo reto que tiene un poco más de complejidad, el “Star Wars - creando una galaxia con código” y para mi sorpresa lo hicieron mucho más rápido e incluso mientras yo iba en el ejercicio 5, algunos me decían que ya estaban en el 9 o 10 ejercicio.
Lo mejor de todo es que ya empiezan a hacer algoritmo sin conocer aún el significado de dicha palabra. Definitivamente como dicen los científicos, jugando se aprende y no se olvida uno nunca.
Comparto la primera Parte de la segunda clase:

Esa clase tiene dos partes porque se fue el internet (gracias Movistar) y luego de unos minutos regresamos, aunque ya unos chicos se habían ido.
Segunda Parte:

En fin,  si te quieres unir al grupo contáctanos por facebook o twitter (@joedayz) o revisar en tu propio espacio y tiempo estos vídeos que están en el canal de youtube de joedayz.
Esta semana si será Jueves a las 8pm y empezaremos con MineCraft.
Nos vemos y a jugar con Steve o Larry.

Joe

Read More

Hangouts del 2015

He descuidado mi blog por mucho tiempo, pero, he estado con muchos proyectos encima. Aunque eso es bueno despues de todo, pero, espero en verdad darle un mejor uso, así que aquí el primer post despues de 4 meses.

El año pasado hemos tenido muy buenos hangouts con la colaboración de miembros de la comunidad de PERU JUG y estoy seguro les gustará tener la lista de reproducción de todos los hangouts del año 2015.

Enjoy!

Joe

Read More

Webinar sobre JavaCard

Ponente: Carlos Ruiz de la Vega

Desarrollador Senior en Oficina Nacional de Procesos Electorales (ONPE)
Especialidades: Java Card, aplicaciones biometricas, JEE, VC++, VB, Spring, Android SDK, ADF, JMF, JAI, Pentaho, Base de datos Oracle, Cognos IBM, MS SQLServer, MySql.

Compartimos la presentación.

Read More

Webinar sobre Metodologías Ágiles

El 02 de Octubre 2015 tuvimos un webinar sobre metodologías ágiles.
Ponente: Christian Paolo Vera Livia.

Especializado en Gestión de Proyectos bajo  las buenas practicas del PMBOK(PMI®) , metodología PRINCE2®  y Gestión de servicios enfocados a ITIL.

Cuento con la siguientes certificaciones a nivel internacional :
PRINCE2® Practitioner Certificate in Project Management, Scrum Fundation Certified (SFC),  Scrum Developer Certified(SDC), Scrum Master Certified (SMC),  Scrum Product Owner Certified (SPOC) SCRUMstudy Certified Trainer (SCT), Cobit5 Foundation ,Agile Service Projects, Agile Scrum, Cloud Computing, ITIL® Service Strategy , ITIL® Service Design, ITIL® Service Transition, ITIL® Service Operation, ITIL® Continual Service Improvement, ITIL® Managing Across the Lifecycle, ITIL® Expert,  Information Security ISO/IEC 27002, Secure Cloud Services,

Con más de 7 años de amplia y solida experiencia en empresas privadas de Producción, Comercialización y de Servicios.

Titulo

Agenda :

1.- Metodologias Agiles"
2.-ScrumStudy
3.-SBOK
Aquí compartimos el vídeo del webinar.

Enjoy!

Read More

Se nos fue Agosto 2015

Cursos

 

Este mes ha sido de mucho trabajo. Hemos podido desarrollar un curso personalizado para Inversiones de la Cruz en Android. Con este grupo tendremos un repaso final el 22 y hacemos la graduación el 29 de Agosto. Gracias por la confianza a ILC.

El 14 de Agosto terminamos un taller de Java, Java EE 6 con WebSphere 8.5 para la empresa TATA. Fueron dos semanas intensas. Esperamos que este nuevo grupo pueda afrontar sus proyectos con una base sólida y como les dije depende de ellos, leer, practicar y estudiar siempre. Gracias chicos y TATA por la confianza en nuestra empresa.

Se termino el curso de Servicios Web. En Septiembre iniciamos con el módulo de BRPMS, aún estamos por definir la fecha. Esta semana estamos liberando los temas a revisar para que se unan al diplomado.

Desarrollos

Estamos trabajando en nuestra web de proyectos. Por ahora estamos trabajando desarrollos en Android y Java para empresas privadas. Agradecemos las referencias de la comunidad para llegar a estas empresas y demostrar que no solo entrenamos sino que aplicamos lo que enseñamos.
Pronto noticias sobre estos desarrollos.

Joe

 

 

Read More

¿Puede tu Padre hackear tu vida?

Hoy 19 de Julio mi Padre cumple un año más que partió a la presencia del Padre.
Mi Padre siempre me mostró un gran amor a su Madre y sus hermanos. En vida siempre se preocupo por ellos, sus sobrinos, sus amigos. El jamás me contó su historia de niño, siempre vivió el presente y me enseño a querer a su familia y respetar a mi Madre, sino,  me atenía a las consecuencias.
Yo creo que todos siempre estamos orgullosos de nuestros Padres. Pero hoy a mis 40 años me doy cuenta que  mi Padre “hackeo” mi vida, ¿de que forma?, paso a explicar:

Cuando uno es niño uno no se da cuenta de si su Padre o Madre solo han estudiado primaria. Mi Padre era un hombre que escribía y se expresaba muy bien, entonces, era comprensible que yo asumiera que había acabados sus estudios primarios y secundarios.

Yo recuerdo hasta ahora que  cuando no sabía el significado de una palabra, en lugar de buscar el significado en el diccionario, le preguntaba a mi Padre y listo, ya tenía la respuesta. Era un capo con las letras.

Si necesitaba una solicitud, o que me hagan un trámite, ahí estaba mi padre. Era un talento al escribir y expresar sus ideas.

Hasta que llego el día que mi Padre y mi Madre me dijeron que estudiarían en la nocturna del colegio “Nstra. Sra. de Belén de Ventanilla” sus estudios secundarios. Yo me quede sorprendido y pense “¿Mis padres no terminaron la secundaria?”.WTF.

Pasaron luego 5 años, y mi Padre termino obteniendo el primer lugar en el C.N. Mx. Nstra. Señora de Belén. Eso fue algo que impactó mucho en mí, donde mis únicas  aspiraciones eran: ser futbolista o tener una banda de rock (iluso).

Por suerte nunca tuve talento para ninguna de esas dos cosas. Así que mi Padre empezó el hackeo del adolescente rebelde en el que me convertí sin darme cuenta.

Pasaron los años y llego mi turno. Termine mi secundaria en el año 90 en el mismo colegio donde estudiaron mi Padre y mi Madre sin saber que hacer luego. Mi Padre quería que fuese Doctor y yo, "Bueno....", me decía.

Lamentablemente, mi inmadurez y la facta de dinero me hicieron atreverme a descansar por 4 años (90 - 93).  Hasta que llego el día en que mi Padre me hizo ver que no llegaría a ningún lado si no me tomaba la vida en serio y me ponía a estudiar o trabajar.

Eramos pobres y no podía ser tan imberbe para darme el lujo de ser vago. Al final con el apoyo de mis padre ingrese a la Universidad Federico Villareal  en el 93 y luego a la Pontificia Universidad Católica del Perú en Febrero de 1994, que fue esta última la  Universidad en la que finalmente me quede.

Lamentablemente mi Padre sólo me pudo ver estudiar 2 ciclos porque le detectaron cáncer al páncreas en Enero del 95 y tras un penoso proceso, falleció un 19 de Julio del 1995. Lo vi preocupado en sus últimos días por mí , pero, ahí fue que me acordé de todo lo que habíamos vivido y le dije “ahora me toca a mí, descansa, yo cuidare a Mamá". Y se me fue mi Paquito.

¿Y como se que hackeo mi vida?
La foto de abajo es una prueba. Es cuando recibe el reconocimiento por ser uno de los mejores alumnos de su promoción. Hoy a mis 40 años me doy cuenta que sin querer mi Padre me dió la clave del éxito: Pasíon y Perseverancia. No exitos rápidos, sino ser maratonista de la vida.

El y mi madre cambiaron mi “rebeldía”, mi “inmadurez”, por un nuevo "programa" de ser Profesional y/o Emprendedor. Siempre me decía que sea cual sea el rol que tenga, que nunca pierda el respeto y el ser solidario con los demás, así no recibamos el vuelto o hablen mal de nosotros, etc.

Yo de niño, joven lo viví en carne propia en su persona. Por ser dirigente de Los Licenciados de Ventanilla se gano muchas enemistades y hablaron mal de el en muchas oportunidades. En fin eso ya es historia, el no recordaba eso y vivía el presente con su agradable forma de ser.

El siempre tenía una buena sonrisa para los demás y si se necesitaba un Papa Noel para el barrio ahí estaba. Un Papa Noel negro jaja.  Lastima que no tengo foto de esa época.

Te extraño mi Paco, sabes que te quiero y siempre estoy/estaré orgulloso de ti. Espero verte cuando mi turno llegue. Espero al menos llegar a ser un tantito, el buen hermano, padre, amigo, esposo que fuiste.  Gracias y hasta pronto viejito.

Tu Cata
Tu Pepe
Mi Esposa y mis hijos hoy te hemos recordado en los laudes.

"Eres mi Mufasa y cuando veo las estrellas, siento que estas ahí orando por nosotros".

Read More

JavaOne Brasil 2015

Por: José Díaz

Hola comunidad JoeDayz. Los Brasileños no pudieron estar mas contentos, pues después de 2 años se volvió a programar un JavaOne en latinoamerica que se desarrollo en TransAmerica Expo Center en Sao Paulo.
Los que asistimos tuvimos el 23, 24 y 25 de Junio bastante cafeína para compartir. Pero antes de iniciar les comento que este es mi punto de vista como asistente al JavaOne. Para Oracle Open World (es otro presupuesto)  y como no soy partner de Oracle, pues, no tengo nada que opinar.

Unos Días antes

En esta oportunidad no viaje solo sino que fui acompañado de mi esposaMiryan y mi último bebe Danielito. Esto fue muy positivo para mí, porque, siempre que voy a un evento, solo visito mc donalds, starbucks, istore, y sitios muy geeks. En cambio ya con la familia visite buenos lugares para cenar e incluso un parque acuático que espero volver a visitar con todos mis hijos llamado Thermas Dos Laranjais, altamente recomendable, no te arrepentiras y queda en Olimpia, puedes llegar ahí con el sistema de Buses que hay en Sao Paulo que es super económico y seguro (en el trayecto va un policía resguardando el viaje).

Primer Día

Llegar a TransAmerica Expo Center no es complicado. El Metro de Sao Paulo es genial. Recuerda que si vas y es en el mismo lugar, tienes que bajarte en Santo Amaro (linea verde) caminas unas tres cuadras y llegas sin problemas.
En la imagen pueden ver las ubicaciones de las empresas partner de Oracle, donde están la zona de demos, Java Hub (para el networking), Servicios, acreditación (donde te dan tu material y te identifican), etc. Es bueno tener esta imagen para ubicarse.

 También es importante tener una imagen del mapa del centro de conferencias. Aunque como es la segunda vez que vengo ya me trasladaba con más facilidad.

No olvides nunca tus credenciales, sin eso no accedes a ningún lugar.
Lo que me impresiono fue que todas las sesiones en general estaban llenas o en su defecto no podías entrar porque estaba full, por seguridad (super bien eso) y verificado por los bomberos del estado.

Hands On Labs

Los HOL son sesiones de laboratorio dónde tu puedes aprender de los expertos desarrollando tutoriales, haciendo código.
Yo fui a dos y las compartí con la comunidad.
1.- Lambda expressions con Simon Ritter de Oracle
2.- JAVA EE 7 con David Delabassee.
Descargue el material de este link. No se si lo mantendré mucho tiempo, así que apresúrese.

Charlas

Aún las charlas no están publicadas al 100%. Pero he podido rescatar estas presentaciones.
1.- ¿Que es lo que viene para JavaEE8?  Por David Delabassee (@delabassee)
2.- MVC 1.0   Por  David Delabassee (@delabassee)
3.- Seguridad para Servicios REST con OAtuh2 Por Rodrigo Silva (@rcandidosilva)
4.- Procesamiento Batch Por Rodrigo Silva (@rcandidosilva)
5.- Java y HTML5 Por Loaine Groner (@loiane)
6.- Java FX desde las trincheras Por Anderson Braz (@mrbraz)
7.- BigData con Spark y Lambda Expressions Por Fabio Velloso (@fabiovelloso)
Cuando salgan mas charlas les avisare por nuestro canal de facebook y twitter.

El futuro de Java

Cuantas veces he escuchado que Java es muy complicado. Mejor pasemos a Ruby los cursos de Programación de en la universidad como EPE UPC. Aquí tienes un niño de 13 años que empezo a los 11 y ya es un desarrollador en Java. No será que no le dedicas el tiempo suficiente o no es lo tuyo.
Cierro este blog indicando que Java apostará por Internet of the Things en los próximos años, y tomando lo mejor del ecosistema de tecnologías para Java EE, Java ME, Java SE, ETC.  Tenemos para rato con Java, aplicaciones empresariales, grandes empresas, trasnacionales, banca, seguros, ejercito, etc.

Finally

Espero les haya gustado y lean y disfruten lo recopilado en este evento.

Nos leemos. Su servidor Joe.

Read More

Introducción a Apache JMETER

INTRODUCCION

Las pruebas de rendimiento sirven a los colaboradores de control de calidad (testers) verificar que tan bien una aplicación o sitio web se desempeña bajo ciertas circunstancias específicas. Es ahí donde entra a tallar Apache JMeter que es una herramienta idónea para llevar a cabo ese tipo de pruebas.
JMeter es un proyecto de Apache Jakarta que puede ser usado como una herramienta de prueba de carga para analizar y medir el desempeño de una variedad de servicios en una aplicación web. Es un software de escritorio escrito enteramente en Java y disponible par todas las plataformas.
JMeter puede ser usado como una herramienta de pruebas unitarias para conexiones a base de datos con JDBC, FTP, LDAP, servicios Web, JMS, http, y conexiones genéricas TCP.

¿Pero, que son las pruebas de rendimiento?
Las pruebas de rendimiento son pruebas de funcionamiento de un sistema para comprobar su operatividad en términos de capacidad de respuesta, rendimiento, fiabilidad y escalabilidad bajo una carga de trabajo determinada.
Las pruebas de rendimiento no tienen por objetivo encontrar defectos o errores en la aplicación, sino que abordan una tarea mas critica, que es la de encontrar el índice de referencia o estándar establecido para la aplicación.
En cristiano, las pruebas de rendimiento sirven para asegurarnos que la aplicación responde dentro de los tiempos limites establecidos por el usuario o no.

Normalmente verificamos durante las pruebas de performance:

• Capacidad: El número máximo de objetos que la aplicación puede manejar.
• Latencia: El tiempo promedio y máximo para completar la operación del sistema.
• Tiempo de Respuesta: El tiempo promedio y máximo de respuesta de la aplicación.
• Rendimiento: La máxima cantidad de transacciones que la aplicación puede manejar.

Ejemplos: Para verificar el tiempo de respuesta de un sistema de procesamiento en línea, y también para medir el tiempo de procesamiento de tareas en lote.

¿Por qué necesitamos pruebas de rendimiento?
Hoy en día la gran mayoría de aplicaciones modernas, especialmente las aplicaciones en línea, están enfocadas en tener un gran número de usuarios, por consiguiente tendrán también un gran número de operaciones simultaneas.
En consecuencia, es importante medir el nivel de rendimiento optimo para un numero de usuarios concurrentes. Es por ello que tenemos que simular de alguna manera el numero de usuarios concurrentes y controlar la calidad y velocidad del servicio bajo dichas condiciones.

 ¿Qué tipos de pruebas de rendimiento existen?

• Pruebas de Carga:

Las pruebas de carga someten al sistema a una carga estática representativa con el fin de medir el rendimiento de la aplicación ante una carga de usuarios.
El objetivo principal es identificar los cuellos de botella de la aplicación en ejecución.

• Pruebas de estrés:

Estas pruebas buscan hacer caer la aplicación e identificar el punto de ruptura. El objetivo es hacer presión extrema al sistema para verificar si falla o no. Y para llevar a cabo esta tarea hay que llevar al sistema fuera de los limites de sus necesidades específicas.

• Pruebas de Volumen:

Estas pruebas de refieren a pruebas con una gran cantidad de información. Por ejemplo, si deseamos probar contra el tamaño limite de la base de datos, expandimos dicha base de datos a dicho tamaño y verificar la performance de la aplicación en dichas circunstancias.
Otro escenario puede ser interactuar con archivos como .dat, .xml. Esta interacción puede ser escribiendo/leyendo datos de/hacia el archivo y hacer también pruebas de volumen de este tipo con la aplicación.

• Pruebas de Escalabilidad:

Estas pruebas son para determinar si la aplicación se comporta efectivamente en “scaling up” para soportar un incremento en carga de usuarios.
Esto es, desplegar la aplicación en diferentes sistemas  y ver como se comporta. El objetivo es entender en que punto la aplicación ya no puede escalar e identificar las razones de esto. Esto nos ayuda a planear la capacidad de nuestro sistema de software.

• Pruebas pico:

Es el proceso de pruebas en el cual una aplicación es probada con incrementos y decrementos de carga. De esta forma se observa como el sistema reacciona ante un aumento y decremento de usuarios.

• Pruebas de resistencia:

Son conocidas como pruebas de fiabilidad. Son pruebas de estrés realizadas durante largos periodos de tiempo para ver la estabilidad de la aplicación. El objetivo principal es verificar que la aplicación puede manejar una gran carga por un largo periodo de tiempo.

CONFIGURACION DE APACHE JMETER

Descargar todos los componentes necesarios para Apache JMeter
Tu necesitas primero descargar la ultima versión de Apache JMeter. Claro Ud. tiene que tener instalado JAVA adecuadamente en su sistema operativo (JAVA_HOME como variable de entorno).
 JMeter simplemente se descomprime en el directorio de tu preferencia.
JAVA ( jdk version 1.7 o reciente) :

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Apache JMeter Binaries:

http://jmeter.apache.org/download_jmeter.cgi

 

Como ejecutar Apache JMeter

Descomprimimos el archivo respectivo y buscamos en el directorio bin los archivos JMeter.sh (para Linux o mac) o JMeter.bat (para Windows).

 

Ejecutar tu primer script en JMeter

Después de ejecutar JMeter seguiremos los siguientes pasos para crear un simple script para verificar con una carga de 5 usuarios nuestro sitio web.
En Windows el .bat no necesita permisos. En Linux o mac si es necesario dar permiso de ejecución antes de lanzar el .sh. Observe en la figura:

 De esta manera el JMeter es ejecutado.

 

Paso 1: Crear un grupo de Hilos y darle valores

Para crear el grupo de hilos, clic derecho en Testplan y Add – Thread – Thread Group. Luego establecer el valor de 5 en Number of Thread y dejar los otros campos con sus valores por defecto. Esto debido a que queremos verificar con una carga de 5 usuarios en 1 segundo.

 

 

Crear una vista de resultado
Para crear una vista de resultado  (View Result Tree), clic derecho en Testplan y  escoger Add – Listener – View Result Tree. No se necesita cambiar nada en view result tree. Nos tenemos que asegurar que esta vista sea añadida a nuestro script.

Crear un reporte resumen
Para crear un reporte resumen, clic derecho en Tesplan y Add – Listener – Summary Report. Igual que en la opción anterior no necesitamos cambiar nada en este reporte resumen. Nosotros necesitamos verificar los resultados como promedio,  tiempo mínimo y máximo de carga por pagina.

 El resultado final es el siguiente:

 

Crear un HTTP Request y establecer los valores adecuados
Para crear un HTTP Request, clic derecho a Thread Group – Add – Sampler – http Request.
Este es un simple request.  Ver la imagen y establecer los valores. Luego clic en el botón Run para ejecutar el script.

 

Ingrese los datos siguientes:

 

Name: http Request
Server Name or IP: www.joedayz.pe (puede probar con sus aplicaciones)
Implementation: HttpClient4
Path : /
Nota: No olvide dar clic en el botón verde. Si le pide grabar su script guárdelo donde Ud. desee.
Verificar el rendimiento en un reporte
Clic en View Result Tree

 Clic en Summary Report

CONCLUSION

Nosotros podemos medir el rendimiento de la aplicación después de la carga de usuarios simulada. Sin una herramienta como esta no  sería posible verificar este tipo de pruebas.

Esperamos le sea de utilidad.

Joe

Read More

apostle.io

apostle.io es otra startup patrocinada por sitepoint.com que me ha gustado mucho porque siempre el tema de enviar e-mails es un dolor (pain) de cabeza. En fin el registro fue sencillo, puedes usar github o facebook si lo deseas o abrir tu cuenta ingresando tus datos desde cero. Empece creando mi template.

El que tiene un editor para crear tu template html.

Así como el status de cada mail, si reboto, si logro llegar, si ya lo abrieron y si fallo nos muestra también un detalle al respecto.

Ahora tu lo puedes integrar a tus aplicaciones muy rápidamente porque tiene soporte para diferentes lenguajes.

 

Finalmente, aquí les paso algunos test que realice.
1. Test para enviar unos mails de prueba

 2. Test para enviar varios mails (ya uds. se la ingenian para leer de algún archivo, BD, etc)

Hay muchas características mas que voy descubriendo. Te invito a probarlo y ver si puede ser útil para tus proyectos.

IMPORTANTE:
Los primeros 5000 mails son gratuitos. De ahí ya te pide hacer un upgrade a tu plan para poder enviar hasta 15000 por solo 19$ y luego te cobra por bloque.

Enjoy!

Joe

Read More