Programación Funcional y Orientada a Objetos con Asincronismos
•
0 recomendaciones•285 vistas
Este documento describe las diferencias entre la programación síncrona y asíncrona, y cómo los paradigmas de programación orientada a objetos y funcional pueden usar técnicas avanzadas de programación asíncrona. Luego, presenta ejemplos prácticos de cómo implementar programación asíncrona en Java 8 y Kotlin, incluido un emulador de Gameboy que usa coroutinas de Kotlin para manejar la CPU de forma asíncrona.
Recomendados
Más contenido relacionado
Similar a Programación Funcional y Orientada a Objetos con Asincronismos
Similar a Programación Funcional y Orientada a Objetos con Asincronismos (20)
Último
Último (20)
Programación Funcional y Orientada a Objetos con Asincronismos
- 1. PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONA Víctor M. Bolinches
- 2. 2 Motivación Programación Síncrona vs Programación (A)síncrona
- 3. 3 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Operaciones bloqueantes • Ejecución secuencial • Comportamiento por transformación de estados • Devolución de resultados por finalización de estado • Mezcla contextos Fronted/Backend • Entorpece la escalabilidad • Satura la CPU • Poco performance Motivación - Programación secuencial
- 4. 4 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Motivación - Programación secuencial
- 5. 5 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Motivación - Programación asíncrona • Operaciones NO bloqueantes • Ejecución NO secuencial • Comportamiento diferido • Devolución del resultado por suspensión • Separa contextos Fronted (UI-Thread) / Backend (Threadn) • Explotación de la CPU / GPU • Alta escalabilidad • Mejor performance
- 6. 6 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Motivación - Programación asíncrona
- 7. 7 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Motivación - Async Versus Sync
- 8. 88 Me presento ... Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Víctor M. Bolinches Software Architect en Capgemini Github Linkedin Twitter vicboma1 victorbolinches @vicboma1
- 9. 9 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Introducción • Conceptos básicos • Programación Orientada a objetos •Java 8, Kotlin y Javascript •Ejemplos prácticos • Programación Funcional •Haskell y F# • Referencias
- 11. 11 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Conceptos básicos • Paradigma de programación • Comunicación entre procesos • Patrón promesa • TDD
- 12. 12 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • 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 Paradigmas de programación
- 13. ” 13
- 14. 14 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Síncrono • Intercambio de información en tiempo real • Concurrente • Ejecución simultánea de tareas en tiempo real • Paralelo • Sistema multi-procesado (Subdomino concurrente) • Asíncrono • Intercambio de información en tiempo diferido Comunicación entre procesos
- 15. 15 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Comunicación entre procesos
- 16. 16 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Redirige flujos uniformes • (A)síncronos • Ordena y estructura bloques • Resolve / Reject • Flexibilidad de código • Evita “Callbacks hell” • Hacer p(), y luego q(), r() y s() → [ p ⇒ q ⇒ r ⇒ s ] • Promise(p).then(q).then(r).then(s); Patrón Promesa
- 17. 17 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Patrón Promesa
- 18. 18 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • 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 Test-Driven Development
- 19. ” 19
- 20. 20 Programación orientada a objetos
- 21. 21 Streams, Function Interface, Multithreading, Producer-Consumer, CompletableFuture… Java 8
- 22. 22 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { java.utils.stream.* } • Clase que soporta operaciones con estilo funcional • Lambdas • Interfaces funcionales • Métodos y constructores por referencia • Definición de métodos predeterminados y estáticos a interfaces • Uso de “pipelines” (Patrón Builder) Java 8 – Streams ← Ejemplos!!!
- 23. 23 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas /**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) .parallelStream() .reduce((p1, p2) -> p1 > p2 ? p1 : p2) .get(); Assert.assertTrue(expected == result); } Java 8 – Streams { reduce }
- 24. 24 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { java.utils.function.* } • Function <T,R> , BiFunction <T,U,R> • Consumer <T>, BiConsumer <T,U> • Predicate <T>, BiPredicate <T,U> • Supplier <R> • Unary Operation <T> • @Functional Interface → Runnable !!! Java 8 – Functional Interface
- 25. 25 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { java.lang.thread.* } • Procesos independientes • Objetos autónomos • Eficiencia en tareas gráficas/renderizadas • Procesamiento masivo de operaciones en segundo plano • Complejidad de uso y entendimiento • Difícil debug (No-determinista) Java 8 – Threads & Runnables
- 26. 26 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { java.util.concurrent.Executors.* } • Abstracción de uso en el manejo de hilos • Tareas asíncronas • Factorías de métodos • Patrón “Thread Pool” • ExecutorService - newFixedThreadPool - newCachedThreadPool | short-lived asynchronous task Java 8 – Executors
- 27. 27 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { java.util.concurrent.* } • Interface • Tipo “Void” de entrada • Tipo “T” de salida • Permuta con Executors Java 8 – Callables
- 28. 28 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Threads + EDA’s bloqueantes • Synchronized • this.{ wait | notify } + EDA’s concurrentes • Object lock + lock.{ wait | notify } + EDA’s concurrentes • Re-entrant Lock.{ lock | unlock } + Condition.{ await | signal } • Semaforos.{ acquire | release } Java 8 – Productor y Consumidor
- 29. 29 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { java.util.concurrent.CompletableFuture<T> } • CompletableStage • Future • Código asíncrono • Abstracción de uso en el manejo de hilos/executors • ForkJoinPool.commonPool-worker-x (thread) • Resultado • Ejecución en tiempo diferido • Organizado mediante callbacks Java 8 – CompletableFuture
- 30. 30 Emulador Gameboy ( DMG 01 ) | HomeBrew | 2013 - Actual Caso práctico
- 31. 31 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Metodología SOLID + TDD • Desarrollo de un Framework ( Winter ) • CPU Z80 emulada con un Pool Asíncrono *** • Backlights customizadas por colores • Scalines emuladas (Horizontales – Verticales – Mixtas ) • Tooling • Consola asíncrona para debug • Decompilador de instrucciones z80 • Análisis de memoria dumpeada (OAM – VRAM – MRAM – CPU) • Rom Hacking Java 8 – Emulador Gameboy DMG 01
- 32. 32 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Custom Backlights
- 33. 33 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Custom Backlights
- 34. 34 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Custom Backlights
- 35. 35 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | LoadAsync Rom
- 36. 36 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas ... LoadAsync Rom Init Memory Map SRAM Promise.All() OAM Logo Nintendo Promise.Completed() Promise Promise.All() ... Promise.Completed() PromiseP.Completed() Promise Lobby/Cover Game Java 8 – Emulador Gameboy DMG 01 | LoadAsync Rom
- 37. 37 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • CompletableFuture.allOf( CompletableFuture [] ) • thenRunAsync( Runnable, Executor ) • CompletableFuture • supplyAsync( Supplier<T> , Executor ) • thenApplyAsync( Function<T,E>) • ExecutorService • newFixedThreadPool • newCachedThreadPool | short-lived asynchronous task • AsynchronousFileChannel Java 8 – Emulador Gameboy DMG 01 | LoadAsync Rom
- 38. 38 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | LoadAsync Rom 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; }
- 39. 39 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Rendering • Activo • Pinta directamente en pantalla • Gestión autónoma • Manipulación a/síncrona • Pasivo • Atada a eventos • Pintada por demanda del S.O. • Diálogos modales
- 40. 40 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Técnicas de Pintado Flashing Double Buffering
- 41. 41 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Técnicas de Pintado • Double Buffering • Block line transfer (btl) • 1 buffer front + 1 buffer back • Un solo puntero a memoria • Crea la imagen y la copia en el screen en una sola operación • Solución al parpadeo de imágenes (Flashing) • Procesamiento en paralelo permite mejor rendimiento
- 42. 42 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Técnicas de Pintado Tearing Page Flipping
- 43. 43 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Técnicas de Pintado • Page Flipping • Cache • Punteros a VRAM | Gráficos -> { Buffer {1..2} } <- Screen • Swap Buffering • Mejora el rendimiento • Eliminación del Tearing (Efecto visual de la imagen desencajada)
- 44. 44 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Scanlines
- 45. 45 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Scanlines Vertical ← Video
- 46. 46 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Scanlines Horizontal ← Video
- 47. 47 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Java 8 – Emulador Gameboy DMG 01 | Scanlines Mixes ← Video
- 48. 48 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Mascara • Display Front nuevo • Mayor cómputo de renderizado • Rompe arquitectura LCD { BG & OBJ } Display de la GameBoy Java 8 – Emulador Gameboy DMG 01 | Técnica Scanlines
- 49. 49 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • GPU • Mejor balanceo y rendimiento • Manejo de shaders • JOCL OpenCL • Difícil manejo e interoperabilidad con C99 a través de Java • Necesidad de varias dependencias • Rootbeer GPU Compiler • Java GPU Programming • CUDA • Necesidad de varias dependencias Java 8 – Emulador Gameboy DMG 01 | Técnica Scanlines
- 50. 50 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • GPU Java 8 – Emulador Gameboy DMG 01 | Técnica Scanlines
- 51. 51 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Deprecar Java 8 • Refactorizaciones con Kotlin • Corregir Interrupts y optimizar TIMA, TMA, TAC • Validar instrucciones del procesador Z80 con test_instruct.gb • Visualizar Tiles 8x16 • Gestión de audio por canales • Perfeccionar Tooling para debuggear • Ingeniería inversa • Usar coroutinas de Kotlin, deprecar Threads de Java Java 8 – Emulador Gameboy DMG 01 | Tareas futuras
- 52. 52 Coroutines { async, await, yield, fibers, continuation, suspend .. } Kotlin
- 53. 53 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - Lenguaje oficial de Android
- 54. 54 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - JVM | JS | Native • ¿Por qué Kotlin? • Compilación • IDE’s • Constructores de proyectos • Coroutines
- 55. 55 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas ¿Por qué Kotlin? Lenguaje de programación con tipado estático (JVM 100%) Conciso Seguro Versátil Interoperable Tooling
- 56. 56 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - Compilación Kotlin/JSKotlin/JVM Kotlin/Native [ LLVM bitcode ]
- 57. 57 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - IDE’s Eclipse IntelliJ IDEA Ultimate Android Studio
- 58. 58 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - Construcción de proyectos Apache Ant Maven Gradle
- 59. 59 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Fiber (co-operative Multitasking) • Ejecución Lightweight • Stackless (no tiene stack propio, proceso corto y eficiente) • Abstracción de alto nivel de usuario • No vincula recursos nativos a la JVM (Mínimo) • Suspensión de funciones - suspen fun foo = { ... } • Coste despreciable de invocación Kotlin - Coroutine
- 60. 60 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - Coroutine | Project Structure
- 61. 61 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - Coroutine | Project Structure
- 62. 62 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas fun main(args: Array<String>) { launch(CommonPool) { delay(1000L) // Non-blocking println("World!") } println("Hello,") Thread.sleep(2000L) //Block main thread } Result : Hello, world! Kotlin - Coroutine Basic fun main(args: Array<String>) = runBlocking<Unit> { launch(CommonPool) { delay(1000L) // Non-blocking println("World!") } println("Hello,") delay(2000L) // Non-blocking } Result : Hello, world! RunBlocking
- 63. 63 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas fun main(a:Array<String>) = runBlocking<Unit> { val job = launch(CommonPool) { doWorld() } println("Hello,") job.join() } suspend fun doWorld() { delay(1000L) println("World!") } Result : Hello, world! Kotlin - Coroutine w/ suspend fun main(args: Array<String>) = runBlocking<Unit> { val jobs = List(100000) { async(CommonPool) { delay(500L) print("*") } } jobs.forEach { it.await() } } Result : **** ... Con Thread`s : out-of-memory… (OEME) Light-weight
- 64. 64 GameBoy Emulator Environment - GBEE | HomeBrew | 2017 - Actual Caso práctico
- 65. 65 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Front-end • { List | Grid {...} } View Asíncrono • Cache • Coroutines - Launch(Swing) - Async • Download Asynk Resources - Covers - Roms Kotlin - GameBoy Emulator Environment (GBEE)
- 66. 66 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE) - Frontend
- 67. 67 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE) - Frontend
- 68. 68 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE) - Frontend
- 69. 69 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE) - List view async
- 70. 70 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE)
- 71. 71 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE) - Grid view async
- 72. 72 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Kotlin - GameBoy Emulator Environment (GBEE)
- 73. 73 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • ConcurrentHashMap<T,H> - Contexto async • SoftReference - Evita OOME *** - Libera memoria antes de hacer System.gc() Kotlin - GameBoy Emulator Environment (GBEE) - Cache
- 74. 74 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Download Asynk Resources Kotlin - GameBoy Emulator Environment (GBEE)
- 75. 75 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Liberación Open Source - Expandir conocimiento • Publicar Json con mapeo de url’s - Covers - Roms (mirrors…) *** - Ayuda de la comunidad Kotlin - GameBoy Emulator Environment (GBEE) | Tareas futuras
- 76. 76 Casos prácticos, async, await, promise, generators, yield Javascript
- 77. 77 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Html5 + async • Injector de dependencias • Promises • Web Workers • Phaser.io V.2.4.4 - Pixi.js, WebGL, WebAudio.. - Patrón Entidad (Draw - Update por EntityComponents ) *** • KotlinJS (Refactors) Javascript - Work-flow
- 78. 78 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Javascript - Intro Street Fighter 1 ( Arcade 1987) ← Github repo + code
- 79. 79 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Javascript - Intro Fighting Street ( PC-Engine ) ← Github repo + code
- 80. 80 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Javascript - Doodle Jump xbox360 for Web
- 81. 81 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Javascript - Doodle Jump xbox360 for Web
- 82. 82 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Javascript - Doodle Jump xbox360 for Web
- 83. 83 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas Javascript - Doodle Jump xbox360 Kinect
- 84. 84 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Callbacks - Async Module • Promises (2012) - Promises/A+ • Generators / Yield (2015) - Hapi • Async / await (2015) - Koa Javascript - Async modules
- 86. 86 Lazy evaluation, Pattern Matching, Type classes, Async, Nomads, Modules … Haskell
- 87. ” 87
- 88. 88 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Package { Control.Concurrent.Async 2.1.0 } • Spawing con automatic cancellation • Querying Async • STM operations • Waiting for multiple Async • Linking Haskell
- 89. 89 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas 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 Haskell
- 90. 90 Lazy evaluation, Pattern Matching, Quoted expression , Async, Tail recursive, Interoperabilidad .NET ... F#
- 91. 91 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • .NET Asynchronous (Clásico) - Thread - AutoResetEvent - BackgroundWorker - IAsyncResult • Async workflows - Async - Async.RunSynchronously - Async.Parallel F#
- 92. 92 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas 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 F# - AutoResetEvent
- 93. 93 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas 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 F# - IAsyncResult
- 94. 94 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas 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 F# - IAsyncResult
- 96. 96 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Explotar rendimiento de procesador/es • Evitar cuellos de botella, bloqueos... • Procesamiento de tareas en paralelo • Trabajar con subprocesos en interfaces de usuario • Soporte a sistemas de alta escabilidad • Robustez en las aplicaciones/juegos desarrollados Conclusiones - OOP
- 97. 97 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Código desarrollado - Entendimiento - Acoplamiento - Mantenibilidad - Dificultad de debuggear Conclusiones - OOP
- 98. 98 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • Minimización del código • Basado en expresiones • Cálculos lambda • Recursión • Eficiencia Conclusiones - FP
- 99. 99 Referencias
- 100. 10 0 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • https://github.com/vicboma1/Java8-Stream • http://itpn.mx/recursosisc/4semestre/topicosavanzados/Unidad%20IV.pdf • http://elmanantialdebits.blogspot.com.es/2013/08/que-es-eso-de-la-progra macion-asincrona.html • http://concurrenteparalela.blogspot.com.es/2012/11/caracteristicas-progra macion.html • http://www.depi.itchihuahua.edu.mx/apacheco/lengs/paralelo/index.html • http://www.johndcook.com/blog/2010/11/03/object-oriented-vs-functional -programming • https://msdn.microsoft.com/en-us/magazine/jj991977.aspx?tduid=(a46d0d 465c0b37947c4a3901d32004e2)(256380)(2459594)(TnL5HPStwNw-mIXzBM 2g9PT4zCIuyzsidQ)() • https://www.todojs.com/programacion-asincrona-paso-de-continuadores-e ventos-promesas-y-generadores/ Referencias
- 101. 10 1 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • 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.ht ml#118542 • http://slides.com/juanramb/promesas-en-javascrip • https://usingstdcpp.files.wordpress.com/2014/12/introduccic3b3n-a-la-pro gramacic3b3n-funcional-en-c.pdf • https://gobyexample.com • http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html • https://dzone.com/articles/functional-programming-java-8 Referencias
- 102. 10 2 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • http://www.drdobbs.com/jvm/lambda-expressions-in-java-8/240166764 • http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread- executor-examples/ • http://zeroturnaround.com/rebellabs/why-the-debate-on-object-oriented-v s-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 • http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression -in-c11 • https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Globa l_Objects/Promise • https://msdn.microsoft.com/es-es/windows/uwp/threading-async/asynchr onous-programming-in-cpp-universal-windows-platform-apps Referencias
- 103. 10 3 Paradigma FP y OOP usando técnicas avanzadas de programación asíncronas • http://trifort.org/ads/index.php/lecture/index/27/ • https://www.slideshare.net/dchenbecker/stepping-up-a-brief-intro-to-scala • https://www.slideshare.net/abhijit.sharma/writing-dsls-in-scala • http://www.jocl.org/ • https://www.youtube.com/watch?v=CxLvnNrutG4 • https://es.slideshare.net/abreslav/jvmls-2016-coroutines-in-kotlin?qid=811 35e2f-e978-40b8-a5e5-f138da695e47&v=&b=&from_search=1 • https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.c oroutines.experimental/launch.html • https://www.slideshare.net/Hybrid0/llvm-28276305 • https://dhole.github.io/post/gameboy_cartridge_emu_1/ Referencias