Docs improvements

docs/design-goals.md

@@ -0,0 +1,17 @@
+### Philosophy & Design Goals
+
+* You shouldn't need a book on functional programming to use Redux.
+* Everything (Stores, Action Creators, configuration) is hot reloadable.
+* Preserves the benefits of Flux, but adds other nice properties thanks to its functional nature.
+* Prevents some of the anti-patterns common in Flux code.
+* Works great in [universal (aka “isomorphic”)](https://medium.com/@mjackson/universal-javascript-4761051b7ae9) apps because it doesn't use singletons and the data can be rehydrated.
+* Doesn't care how you store your data: you may use JS objects, arrays, ImmutableJS, etc.
+* Under the hood, it keeps all your data in a tree, but you don't need to think about it.
+* Lets you efficiently subscribe to finer-grained updates than individual Stores.
+* Provides hooks for powerful devtools (e.g. time travel, record/replay) to be implementable without user buy-in.
+* Provides extension points so it's easy to [support promises](https://github.com/gaearon/redux/issues/99#issuecomment-112212639) or [generate constants](https://gist.github.com/skevy/8a4ffc3cfdaf5fd68739) outside the core.
+* No wrapper calls in your stores and actions. Your stuff is your stuff.
+* It's super easy to test things in isolation without mocks.
+* You can use “flat” Stores, or [compose and reuse Stores](https://gist.github.com/gaearon/d77ca812015c0356654f) just like you compose Components.
+* The API surface area is minimal.
+* Have I mentioned hot reloading yet?

docs/examples.md

@@ -0,0 +1,39 @@
+## Examples
+
+### Simple Examples
+
+Redux is distributed with a Counter and a TodoMVC example in its source code.
+
+First, clone the repo:
+
+```
+git clone https://github.com/gaearon/redux.git
+cd redux
+```
+
+Run the Counter example:
+
+```
+cd redux/examples/counter
+npm install
+npm start
+```
+
+Run the TodoMVC example:
+
+```
+cd ../todomvc
+npm install
+npm start
+```
+
+### Async and Universal Examples with Routing
+
+These async and [universal (aka “isomorphic”)](https://medium.com/@mjackson/universal-javascript-4761051b7ae9) examples using React Router should help you get started:
+
+* [redux-react-router-async-example](https://github.com/emmenko/redux-react-router-async-example): Work in progress. Semi-official. Only the client side. Uses React Router.
+* [react-redux-universal-hot-example](https://github.com/erikras/react-redux-universal-hot-example): Universal. Uses React Router.
+* [redux-example](https://github.com/quangbuule/redux-example): Universal. Uses Immutable, React Router.
+* [isomorphic-counter-example](https://github.com/khtdr/redux-react-koa-isomorphic-counter-example): Universal. A bare-bone implentation of the [counter example app](https://github.com/gaearon/redux/tree/master/examples/counter). Uses promises-middleware to interact with API via Koa on the server.
+
+Don’t be shy, add your own!

docs/faq.md

@@ -0,0 +1,101 @@
+## FAQ
+
+### How does hot reloading work?
+
+* http://webpack.github.io/docs/hot-module-replacement.html
+* http://gaearon.github.io/react-hot-loader/
+* Literally that's it. Redux is fully driven by component props, so it works on top of React Hot Loader.
+
+### Can I use this in production?
+
+Yep. People already do that although I warned them! The API surface is minimal so migrating to 1.0 API when it comes out won't be difficult. Let us know about any issues.
+
+### How do I do async?
+
+There's already a built-in way of doing async action creators:
+
+```js
+// Can also be async if you return a function
+export function incrementAsync() {
+  return dispatch => {
+    setTimeout(() => {
+      // Yay! Can invoke sync or async actions with `dispatch`
+      dispatch(increment());
+    }, 1000);
+  };
+}
+```
+
+It's also easy to implement support for returning Promises or Observables with a custom middleware. [See an example of a custom Promise middleware.](https://github.com/gaearon/redux/issues/99#issuecomment-112212639)
+
+### But there are switch statements!
+
+`(state, action) => state` is as simple as a Store can get. You are free to implement your own `createStore`:
+
+```js
+export default function createStore(initialState, handlers) {
+  return (state = initialState, action) =>
+    handlers[action.type] ?
+      handlers[action.type](state, action) :
+      state;
+}
+```
+
+and use it for your Stores:
+
+```js
+export default createStore(0, {
+  [INCREMENT_COUNTER]: x => x + 1,
+  [DECREMENT_COUNTER]: x => x - 1
+});
+```
+
+It's all just functions.
+Fancy stuff like generating stores from handler maps, or generating action creator constants, should be in userland.
+Redux has no opinion on how you do this in your project.
+
+See also [this gist](https://gist.github.com/skevy/8a4ffc3cfdaf5fd68739) for an example implementation of action constant generation.
+
+### What about `waitFor`?
+
+I wrote a lot of vanilla Flux code and my only use case for it was to avoid emitting a change before a related Store consumes the action. This doesn't matter in Redux because the change is only emitted after *all* Stores have consumed the action.
+
+If several of your Stores want to read data from each other and depend on each other, it's a sign that they should've been a single Store instead. [See this discussion on how `waitFor` can be replaced by the composition of stateless Stores.](https://gist.github.com/gaearon/d77ca812015c0356654f)
+
+### My views aren't updating!
+
+Redux makes a hard assumption that you never mutate the state passed to you. It's easy! For example, instead of
+
+```js
+function (state, action) {
+  state.isAuthenticated = true;
+  state.email = action.email;
+  return state;
+}
+```
+
+you should write
+
+```js
+function (state, action) {
+  return {
+    ...state,
+    isAuthenticated: true,
+    email: action.email
+  };
+}
+```
+
+[Read more](https://github.com/sebmarkbage/ecmascript-rest-spread) about the spread properties ES7 proposal.
+
+### How do Stores, Actions and Components interact?
+
+Action creators are just pure functions so they don't interact with anything. Components need to call `dispatch(action)` (or use `bindActionCreators` that wraps it) to dispatch an action *returned* by the action creator.
+
+Stores are just pure functions too so they don't need to be “registered” in the traditional sense, and you can't subscribe to them directly. They're just descriptions of how data transforms. So in that sense they don't “interact” with anything either, they just exist, and are used by the dispatcher for computation of the next state.
+
+Now, the dispatcher is more interesting. You pass all the Stores to it, and it composes them into a single Store function that it uses for computation. The dispatcher is also a pure function, and it is passed as configuration to `createRedux`, the only stateful thing in Redux. By default, the default dispatcher is used, so if you call `createRedux(stores)`, it is created implicitly.
+
+To sum it up: there is a Redux instance at the root of your app. It binds everything together. It accepts a dispatcher (which itself accepts Stores), it holds the state, and it knows how to turn actions into state updates. Everything else (components, for example) subscribes to the Redux instance. If something wants to dispatch an action, they need to do it on the Redux instance. `Connector` is a handy shortcut for subscribing to a slice of the Redux instance's state and injecting `dispatch` into your components, but you don't have to use it.
+
+There is no other “interaction” in Redux.