Node para Javeros: Conoce a tu enemigo

Node para Javeros
Conoce a tu enemigo
Micael Gallego (CodeURJC)
@micael_gallego
MAD · NOV 24-25 · 2017

Node para Javeros · @micael_gallego
Este quién es?
@micael_gallego
micael.gallego@urjc.es
@micaelgallego
Profesor Universitario / Formador & Consultor
Developer

Consultancy / Training
Cloud Computing
Web Technologies
Extreme Programming
Testing / Git / Jenkins
Software Architecture
Concurrent Programming
http://codeurjc.es
Open source elastic platform
for end to end testing
http://elastest.io
Log Analysis
Test orchestration and comparison
Web and Mobile testing
Security testing
IoT testing
Performance testing

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?
I

Realmente
node.js se usa
tanto?

Node para Javeros · @micael_gallegohttps://medium.com/the-node-js-collection/node-js-state-of-the-union-blog-2017-ed86640ec451
Node.js Interactive 2017

https://nodejs.org/static/documents/casestudies/Nodejs_2017_User_Survey_Exec_Summary.pdf
2017 Node.js
Users Survey

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

public class Empleado {
private String nombre;
private double salario;
public Empleado(String nombre,
double salario){
this.nombre = nombre;
this.salario = salario;
}
public String getNombre(){
return nombre;
}
public String toString(){
return "Nombre:"+nombre+
", Salario:"+salario;
}
}
Java
export class Empleado {
private nombre:string;
private salario:number;
constructor(nombre:string,
salario:number){
this.nombre = nombre;
this.salario = salario;
}
getNombre():string {
return this.nombre;
}
toString(): string{
return "Nombre:"+this.nombre+
", Salario:"+this.salario;
}
}
TypeScript
Java vs TypeScript

List<Empleado> emps = new ArrayList<>();
emps.add(new Empleado('Pepe', 500));
emps.add(new Empleado('Juan', 200));
for(Empleado emp : emps){
System.out.println(emp.getNombre());
}
empleados.forEach(emp -> {
System.out.println(emp);
});
Java
import { Empleado } from "./Empleado";
let emps = new Array<Empleado>();
emps.push(new Empleado('Pepe', 500));
emps.push(new Empleado('Juan', 200));
for(let emp of emps){
console.log(emp.getNombre());
}
empleados.forEach(emp => {
console.log(emp);
});
TypeScript
Java vs TypeScript

● TypeScript es más flexible
– Tipado opcional
– Tipos union
– Objetos literales (sin clase)
– Cambio dinámico de objetos
– Implementación implícita de
interfaces
● Java es más rígido
– No funciones fuera de
objetos
– No inferencia de tipos*
– Clases para objetos
– Más verboso
* En Marzo 2018 lo tendremos
Java vs TypeScript
Pero son muy parecidos

Kotlin es mucho más parecido aTS que Java
●
Sintaxis más concisa
●
Funciones de alto nivel
●
Inferencia de tipos
●
Casting implícito con instanceof
●
Data classes
Java vs TypeScript
* Existe compilador de Kotlin a JavaScript

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

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

vs

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

rígido, verboso
complicado
pero ordenado!
caótico, propenso a
errores, no estructurado
pero flexible!
Históricamente...

más flexible y
menos verboso
(lambdas)
Más estructurado y menos
propenso a errores
(let, arrow, modulos)
Actualmente...

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

Librería estándar
Clases esenciales para
interoperabilidad, comunicación
con el sistema y red
Además de las esenciales,
Swing, AWT, CORBA, MIDI y
muuuuchas más ;)

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ía estándar

https://www.npmjs.com/
https://search.maven.org/
Java Node
Librerías de terceros

Node para Javeros · @micael_gallegohttp://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
Declarative XML Logic
Declarative and imperative Groovy
Imperative JavaScript
Bash scripts & JavaScript tools

Siempre acabas
poniendo pegamento
en scripts ;)
Project lifecycle

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
Navegador
web
Servidor
web
URL
HTML + Imágenes
JSON

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

● Ventajas
● Administración centralizada
● Desarrolladores
despreocupados de
aspectos de despliegue
● Inconvenientes
● Administración centralizada
● Desarrolladores
despreocupados de
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
● Difícil actualizar el “servidor de
aplicaciones” por los problemas de
compatibilidad entre aplicaciones
● Muuuchos años con Java 6 ;)
● Desarrollo muy pesado
Así se compartían
servidores cuando
la virtualización
no era mainstream

● 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
● Orientado a objetos (clases)
● Inyección de dependencias
● Síncrono (bloqueante)
● Anotaciones en código para
configuración
● Object Relational Mapping
(ORM) para BBDD SQL
● Funcional
● Asíncrono (no bloqueante)
● Configuración con funciones
● Bases de datos documentales
NoSQL (MongoDB)
tradicional...

● Funcional
● Asíncrono (no
bloqueante)
● Configuración
con funciones
en la actualidad...
import io.vertx.core.AbstractVerticle;
public class Server extends AbstractVerticle {
public void start() {
vertx.createHttpServer().requestHandler(req -> {
req.response()
.putHeader("content-type", "text/plain")
.end("Hello from Vert.x!");
}).listen(8080);
}
}
http://vertx.io/

● Funcional
● Asíncrono (no bloqueante)
● Configuración con funciones
en la actualidad...
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));
});
Reactor +
WebFlux
http://www.baeldung.com/spring-5-functional-web

● 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
en la actualidad...
https://github.com/mauricio/postgresql-async

La misma librería de programación reactiva para Java y Node
en la actualidad...
RxJava RxJS

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

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

Cualquier estilo se puede usar
ambas plataformas

Rendimiento
(la máquina virtual)

JVM
Java Virtual Machine
vs

JVM
Java Virtual Machine
● Una de lasVMs más eficientes y optimizadas
● JIT compiler genera código muy optimizado
● Permite concurrencia conThreads del kernel del
sistema
● Gestión de memoria potente (Weak references)

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

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

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

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

Rendimiento
https://www.paypal-engineering.com/2013/11/22/node-js-at-paypal/

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
https://docs.spring.io/spring/docs/5.0.1.RELEASE/spring-framework-reference/web-reactive.html#spring-webflux
Te puedes
hacer tu
propio
procesador si
quieres (como
Google)

Conclusiones

●
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
vs

JAVEROS JAVASCRIPTERS

Node para Javeros
Conoce a tu enemigo
Micael Gallego (CodeURJC)
@micael_gallego
MAD · NOV 24-25 · 2017
Muchas Gracias!!

Node para Javeros: Conoce a tu enemigo

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Node para Javeros: Conoce a tu enemigo

Similar a Node para Javeros: Conoce a tu enemigo (20)

Más de Micael Gallego

Más de Micael Gallego (16)

Último

Último (6)

Node para Javeros: Conoce a tu enemigo