pizzarob

import React from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames';

const ANIMATION_DURATION = 1000;

class BatchDropZone extends React.Component {

  static propTypes = {

cscalfani

Elm in Node (0.17)

Why?

Sharing code between the client and the server in a Universal Javascript application is a big gain. No more are the days of rewriting code for the server.

But moving from Javascript to Elm in the front end can feel like a move backwards. So much of the code we write is environment independent. And it would be great if we could leverage some of the front end logic on the backend.

How?

wallyqs

FROM golang:1.6.2

COPY . /go

RUN go get github.com/nats-io/nats
RUN go build api-server.go

EXPOSE 8080
ENTRYPOINT ["/go/api-server"]

Arachnid

/**
 * Base contract that all upgradeable contracts should use.
 * 
 * Contracts implementing this interface are all called using delegatecall from
 * a dispatcher. As a result, the _sizes and _dest variables are shared with the
 * dispatcher contract, which allows the called contract to update these at will.
 * 
 * _sizes is a map of function signatures to return value sizes. Due to EVM
 * limitations, these need to be populated by the target contract, so the
 * dispatcher knows how many bytes of data to return from called functions.

griffinmichl

function queue(concurrency = 1) {
  let running = 0
  const taskQueue = []

  const runTask = (task) => {
    running++
    task(() => {
      running--
      if (taskQueue.length > 0) {
        runTask(taskQueue.shift())

griffinmichl

const fetchContent = (url) =>
    rx.Observable.create(observer => 
      fetch(url)
        .then(res => res.json())
        .then(json => {
          observer.onNext(json)
          observer.onCompleted()
        )
        .catch(e => observer.onError())
    )

banunatina

System Design Cheatsheet

Step One: Framing The Problem a.k.a get the MVP

• Identify the use cases that are in scope
• Determine constraints based on scoped use cases

use case : the things your system needs to be do.

constraints : the things your system will have to consider to be able to do stuff

ejcx

 this.ycQuestions = [
    "So what are you working on?",
    "Have you raised funding?",
    "What makes new users try you?",
    "What competition do you fear most?",
    "What’s the worst thing that has happened?",
    "Will you reincorporate as a US company?",
    "What’s an impressive thing you have done?",
    "Where is the rocket science here?",
    "Why did you pick this idea to work on?",

grayrest

import React, {Component} from 'react';
import ReactDOM from 'react-dom';
import {observable, computed} from 'mobx';
import {observer} from 'mobx-react';
// import DevTools from 'mobx-react-devtools';

class Server {
  @observable days = [];
  @observable name = "";
  @computed get upDays() {

axic

//
// In Solidity, a mapping is like a hashmap and works with `string` like this:
//   mapping (string => uint) a; 
//
// However it doesn't support accessors where string is a key:
//   mapping (string => uint) public a;
//
// "Internal compiler error: Accessors for mapping with dynamically-sized keys not yet implemented."
//
// An accessor returns uint when called as `a(string)`.