kevinold

var Immutable = require('immutable');
var todos = OrderedMap();

var TodoStore = createStore({
  getAll() { return todos; }
});

Dispatcher.register(function(action) {
  if (action.actionType === "create") {
    var id = createGUID();

rattrayalex

Bacon = require('baconjs')
Imm = require('immutable')
React = require('react')

window.Actions =
  changeFirstName: new Bacon.Bus()
  changeLastName: new Bacon.Bus()
  changeCountry: new Bacon.Bus()
  addCountryBird: new Bacon.Bus()
  addFriend: new Bacon.Bus()

ericelliott

Essential JavaScript Links

I no longer mantain this list. There are lots of other very comprehensive JavaScript link lists out there. Please see those, instead (Google "awesome JavaScript" for a start).

evancz

Towards Discussion Guidelines

I personally like to have discussions in the spirit of the Socratic method. Instead of declaring my opinion, I ask a relevant question. How about this situation? What about this case? This has two possible outcomes.

1. The other person explains to me how things work in that case. I realize that I misunderstood, and we both come out enriched and in agreement.
2. The other person realizes that those situations are not covered. They realize they misunderstood, and we both come out enriched and in agreement.

In both cases, it could have been a conflict, egos crashing together. But by asking questions, it becomes a collaboration to find the best answer. Even the simple act of asking a question in the first place says, "I care what you have to say, we can agree on this." That said, I have noticed that it is definitely still possible for things to go wrong within this framework. How can this happen?

There was a passage from [The

james-world

/* Name of Gist */

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---

MohamedAlaa

tmux shortcuts & cheatsheet

start new:

tmux

start new with session name:

tmux new -s myname

igstan

(function privateName(i) {
  if (i === 0)
    return;

  console.log(i);

  privateName(i - 1);
})(5);

jpoehls

var cluster = require('cluster');

if (cluster.isWorker) {

  console.log('Worker ' + process.pid + ' has started.');

  // Send message to master process.
  process.send({msgFromWorker: 'This is from worker ' + process.pid + '.'})

  // Receive messages from the master process.

igstan

I'll throw my opinion in here, but take it with a pretty large grain of salt as I've done no professional development in a functional language yet. Just tinkering with (quite a few of) them in my spare time. Some of the patterns I spotted are irrespective of type systems (static, dynamic).

• lists, sequences or similar primitives are ubiquitous
• abstract away duplicate code using higher-order functions
• no iteration constructs, recursion is the only way to traverse lists
• watch out your recursion, be sure it's tail-recursive
• abstract over this tail-recursive pattern with a higher-order function: foldLeft or foldRight. So, know your language's equivalent of foldLeft/foldRight and prefer these over explicit recursion.
• abstract over folds in an even more general way and provide folding functions for arbitrary data structures, not just list, e.g., trees.
• provide a few convenience higher-order functions (implementable using fold) like: map, filter, any/some, all/every, zip, `zipWith