Node para Javeros: Conoce a tu enemigo

Node.js es una tecnología cada vez más popular para el desarrollo de servicios web. Grandes abanderados de Java como Netflix están usando cada vez más JavaScript para implementar parte de su backend. Pese a esta realidad, muchos javeros como yo no quieren tocar JavaScript ni con un palo, y cuando hay que hacerlo, sólo en el browser.

Si eres javero y no te gusta JavaScript, en esta presentación tendrás una visión general sobre cómo desarrollar servicios web con Node.js. Verás cómo con TypeScript, async/await y frameworks como Nest y TypeORM no echarás de menos a Spring y JPA. Pero lo mismo pasa al revés, verás cómo en Java también puedes implementar apps con los mismos principios reactivos y funcionales tan comunes en Node.js.

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

2. Node para Javeros · @micael_gallego
Este quién es?
@micael_gallego
[email protected]
@micaelgallego
Profesor Universitario / Formador & Consultor
Developer

3. Node para Javeros · @micael_gallego
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

4. Node para Javeros · @micael_gallego

5. Node para Javeros · @micael_gallego
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

6. Node para Javeros · @micael_gallego
Realmente
node.js se usa
tanto?

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

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

10. vs

12. Node para Javeros · @micael_gallego
El lenguaje
(o los lenguajes)

13. Node para Javeros · @micael_gallego
Java Node
ES5 / ES6 / ES2016

14. Node para Javeros · @micael_gallego
Java vs TypeScript
●
Tipado estático
●
Imperativo y funcional
●
Recolector de basura
●
Orientado a objetos
●
Modularidad con paquetes

15. 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

16. 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

17. Node para Javeros · @micael_gallego
●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

18. Node para Javeros · @micael_gallego
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
Java vs TypeScript
* Existe compilador de Kotlin a JavaScript

20. Node para Javeros · @micael_gallego
●Imperativo y
funcional
●Asíncrono / No
concurrente
●Muy flexible
●Tipado dinámico
●Funciones como
elementos de primera
clase
●Orientado a objetos
con prototipos

23. Node para Javeros · @micael_gallego
Afortunadamente JavaScript ha mejorado
mucho (muchísimo) con ES6 y ES7
●Async / Await
●Map
●Módulos
●Declaración let y const
●Arrow functions
●Clases

24. Node para Javeros · @micael_gallego
vs

25. Node para Javeros · @micael_gallego
vs
Ni idea…
habrá que
preguntar al
maestro Iván
López ;)

26. Node para Javeros · @micael_gallego
rígido, verboso
complicado
pero ordenado!
caótico, propenso a
errores, no estructurado
pero flexible!
Históricamente...

27. Node para Javeros · @micael_gallego
más flexible y
menos verboso
(lambdas)
Más estructurado y menos
propenso a errores
(let, arrow, modulos)
Actualmente...

28. Node para Javeros · @micael_gallego
Librerías
(la estándar y las de
terceros)

29. Node para Javeros · @micael_gallego
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 ;)

30. 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

31. Node para Javeros · @micael_gallego
https://www.npmjs.com/
https://search.maven.org/
Java Node
Librerías de terceros

32. Node para Javeros · @micael_gallegohttp://www.modulecounts.com/
Librerías de terceros

33. Node para Javeros · @micael_gallego
Hay “módulos” que
tienen una única
función, así
cualquiera ;)
https://www.npmjs.com/
https://www.npmjs.com/package/left-pad
Librerías de terceros

34. Node para Javeros · @micael_gallego
Project lifecycle
(aka building)

35. Node para Javeros · @micael_gallego
Project lifecycle
Java Node
Scripts
Declarative XML Logic
Declarative and imperative Groovy
Imperative JavaScript
Bash scripts & JavaScript tools

36. Node para Javeros · @micael_gallego
Siempre acabas
poniendo pegamento
en scripts ;)
Project lifecycle

37. Node para Javeros · @micael_gallego
Frameworks
Web / REST

38. Node para Javeros · @micael_gallego
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

39. Node para Javeros · @micael_gallego
Java EE / Servidores Web
Glassfish
●Un gran servidor
administrador
●Múltiples aplicaciones
Java desplegadas
Tomcat
Frameworks Web / REST

40. Node para Javeros · @micael_gallego
Java EE / Servidores Web
●Ventajas
●Administración centralizada
●Desarrolladores
despreocupados de
aspectos de despliegue
●Inconvenientes
●Administración centralizada
●Desarrolladores
despreocupados de
aspectos de despliegue
Frameworks Web / REST

41. Node para Javeros · @micael_gallego
Java EE / Servidores Web
●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
Frameworks Web / REST

42. Node para Javeros · @micael_gallego
Java EE / Servidores Web
●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
Frameworks Web / REST

43. Node para Javeros · @micael_gallego
●La app incluye el servidor, es autocontenida
●Arranca de forma instantánea
●Ciclo de editar / probar muy rápido
Frameworks Web / REST

44. Node para Javeros · @micael_gallego
Java se modernizó
En 2012 surgió el movimiento “containerless”
ofreciendo la misma experiencia en Java
spring
boot
Frameworks Web / REST

45. Node para Javeros · @micael_gallego
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...

46. Node para Javeros · @micael_gallego
Estilo de programación
●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/

47. Node para Javeros · @micael_gallego
Estilo de programación
●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

48. Node para Javeros · @micael_gallego
Estilo de programación
●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

49. Node para Javeros · @micael_gallego
Estilo de programación
La misma librería de programación reactiva para Java y Node
en la actualidad...
RxJava RxJS

50. Node para Javeros · @micael_gallego
Estilo de programación
●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);
}
}

51. Node para Javeros · @micael_gallego
Estilo de programación
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);

52. Node para Javeros · @micael_gallego
Estilo de programación
Cualquier estilo se puede usar
ambas plataformas

53. Node para Javeros · @micael_gallego
Rendimiento
(la máquina virtual)

54. Node para Javeros · @micael_gallego
JVM
Java Virtual Machine
vs

55. Node para Javeros · @micael_gallego
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)

56. Node para Javeros · @micael_gallego
●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

57. Node para Javeros · @micael_gallego

58. Node para Javeros · @micael_gallego
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

59. Node para Javeros · @micael_gallego
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

60. Node para Javeros · @micael_gallego
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

61. Node para Javeros · @micael_gallego
Rendimiento
https://www.paypal-engineering.com/2013/11/22/node-js-at-paypal/

62. Node para Javeros · @micael_gallego
Rendimiento
https://www.tandemseven.com/blog/performance-java-vs-node/

63. Node para Javeros · @micael_gallego
Rendimiento
https://www.tandemseven.com/blog/performance-java-vs-node/

64. Node para Javeros · @micael_gallego
Rendimiento
●Cómo comparar?
–Cálculos intensivos?
–Uso intensivo de IO?
–Java síncrono vs Node asíncrono? Y los
dos asíncronos?

65. Node para Javeros · @micael_gallego
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

66. Node para Javeros · @micael_gallego
Rendimiento
Si para tí lo más importante es el
rendimiento, por qué no
programas en C++? O en C?
O en ensamblador?

67. Node para Javeros · @micael_gallego
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)

68. Node para Javeros · @micael_gallego
Conclusiones

69. Node para Javeros · @micael_gallego
●
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

70. Node para Javeros · @micael_gallego
●
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

71. Node para Javeros · @micael_gallego
Usa el que más te guste!
Siempre podrás trolear el otro por algo ;)
vs

72. Node para Javeros · @micael_gallego
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

73. Node para Javeros · @micael_gallego
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

74. Node para Javeros · @micael_gallego
JAVEROS JAVASCRIPTERS

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