Andrey Popp andreypopp

Interesting part (unmounting & API) is at the end if you're not interested in the rest =).

Stress Tests

This animation proposal is just an attempt. In case it doesn't work out, I've gathered a few examples that can test the power of a future animation system.

Parent is an infinitely spinning ball, and has a child ball that is also spinning. Clicking on the parent causes child to reverse spinning direction. This tests the ability of the animation system to compose animation, not in the sense of applying multiple interpolations to one or more variables passed onto the child (this should be trivial), but in the sense that the parent's constantly updating at the same time as the child, and has to ensure that it passes the animation commands correctly to it. This also tests that we can still intercept these animations (the clicking) and immediately change their configuration instead of queueing them.
Typing letters and let them fly in concurrently. This tests concurrency, coordination of an array of ch

While I was experimenting with animation, I had to make a few basic prototypes for a layout system and see how they intertwine. Here's the API in conjunction with React:

var MyComp = React.createClass({
  registerLayoutValues: function() {
    return {
      self: {
        width: 30,
        left: (get('parent', 'width') - get('self', 'width')) / 2 // Center.
 }

This is taken directly from Figure 5.2 in http://nixos.org/~eelco/pubs/phd-thesis.pdf. It is presented here to be more directly linkable.

serialise(fso) = str("nix-archive-1") + serialise1(fso)

serialise1(fso) = str("(") + seralise2(fso) + str(")")

serialise2(type=Regular, exec, contents) =
  str("type") + str("regular")
 + (

Parser

/src/parser/spider_monkey_ast.ml: The type definitions for the AST. Tries to stay very close to ESTree
/src/parser/lexer_flow.mll: The ocamllex lexer logic
/src/parser/parser_flow.ml: The recursive descent JS parser

Inference

/src/typing/type_inference_js.ml: Contains the "entry point" for inference (Function called infer_ast).
/src/typing/statement.ml: Most of the inference logic (runs through the AST and generates the initial constraints)

Please 🌟 this gist to vote for this proposal!

Make linting great again!

No other topic in software development probably has so much controversy as linting.

With a wrong workflow linting can be really a pain and will slow you and your team down. With a proper setup, though, it can save you hours of manual work reformatting the code and reducing the code-review overhead.

	/** @jsx React.DOM */

	var Bubbler = React.createClass({
	render: function() {
	return <input type="button" onClick={this.props.onFoo} value="Click me"/>;
	}
	});

	var Handler = React.createClass({
	onFoo: function() {

	import { Component } from "React";

	export var Enhance = ComposedComponent => class extends Component {
	constructor() {
	this.state = { data: null };
	}
	componentDidMount() {
	this.setState({ data: 'Hello' });
	}
	render() {

	{
	"env": {
	"browser": true,
	"node": true,
	"es6": true
	},

	"plugins": ["react"],

	"ecmaFeatures": {

	<ViewList animator> // passes context: { step: 0.555 }
	<View /> // extends context with { index: 0 }
	<View /> // ...
	<View> // extends context with { index: 2 }

	// here's the tricky part: you can nest ViewLists, and they should pass their "new" context down to their children
	<ViewList> // reset context { step: 0 }
	<View /> // reset context { index: 0 }
	</ViewList>
	</View>

	#!/usr/bin/env python

	import pynvim, os, re, sys, time

	# Get a list of buffers that haven't been deleted. `nvim.buffers` includes
	# buffers that have had `:bdelete` called on them and aren't in the buffer
	# list, so we have to filter those out.
	def get_listed_buffers(nvim):
	return set(buf.number for buf in nvim.buffers \
	if nvim.eval('buflisted(%d)' % buf.number))