ponyjackal

ruby '2.7.1'

gem 'rails', github: 'rails/rails'
gem 'tzinfo-data', '>= 1.2016.7'  # Don't rely on OSX/Linux timezone data

# Action Text
gem 'actiontext', github: 'basecamp/actiontext', ref: 'okra'
gem 'okra', github: 'basecamp/okra'

# Drivers

ponyjackal

import React, { useState, useEffect, useCallback } from "react";

const useToggle = (initState = false) => {
  const [status, setStatus] = useState(initState);

  const toggle = useCallback(() => {
    setStatus((status) => {
      return !status;
    });
  }, []);

ponyjackal

import React, { useState, useEffect } from "react";

const useDebounce = (value, delay) => {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

ponyjackal

var Query = require('graphql-query-builder');


const client = new ApolloClient({
  uri: 'http://localhost:4000',
}); 

function Test() {
  const greeting = 'Hello Function Component!';

ponyjackal

// Add grant to join voice conference (fire event to join voice conference)

 $voiceToken = new AccessToken(
                    $_ENV['TWILIO_SID'],
                    $_ENV['TWILIO_VIDEO_SID'],
                    $_ENV['TWILIO_VIDEO_SECRET'],
                    3600,
                    $userIdentity
                );
  $voiceGrant = new VoiceGrant();

ponyjackal

Also known as the oldest way to handle asynchronous data, callbacks allow us to inject a function into an asynchronous execution so that we can control the result(s) when they are available. In a very indirect way, it's as if we're sending a "spy" who will inform us when something happens within the call we are executing.

We'll create a simple example to get started, a function that returns a new Date():

function getNewDate() {
  return new Date();
}

const result = getNewDate();

ponyjackal

Promises are a native JavaScript implementation to more elegantly and simply handle asynchronous data.

Just like promises in the real world, promises in JavaScript can or not happen, technically we can say that we have control of the moment of success and error of the flows we are dealing with, but you can think, "but I also already have this possibility of handler with callbacks", and yes you can handler your errors using callbacks too, but imagine being able to compose, pipe your operarations and also get errors in a more elegant and literally more declarative way, that's just a little bit of what Promises can do.
Creating a Promise

The promises have 2 stages, creation and consume. Let's check the basics to create a new promise:

const myPromise = new Promise(function (resolve, reject) {
  // do something
  if (true) {

ponyjackal

The keyword async was implemented in ES2017. It makes it possible to create naturally asynchronous functions using the following notation:

async function myAsyncFunction() {}

Something important and even more interesting about this implementation is that every async function returns a Promise, meaning that we can use all the interfaces we already know in the article about promises. Let's look at an example to better understand:

async function myAsyncFunction() {
  return "Hello!";
}

ponyjackal

import { useState, useEffect } from "react";

export const usePromise = (
  fn,
  { resolve = false, resolveCondition = [] } = {}
) => {
  const [data, setData] = useState();
  const [isLoading, setLoading] = useState(resolve);
  const [lastUpdated, setLastUpdated] = useState();
  const [error, setError] = useState();

ponyjackal

People

:bowtie:	😄 :smile:	😆 :laughing:
😊 :blush:	😃 :smiley:	☺️ :relaxed:
😏 :smirk:	😍 :heart_eyes:	😘 :kissing_heart:
😚 :kissing_closed_eyes:	😳 :flushed:	😌 :relieved:
😆 :satisfied:	😁 :grin:	😉 :wink:
😜 :stuck_out_tongue_winking_eye:	😝 :stuck_out_tongue_closed_eyes:	😀 :grinning:
😗 :kissing:	😙 :kissing_smiling_eyes:	😛 :stuck_out_tongue: