tjfontaine

There are four kinds of deferral mechanisms in Node.js:

• setTimeout
• setInterval
• setImmediate
• process.nextTick

setTimeout and setInterval are quite familiar to those used to JavaScript in the browser and their semantics are fairly well understood. They return opaque values that can be passed to their clear counterparts, and have been around forever. setImmediate is a newer construct and its adoption in the browser is not very wide, and nextTick is a creation solely unto Node.js. The latter two are mechanisms to queue a callback in the short future, such that currently executing JavaScript may continue. If you're used to trying to do this pattern in the browser you may be used to using something like setTimeout(fn, 0).

If Node.js actually exposed the idea of a turn of the event loop, you would be expecting the scheduled callback to run at the end of the current loop, or the start of the next -- though from the perspective of your application there isn't really a difference. In

rf

var fs = require('fs');

var infile = process.argv[2];

if (!infile) return console.log("need infile");

var data = fs.readFileSync(infile, 'utf8').split('\n');
var outlines = [];

data.forEach(function(item) {

pgte

Recipe for customizing a SmartoOS image and cloning it

1. Create base image

1.1. Download and install the base image:

[root@00-0c-29-aa-24-ba ~]# imgadm list
UUID                                  NAME             VERSION  OS       PUBLISHED
9eac5c0c-a941-11e2-a7dc-57a6b041988f  base64           13.1.0   smartos  2013-04-26T15:17:57Z

soarez

#!/bin/bash

function deploy {
  # Update the rsync target on the server
  rsync \
    -av \
    --delete \
    --delete-excluded \
    $rsync_ignore_list_param \
    $rsync_source/ $target:$rsync_target

jasny

/**
 * Use em or rem font-size in Bootstrap 3
 */

@font-size-root: 14px;
@font-unit: 0rem; // Pick em or rem here


// Convert all variables to em

tiagoa

// Inspired by https://github.com/logicalparadox/backbone.iobind/blob/master/lib/sync.js
// Overwrite Backbone.sync method
Backbone.sync = function(method, model, options){

  // create a connection to the server
  var ws = new WebSocket('ws://127.0.0.1:1234');

  // send the command in url only if the connection is opened
  // command attribute is used in server-side.
  ws.onopen = function(){

mathisonian

The final result: require() any module on npm in your browser console with browserify

This article is written to explain how the above gif works in the chrome (and other) browser consoles. A quick disclaimer: this whole thing is a huge hack, it shouldn't be used for anything seriously, and there are probably much better ways of accomplishing the same.

Update: There are much better ways of accomplishing the same, and the script has been updated to use a much simpler method pulling directly from browserify-cdn. See this thread for details: mathisonian/requirify#5

inspiration

creationix

// A streaming byte oriented JSON parser.  Feed it a single byte at a time and
// it will emit complete objects as it comes across them.  Whitespace within and
// between objects is ignored.  This means it can parse newline delimited JSON.
function jsonMachine(emit, next) {
  next = next || $value;
  return $value;
  
  function $value(byte) {
    if (!byte) return;
    if (byte === 0x09 || byte === 0x0a || byte === 0x0d || byte === 0x20) {

trevnorris

The prep-script.sh will setup the latest Node and install the latest perf version on your Linux box.

When you want to generate the flame graph, run the following (folder locations taken from install script):

sudo sysctl kernel.kptr_restrict=0
# May also have to do the following:
# (additional reading http://unix.stackexchange.com/questions/14227/do-i-need-root-admin-permissions-to-run-userspace-perf-tool-perf-events-ar )
sudo sysctl kernel.perf_event_paranoid=0

dominictarr

(dominic: this list of papers was originally recommended to me by Brain Noguchi @bnoguchi, and was a great start to understanding distributed systems)

Here's a selection of papers that I think you would find helpful and interesting:

Time, Clocks, and the Ordering of Events in a Distributed System

The seminal paper about event ordering and concurrency. The important result is that events in a distributed system define a partially ordered set. The connection to what we're working on is fundamental, as this defines how to detect concurrent updates. Moreover, the chosen algorithm to turn the partially ordered set into a totally ordered set defines the conflict resolution algorithm.

http://research.microsoft.com/en-us/um/people/lamport/pubs/time-clocks.pdf