Friday, September 18, 2020
Times are in UK Time (BST or UTC +1)

Welcome & Intros

12:00 pm -
12:15 pm

Welcome & Intros

Michael Hladky - Reactive Ephemeral State

12:15 pm -
12:45 p
m

Ever heard about ephemeral state? 

 

Ngrx, ngxs, akita etc did a great job in managing global state in SPAs.

However, nobody talked about the complexity and pain of managing the component state. 

 

There is this quote of “Gang of Four”: 

“If you stick to the paradigms of OOP the-design patterns appear naturally.”

 

This will be the fundamental motivation for this talk.

 

As a result of Michael's studies, you will get an overview of terms and ways to categorize state.  You will know the tricky problems and challenges and learn how to craft component state reactively.

 

A few of the main problems you will run into when implementing local state management in a reactive way are:

  • Encapsulation and instantiation of local state

  • The late subscriber problem

    • Composition of cold observables

  • Sharing references over observables

  • Bind Subscription life-time to components/directives/pipes

  • Handle local side-effects

 

In a final step, the above problems are put together and implemented as a first draft of ephemeral-state-management based on Michael's findings. 

 

After this talk, you will be able to solve all of these problems with a clean and structured approach. As a side effect, the application will work (nearly) automatically zone-less.

68747470733a2f2f692e696d6775722e636f6d2f

Lamis Chebbi - Embrace RealTime components using Angular, WebSocket and RxJS

12:45 pm -

01:15 pm

Ever wondered how to push data in real time to Angular Components? Are you curious about how to achieve this at the lowest cost using RxJS WebSocketSubject? Are you interested in exploring the performance challenges behind this and seeing a live demo? Then this talk is for you.

rxjs_speaker_lamis_chebbi.jpg

Kwinten Pisman & Dominic Elm - RxJS by Example

01:15 pm - 

01:45 pm

RxJS is known as a library that brings the concept of reactive programming to the web. However, it can be very intimidating at first, and it has a very steep learning which sometimes makes it hard to apply. In this talk we will have a look at different real world examples and see various operators in action. We want everyone to walk away with ideas of where to use reactive programming.

rxjs_speakers_kwinten_and_dominic.png

Jan-Niklas Wortmann - Demystifying RxJS Operators

01:45 pm -

02:15 pm

Everyone that already uses RxJS knows that the added value of RxJS mostly comes from the provided operators. These operators enable us to develop complex scenarios in a fairly comprehensible manner. 
 

Right now RxJS already provides over 100 different operators and it is also possible to extend this huge list by developing custom operators. 

But wait, do you actually know how operators are internally structured? How is this magic piece of code developed that brings so much power?
 

Everyone uses RxJS operators on a daily bases, but no one really knows about the internals of it! Within this talk, we will take a deep dive into the internals of RxJS to understand how operators are developed. This will first make us understand how these operators work and second enables us to write our own operators to fully embrace the power of RxJS

jan-niklas worrtmann.jpg

Jay Phelps - Don’t Lose Your Marbles, We Can Test RxJS Code

02:15 pm -

02:45 pm

Testing complex async code can be challenging. But, since we’re using RxJS, there are utilities and patterns that can help us tremendously.

In this talk, we’ll cover the various ways you can test your RxJS code, including how to effectively use the TestScheduler with ASCII marble diagrams to virtualize time, which gives us fast, deterministic tests.

jayphelps.jpg

Speaker - Estefania Garcia Gallardo & Carlos Caballero - The power of RxJS: Building Flappy Bird in Angular

02:45 pm -

03:15 pm

To introduce reactive programming in with RxJS, we will be building the famous Flappy Bird minigame. We will cover everything from the basic concepts of reactive programming (observables, observers, subscriptions etc) to an advanced use of RxJS operators, as well as the latest versions of powerful web technologies like Angular and Pixi.js

rxjs_speakers_nya_and carlos.png

Coffee Break

03:15 pm - 03:30 pm

Grab a snack & coffee or tea, and tweet about #rxjsliveonair2020

RxJS_live_london..png

Ben Lesh - The Future of RxJS

03:30 pm -

04:10 pm

The future of RxJS is bright! Ben will give us a preview into the RxJS roadmap for 2020!

2JzRKVvH_400x400.jpg

Kapehe Jorgenson - The Battle of House Promises vs. House Observables

04:10 pm -
04:30 pm

When learning RxJS, the naturally reaction is to compare it to JavaScript Promises. That’s fair. So in this talk I will be going over the creation and usage differences between promises and observables. Which one is better? Or which one will make the most sense in my project?

 

RxJS observables can be scary to transition over to, but I will show you the way. Why leave promises behind, you ask? No need. Keep those close. I will show you some pros and cons of using each and then leave you to make your final opinion.

I3pCcy20_400x400.jpg

Nicholas Jamieson & Moshe Kolodny - Automated RxJS Code Analysis using Traits

04:30 pm -

05:00 pm 

RxJS has a large API and introduces concepts with which developers are often unfamiliar. Identifying and explaining problematic API usage can make learning and working with RxJS a more enjoyable and efficient experience.

 

In this talk, we'll look how RxJS's TypeScript definitions can be augmented to include an observable's traits: whether it's synchronous; whether it completes; and the number of elements it will emit.

 

We'll look at the type-level programming that can be used to coax TypeScript to perform most of the static analysis and will show how a linter can be used to give immediate feedback within a developer's editor.

rxjs_speakers_nicholas and moshe.png

Speaker - David Khourshid - Putting the "Act" in Reactive: From Observables to Actors

05:00 pm -

05:30 pm

Can a half-century-old model of computation reduce complexity, improve performance, and make our applications exponentially more scalable and visually clear? The Actor Model can hold the key to simplifying the reactive apps we work on. Learn how RxJS observables and state machines can be used together make our apps more predictable, faster, and testable, with plenty of demos that will inspire you to put this event-driven, reactive model into action.

rxjs_speaker_david_piano.jpg

After Party

05:30 pm -

06:30pm

After Party - Lounge, Informal Discussions

USE CODE "RxJS30" for a 30% discount on tickets

ONLINE

  • White Twitter Icon

Follow RxJS Live on Twitter