kastermester

var estreeWalker = require('estree-walker');
module.exports = function(ast, mapper){
	estreeWalker.walk(ast, {
		enter: function(node, parent){
			if(node.type !== 'CallExpression'){
				return;
			}
			if(node.callee.type == 'Identifier'){
				if(node.callee.name == 'require' || node.callee.name == 'define'){
					// AMD style require/defines

boopathi

Object.prototype.addEvent = function(evt, handler, useCapt) {
	//JUST A CHECK TO HANDLE “onclick” and “click” as evt
	if(evt.match(“^on”)) 
		evt = evt.substr(2);
	if(this.attachEvent) 
		return this.attachEvent('on' + evt, handler); // FOR IE
	else if(this.addEventListener) 
		return this.addEventListener(evt, handler, useCapt); // OTHERS
	else {
		//IF BOTH FAILS

boopathi

// everyone's new favorite closure pattern:
(function(window,document,undefined){ ... })(this,this.document);

// when minified:
(function(w,d,u){ ... })(this,this.document);

// which means all uses of window/document/undefined inside the closure 
// will be single-lettered, so big gains in minification.

// it also will speed up scope chain traversal a tiny tiny little bit.

boopathi

<!-- so it turns out that the object tag can act like an iframe 
     but the cool thing is you can nest object tags inside eachother for a fallback path.
    what this means is you can "objectframe" a site.. and if it fails.. (site down, offline, whatever).. it'll use the next one.

    so you can objectframe the live site and fallback to a screenshot.
    or something.

    demo at : http://jsfiddle.net/paul/CY2FQ/1/
-->

hiroshi-manabe

base = 10

def radix_sort(x, max):
    radix = 1
    while radix < max:
        x = counting_sort(x, radix)
        radix *= base
    return x

def counting_sort(a, radix):

ryanflorence

For those of you asking about my "redux mental breakthrough":

I've struggled with how to keep the state of multiple instances of the same component class in redux. I kept thinking that I had an "unkown number" of instances and would need to somehow carve out a piece of state when the new instance was mounted.

I don't know why I was thinking this way. Thinking is hard, isn't it? (I'm in the UK and they often say "isn't it?" after asserting something and I love it, anyway....)

domenic

// Let `doAjax`, `fadeIn`, `fadeOut`, and `delay` be promise-returning functions.

// In all the following examples, `example` is meant to return a promise that is fulfilled when
// all operations are completed, or rejected if any of the steps fail.

// ES5
function example() {
    return doAjax("data.json").then(function (data) {
        document.getElementById("data").innerText = data;

bolshchikov

// lo-dash lib is the dependency

function readOnly(target){
  var _readOnly = function (target, acc) {
          
    // acc is passed into the function to be used for observer
    var _defineProperty = function (propName, target, acc) {
      var i, len;
      
      // operation to be performed when add occurred

jlongster

const t = require("tcomb");
// imstruct is a tcomb type builder that internally builds an
// Immutable.Record object, but applies tcomb's type system to it
const imstruct = require("../util/imstruct");

const Person = imstruct({
  name: t.String,
  age: t.Number
});

jcoglan

class Module
  def subclasses
    classes = []
    ObjectSpace.each_object do |klass|
      next unless Module === klass
      classes << klass if self > klass
    end
    classes
  end
end