Node para Javeros4 PDF

Node para Javeros
Conoce a tu enemigo
Micael Gallego (CodeURJC)

@micael_gallego
MAD · NOV 24-25 · 2017
Este quién es?
Developer
@micael_gallego Profesor Universitario / Formador & Consultor

micael.gallego@urjc.es
@micaelgallego
Node para Javeros · @micael_gallego
Consultancy / Training
Open source elastic platform
Cloud Computing for end to end testing
Web Technologies
Extreme Programming Log Analysis
Testing / Git / Jenkins Test orchestration and comparison
Software Architecture Web and Mobile testing
Concurrent Programming Security testing

IoT testing
Performance testing
http://codeurjc.es http://elastest.io
Es de verdad Node.js tan
bueno como lo pintan?
Será una tecnología para hacer

software “de verdad”?
Me estaré haciendo
mayor?
Soy un Javasaurio?
Node para Javeros · @micael_gallego I
Realmente
node.js se usa
tanto?

Node.js Interactive 2017
https://medium.com/the-node-js-collection/node-js-state-of-the-union-blog-2017-ed86640ec451
2017 Node.js
Users Survey
https://nodejs.org/static/documents/casestudies/Nodejs_2017_User_Survey_Exec_Summary.pdf
vs
El lenguaje
(o los lenguajes)

Java Node
ES5 / ES6 / ES2016

Java vs TypeScript
●
Tipado estático
●
Imperativo y funcional
●
Recolector de basura
●
Orientado a objetos
●
Modularidad con paquetes

Java vs TypeScript
Java TypeScript
public class Empleado { export class Empleado {
private String nombre; private nombre:string;

private double salario; private salario:number;
public Empleado(String nombre, constructor(nombre:string,

double salario){ salario:number){
this.nombre = nombre; this.nombre = nombre;
this.salario = salario; this.salario = salario;
} }
public String getNombre(){ getNombre():string {

return nombre; return this.nombre;
} }
public String toString(){ toString(): string{

return "Nombre:"+nombre+ return "Nombre:"+this.nombre+
", Salario:"+salario; ", Salario:"+this.salario;
} }
} }
Java vs TypeScript
Java TypeScript
import { Empleado } from "./Empleado";
List<Empleado> emps = new ArrayList<>(); let emps = new Array<Empleado>();
emps.add(new Empleado('Pepe', 500)); emps.push(new Empleado('Pepe', 500));

emps.add(new Empleado('Juan', 200)); emps.push(new Empleado('Juan', 200));
for(Empleado emp : emps){ for(let emp of emps){

System.out.println(emp.getNombre()); console.log(emp.getNombre());
} }
empleados.forEach(emp -> { empleados.forEach(emp => {

System.out.println(emp); console.log(emp);
}); });
Java vs TypeScript
● Java es más rígido ● TypeScript es más flexible

– No funciones fuera de – Tipado opcional
objetos – Tipos union
– No inferencia de tipos* – Objetos literales (sin clase)
– Clases para objetos – Cambio dinámico de objetos
– Más verboso – Implementación implícita de
interfaces
Pero son muy parecidos
* En Marzo 2018 lo tendremos Node para Javeros · @micael_gallego
Java vs TypeScript
Kotlin es mucho más parecido a TS que Java
●
Sintaxis más concisa
●
Funciones de alto nivel
●
Inferencia de tipos
●
Casting implícito con instanceof
●
Data classes
* Existe compilador de Kotlin a JavaScript

● Tipado dinámico ● Imperativo y
● Funciones como funcional
elementos de primera ● Asíncrono / No
clase concurrente
● Orientado a objetos ● Muy flexible
con prototipos

Afortunadamente JavaScript ha mejorado
mucho (muchísimo) con ES6 y ES7
● Declaración let y const ● Async / Await
● Arrow functions ● Map
● Clases ● Módulos

vs

vs
Ni idea…
habrá que
preguntar al
maestro Iván
López ;)

Históricamente...
rígido, verboso caótico, propenso a

complicado errores, no estructurado
pero ordenado! pero flexible!

Actualmente...
más flexible y Más estructurado y menos

menos verboso propenso a errores
(lambdas) (let, arrow, modulos)

Librerías
(la estándar y las de
terceros)

Librería estándar
Además de las esenciales, Clases esenciales para

Swing, AWT, CORBA, MIDI y interoperabilidad, comunicación
muuuuchas más ;) con el sistema y red

Librería estándar
Es uno de los motivos por los

que han creado módulos en
Java 9
Así se pueden crear paquetes

sólo con las clases esenciales
Librerías de terceros
Java Node
https://www.npmjs.com/
https://search.maven.org/

http://www.modulecounts.com/
Hay “módulos” que

tienen una única
función, así
cualquiera ;)
https://www.npmjs.com/
https://www.npmjs.com/package/left-pad

Project lifecycle
(aka building)

Project lifecycle
Java Node
Scripts
Bash scripts & JavaScript tools

Declarative XML Logic
Declarative and imperative Groovy

Imperative JavaScript

Project lifecycle
Siempre acabas
poniendo pegamento
en scripts ;)

Frameworks
Web / REST

Frameworks Web / REST
Uno de los usos princiaples de Java y Node es el

desarrollo de apps web MVC o con API REST
URL
Navegador Servidor
web web
HTML + Imágenes
JSON

Java EE / Servidores Web
● Un gran servidor
administrador
● Múltiples aplicaciones
Java desplegadas Glassfish Tomcat

● Ventajas ● Inconvenientes
● Administración centralizada ● Administración centralizada
● Desarrolladores ● Desarrolladores
despreocupados de despreocupados de
aspectos de despliegue aspectos de despliegue

● Más inconvenientes
● Difícil actualizar el “servidor de
aplicaciones” por los problemas de
compatibilidad entre aplicaciones
● Muuuchos años con Java 6 ;)
● Desarrollo muy pesado
● Más inconvenientes Así se compartían

● Difícil actualizar el “servidor de servidores cuando
aplicaciones” por los problemas de la virtualización
compatibilidad entre aplicaciones no era mainstream
● Muuuchos años con Java 6 ;)
● Desarrollo muy pesado
● La app incluye el servidor, es autocontenida

● Arranca de forma instantánea
● Ciclo de editar / probar muy rápido

Java se modernizó
En 2012 surgió el movimiento “containerless”
ofreciendo la misma experiencia en Java
spring
boot
Estilo de programación
tradicional...
● Orientado a objetos (clases)

● Funcional
● Inyección de dependencias
● Asíncrono (no bloqueante)
● Síncrono (bloqueante)
● Configuración con funciones
● Anotaciones en código para
configuración ● Bases de datos documentales
NoSQL (MongoDB)
● Object Relational Mapping
(ORM) para BBDD SQL
en la actualidad...
import io.vertx.core.AbstractVerticle;
public class Server extends AbstractVerticle {
● Funcional public void start() {

vertx.createHttpServer().requestHandler(req -> {
req.response()
● Asíncrono (no .putHeader("content-type", "text/plain")
bloqueante) .end("Hello from Vert.x!");
}).listen(8080);
}
● Configuración }
con funciones
http://vertx.io/
en la actualidad...
Reactor + ● Funcional
● Asíncrono (no bloqueante)
WebFlux ● Configuración con funciones
RouterFunction<?> route = route(GET("/person/{id}"),

request -> {
Mono<Person> person = Mono.justOrEmpty(request.pathVariable("id"))
.map(Integer::valueOf)
.then(repository::getPerson);
return Response.ok().body(fromPublisher(person, Person.class));
});
http://www.baeldung.com/spring-5-functional-web
en la actualidad...
● Aunque años de sólo programación síncrona tienen su

peso…
– Las herramientas, IDEs no están muy desarrolladas
– No hay drivers oficiales asíncronos a BBDD relacionales
– Hay clientes MySQL / PostgreSQL asíncronos pero
limitados en funcionalidad
https://github.com/mauricio/postgresql-async
en la actualidad...
RxJava RxJS
La misma librería de programación reactiva para Java y Node

en la actualidad...
● Orientado a Objetos
● Inyección de dependencias
● Clases y anotaciones
@Controller('cats')
export class CatsController {
constructor(private catsService: CatsService) {}
@Post()
async create(@Body() cat: Cat) {
this.catsService.create(cat);
}
} Node para Javeros · @micael_gallego
en la actualidad...
const user = new User();

user.firstName = "Timber";
user.lastName = "Saw";
user.age = 25;
@Entity() await repository.save(user);
export class User {
const allUsers = await repository.find();
@PrimaryGeneratedColumn() const firstUser = await repository.findOneById(1);
id: number; const timber = await repository.findOne({
firstName: "Timber", lastName: "Saw" });
@Column()
firstName: string; await repository.remove(timber);
@Column()
age: number;
}
http://typeorm.io
Cualquier estilo se puede usar

ambas plataformas

Rendimiento
(la máquina virtual)

JVM vs
Java Virtual Machine

JVM
Java Virtual Machine
● Una de las VMs más eficientes y optimizadas

● JIT compiler genera código muy optimizado
● Permite concurrencia con Threads del kernel del
sistema
● Gestión de memoria potente (Weak references)

● Una de las VMs con menor latencia para iniciar
la ejecución de un programa
● Implementa un EventLoop
● Sólo permite un hilo de ejecución

Rendimiento
Sistemas Multicore
Modelo de concurrencia de Existe el paso de mensajes,

memoria mutable compartida pero no se suele usar
● Potente, bajo nivel, máximo ● Fuerza el modelo asíncrono
control (no bloqueante)
● Pero complejo… data races, ● Mucho más sencillo
errores que aparecen cuando ● Más limitado para
hay mucha carga, difíciles de aprovechar al máximo la
depurar CPU
Rendimiento
Escalabilidad
Modelo bloqueante Modelo asíncrono

● Un hilo por petición (hasta un ● Cuando la lógica tiene que
máximo) esperar por la respuesta de IO,
el hilo se aprovecha para otra
● Con muchas peticiones que petición
esperen a la BBDD la mayor
parte del tiempo se ● Se suelen tener tantos hilos
desperdician recursos como cores

Rendimiento
Escalabilidad
Modelo asíncrono
● Un proceso node por core
● Balanceo con un router externo
● Se suelen comunicar usando
sistemas externos (Redis)
● Facilita escalabilidad horizontal

Rendimiento
https://www.paypal-engineering.com/2013/11/22/node-js-at-paypal/
Rendimiento
https://www.tandemseven.com/blog/performance-java-vs-node/
Rendimiento
https://www.tandemseven.com/blog/performance-java-vs-node/
Rendimiento
● Cómo comparar?
– Cálculos intensivos?
– Uso intensivo de IO?
– Java síncrono vs Node asíncrono? Y los
dos asíncronos?

Rendimiento
● El rendimiento tiene muchas características y

significados. No bloqueante y reactivo en general no
hace que las aplicaciones se ejecuten más rápido.
● El beneficio del estilo no-bloqueante es la habilidad de
escalar con un número pequeño y fijo de hilos y menos
memoria. Eso hace a las aplicaciones más resilientes
bajo carga porque escalan de forma más predecible.
https://docs.spring.io/spring/docs/5.0.1.RELEASE/spring-framework-reference/web-reactive.html#spring-webflux
Rendimiento
Si para tí lo más importante es el

rendimiento, por qué no
programas en C++? O en C?
O en ensamblador?

Rendimiento
Te puedes
hacer tu
propio
procesador si
quieres (como
Google)
https://docs.spring.io/spring/docs/5.0.1.RELEASE/spring-framework-reference/web-reactive.html#spring-webflux
Conclusiones

vs
●
Las plataformas cada vez se parecen más entre sí
●
Se puede elegir cualquier estilo de programación
– Lenguaje tipado estático o dinámico
– Mas orientado a objetos o más funcional
– Con o sin anotaciones
– Inyección de dependencias
●
Son comparables en rendimiento

vs
●
Elige plataforma, lenguaje y estilo en función de…
– Experiencia del equipo (frontend developers?)
– Importancia del rendimiento algoritmico vs IO
– Tamaño del equipo (cuanto más grande, más se valoran
los tipos estáticos)
– Riesgos asumibles (Java es rock solid)

vs
Usa el que más te guste!

Siempre podrás trolear el otro por algo ;)

vs
Puede tener sentido usar las dos tecnologías a la vez?

●
Es cada vez más habitual que una app con arquitectura
microservicios use tecnologías diferentes en cada
microservicio

vs
Puede tener sentido usar las dos tecnologías a la vez?

●
Netflix, arquitectura microservicios en Java, está
incorporando MS en NodeJS para Backend as a Service

JAVEROS JAVASCRIPTERS

Node para Javeros
Conoce a tu enemigo
Muchas Gracias!!
Micael Gallego (CodeURJC)

@micael_gallego
MAD · NOV 24-25 · 2017

Node para Javeros4 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Node para Javeros4 PDF

Cargado por

Copyright:

Formatos disponibles

Node para Javeros

Micael Gallego (CodeURJC)

@micael_gallego Profesor Universitario / Formador & Consultor

Software Architecture Web and Mobile testing

Concurrent Programming Security testing

Será una tecnología para hacer

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

private String nombre; private nombre:string;

public Empleado(String nombre, constructor(nombre:string,

public String getNombre(){ getNombre():string {

public String toString(){ toString(): string{

List<Empleado> emps = new ArrayList<>(); let emps = new Array<Empleado>();

emps.add(new Empleado('Pepe', 500)); emps.push(new Empleado('Pepe', 500));

for(Empleado emp : emps){ for(let emp of emps){

empleados.forEach(emp -> { empleados.forEach(emp => {

● Java es más rígido ● TypeScript es más flexible

* Existe compilador de Kotlin a JavaScript

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

rígido, verboso caótico, propenso a

Node para Javeros · @micael_gallego

más flexible y Más estructurado y menos

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Además de las esenciales, Clases esenciales para

Node para Javeros · @micael_gallego

Es uno de los motivos por los

Así se pueden crear paquetes

Node para Javeros · @micael_gallego

Hay “módulos” que

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Bash scripts & JavaScript tools

Declarative and imperative Groovy

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Node para Javeros · @micael_gallego

Uno de los usos princiaples de Java y Node es el

Node para Javeros · @micael_gallego

Java EE / Servidores Web

Node para Javeros · @micael_gallego

Java EE / Servidores Web

Node para Javeros · @micael_gallego

Java EE / Servidores Web

Java EE / Servidores Web

● Más inconvenientes Así se compartían

● La app incluye el servidor, es autocontenida

Node para Javeros · @micael_gallego

● Orientado a objetos (clases)

public class Server extends AbstractVerticle {

● Funcional public void start() {

RouterFunction<?> route = route(GET("/person/{id}"),

● Aunque años de sólo programación síncrona tienen su

Node para Javeros · @micael_gallego

constructor(private catsService: CatsService) {}

const user = new User();

Cualquier estilo se puede usar

Node para Javeros · @micael_gallego