shuhei

const url = require('url');
const https = require('https');

const agent = new https.Agent({
  keepAlive: true
});

function getAPI(uri) {
  return new Promise((resolve, reject) => {
    const { protocol, hostname, path } = url.parse(uri);

shuhei

Execution of Promise Chain in Node.js

After reading The Node.js Event Loop, Timers, and process.nextTick()...

Q. I write a lot of promise chains in applications. How is a promise chain executed? Is it performant?

The experiment shows:

• Chained promises are eagerly executed before proceeding to the next phase.
• Promise chaining is a bit slower than synchronous execution, but not too much.

shuhei

import * as React from 'react';
import { mount } from 'enzyme';
import sinon from 'sinon';

function isImageLoaded(img: HTMLImageElement) {
  return img.complete && img.naturalHeight > 0;
}

type Props = {
  src: string,

shuhei

module App exposing (..)

import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import Validate exposing (..)


-- FIELD

shuhei

Node.js HTTP timeout

Findings

• http.request({ timeout }) is not working for response timeout.
  • Agent timeout supercedes the option
• Doesn't leak because request.on('timeout') instead of socket.on('timeout'). It's easier because request is always thrown away.
  • Then why header leaks?
    • Print socket's listeners('timeout').length
• Try dropRequestAfter together

shuhei

'use strict';

const assert = require('assert');
const http = require('http');
const Agent = require('agentkeepalive');
const request = require('../lib/request');

describe('request timeout', () => {
    it('should not leak timeout event handler', (done) => {
        const server = http.createServer((req, res) => {

shuhei

declare opaque type Decoder<T>;

declare var num: Decoder<number>;
declare var str: Decoder<string>;
declare var bool: Decoder<boolean>;
declare function array<T>(decoder: Decoder<T>): Decoder<T[]>;
declare function field<T>(key: string, decoder: Decoder<T>): Decoder<T>;
declare function nullable<T>(decoder: Decoder<T>): Decoder<?T>;
declare function maybe<T>(decoder: Decoder<T>): Decoder<?T>;
declare function at<T>(keys: string[], decoder: Decoder<T>): Decoder<T>;

shuhei

package main

import (
	"fmt"
	"time"
)

func main() {
	input := make(chan int)
	go startMaster(input)

shuhei

const net = require('net');
const dns = require('dns');
const request = require('request');

const start = Date.now();

function log() {
  const time = (Date.now() - start).toString();
  console.log.apply(console, [time].concat(Array.from(arguments)));
}

shuhei

const net = require('net');
const dns = require('dns');
const http = require('http');

const start = Date.now();

function log() {
  const time = (Date.now() - start).toString();
  console.log.apply(console, [time].concat(Array.from(arguments)));
}