JSFoo 2017

JSFoo is a conference about JavaScript and everything related.

Trends in Async Javascript

Submitted by Mayank Verma (@knayam91) on Jun 14, 2017

Section: Full Talk Technical level: Intermediate Status: Rejected

Abstract

Generators, Async-Await, Observables (Reactive Programming) - too much jargon?

The ways of handling asynchronous Javascript have evolved over the years. These ways sometimes seem too much for someone starting afresh in Javascript.

This talk attempts to streamline understanding these evolving patterns for beginners and looks at where these trends are leading the current Javascript ecosystem.

Outline

A tentative outline:

  1. Breaking the ice
    1.1 Synchronous & Asynchronous
    1.2 Functional Programming
    1.3 Functions as ‘First-Class’ Objects

  2. Callbacks, hell, & a Promise to resolve
    2.1 Callback functions, usage & Callback hell
    2.2 I promise to resolve Promises for you
    2.3 Promise Pyramid of Doom: Old wine in a new bottle
    2.4 Generator functions and Promises

  3. Async-Await
    3.1 Bro, do you even “async”?
    3.2 Async functions: sync-like, human-readable.

  4. Observables (Reactive Programming)
    4.1 Sequences in space vs Sequences in time
    4.2 Async event/data streams
    4.3 Reactive: tools to combine, create & filter streams

  5. Thinking in Reactive Programming
    5.1 Observables and observers
    5.2 Getting values asynchronously
    5.3 Handling any no. of ‘async’ return values
    5.4 Use cases

  6. Conclusion & take-aways

Speaker bio

Who am I?

I am a Software Engineer and I recently joined Nykaa, where we’re re-writing the entire frontend using React-Redux. If confirmed, this shall be my first talk/session at any JS conference.

Why should you let me talk about this / Why am I excited about it?

I moved from object-oriented programming to Javascript (functional programming) and faced issues grasping the concept of functions being first-class objects and the general usage of ‘callbacks’. I want to make it easier for others starting out.

I want to incrementally talk about better patterns that emerged as Javascript evolved.

I want to share the new, still-evolving patterns for async behaviour and where those are leading the Javascript ecosystem as a whole.

Slides

https://docs.google.com/presentation/d/1dzsrrwt_rI_tvQvmg7IPvkTa-Znl6TpmwHXWEKi6Mc4/edit?usp=sharing

Preview video

https://www.youtube.com/watch?v=Bg2U93dZ6XA

Comments

{{ gettext('Login to leave a comment') }}

{{ gettext('You need to be a participant to comment.') }}

{{ formTitle }}
{{ gettext('Post a comment...') }}
{{ gettext('New comment') }}

{{ errorMsg }}