Upload keynote to can view it.

Feb 2, 20110 likes205 views

Rx is a library for composing asynchronous and event-based programs using observable collections. It has a strong theoretical basis using the duality between the classic Iterator and Observer design patterns to simplify controlling asynchrony. Rx allows defining and combining asynchronous data streams through declarative query operators.

RX
R e t h i n k i n g t h e w a y w e
d o s t u f f

RX

Rx is a library for composing asynchronous and event-based
programs using observable collections.

Rx has a strong theoretical basis by using the duality between the
classic Iterator and Observer design patterns to simplify controlling
asynchrony

Genesis 2

AMQP (and it’s brokers
RabbitMQ etc)

What we want?

We want something Generic

LINQ

Microsoft

Functional Programming (posta)

LINQ II

var?query?=?yourData
????.GroupBy(x?=>?x.Name,
?????????????(k,?g)?=>?g.Aggregate((a,?x)?
=>?(x.Priority?>?a.Priority)???x?:?a));

select es fmap (list map)

SelectMany (mapcat) listmap

In other words, x >>= k is a computation
which runs x, and then uses the result(s)
of x to decide what computation to run
second, using the output of the second
computation as the result of the entire
computation.

[ EVENT(KEY) -> (KEY ->
EVENT(MOUSE) ] -> EVENT(MOUSE)

In the process we've discovered what Rx really is: a fancy way of writing event handlers,
specifically event handlers that fire events that trigger other event handlers that fire events, and so on in big
chain that looks like a query

Async everywhere

NEXT STEPS:

RUBY LIBRARY

JS LIBRARY (for dealing with UI)

This document provides an overview of a toy model for simulating particle collisions. It describes sampling particle data from experimental measurements to generate events. A jet finding algorithm is used to cluster particles into jets using FastJet. The current status indicates particle generation works as expected but jet finding results appear buggy. Next steps involve analyzing jet distributions and performance of the jet finder on simulated events without embedded jets. Possible extensions include jet fragmentation.

Workshop introduction-to-rxjsKristinaBistrickiene1

骋补濒濒颈苍补による証明駆动开発の魅力Hiroki Mizuno

The document discusses Coq and Gallina, the language used for formal proofs in Coq. It provides examples of proof goals, such as proving that reversing a list twice returns the original list, and that decoding and encoding with base64 returns the original string. It also lists several Coq-based projects, including CompCert for formally verified C code generation, and links to learning resources for Coq.

Memory Management & Garbage CollectionAbhishek Sur

The document discusses .NET memory management and garbage collection. It explains that memory is allocated on the managed heap for reference types using new. The garbage collector removes objects from the heap that are no longer referenced to free up memory. It compacts the heap during garbage collection to improve performance. While the garbage collector handles managed memory, it does not free unmanaged resources so classes use finalizers/destructors or implement IDisposable to release unmanaged resources.

Reactive Programming with RxJSDanca Prima

This document provides an overview of reactive programming with RxJS. It defines reactive programming as programming with asynchronous data streams, where anything can be a stream like variables, user inputs, and data structures. It introduces RxJS as a library that implements reactive programming in JavaScript and other languages. It describes the key components in RxJS - Observables that emit data and Observers that receive data. Finally, it provides examples of Observable operators like map, filter, concat, and buffer that allow transforming and combining streams.

ACM DEBS Grand Challenge: Continuous Analytics on Geospatial Data Streams wit...Srinath Perera

The document discusses the application of WSO2 Complex Event Processor (CEP) for continuous analytics on geospatial data streams, specifically using taxi ride data from New York in 2013. It presents two queries focusing on frequent taxi routes and profitable areas for drivers, along with various optimization techniques to enhance performance. The results indicate improvements in throughput and latency, leading to successful implementations on both physical and cloud environments.

W3C HTML5 KIG-How to write low garbage real-time javascriptChanghwan Yi

This document summarizes techniques for writing low-garbage real-time JavaScript code. It discusses how to avoid object allocation using syntax like {} and [] instead of the new keyword. It also recommends reusing objects by wiping their properties instead of creating new ones. Functions should be created at startup instead of during runtime. Vector objects should be returned as individual values instead of vector objects. While avoiding garbage entirely is difficult, these techniques can help craft responsive real-time JavaScript with minimal garbage collector overhead.

Garbage collectionMudit Gupta

The document summarizes how garbage collection works in Java. It describes the marking phase where referenced and unreferenced objects are identified. Unreferenced objects are then deleted in the normal deletion step. For better performance, referenced objects can also be compacted together. The document further explains generational garbage collection, where new objects are allocated to the young generation and aged objects are promoted to the old generation. Minor and major garbage collections handle each generation. Different garbage collectors, like serial, parallel, CMS and G1, are also summarized regarding their implementation and suitability for different applications.

Introduction to Garbage CollectionArtur Mkrtchyan

Garbage collection is a form of automatic memory management used in computer programs to reclaim memory occupied by objects that are no longer needed. John McCarthy invented garbage collection for Lisp in 1959. Languages either use garbage collection or require manual memory management through techniques like allocating and freeing memory. Common garbage collection algorithms include reference counting, mark and sweep, and generational collection. The Java Virtual Machine uses different garbage collectors like serial, parallel, concurrent mark and sweep, and Garbage First collectors to reclaim memory in the Java heap.

RxJS - The Reactive Extensions for JavaScriptViliam Elischer

RxJS is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators. It offers a language neutral approach to reactive programming using observables that asynchronously push values to observers. Some key benefits of RxJS include clean asynchronous code, error handling, composable observables, and abstraction. The core concepts include observables, observers, and operators to process and transform streams of data over time.

In class, we discussed min-heaps. In a min-heap the element of the heap with ...licservernoida

The document outlines a project to develop a binary tree ADT and a flex-heap ADT in Java, specifying requirements for min-heap and max-heap functionality. The flex-heap must implement operations like remove() and toggleheap(), with specified time complexities, and use an extendable array-list for binary tree representation. Deliverables include specifications, pseudo code, and well-documented Java source code with example tests to demonstrate the implementation of the ADTs.

Garbage Collection In MicorosoftSmithaNatarajamurthy

The document discusses garbage collection in Microsoft .NET, detailing how the garbage collector (GC) operates, including algorithms like mark-sweep and generational GC. It highlights the differences between the stack and heap, gives tips for optimizing garbage collection, and describes the new background garbage collector introduced in CLR 4.0. Key takeaways include the importance of managing objects efficiently and understanding the lifecycle of managed and unmanaged resources.

Parallel Computing in JSAhmed Gaber

This document discusses parallel computing techniques in JavaScript including web workers, Node.js clustering, and asynchronous programming. It introduces parallel computing concepts and explains how JavaScript handles parallelism through an event loop, message queue, and asynchronous functions despite being a single-threaded language. Code examples are provided to demonstrate parallel computing approaches in JavaScript.

Raster Processing with Scipy.ndimage (Dev Meet Up II)JHasthorpe

The document discusses raster processing using the SciPy ndimage library, highlighting its open-source nature and suitability for large-scale concurrent processing. It explains how to set up data input and output using arcpy with numpy, and illustrates operations such as calculating median filters, slopes, and focal maximums. The author emphasizes the efficiency and flexibility of ndimage compared to ArcGIS's spatial analyst tools.

Rethinking garbage collectionBazlur Rokon

The document discusses advancements in garbage collection, particularly focusing on reference counting (RC) and its optimization for better performance in modern systems. It compares various garbage collection techniques, highlighting a new RC approach that combines its advantages with features of the Immix algorithm to improve efficiency. Ultimately, the new RC method demonstrates competitive performance against traditional methods, achieving faster object collection while retaining locality benefits.

Streaming data to s3 using akka streamsMikhail Girkin

This document summarizes using Akka streams to stream large database result sets to Amazon S3. The key points are: - Akka streams can handle streaming large amounts of data without overloading memory by processing data in chunks. - A stream consists of a source (database query), flow (serialization), and sink (S3 upload). - The stream serializes database rows into bytes and uploads them to S3 in parallel chunks using S3's multipart upload API to avoid timeouts. - Anorm provides an Akka stream source to query a database, and a custom S3 sink uploads chunks to S3 concurrently. Retries and error handling would be needed for production.

Discovering Unbounded Synchronization Conditions in Artifact-Centric Process ...Marlon Dumas

The document discusses a methodology for discovering synchronization conditions in artifact-centric process models using an artifact model discovery tool. It outlines steps to extract artifact logs and identify synchronization points between primary and secondary artifacts based on event occurrences. The research demonstrates the tool's effectiveness in discovering synchronization conditions in synthetic and real-world logs, paving the way for future enhancements in extracting models from ERP systems.

S2Daniel Marcous

The document discusses the S2 Geometry Library, which enables spatial indexing and geo operations on a spherical model of the Earth. It highlights key features such as fast geo operations, flexible shapes, and easy usability, along with design principles including the use of a quadtree and Hilbert space-filling curves for cell enumeration. Additionally, it mentions practical applications like growth prediction and reverse geocoding, alongside alternative spatial indexing methods.

骋补耻肠丑别で本を作るguest7a66b8

.Net Garbage Collector 101Woody Pewitt

The document discusses .NET garbage collection. It explains that concurrent garbage collection is used in desktop applications while synchronous collection is used by default in server applications like ASP.NET. It notes the benefits of garbage collection, but also issues to watch out for like too many allocations, strings, and almost long-lived objects. It discusses how to avoid issues with strings, finalization, the Dispose pattern, weak references, and when to induce collections.

From Java to Kotlin - The first month in practice v2StefanTomm

The document discusses the transition from Java to Kotlin, highlighting the advantages of Kotlin such as null-safety, data classes, and higher-order functions. It includes practical examples of coding in Kotlin, demonstrating its expressive syntax and reduced boilerplate code compared to Java. The presentation also covers advanced features like coroutines and operator overloading, aimed at enhancing productivity for developers transitioning to Kotlin.

Incremental and parallel computation of structural graph summaries for evolvi...Till Blume

This document presents an incremental and parallel algorithm for computing structural graph summaries of evolving graphs. The algorithm incrementally updates graph summaries when the input graph changes, which is often faster than recomputing from scratch. The algorithm partitions the graph and computes summaries in parallel. Experimental results on real-world and benchmark graphs show the incremental algorithm outperforms batch computation even when 50% of the graph changes. The algorithm runs in linear time with respect to graph changes and degree.

RxJS - The Reactive extensions for JavaScriptViliam Elischer

RxJS is a library for composing asynchronous and event-based programs using observable sequences and functional style operators. It provides developers with Observables to represent asynchronous data streams, operators to query those streams, and Schedulers to parameterize concurrency. Some key operators include map to project values, filter to select values, reduce to aggregate values, and flatMap to flatten nested observables. RxJS supports both hot and cold observables, and is used for tasks like DOM event handling, API communication, and state management in applications.

Qtp excel compareRamu Palanki

GraphiteAdrian Moisey

This document provides an overview of Graphite and StatsD. StatsD is a network daemon that listens for statistics like counters or timers over UDP and sends them to Carbon. Carbon is another network daemon that listens for statistics over TCP and stores them on disk using Whisper, a fixed-size database like RRD. Graphite is a web-based interface for visualizing the stored metrics, allowing users to render graphs and create dashboards from the collected time-series data.

201707 SER332 Lecture 16 Javier Gonzalez-Sanchez

This document provides instructions for Lab 3 of an introduction to graphics and game development course. It includes 5 steps: 1) download and run source code to load an OBJ file, 2) download additional OBJ files, 3) modify the code to load and display the additional files by creating display lists, 4) scale and position the objects, and 5) add controls to rotate one object and move another using arrow keys.

Data exploration using elastic stack for beginnersDaliya Spasova

This document provides an introduction to exploring data using the Elastic stack, which includes Logstash, Beats, Elasticsearch, and Kibana. It outlines the basic steps to get data into Elasticsearch, explore it, clean and transform the data, and then productionize the data exploration process. A demo example is also presented that uses a cars.csv file to demonstrate exploring used car offerings data in the Elastic stack. The document concludes by noting how the general setup scales well for large data sets and recommends moving data transformation upstream and creating clean dashboards for end users.

Home/Garden Still Lifecoreylesh

Cats: Provider of Happiness and JoySatsugai Se-o

Glass Still Lifecoreylesh

More Related Content

What's hot (19)

Introduction to Garbage CollectionArtur Mkrtchyan

RxJS - The Reactive Extensions for JavaScriptViliam Elischer

In class, we discussed min-heaps. In a min-heap the element of the heap with ...licservernoida

Garbage Collection In MicorosoftSmithaNatarajamurthy

Parallel Computing in JSAhmed Gaber

Raster Processing with Scipy.ndimage (Dev Meet Up II)JHasthorpe

Rethinking garbage collectionBazlur Rokon

Streaming data to s3 using akka streamsMikhail Girkin

Discovering Unbounded Synchronization Conditions in Artifact-Centric Process ...Marlon Dumas

S2Daniel Marcous

骋补耻肠丑别で本を作るguest7a66b8

.Net Garbage Collector 101Woody Pewitt

From Java to Kotlin - The first month in practice v2StefanTomm

Incremental and parallel computation of structural graph summaries for evolvi...Till Blume

RxJS - The Reactive extensions for JavaScriptViliam Elischer

Qtp excel compareRamu Palanki

GraphiteAdrian Moisey

201707 SER332 Lecture 16 Javier Gonzalez-Sanchez

Data exploration using elastic stack for beginnersDaliya Spasova

Introduction to Garbage CollectionArtur Mkrtchyan

RxJS - The Reactive Extensions for JavaScriptViliam Elischer

In class, we discussed min-heaps. In a min-heap the element of the heap with ...licservernoida

Garbage Collection In MicorosoftSmithaNatarajamurthy

Parallel Computing in JSAhmed Gaber

Raster Processing with Scipy.ndimage (Dev Meet Up II)JHasthorpe

Rethinking garbage collectionBazlur Rokon

Streaming data to s3 using akka streamsMikhail Girkin

Discovering Unbounded Synchronization Conditions in Artifact-Centric Process ...Marlon Dumas

S2Daniel Marcous

骋补耻肠丑别で本を作るguest7a66b8

.Net Garbage Collector 101Woody Pewitt

From Java to Kotlin - The first month in practice v2StefanTomm

Incremental and parallel computation of structural graph summaries for evolvi...Till Blume

RxJS - The Reactive extensions for JavaScriptViliam Elischer

Qtp excel compareRamu Palanki

GraphiteAdrian Moisey

201707 SER332 Lecture 16 Javier Gonzalez-Sanchez

Data exploration using elastic stack for beginnersDaliya Spasova

Viewers also liked (8)

Home/Garden Still Lifecoreylesh

Cats: Provider of Happiness and JoySatsugai Se-o

Glass Still Lifecoreylesh

This document discusses copyright issues related to using online content in education from the 1970s to present day. It outlines key court cases and amendments to copyright law regarding technologies like photocopiers, video recorders, and the internet. While the education license allows copying 10% of words or whole artistic works for classroom use, copyrighted content posted online like to YouTube may not be covered. The document warns of common misconceptions and provides recommendations to check restrictions and seek permission before publishing copyrighted material publicly.

Researchsummarydavidwzhang

This research summary discusses insights from a study of mature families with mid to high-end incomes and their use of technology in the living room. The study found that male and female users have differing desires, with males wanting variety of functions and aesthetics while females want control over style and the social aspects. It also found serious cable management issues behind entertainment cabinets and a need for future-proof designs that can accommodate evolving devices and integration of technologies.

Travelguestaffbe9

???, ??? ??? ???? ??Yoon Hyuk Choi

Satsugaicat Teach You how to start twitterSatsugai Se-o

This document provides a guide for cats to use Twitter. It outlines the benefits of Twitter for cats, such as following other cats to learn wisdom and meet animal friends. It recommends following popular cat accounts like @satsugaicat and the famous cat Sockington. The guide also provides steps for cats to set up their own Twitter account, including signing up at www.twitter.com, confirming their email, and adding a profile picture.

Home/Garden Still Lifecoreylesh

Cats: Provider of Happiness and JoySatsugai Se-o

Glass Still Lifecoreylesh

Researchsummarydavidwzhang

Travelguestaffbe9

???, ??? ??? ???? ??Yoon Hyuk Choi

Satsugaicat Teach You how to start twitterSatsugai Se-o

Similar to Upload keynote to can view it. (20)

Introduction to RxJSBrainhub

RxJS is a library for reactive programming that allows composing asynchronous and event-based programs using observable sequences. It provides the Observable type for pushing multiple values to observers over time asynchronously. Operators allow transforming and combining observables. Key types include Observable, Observer, Subject, BehaviorSubject, and ReplaySubject. Subjects can multicast values to multiple observers. Overall, RxJS is useful for handling asynchronous events as collections in a declarative way.

Luis Atencio on RxJSLuis Atencio

Reactive programming and RxJSRavi Mone

This document provides an introduction to reactive programming and RxJS. It begins by explaining the benefits of the reactive approach for asynchronous and event-driven code. It then contrasts reactive and functional programming, noting that reactive programming deals with asynchronous data streams. The document introduces RxJS and how it handles promises and observables. It defines observables and operators. Examples are provided to demonstrate reactive concepts. Resources for further learning are included at the end.

Real Time Big Data ManagementAlbert Bifet

Intro to Rx JavaSyed Awais Mazhar Bukhari

Reactive programming is a programming paradigm oriented around data flows and the propagation of change. It involves expressing static or dynamic data flows and automatically propagating changes through the flow. Reactive programming uses asynchronous data streams that can emit values, errors, or a completion signal. RxJava is a library that uses the observer pattern to support reactive programming. It defines Observables that emit events to Observers. Subjects in RxJava can act as both Observables and Observers, allowing values to be pushed to subscribers. RxJava provides operators like filter and distinct to transform streams of data.

NGRX Apps in DepthTrayan Iliev

The document discusses various topics related to reactive and functional programming including NGRX, RxJS, Redux, Reactive Streams specification, and computing derived data using Reselect. It provides code examples for setting up an NGRX application with state management, effects, selectors, and composing the root reducer. It also discusses hot and cold streams, converting cold streams to hot, and the anatomy of RxJS operators.

Introduction to RxJSAbul Hasan

RxJsAkila Iroshan

The document discusses the reactive programming paradigm that responds to various stimuli, emphasizing its application in handling asynchronous data streams from multiple sources. It introduces observables as a key component for managing these streams and lists several programming languages that support reactive extensions (Rx) such as Java, JavaScript, C#, and Python. The content highlights the utility of observables for filtering, transforming, and composing data while noting the learning curve associated with the extensive Rx API.

2014.06.24.what is ubixJim Cooley

Ubix is an integrated platform built on Apache Spark that allows users to ingest data from various sources, perform multiple analytics steps and transformations, and produce powerful interactive visualizations on both historical and streaming data. It contains over 170 functions for data wrangling, machine learning, graph processing, and visualization. While users could build their own Spark workflows, Ubix aims to simplify this process and provide an out-of-the-box platform for advanced analytics.

2017 nov reflow sbtbmariuseriksen4

Marius Eriksen discusses Reflow, a new cloud-native workflow framework for bioinformatics. Reflow programs workflows directly using a functional programming language for simplicity and composability. It leverages lazy evaluation and caching to efficiently parallelize and distribute work across private clusters. Reflow aims to untie the hands of implementors compared to traditional workflow systems through its unified approach to programming, execution, and infrastructure.

Reactive Functional Programming with Java 8 on Android NShipeng Xu

The document discusses reactive functional programming with Java 8 on Android N. It introduces reactive programming concepts like Observables and Subscribers. It provides an example of using RxJava to find PNG images in a folder and load them into a gallery, as compared to the vanilla Java approach. It also demonstrates creating Observables, Subscribers, transforming streams, handling REST responses, and subscribing to streams. Specifically, it shows an example of clicking a button to get a user's followers from GitHub, get details on each follower, filter by company, and update the UI with results.

How to Think in RxJava Before ReactingIndicThreads

The document provides an overview of RxJava, a Java implementation of Reactive Programming focused on asynchronous programming with observable streams. It covers key concepts like the observer pattern, operators for manipulating streams, and techniques for multithreading, including how to create observables and handle errors. The document offers practical examples demonstrating the creation and use of observables, as well as the application of various operators and concurrency management.

Reactive programmingsaykopatt

The document discusses reactive programming and provides examples using RxJS. It defines reactive programming as working with asynchronous data streams. Streams can represent events like user inputs or API responses. Key concepts discussed include: - Observables represent streams of data that can be subscribed to. Common stream operations like map, filter, and scan can transform streams. - An example demonstrates creating a stream for a "Who to follow" API, making a request on startup and refresh, and rendering responses. - Other operators like merge, startWith, and combineLatest are used to combine multiple streams of events and responses.

A "Do-It-Yourself" Specification Language with BeepBeep 3 (Talk @ Dagstuhl 2017)Sylvain Hallé

The document describes a do-it-yourself specification language named BeepBeep, which processes arbitrary data elements in a stream using Java objects. It outlines various processors and functions available for transforming input streams into output streams, as well as custom processors and palettes to meet specific user needs. Additionally, it discusses creating a domain-specific language with a customizable runtime parser, allowing users to define their own syntax and processing capabilities.

Data analysis in RAndrew Lowe

This document is a comprehensive guide on installing and using R and RStudio for data analysis and machine learning, outlining R's features, packages, and resources. It emphasizes R's strengths, including its free nature, community support, and advanced analytics capabilities, while also mentioning some of its limitations. Additionally, it covers foundational concepts of the R language, such as data types, vectors, lists, and data frames, providing essential knowledge for effective programming.

Taste of RxJSMd. Ziaul Haq

The document discusses RxJS, a library for composing asynchronous and event-based programs using observable sequences. It covers key concepts such as observables, observers, and operators, highlighting the advantages of RxJS over promises, including the ability to handle multiple events and support cancellation. Additionally, it notes that RxJS is utilized in frameworks like Angular for managing asynchronous actions.

R and C++Romain Francois

- Rcpp is a package that facilitates interoperability between R and C++ by providing data structures and functions that make it easy to write C++ code that integrates with R. It has been released 54 times since 2008 with over 170 CRAN packages depending on it. - Rcpp allows users to source C++ code from R using sourceCpp() and export C++ functions to R using attributes like // [[Rcpp::export]]. This improves performance over pure R code by leveraging fast C++ implementations. - dplyr is a popular R package for data manipulation that achieves great performance through its use of Rcpp. Functions like arrange(), filter(), and summarise() are much faster when

Spring 5 Webflux - Advances in Java 2018Trayan Iliev

The document discusses a presentation on functional reactive services with Spring 5 WebFlux. It introduces functional reactive programming (FRP), Project Reactor, building REST services with Spring 5 WebFlux including routers, handlers, filters, and reactive repositories. It also covers end-to-end non-blocking reactive service-oriented architecture with Netty, reactive WebClients, and real-time event streaming to JavaScript clients using server-sent events (SSE). The presentation code examples are available on GitHub.

rx.js make async programming simplerAlexander Mostovenko

The document discusses Rx.js, a library for reactive programming using Observables. It begins by introducing Rx.js and some of its key benefits over other approaches to asynchronous programming like callbacks and Promises. It then provides examples of using Observables to represent asynchronous data streams and operations like DOM events. Key points made include that Observables allow for lazy execution, cancellation, composition of existing event streams, and treating asynchronous values as collections. The document concludes by demonstrating how Rx.js allows building a Morse code parser by modeling DOM events and signals as Observable streams.

WebCamp:Front-end Developers Day. Александр Мостовенко "Rx.js - делаем асинхр...GeeksLab Odessa

The document discusses the benefits of using rx.js for simplifying asynchronous programming, highlighting its extensive documentation and implementation across various programming languages. It contrasts traditional callback methods with promises and observables, showcasing how observables enable handling multiple values, lazy execution, and cancellation. Additionally, it provides practical examples, including real-time user interactions like drag-and-drop functionality, demonstrating how to manage event streams with rx.js.

Introduction to RxJSBrainhub

Luis Atencio on RxJSLuis Atencio

Reactive programming and RxJSRavi Mone

Real Time Big Data ManagementAlbert Bifet

Intro to Rx JavaSyed Awais Mazhar Bukhari

NGRX Apps in DepthTrayan Iliev

Introduction to RxJSAbul Hasan

RxJsAkila Iroshan

2014.06.24.what is ubixJim Cooley

2017 nov reflow sbtbmariuseriksen4

Reactive Functional Programming with Java 8 on Android NShipeng Xu

How to Think in RxJava Before ReactingIndicThreads

Reactive programmingsaykopatt

A "Do-It-Yourself" Specification Language with BeepBeep 3 (Talk @ Dagstuhl 2017)Sylvain Hallé

Data analysis in RAndrew Lowe

Taste of RxJSMd. Ziaul Haq

R and C++Romain Francois

Spring 5 Webflux - Advances in Java 2018Trayan Iliev

rx.js make async programming simplerAlexander Mostovenko

WebCamp:Front-end Developers Day. Александр Мостовенко "Rx.js - делаем асинхр...GeeksLab Odessa

Upload keynote to can view it.

1. RX R e t h i n k i n g t h e w a y w e d o s t u f f

2. RX Rx is a library for composing asynchronous and event-based programs using observable collections. Rx has a strong theoretical basis by using the duality between the classic Iterator and Observer design patterns to simplify controlling asynchrony

3. Genesis JSON

4. Genesis JSON

5. Genesis 2 AMQP (and it’s brokers RabbitMQ etc)

6. Genesis 2 AMQP

7. genesis III ZMQ

8. What we want? We want something Generic

9. Problem

10. CUGLY CUGLY = FUGLY but for Callbacks

11. LINQ Microsoft Functional Programming (posta)

12. LINQ III

13. LINQ II var?query?=?yourData ????.GroupBy(x?=>?x.Name, ?????????????(k,?g)?=>?g.Aggregate((a,?x)? =>?(x.Priority?>?a.Priority)???x?:?a));

14. select es fmap (list map) SelectMany (mapcat) listmap

15. DEMO

16. Implementation

19. In other words, x >>= k is a computation which runs x, and then uses the result(s) of x to decide what computation to run second, using the output of the second computation as the result of the entire computation.

20. [ EVENT(KEY) -> (KEY -> EVENT(MOUSE) ] -> EVENT(MOUSE)

21. In the process we've discovered what Rx really is: a fancy way of writing event handlers, specifically event handlers that fire events that trigger other event handlers that fire events, and so on in big chain that looks like a query

22. Async everywhere NEXT STEPS: RUBY LIBRARY JS LIBRARY (for dealing with UI)

Editor's Notes

#2: \n
#3: \n
#4: \n
#5: \n
#6: \n
#7: \n
#8: \n
#9: \n
#10: \n
#11: \n
#12: \n
#13: \n
#14: \n
#15: \n
#16: \n
#17: \n
#18: \n
#19: \n
#20: \n
#21: \n
#22: \n
#23: \n

狠狠撸

Upload keynote to can view it.

Recommended

More Related Content

What's hot (19)

Viewers also liked (8)

Similar to Upload keynote to can view it. (20)

Upload keynote to can view it.

Editor's Notes