alert("I'd like some Spaghetti!");
alert("I'd like some Chocolate Moose!");
function SwedishChef( food )
{
alert("I'd like some " + food + "!");
}
SwedishChef("Spaghetti");
SwedishChef("Chocolate Moose");
Cook( "lobster",
"water",
function(x) { alert("pot " + x); }
);
Cook( "chicken",
"coconut",
function(x) { alert("boom " + x);}
);
alert("get the lobster");
PutInPot("lobster");
PutInPot("water");
alert("get the chicken");
BoomBoom("chicken");
BoomBoom("coconut");
function Cook( i1, i2, f )
{
alert("get the " + i1);
f(i1);
f(i2);
}
Cook( "lobster", "water", PutInPot );
Cook( "chicken", "coconut", BoomBoom );
funciones anónimas como argumentos
var a = [1,2,3];
for (i=0; i<a.length; i++)
{
a[i] = a[i] * 2;
}
function map(fn, a)
{
for (i = 0; i < a.length; i++)
{
a[i] = fn(a[i]);
}
}
map( function(x){return x*2;}, a );
map( alert, a );
funciones anónimas como argumentos
function sum(a)
{
var s = 0;
for (i = 0; i < a.length; i++)
s += a[i];
return s;
}
function join(a)
{
var s = "";
for (i = 0; i < a.length; i++)
s += a[i];
return s;
}
alert(sum([1,2,3]));
alert(join(["a","b","c"]));
function reduce(fn, a, init)
{ var s = init;
for (i = 0; i < a.length; i++)
s = fn( s, a[i] );
return s;
}
function sum(a)
{ return reduce(
function(a, b){ return a + b; },
a,
0 );
}
function join(a)
{ return reduce(
function(a, b){ return a + b; },
a,
"" );
}
funciones anónimas como argumentos
function pair(a)
{ var s = [];
for (i = 0; i < a.length; i++){
if (a[i]%2==0){
s.push(a[i]);
}
}
return s;
}
alert(pair([1,2,3]));
function filter(fn, a)
{ var s = init;
for (i = 0; i < a.length; i++)
s = fn( s, a[i] );
return s;
}
function pair(a)
{ return filter(
function(x){ return (x%2==0); },
a);
}
funciones anónimas como argumentos
"se pueden pasar como argumento"
map( function(x){return x*2;}, a );
map( alert, a );
sin efectos colaterales
mismas salidas para mismas entradas
a = b + c
fáciles de concatenar
x = y + z
a = x - b
a = y + z - b
sin estado
inmutables
Haskell Curry (1900 – 1982)
function(x) {
return function(y) {
return x + y;
};
}
function(x, y) {
return x + y;
}
(x, y) → x + y
x → (y → x + y)
function g(h) {
return function(y) {
return h(h(y));
};
}
1000 === g(function(x) {
return x * x;
})(10);
function g(h) {
return function(y) {
return h(h(y));
};
}
var n = g(function(x) {
return x * x;
});
1001000 === n(10) + n(100);
funciones que reciben funciones y devuelven funciones
muchos patrones son específicos del paradigma,
resuelven problemas específicos del paradigma...
...cada paradigma tiene sus patrones
cómo
qué
~ otro paradigma ~
var a = [1,2,3];
for (i=0; i<a.length; i++)
{
a[i] = a[i] * 2;
}
map( function(x){return x*2;}, a );
- trabajar con funciones puras
- un lenguaje con funciones como first-class citizen
- funciones de orden superior
"propagación del cambio"
FRP = FP + RP
mismas entradas dan mismas salidas
siempre input - transform - output
+
... pero las aplicaciones
dan outputs diferentes ...
... porque en las aplicaciones
los inputs varian con el tiempo.
el estado de la aplicación es la combinación de los inputs
clásicamente el programador conoce el estado e indica cómo hace la máquina
aquí el programador indica qué hace la máquina en función de los inputs
un puñado de clicks
una secuencia de entrada
un array de eventos
stream
patrones relacionados con emitir y recibir
Iterator y Observer
Iterador:
Wikipedia:
"define una interfaz que declara los métodos necesarios para acceder secuencialmente a un grupo de objetos de una colección."
Observer:
Wikipedia:
"define una dependencia del tipo uno-a-muchos entre objetos, de manera que cuando uno de los objetos cambia su estado, notifica este cambio a todos los dependientes."
Iterador
Observer
productor tiene el control
receptor tiene el control
Observable
next,
error,
last
next,
error,
last
Using Rx, developers represent
asynchronous data streams with Observables,
query asynchronous data streams using LINQ operators, and
parameterize the concurrency in the asynchronous data streams using Schedulers.
Simply put, Rx = Observables + LINQ + Schedulers.
Reactive Extensions Library
stream - function - stream
"eventos se interpretan como datos entrantes, el sistema responde en tiempo real"
FRP es el nuevo OOP
- Internet had 280 million users.
- Java se vendía bien por el "escríbelo una vez, ejecutalo en cualquier sitio"
(Cualquier sitio en el que se instalar JVM, sin conceptos de Cloud ni IoT)
- J2EE, SOA, and XML
- The Internet had 1 billion users.
- Facebook had 5.5 million users.
- YouTube was a newborn (February, 2005).
- Twitter wasn’t alive yet (2006).
- Netflix had yet to introduce video streaming (2007).
- 2,950,000,000 (2.95 billion)
- China alone has 640 million Internet users.
- The United States has 280 million.
- Two of the most popular websites today:
- Facebook — 1.3 billion users.
- Twitter — 270 million users.
¿responderá correctamente la programación reactiva?
enorme cantidad de eventos en tiempo real que dan alta interactividad al usuario.
nos enfrentamos a enormes problemas de escala, expectativas y confianza en el software de nuestra vida cotidiana.
se puede ver como algunos paradigmas del pasado puede que no se escalen bien en el presente, y seguramente no en el futuro.
FRP es el nuevo OOP
"Systems built as Reactive Systems are more flexible, loosely-coupled and scalable.
This makes them easier to develop and amenable to change.
They are significantly more tolerant of failure and when failure does occur they meet it with elegance rather than disaster.
Reactive Systems are highly responsive, giving users effective interactive feedback."
hay mucho más
hay mucho más
hay mucho más
¿a quién seguir?