PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONA

PARADIGMAS FP Y OOP
USANDO TÉCNICAS AVANZADAS
DE PROGRAMACIÓN ASÍNCRONA
Cátedra Capgemini 2016/17 - Universitat de València a la innovación en el desarrollo de Software

Me presento ...
Víctor M. Bolinches
Software Architect en Capgemini.
Founder Programmer en PlayGram Games.
Ninja Developer en Indie VideoGames Development.
Github Linkedin Twitter
vicboma1 victorbolinches @vicboma1
2

Conceptos Básicos
Abstracciones semánticas
3

Paradigmas de Programación
▹ OOP
▸ Estructura de datos llamados objetos
▸ Aglutinan propiedades y métodos
▸ Manipula datos de entrada para generar datos de salida específicos
▹ FP
▸ Estructura mediante expresiones
▸ Variables sin estado e inmutables
▸ Recursión y Funciones de primer orden
▸ Definición de cómputos y cálculo de lambdas
4

Objeto inmutable
▹ Objeto cuyo estado no puede ser modificado
▹ Seguridad de trabajo en proceso Multihilos
▹ Java/C#: String, Integer, Long, Short…
▹ Scala : val (keyword)
▹ C++ : “const”
6

Lambdas
▹ Bloque de código abstracto
▹ Procesamiento inline
▸ Árboles de decisión
▸ Delegados
▹ Parámetros de entrada y salida
▹ Inferencia de tipos
7

Lambdas
class A {
public void foo() {
Arrays.asList(1,2,3,4,5,6).forEach( s -> { System.out.println(s); } );
}
}
...eq
class A {
public void foo() {
Arrays.asList(1,2,3,4,5,6).forEach( [lambda for lambda$1 as Block] );
}
static void lambda$1(String s) {
System.out.println(s);
return;
}
8

Traits
▹ Tipos abstractos
▹ Modelo conceptual simple
▹ Incluye definición de métodos
9

Traits - Mejores prácticas por composición
public class BaseClass {
protected Logger logger = LoggerFactory.getLogger(this.getClass());
@Override public Integer foo() { logger().info("foo…!!!!"); }
}
...
public interface Loggable {
default Logger getLogger(){
return LoggerFactory.getLogger(this.getClass());
}
public class BaseClass implements Loggable , Comparable … {
@Override public Integer foo() { getLogger().info("foo…!!!!"); }
}
10

Mixins
▹ Clase abstractas
▹ Modelo conceptual simple
▹ Puede guardar el estado de un objeto
▹ Clase base no tiene control sobre la composición del mixin
11

Mixins
public class abstract AbstractClass {
protected Logger logger = LoggerFactory.getLogger(this.getClass());
@Override public Integer foo() { logger().info("foo…!!!!"); }
}
...
public interface Loggable {
default Logger getLogger(){ return LoggerFactory.getLogger(this.getClass()); }
}
public class abstract AbstractClass implements Loggable {
protected Integer LoggerInfoFoo() { getLogger().info("foo…!!!!"); }
}
public class BaseClass extends AbstractClass {
...
12

Comunicación entre procesos
▹ Síncrono
▸ Intercambio de información en tiempo real
▹ Concurrente
▸ Ejecución simultánea de tareas en tiempo real
▹ Paralelo
▸ Sistema multi-procesado (subdominio concurrente)
▹ Asíncrono
▸ Intercambio de información en tiempo diferido
13

Comunicación entre procesos14

Patrón Promesa
▹ Redirige flujos uniformes
▸ (A)sincronos
▹ Ordenada y estructura bloques
▸ then(myFunctionResolved(), myFunctionRejected())
▹ Flexibiliza nuestro código
▸ CallBacks
▹ Hacer p(), y luego q(), r() y s() - [ p ⇒ q ⇒ r ⇒ s ]
▸ Promise(p).then(q).then(r).then(s);
15

Test-driven Development ( TDD )
▹ Iteraciones
▸ Desarrollo mediante pruebas (Fallo - Acierto)
▸ Refactorizaciones
▹ Implementaciones mínimas necesarias
▹ Minimización del número de errores en producción
▹ Software modular, reutilizable y tolerable a cambios
16

1. Object Oriented Programming
Java 8, kotlin, scala, C#, C/C++, JavaScript ...
18

Java 8
Streams, Function Interface, Threading, CompletableFuture…

Java 8 - Emulador GameBoy DMG 01 / Homebrew
▹ Metodología SOLID + TDD
▹ Desarrollo de un Framework (Winter)
▹ CPU Z80 emulada con un Pool Asíncrono
▹ SRAM emulada para el Display LCD
▹ Backlights customizadas por colores
▹ Tooling
▸ Consola asíncrona para debug
▸ Decompilador de instrucciones Z80
▸ Rom Hacking
20

Java 8 - Ejemplo de uso - Emulador GameBoy21

Java 8 - Mejores Prácticas con Streams { Ejemplos }
▹ Clase que soporta operaciones con estilo funcional
▹ Lambdas
▹ Interfaces funcionales
▹ Métodos y constructores por referencias
▹ Definición de métodos predeterminados y estáticos a
interfaces (Traits ?)
▹ Acceso mediante patrón “Builder” - Pipelines
24

Java 8 - Streams { allMatch }25
/**
* Returns whether all elements of this stream match the provided predicate
* @throws Exception
*/
@Test
public void allMatch() throws Exception {
final boolean result = IntStream.of(0, 1, 2, 3, 4, 5, 6)
.allMatch(value -> value % 1 == 0);
Assert.assertTrue(result);
}

Java 8 - Streams { reduce }26
/** Performs a reduction on the elements of this stream, using an associative accumulation
* function, and returns an Optional describing the reduced value, if any.
* @throws Exception
*/
@Test
public void reduce() throws Exception {
final int expected = 789;
final int result = Arrays.asList(18, 19, 29, 23, 43, 266, 789)
.stream()
.reduce((p1, p2) -> p1 > p2 ? p1 : p2)
.get();
Assert.assertTrue(expected == result);
}

Java 8 - Creando nuestra programación funcional27
▹ Package java.utils.Functions
▸ Function <T,R>, BiFunction <T,U,R>
▸ Consumer <T>, BiConsumer <T,U>
▸ Predicate <T>, BiPredicate <T,U>
▸ Supplier <T>
▸ BinaryOperation <T>
▸ UnaryOperation <T>
▹ @Functional Interface

Java 8 - Creando nuestra programación funcional 128
/**
* Expresión Lambda que suma un incremento de +1
* @throws Exception
*/
Function<Integer,Integer> add1 = x -> x + 1;
@Test
public void addTest() throws Exception {
final int result = add1.apply(1);
}

Java 8 - Migrando OOP a FP29
/**
* Clase que suma un incremento de +2
* @throws Exception
*/
public class Utils { public static Integer add2(Integer x) { return x + 2; } }
Function<Integer,Integer> add2 = Utils::add2;
@Test
public void addTest() throws Exception {
final int result = add2.apply(2);
}

Java 8 - Ejemplo de uso - Scanlines Horizontal w/576i Emu GameBoy30

Java 8 - Ejemplo de uso - Scanlines Horizontal w/576i Emu GameBoy31

Java 8 - Ejemplo de uso - Scanlines Horizontal w/576i Emu GameBoy
▹ Proceso Concurrente
▹ Productor y Consumidor de Imágenes
▹ Recorrido, filtrado y reducciones con Streams
▹ Uso de variables ‘volatiles’ en contexto Threading
32

Java 8 - Programación Asíncrona33
▹ Thread - Runnable
▹ Executors
▹ Callables - Futures
▹ Scheduled Executors
▹ CompletableFuture (Patrón Promesa)
▸ CompletableStage
▸ Future

Java 8 - Threads y Runnables34
final Runnable runnable = () -> {
String threadName = Thread.currentThread().getName();
System.out.println("Hello " + threadName);
};
final Thread thread = new Thread(runnable);
thread.start();
System.out.println("Done!");
… eq
new Thread(() -> { System.out.println("Hello " + Thread.currentThread().getName()) }).start();
System.out.println("Done!");

Java 8 - CompetableFutures (LoadAsync Roms for Gb Emulator)35
public static CompletableFuture<ByteBuffer> read(String filePath, int total) throws Exception {
final CompletableFuture<ByteBuffer> completableFuture = new CompletableFuture();
final AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(filePath), StandardOpenOption.READ);
final ByteBuffer buffer = ByteBuffer.allocate(total);
channel.read(buffer, 0, null, new CompletionHandler<Integer, Void>() {
@Override public void completed(Integer result, Void attachment) {
try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
buffer.flip();
completableFuture.complete(buffer);
}
@Override public void failed(Throwable exc, Void attachment) {
completableFuture.completeExceptionally(exc);
}
});
});
return completableFuture; }

C# - Ejemplo de uso - T-Rex Game Lovely37

C# - Ejemplo de uso - T-Rex Game Lovely38

C# - Ejemplo de uso
▹ Cube Line Match 3
Focus Node Selected**
Auto Remove Link Match
Line / Left outer join**
** Copia de SleepyWings
39

C# - Ejemplo de uso ‘Cube Line Match 3’
▹ Arquitectura MVC + Adaptador
▹ Procesamiento Asíncrono con ‘Tasks’
▹ Pool Threading Task Async
▹ Uso de Linq
▹ ‘Left Outer Join’ sobre LinkedList
▹ Resolución de Matchs por Recursión
40

Unitor - Micro Framework para Unity 2D/3D
▹ Metodología SOLID + TDD
▹ Arquitectura basada en los mejores Frameworks
▸ Contexto
▸ Injector
▸ Dispatcher Asíncrono
▸ CommandMappers Asíncrono
▸ Pre-Configuración de recursos Asíncronos
▸ Promesas
▸ ...
41

C# - Programación Funcional
▹ Delegados
▸ Func<in T, out T>
▸ Action<in T>
▸ Predicate<in T>
▹ Lambdas
▸ Compile-time duck typing (dynamic keyword)
▹ Linq Queries
42

C# - Lambda Expression
public static void Main(string[] args ) {
var first = Array.Find({ new Point(250, 375),new Point(275, 395), new Point(295, 450) },
point => point.X * point.Y > 100000 );
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
}
public static void Main(string[] args) {
var dividir = (x,y) => Console.WriteLine(string.Format("Division: {0}", x/y));
dividir(10,5);
}
public static void Main(string[] args) {
var multiplicar = (x, y) => (x * y);
Console.WriteLine(string.Format("Multiplicar: {0}", multiplicar(10,5));
}
43

C# - Linq Query - TakeWhile
public void TakeWhile_Indexer() {
int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);
Console.WriteLine("First numbers less than 6:");
foreach (var n in firstNumbersLessThan6)
{
Console.WriteLine(n);
}
}
-eq
public static void TakeWhile_Indexer(string[] args ) {
Console.WriteLine("First numbers less than 6:");
new[]{ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 }.TakeWhile(n => n < 6)
.ToList()
.ForEach(x => Console.WriteLine(x));
}
44

C# - Programación Asíncrona
▹ CLR v1: APM – Modelo de Programación Asíncrona
▹ CLR v2: EAP – Patrón Asíncrono basado en Eventos
▹ CLR v4: TAP – Patrón Asíncrono basado en Tareas
▸ V4.5 async/await
▸ V4.6 Métodos estáticos con async/await & bloques
catch/finally
▹ C# v7 : Out vars, Pattern Matching, Arbitrary async returns
45

C# - Task & Patrón Asíncronos basado en Eventos (EAP)
// Método que permite descargar de manera asíncrona
// una url
//
public static Task<string> DownloadStringAsync(Uri url)
{
var tcs = new TaskCompletionSource<string>(); EventHandler es ineficiente… Debemos
var wc = new WebClient(); usar Action<T> / Func<T,H> ...
wc.DownloadStringCompleted += (s,e) =>
{
if (e.Error != null) tcs.TrySetException(e.Error);
else if (e.Cancelled) tcs.TrySetCanceled();
else tcs.TrySetResult(e.Result);
};
wc.DownloadStringAsync(url);
return tcs.Task;
}
46

”47
▹ Async es un modificador que permite establecer o modificar la firma
de un método formal, una expresión lambda, o un método anónimo
para que sea tratado como un método asíncrono.
▹ await es un keyword que aplica a una tarea de un método asíncrono
para suspender la ejecución del mismo hasta que la tarea en espera
se resuelva.
Nota: Declarar un método como async es requisito indispensable para poder usar await.

C# - Mejores Prácticas con Task.Run<T>
// Método que permite obtener de manera asíncrona
// el tamaño en bytes de la página solicitada
//
private async Task<byte[]> SumPageSizesAsync()
{
HttpClient client = new HttpClient();
Task<byte[]> getContentsTask = client.GetByteArrayAsync(url);
return getContentsTask;
}
var result = await SumPageSizesAsync();
..eq
byte[] result = await SumPageSizesAsync();
48

+
C/C++ - Space Invader Nintendo DS
▹ Compilador "devkitPro 1.5.0 ARM" no oficial
▹ Librería Libnds para la gestión del proyecto
▹ Librería Libfat-nds para el manejo de ficheros
▹ Librería MaxMod para el sonido
50

C/C++ - Space Invader Nintendo DS51

C/C++ - Programación funcional
▹ Lambdas
▸ Compile-time duck typing
▹ std::function
▸ Programación funcional abstracta
▸ Run-time duck typing
52

C/C++ - Estructura Lambdas
[closures] (params) -> ret{body}
▹ Closures entre corchetes []
▹ Parámetros (si los hay) entre paréntesis ()
▹ El tipo de retorno precedido por ->
▹ El cuerpo de la función entre corchetes {}
53

C/C++ - Closures Lambdas
▹ [] Tipo void, no encapsula nada
▹ [&] Variables capturadas por referencia
▹ [=] Variables capturadas por valor
▹ [this] Acceso a los miembros de un objeto
▹ [x=y] Captura con renombrado (C++14)
54

C/C++ - Lambdas
#include <iostream>
using namespace std;
class Foo {
public :
Foo () : _x( 12345 ) {}
void apply_x(const vector<int>& v)const { for_each(v.begin(),v.end(),[this](int n){cout<< n*_x <<endl;}); }
void func () { [this] () { cout << _x; } (); }
private :
int _x;
};
int main() {
auto print = [] () { cout << "Hello world"; };
auto print2 = [] () { return 1; } //Infiere la salida el compilador
auto print3 = [] () -> int { return 1; } // Imponemos el tipo de salida
print();
print2();
print3();
Foo f;
f.func();
}
55

C/C++ - std::function
#include <iostream>
#include <functional>
using namespace std;
void global_f() { cout << "global_f()" << endl; }
struct Functor { void operator()() { cout << "Functor" << endl; } };
int main() {
std::function<void()> foo;
cout << "sizeof(f) == " << sizeof(f) << endl;
foo = global_f;
foo();
foo = [](){ cout << "Lambda" << endl;};
foo();
Functor functor;
foo= functor;
foo();
}
56

C/C++ - Programación concurrente con ppltask.h
▹ Concurrency::task
▸ Encadena múltiples operaciones sincrónicas y asincrónicas
▸ Administra excepciones
▸ Realizar cancelaciones
▸ Garantizar que las tareas individuales se ejecuten en el contexto o
contenedor de subproceso apropiado
57

C/C++ - Encadenamiento de Op Async con Tareas
#include <ppltasks.h>
using namespace concurrency;
using namespace Windows::Storage;
void App::DeleteWithTasks(String^ fileName)
{
StorageFolder^ localFolder = ApplicationData::Current::LocalFolder;
auto getFileTask = create_task(localFolder->GetFileAsync(fileName));
getFileTask
.then([](StorageFile^ storageFileSample) ->IAsyncAction^ {
return storageFileSample->DeleteAsync();
})
.then([](void) {
OutputDebugString(L"File deleted.");
});
}
58

C/C++ - Cancelación de Tareas
#include <ppltasks.h>
using namespace concurrency;
using namespace Windows::Storage;
void App::DeleteWithTasks(String^ fileName)
{
cancellation_token_source m_fileTaskTokenSource;
StorageFolder^ localFolder = ApplicationData::Current::LocalFolder;
m_fileTaskTokenSource.cancel();
auto getFileTask = create_task(localFolder->GetFileAsync(fileName), m_fileTaskTokenSource.get_token() );
getFileTask
.then([](StorageFile^ storageFileSample) ->IAsyncAction^ {
return storageFileSample->DeleteAsync();
})
.then([](void) {
OutputDebugString(L"File deleted.");
});
}
59

C/C++ - Calling Haskell / Cpphs
#include <HsFFI.h>
#ifdef __GLASGOW_HASKELL__
#include "Safe_stub.h"
extern void __stginit_Safe(void);
#endif
#include <stdio.h>
int main(int argc, char *argv[]) {
int i;
hs_init(&argc, &argv);
#ifdef __GLASGOW_HASKELL__
hs_add_root(__stginit_Safe);
#endif
i = fibonacci_hs(42);
printf("Fibonacci: %dn", i);
hs_exit();
return 0;
}
60
{-# LANGUAGE ForeignFunctionInterface #-}
module Safe where
import Foreign.C.Types
fibonacci :: Int -> Int
fibonacci n = fibs !! n
where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
fibonacci_hs :: CInt -> CInt
fibonacci_hs = fromIntegral . fibonacci . fromIntegral
foreign export ccall fibonacci_hs :: CInt -> CInt

JavaScript - Programación Asíncrona
▹ Callbacks - Async Module
▹ Promises (2012) - Promises/A+
▹ Generators / Yield (2015) - Hapi
▹ Async / await (2015) - Koa
62

JavaScript - Ejempo de uso Intro Street Fighter 1 <- Código + Assets63

JavaScript - Ejempo de uso Intro Street Fighter 1
▹ Promesa nativas de JS
▹ Timer Task
▹ Tweens
64

Scala y Kotlin - Programación Asíncrona
▹ Threads
▹ Futures
▹ Async/await
▹ Coroutines
65

Scala - Programming in Scala First Edition67

2. Functional Programming
Haskell, Python, F#, ...
68

Haskell
▹ Lazy Evaluation
▹ Pattern Matching
▹ Type classes
▹ Funciones de primer orden
▹ Monads
▹ Recursividad
▹ Modules
71

Haskell - Programación asíncrona
▹ Control.Concurrent.Async 2.1.0
▸ Spawning con automatic cancellation
▸ Querying Async
▸ STM operations
▸ Waiting for multiple Async
▸ Linking
72

Haskell - Combine Task
import Control.Concurrent (threadDelay)
test1 :: Task Int test2 :: Task Int
test1 = task1 $ do threadDelay 500000 test2 = task2$ do threadDelay 500000
putStrLn "Hello," putStrLn " world!"
return 1 return 2
combineTask :: Task Int
combineTask = do
n1 <- test1
n2 <- test2
return (n1 + n2)
main = do
fut <- fork combineTask
n <- fut
print n
73

Haskell - Async wait
import Control.Concurrent.Async
…
main = defaultMain tests
tests = [ testCase "asyncWait" asyncWait ]
value = 42 :: Int
data TestException = TestException deriving (Eq,Show,Typeable)
instance Exception TestException
asyncWait :: Assertion
asyncWait = do
a <- async (return value)
r <- wait a
assertEqual "async_wait" r value
74

F#
▹ Declaración Imperativa
▹ Lazy Evaluation a través de keyword (lazy)
▹ Pattern Matching
▹ Quoted Expression
▹ Funciones de primer orden
▹ Interoperabilidad con .Net
▹ Recursividad (Tail)
76

F# - Programación asincrona
▹ Clásico
▸ Thread, AutoResetEvent, BackgroundWorker y IAsyncResult
▹ Asynchronous workflows
▸ Async
▸ Async.RunSynchronously
▸ Async.Parallel
77

F# - AutoResetEvent
open System
let userTimerWithCallback =
let event = new System.Threading.AutoResetEvent(false)
let timer = new System.Timers.Timer(2000.0)
timer.Elapsed.Add (fun _ -> event.Set() | > ignore )
printfn "Esperando : %O" DateTime.Now.TimeOfDay
timer.Start()
printfn "Haciendo cosas mientras esperamos al evento"
event.WaitOne() | > ignore
printfn "Timer ticked %O" DateTime.Now.TimeOfDay
78

F# - IAsync Result / Async.RunSynchronously
let fileWriteWithAsync =
use stream = new System.IO.FileStream("test.txt", System.IO.FileMode.Create)
printfn "Empezando escritura asincrona"
let asyncResult = stream.BeginWrite(Array.empty,0,0,null,null)
let async = Async.AwaitIAsyncResult(asyncResult) |> Async.Ignore
printfn "Haciendo cosas mientras esperamos al evento"
Async.RunSynchronously async
printfn "Escritura asíncrona completada"
…
let sleepWorkflow = async{
printfn "Empezamos a dormir el workflow %O" DateTime.Now.TimeOfDay
do! Async.Sleep 2000
printfn "workflow finalizado %O" DateTime.Now.TimeOfDay
}
Async.RunSynchronously sleepWorkflow
79

F# - Async.Parallel
let sleepWorkflowMs ms = async {
printfn "%i ms workflow started" ms
do! Async.Sleep ms
printfn "%i ms workflow finished" ms
}
let sleep1 = sleepWorkflowMs 1000
let sleep2 = sleepWorkflowMs 2000
#time
[sleep1; sleep2]
|> Async.Parallel
|> Async.RunSynchronously
#time
80

Beneficios aportados por la programación asíncrona
▹ Explotamos rendimiento de procesador/es
▹ Evitamos cuellos de botella, bloqueos...
▹ Procesamiento de tareas en paralelo
▹ Trabajamos con subprocesos en interfaces de usuario
▹ Soporte a sistemas de alta escabilidad
▹ Robustez en las aplicaciones/juegos desarrollados
82

Desventajas de la programación asíncrona
▹ Código desarrollado
▸ Entendimiento
▸ Acoplamiento
▸ Mantenibilidad
▸ Dificultad de debuggear
83

Beneficios de la programación funcional
▹ Minimización del código
▹ Basado en expresiones
▹ Cálculos lambda
▹ Recursión
▹ Eficiencia
84

Preguntas / Sugerencias ???
86

Referencias
▹ https://github.com/vicboma1/Java8-Stream
▹ https://www.todojs.com/programacion-asincrona-paso-de-continuadores-eventos-pro
mesas-y-generadores/
▹ http://itpn.mx/recursosisc/4semestre/topicosavanzados/Unidad%20IV.pdf
▹ http://elmanantialdebits.blogspot.com.es/2013/08/que-es-eso-de-la-programacion-asi
ncrona.html
▹ http://concurrenteparalela.blogspot.com.es/2012/11/caracteristicas-programacion.ht
ml
▹ http://www.depi.itchihuahua.edu.mx/apacheco/lengs/paralelo/index.html
▹ http://www.johndcook.com/blog/2010/11/03/object-oriented-vs-functional-programmi
ng
▹ https://msdn.microsoft.com/en-us/magazine/jj991977.aspx?tduid=(a46d0d465c0b3794
7c4a3901d32004e2)(256380)(2459594)(TnL5HPStwNw-mIXzBM2g9PT4zCIuyzsidQ)()
88

Referencias
▹ https://dzone.com/articles/functional-programming-java-8
▹ http://www.drdobbs.com/jvm/lambda-expressions-in-java-8/240166764
▹ http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-exa
mples/
▹ http://zeroturnaround.com/rebellabs/why-the-debate-on-object-oriented-vs-functional
-programming-is-all-about-composition/
▹ https://msdn.microsoft.com/es-es/library/mt674882.aspx
▹ http://es.slideshare.net/JeffHart6/async-await-46060988
▹ https://msdn.microsoft.com/es-es/library/jj130730.aspx
▹ https://www.microsoft.com/en-us/download/confirmation.aspx?id=19957
▹ http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
89

Referencias
▹ https://msdn.microsoft.com/es-es/windows/uwp/threading-async/asynchronous-progr
amming-in-cpp-universal-windows-platform-apps
▹ https://blog.risingstack.com/introduction-to-koa-generators/
▹ https://www.npmjs.com/package/async
▹ https://github.com/promises-aplus
▹ https://github.com/vicboma1/C-Sharp-Promise
▹ https://msdn.microsoft.com/es-es/library/bb397687.aspx
▹ http://www.adobe.com/support/documentation/en/flex/1/mixin/mixin2.html#118542
▹ http://slides.com/juanramb/promesas-en-javascrip
▹ https://usingstdcpp.files.wordpress.com/2014/12/introduccic3b3n-a-la-programacic3b
3n-funcional-en-c.pdf
▹ https://gobyexample.com
90

Java 8 - Rom Hacking <- Video91

PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONA

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (19)

Ähnlich wie PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONA

Ähnlich wie PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONA (20)

Mehr von Víctor Bolinches

Mehr von Víctor Bolinches (6)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONA