bradmontgomery

#!/usr/bin/env python
"""
Very simple HTTP server in python (Updated for Python 3.7)

Usage:

    ./dummy-web-server.py -h
    ./dummy-web-server.py -l localhost -p 8000

Send a GET request:

derek-schaefer

wget --output-document=/dev/null http://speedtest.wdc01.softlayer.com/downloads/test500.zip

roxlu

#include <roxlu/core/Log.h>
#include <roxlu/core/Utils.h>
#include <video/X264Encoder.h>

X264Encoder::X264Encoder() 
  :in_width(0)
  ,in_height(0)
  ,in_pixel_format(AV_PIX_FMT_NONE)
  ,out_width(0)
  ,out_height(0)

JedWatson

This is an example of how to scaffold API endpoints to list / get / create / update / delete Posts in a Keystone website.

It's a modification of the default project created with the yo keystone generator (see https://github.com/JedWatson/generator-keystone)

Gists don't let you specify full paths, so in the project structure the files would be:

routes-index.js        -->    /routes/index.js         // modified to add the api endpoints
routes-api-posts.js    -->    /routes/api/posts.js     // new file containing the Post API route controllers

austinhyde

Observables

You don't really need a framework or fancy cutting-edge JavaScript features to do two-way data binding. Let's start basic - first and foremost, you need a way to tell when data changes. Traditionally, this is done via an Observer pattern, but a full-blown implementation of that is a little clunky for nice, lightweight JavaScript. So, if native getters/setters are out, the only mechanism we have are accessors:

var n = 5;
function getN() { return n; }
function setN(newN) { n = newN; }

console.log(getN()); // 5

setN(10);

NicolaeNMV

If you were playing with reactive-stream, and you got this error

scala> val sum = source.runWith(sink)
<console>:14: error: could not find implicit value for parameter materializer: akka.stream.FlowMaterializer

You need an implicit FlowMaterializer

def runWith[Mat2](sink: Graph[SinkShape[Out], Mat2])(implicit materializer: FlowMaterializer): Mat2

CMCDragonkai

HTTP Streaming (or Chunked vs Store & Forward)

The standard way of understanding the HTTP protocol is via the request reply pattern. Each HTTP transaction consists of a finitely bounded HTTP request and a finitely bounded HTTP response.

However it's also possible for both parts of an HTTP 1.1 transaction to stream their possibly infinitely bounded data. The advantages is that the sender can send data that is beyond the sender's memory limit, and the receiver can act on

tjanczuk

// How to connect 5 publishers with 5 subscribers 
// over TCP using ZeroMQ's XPUB/XSUB proxy.

// sub (connect) 
//   <-8701-> 
// (bind) xpub <---> xsub (bind) 
//   <-8700-> 
// (connect) pub

var zmq = require('zmq');

karpathy

""" Trains an agent with (stochastic) Policy Gradients on Pong. Uses OpenAI Gym. """
import numpy as np
import cPickle as pickle
import gym

# hyperparameters
H = 200 # number of hidden layer neurons
batch_size = 10 # every how many episodes to do a param update?
learning_rate = 1e-4
gamma = 0.99 # discount factor for reward

swlaschin

(*
Example of domain-driven design for Checkers
Rules from here: https://www.itsyourturn.com/t_helptopic2030.html

A SERIES OF SCRATCH DESIGNS
*)

// As we go through the rules, and learn things, we create a series of designs

module Version1 =