Wouter Willaert wouterw

Hang on, I'm not saying flux is dead, or that redux isn't amazing.

Okay ...

Most everybody is familiar with flux by now:

User Interaction --event data-->
  Action Creator --action-->
 Dispatcher --payload--&gt;

Why would you want to do this? Because you often don't need more. It's nice to not have to think about your "router" as this big special thing.

Instead, with this approch, your app's current pathname is just another piece of state, just like anything else.

This also means that when doing server-side rendering of a redux app, you can just do:

var app = require('your/redux/app')
var React = require('react')

Things that programmers don't know but should

(A book that I might eventually write!)

Gary Bernhardt

I imagine each of these chapters being about 2,000 words, making the whole book about the size of a small novel. For comparison, articles in large papers like the New York Times average about 1,200 words. Each topic gets whatever level of detail I can fit into that space. For simple topics, that's a lot of space: I can probably walk through a very basic, but working, implementation of the IP protocol.

This guide assumes that you recently run brew upgrade postgresql and discovered to your dismay that you accidentally bumped from one major version to another: say 9.3.x to 9.4.x. Yes, that is a major version bump in PG land.

First let's check something.

brew info postgresql

The top of what gets printed as a result is the most important:

	function main() {
	return {
	DOM: Rx.Observable.timer(0, 1000)
	.map(i => `Seconds elapsed ${i}`)
	};
	}

	const drivers = {
	DOM: function DOMDriver(sink) {
	sink.subscribe(text => {

	defmodule SimpleSup do
	@moduledoc """
	This file shows methods for starting a configurable number of children under
	a `:simple_one_for_one` supervisor.

	When the supervision tree is first started all methods behave the same, `size`
	children are started and the `:starter` returns `:ignore`. However if the
	restart limit for those children is reached the `:simple_one_for_one`
	supervisor will be restarted and then the `:starter`. It is possible that the
	`:simple_one_for_one` is restarted successfully but the `:starter` fails to

	import UIKit

	extension String {
	var hexColor: UIColor? {
	let hex = self.stringByTrimmingCharactersInSet(NSCharacterSet.alphanumericCharacterSet().invertedSet)
	var int = UInt32()
	guard NSScanner(string: hex).scanHexInt(&int) else {
	return nil
	}
	let a, r, g, b: UInt32

	function mapValues(obj, fn) {
	return Object.keys(obj).reduce((result, key) => {
	result[key] = fn(obj[key], key);
	return result;
	}, {});
	}

	function pick(obj, fn) {
	return Object.keys(obj).reduce((result, key) => {
	if (fn(obj[key])) {

	#!/usr/bin/sudo sh

	## ruby_revealer.sh -- decrypt obfuscated GHE .rb files. 2.0.0 to 2.3.1+.

	## From `strings ruby_concealer.so`:
	##
	## > This obfuscation is intended to discourage GitHub Enterprise customers
	## > from making modifications to the VM.
	##
	## Well, good, as long as its not intended to discourage me from doing this!

	// Simple wrapper to use bootstrap's grid system to position elements side-by-side
	var VerticalFieldsElement = React.createClass({
	render: function() {
	return dom.div(
	{ className: 'clearfix' },
	React.Children.map(this.props.children, function(child) {
	if(!child) {
	return child;
	}