fix your ~/.ssh permissions

Ssh is very picky about permissions on the ~/.ssh directory and files. Sometimes you may do something to mess up these permissions. Run the following to fix most permissions problems. You may have to do this on both the remote host and local host.

    chmod 700 ~/.ssh

    chmod 600 ~/.ssh/id_rsa

    chmod 644 ~/.ssh/id_rsa.pub  

    chmod 644 ~/.ssh/authorized_keys

    chmod 644 ~/.ssh/known_hosts

Also no directory above ~/.ssh can have 'group' or 'other' write permissions.

http://blog.kristeraxel.com/2012/06/fix-your-ssh-permissions/

Most useful function!

function get_happy { open -a "/Applications/Google Chrome.app" "http://play.navabros.com/vivire-para-ti.mp3" }

a great pattern in js

http://www.slideshare.net/toddanglin/5-tips-for-better-javascript

JavaScript: The Good Parts

Immediately-invoked function expression

An immediately-invoked function expression (or IIFE, pronounced "iffy") is a JavaScript design pattern which produces block scoping using JavaScript's function scoping. Immediately-invoked function expressions can be used to avoid variable hoisting from within blocks, protect against polluting the global environment and simultaneously allow public access to methods while retaining privacy for variables defined within the function. This pattern has been referred to as a self-executing anonymous function,^[1] but Ben Alman introduced the term IIFE as a more semantically accurate term for the pattern.^[2][3]

Usage

Immediately-invoked function expressions may be written in a number of different ways,^[4] although a common convention is to enclose both the function expression and invokation in parentheses.^[5][6]

(function(){
  /* code */ 
}());

Examples

Key to understanding design patterns such as immediately-invoked function expressions is to realize JavaScript has function scope (but not block scope) and passes values by reference inside a closure.^[7]

[edit]Evaluation context

A lack of block scope means that variables defined inside, for example, a for loop will have their definition "hoisted' to the top of the enclosing function. Evaluating a function which depends on variables modified by the outer function (including by iteration) can be difficult. We can see this without a loop if we update a value between defining and invoking the function.^[8]

var v, getValue;
getValue = function() { return v; };
v = 2;
 
getValue(); // 2

While the result may seem obvious when updating v manually, it can produce unintended results when getValue() is defined inside a loop.

var v, getValue;
v = 1;
getValue = (function(v) {
  return function() {return v;};
}(v));
v = 2;
 
getValue(); //1

Here the function passes v as an argument and is invoked immediately, preserving the inner function's execution context.^[9]

David Herman's Effective JavaScript contains an example illustrating the problems of evaluation context inside loops.^[10] While Herman's example is deliberately convoluted it arises directly from the same lack of block scope.^[11]

Establishing private variables and accessors

IIFEs are also useful for establishing private methods for accessible functions while still exposing some properties for later use.^[12] The following example comes from Alman's post on IIFEs.^[2]

var counter = (function(){
  var i = 0;
 
  return {
    get: function(){
      return i;
    },
    set: function( val ){
      i = val;
    },
    increment: function() {
      return ++i;
    }
  };
}());
 
// 'counter' is an object with properties, which in this case happen to be
// methods.
 
counter.get(); // 0
counter.set( 3 );
counter.increment(); // 4
counter.increment(); // 5

If we attempt to access counter.i from the global environment, it will be undefined as it is enclosed within the invoked function and is not a property of counter. Likewise, if we attempt to access i it will result in an error as we have not declared i in the global environment.

[edit]

http://en.wikipedia.org/wiki/Immediately-invoked_function_expression

jquery core

	var
	// A central reference to the root jQuery(document)
	rootjQuery,
	// The deferred used on DOM ready
	readyList,
	// Support: IE9
	// For `typeof xmlNode.method` instead of `xmlNode.method !== undefined`
	core_strundefined = typeof undefined,
	// Use the correct document accordingly with window argument (sandbox)
	location = window.location,
	document = window.document,
	docElem = document.documentElement,
	// Map over jQuery in case of overwrite
	_jQuery = window.jQuery,
	// Map over the $ in case of overwrite
	_$ = window.$,
	// [[Class]] -> type pairs
	class2type = {},
	// List of deleted data cache ids, so we can reuse them
	core_deletedIds = [],
	core_version = "@VERSION",
	// Save a reference to some core methods
	core_concat = core_deletedIds.concat,
	core_push = core_deletedIds.push,
	core_slice = core_deletedIds.slice,
	core_indexOf = core_deletedIds.indexOf,
	core_toString = class2type.toString,
	core_hasOwn = class2type.hasOwnProperty,
	core_trim = core_version.trim,
	// Define a local copy of jQuery
	jQuery = function( selector, context ) {
	// The jQuery object is actually just the init constructor 'enhanced'
	return new jQuery.fn.init( selector, context, rootjQuery );
	},
	// Used for matching numbers
	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
	// Used for splitting on whitespace
	core_rnotwhite = /\S+/g,
	// A simple way to check for HTML strings
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
	// Strict HTML recognition (#11290: must start with <)
	rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
	// Match a standalone tag
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
	// Matches dashed string for camelizing
	rmsPrefix = /^-ms-/,
	rdashAlpha = /-([\da-z])/gi,
	// Used by jQuery.camelCase as callback to replace()
	fcamelCase = function( all, letter ) {
	return letter.toUpperCase();
	},
	// The ready event handler and self cleanup method
	completed = function() {
	document.removeEventListener( "DOMContentLoaded", completed, false );
	window.removeEventListener( "load", completed, false );
	jQuery.ready();
	};
	jQuery.fn = jQuery.prototype = {
	// The current version of jQuery being used
	jquery: core_version,
	constructor: jQuery,
	init: function( selector, context, rootjQuery ) {
	var match, elem;
	// HANDLE: $(""), $(null), $(undefined), $(false)
	if ( !selector ) {
	return this;
	}
	// Handle HTML strings
	if ( typeof selector === "string" ) {
	if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
	// Assume that strings that start and end with <> are HTML and skip the regex check
	match = [ null, selector, null ];
	} else {
	match = rquickExpr.exec( selector );
	}
	// Match html or make sure no context is specified for #id
	if ( match && (match[1] || !context) ) {
	// HANDLE: $(html) -> $(array)
	if ( match[1] ) {
	context = context instanceof jQuery ? context[0] : context;
	// scripts is true for back-compat
	jQuery.merge( this, jQuery.parseHTML(
	match[1],
	context && context.nodeType ? context.ownerDocument || context : document,
	true
	) );
	// HANDLE: $(html, props)
	if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
	for ( match in context ) {
	// Properties of context are called as methods if possible
	if ( jQuery.isFunction( this[ match ] ) ) {
	this[ match ]( context[ match ] );
	// ...and otherwise set as attributes
	} else {
	this.attr( match, context[ match ] );
	}
	}
	}
	return this;
	// HANDLE: $(#id)
	} else {
	elem = document.getElementById( match[2] );
	// Check parentNode to catch when Blackberry 4.6 returns
	// nodes that are no longer in the document #6963
	if ( elem && elem.parentNode ) {
	// Inject the element directly into the jQuery object
	this.length = 1;
	this[0] = elem;
	}
	this.context = document;
	this.selector = selector;
	return this;
	}
	// HANDLE: $(expr, $(...))
	} else if ( !context || context.jquery ) {
	return ( context || rootjQuery ).find( selector );
	// HANDLE: $(expr, context)
	// (which is just equivalent to: $(context).find(expr)
	} else {
	return this.constructor( context ).find( selector );
	}
	// HANDLE: $(DOMElement)
	} else if ( selector.nodeType ) {
	this.context = this[0] = selector;
	this.length = 1;
	return this;
	// HANDLE: $(function)
	// Shortcut for document ready
	} else if ( jQuery.isFunction( selector ) ) {
	return rootjQuery.ready( selector );
	}
	if ( selector.selector !== undefined ) {
	this.selector = selector.selector;
	this.context = selector.context;
	}
	return jQuery.makeArray( selector, this );
	},
	// Start with an empty selector
	selector: "",
	// The default length of a jQuery object is 0
	length: 0,
	toArray: function() {
	return core_slice.call( this );
	},
	// Get the Nth element in the matched element set OR
	// Get the whole matched element set as a clean array
	get: function( num ) {
	return num == null ?
	// Return a 'clean' array
	this.toArray() :
	// Return just the object
	( num < 0 ? this[ this.length + num ] : this[ num ] );
	},
	// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack: function( elems ) {
	// Build a new jQuery matched element set
	var ret = jQuery.merge( this.constructor(), elems );
	// Add the old object onto the stack (as a reference)
	ret.prevObject = this;
	ret.context = this.context;
	// Return the newly-formed element set
	return ret;
	},
	// Execute a callback for every element in the matched set.
	// (You can seed the arguments with an array of args, but this is
	// only used internally.)
	each: function( callback, args ) {
	return jQuery.each( this, callback, args );
	},
	ready: function( fn ) {
	// Add the callback
	jQuery.ready.promise().done( fn );
	return this;
	},
	slice: function() {
	return this.pushStack( core_slice.apply( this, arguments ) );
	},
	first: function() {
	return this.eq( 0 );
	},
	last: function() {
	return this.eq( -1 );
	},
	eq: function( i ) {
	var len = this.length,
	j = +i + ( i < 0 ? len : 0 );
	return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
	},
	map: function( callback ) {
	return this.pushStack( jQuery.map(this, function( elem, i ) {
	return callback.call( elem, i, elem );
	}));
	},
	end: function() {
	return this.prevObject || this.constructor(null);
	},
	// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push: core_push,
	sort: [].sort,
	splice: [].splice
	};
	// Give the init function the jQuery prototype for later instantiation
	jQuery.fn.init.prototype = jQuery.fn;
	jQuery.extend = jQuery.fn.extend = function() {
	var options, name, src, copy, copyIsArray, clone,
	target = arguments[0] || {},
	i = 1,
	length = arguments.length,
	deep = false;
	// Handle a deep copy situation
	if ( typeof target === "boolean" ) {
	deep = target;
	target = arguments[1] || {};
	// skip the boolean and the target
	i = 2;
	}
	// Handle case when target is a string or something (possible in deep copy)
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
	target = {};
	}
	// extend jQuery itself if only one argument is passed
	if ( length === i ) {
	target = this;
	--i;
	}
	for ( ; i < length; i++ ) {
	// Only deal with non-null/undefined values
	if ( (options = arguments[ i ]) != null ) {
	// Extend the base object
	for ( name in options ) {
	src = target[ name ];
	copy = options[ name ];
	// Prevent never-ending loop
	if ( target === copy ) {
	continue;
	}
	// Recurse if we're merging plain objects or arrays
	if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
	if ( copyIsArray ) {
	copyIsArray = false;
	clone = src && jQuery.isArray(src) ? src : [];
	} else {
	clone = src && jQuery.isPlainObject(src) ? src : {};
	}
	// Never move original objects, clone them
	target[ name ] = jQuery.extend( deep, clone, copy );
	// Don't bring in undefined values
	} else if ( copy !== undefined ) {
	target[ name ] = copy;
	}
	}
	}
	}
	// Return the modified object
	return target;
	};
	jQuery.extend({
	// Unique for each copy of jQuery on the page
	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
	noConflict: function( deep ) {
	if ( window.$ === jQuery ) {
	window.$ = _$;
	}
	if ( deep && window.jQuery === jQuery ) {
	window.jQuery = _jQuery;
	}
	return jQuery;
	},
	// Is the DOM ready to be used? Set to true once it occurs.
	isReady: false,
	// A counter to track how many items to wait for before
	// the ready event fires. See #6781
	readyWait: 1,
	// Hold (or release) the ready event
	holdReady: function( hold ) {
	if ( hold ) {
	jQuery.readyWait++;
	} else {
	jQuery.ready( true );
	}
	},
	// Handle when the DOM is ready
	ready: function( wait ) {
	// Abort if there are pending holds or we're already ready
	if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
	return;
	}
	// Remember that the DOM is ready
	jQuery.isReady = true;
	// If a normal DOM Ready event fired, decrement, and wait if need be
	if ( wait !== true && --jQuery.readyWait > 0 ) {
	return;
	}
	// If there are functions bound, to execute
	readyList.resolveWith( document, [ jQuery ] );
	// Trigger any bound ready events
	if ( jQuery.fn.trigger ) {
	jQuery( document ).trigger("ready").off("ready");
	}
	},
	// See test/unit/core.js for details concerning isFunction.
	// Since version 1.3, DOM methods and functions like alert
	// aren't supported. They return false on IE (#2968).
	isFunction: function( obj ) {
	return jQuery.type(obj) === "function";
	},
	isArray: Array.isArray,
	isWindow: function( obj ) {
	return obj != null && obj === obj.window;
	},
	isNumeric: function( obj ) {
	return !isNaN( parseFloat(obj) ) && isFinite( obj );
	},
	type: function( obj ) {
	if ( obj == null ) {
	return String( obj );
	}
	// Support: Safari <= 5.1 (functionish RegExp)
	return typeof obj === "object" || typeof obj === "function" ?
	class2type[ core_toString.call(obj) ] || "object" :
	typeof obj;
	},
	isPlainObject: function( obj ) {
	// Not plain objects:
	// - Any object or value whose internal [[Class]] property is not "[object Object]"
	// - DOM nodes
	// - window
	if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
	return false;
	}
	// Support: Firefox <20
	// The try/catch suppresses exceptions thrown when attempting to access
	// the "constructor" property of certain host objects, ie. |window.location|
	// https://bugzilla.mozilla.org/show_bug.cgi?id=814622
	try {
	if ( obj.constructor &&
	!core_hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
	return false;
	}
	} catch ( e ) {
	return false;
	}
	// If the function hasn't returned already, we're confident that
	// |obj| is a plain object, created by {} or constructed with new Object
	return true;
	},
	isEmptyObject: function( obj ) {
	var name;
	for ( name in obj ) {
	return false;
	}
	return true;
	},
	error: function( msg ) {
	throw new Error( msg );
	},
	// data: string of html
	// context (optional): If specified, the fragment will be created in this context, defaults to document
	// keepScripts (optional): If true, will include scripts passed in the html string
	parseHTML: function( data, context, keepScripts ) {
	if ( !data || typeof data !== "string" ) {
	return null;
	}
	if ( typeof context === "boolean" ) {
	keepScripts = context;
	context = false;
	}
	context = context || document;
	var parsed = rsingleTag.exec( data ),
	scripts = !keepScripts && [];
	// Single tag
	if ( parsed ) {
	return [ context.createElement( parsed[1] ) ];
	}
	parsed = jQuery.buildFragment( [ data ], context, scripts );
	if ( scripts ) {
	jQuery( scripts ).remove();
	}
	return jQuery.merge( [], parsed.childNodes );
	},
	parseJSON: JSON.parse,
	// Cross-browser xml parsing
	parseXML: function( data ) {
	var xml, tmp;
	if ( !data || typeof data !== "string" ) {
	return null;
	}
	// Support: IE9
	try {
	tmp = new DOMParser();
	xml = tmp.parseFromString( data , "text/xml" );
	} catch ( e ) {
	xml = undefined;
	}
	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
	jQuery.error( "Invalid XML: " + data );
	}
	return xml;
	},
	noop: function() {},
	// Evaluates a script in a global context
	globalEval: function( code ) {
	var script,
	indirect = eval;
	code = jQuery.trim( code );
	if ( code ) {
	// If the code includes a valid, prologue position
	// strict mode pragma, execute code by injecting a
	// script tag into the document.
	if ( code.indexOf("use strict") === 1 ) {
	script = document.createElement("script");
	script.text = code;
	document.head.appendChild( script ).parentNode.removeChild( script );
	} else {
	// Otherwise, avoid the DOM node creation, insertion
	// and removal by using an indirect global eval
	indirect( code );
	}
	}
	},
	// Convert dashed to camelCase; used by the css and data modules
	// Microsoft forgot to hump their vendor prefix (#9572)
	camelCase: function( string ) {
	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
	},
	nodeName: function( elem, name ) {
	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
	},
	// args is for internal usage only
	each: function( obj, callback, args ) {
	var value,
	i = 0,
	length = obj.length,
	isArray = isArraylike( obj );
	if ( args ) {
	if ( isArray ) {
	for ( ; i < length; i++ ) {
	value = callback.apply( obj[ i ], args );
	if ( value === false ) {
	break;
	}
	}
	} else {
	for ( i in obj ) {
	value = callback.apply( obj[ i ], args );
	if ( value === false ) {
	break;
	}
	}
	}
	// A special, fast, case for the most common use of each
	} else {
	if ( isArray ) {
	for ( ; i < length; i++ ) {
	value = callback.call( obj[ i ], i, obj[ i ] );
	if ( value === false ) {
	break;
	}
	}
	} else {
	for ( i in obj ) {
	value = callback.call( obj[ i ], i, obj[ i ] );
	if ( value === false ) {
	break;
	}
	}
	}
	}
	return obj;
	},
	trim: function( text ) {
	return text == null ? "" : core_trim.call( text );
	},
	// results is for internal usage only
	makeArray: function( arr, results ) {
	var ret = results || [];
	if ( arr != null ) {
	if ( isArraylike( Object(arr) ) ) {
	jQuery.merge( ret,
	typeof arr === "string" ?
	[ arr ] : arr
	);
	} else {
	core_push.call( ret, arr );
	}
	}
	return ret;
	},
	inArray: function( elem, arr, i ) {
	return arr == null ? -1 : core_indexOf.call( arr, elem, i );
	},
	merge: function( first, second ) {
	var l = second.length,
	i = first.length,
	j = 0;
	if ( typeof l === "number" ) {
	for ( ; j < l; j++ ) {
	first[ i++ ] = second[ j ];
	}
	} else {
	while ( second[j] !== undefined ) {
	first[ i++ ] = second[ j++ ];
	}
	}
	first.length = i;
	return first;
	},
	grep: function( elems, callback, inv ) {
	var retVal,
	ret = [],
	i = 0,
	length = elems.length;
	inv = !!inv;
	// Go through the array, only saving the items
	// that pass the validator function
	for ( ; i < length; i++ ) {
	retVal = !!callback( elems[ i ], i );
	if ( inv !== retVal ) {
	ret.push( elems[ i ] );
	}
	}
	return ret;
	},
	// arg is for internal usage only
	map: function( elems, callback, arg ) {
	var value,
	i = 0,
	length = elems.length,
	isArray = isArraylike( elems ),
	ret = [];
	// Go through the array, translating each of the items to their
	if ( isArray ) {
	for ( ; i < length; i++ ) {
	value = callback( elems[ i ], i, arg );
	if ( value != null ) {
	ret[ ret.length ] = value;
	}
	}
	// Go through every key on the object,
	} else {
	for ( i in elems ) {
	value = callback( elems[ i ], i, arg );
	if ( value != null ) {
	ret[ ret.length ] = value;
	}
	}
	}
	// Flatten any nested arrays
	return core_concat.apply( [], ret );
	},
	// A global GUID counter for objects
	guid: 1,
	// Bind a function to a context, optionally partially applying any
	// arguments.
	proxy: function( fn, context ) {
	var tmp, args, proxy;
	if ( typeof context === "string" ) {
	tmp = fn[ context ];
	context = fn;
	fn = tmp;
	}
	// Quick check to determine if target is callable, in the spec
	// this throws a TypeError, but we will just return undefined.
	if ( !jQuery.isFunction( fn ) ) {
	return undefined;
	}
	// Simulated bind
	args = core_slice.call( arguments, 2 );
	proxy = function() {
	return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
	};
	// Set the guid of unique handler to the same of original handler, so it can be removed
	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
	return proxy;
	},
	// Multifunctional method to get and set values of a collection
	// The value/s can optionally be executed if it's a function
	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
	var i = 0,
	length = elems.length,
	bulk = key == null;
	// Sets many values
	if ( jQuery.type( key ) === "object" ) {
	chainable = true;
	for ( i in key ) {
	jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
	}
	// Sets one value
	} else if ( value !== undefined ) {
	chainable = true;
	if ( !jQuery.isFunction( value ) ) {
	raw = true;
	}
	if ( bulk ) {
	// Bulk operations run against the entire set
	if ( raw ) {
	fn.call( elems, value );
	fn = null;
	// ...except when executing function values
	} else {
	bulk = fn;
	fn = function( elem, key, value ) {
	return bulk.call( jQuery( elem ), value );
	};
	}
	}
	if ( fn ) {
	for ( ; i < length; i++ ) {
	fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
	}
	}
	}
	return chainable ?
	elems :
	// Gets
	bulk ?
	fn.call( elems ) :
	length ? fn( elems[0], key ) : emptyGet;
	},
	now: Date.now,
	// A method for quickly swapping in/out CSS properties to get correct calculations.
	// Note: this method belongs to the css module but it's needed here for the support module.
	// If support gets modularized, this method should be moved back to the css module.
	swap: function( elem, options, callback, args ) {
	var ret, name,
	old = {};
	// Remember the old values, and insert the new ones
	for ( name in options ) {
	old[ name ] = elem.style[ name ];
	elem.style[ name ] = options[ name ];
	}
	ret = callback.apply( elem, args || [] );
	// Revert the old values
	for ( name in options ) {
	elem.style[ name ] = old[ name ];
	}
	return ret;
	}
	});
	jQuery.ready.promise = function( obj ) {
	if ( !readyList ) {
	readyList = jQuery.Deferred();
	// Catch cases where $(document).ready() is called after the browser event has already occurred.
	// we once tried to use readyState "interactive" here, but it caused issues like the one
	// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
	if ( document.readyState === "complete" ) {
	// Handle it asynchronously to allow scripts the opportunity to delay ready
	setTimeout( jQuery.ready );
	} else {
	// Use the handy event callback
	document.addEventListener( "DOMContentLoaded", completed, false );
	// A fallback to window.onload, that will always work
	window.addEventListener( "load", completed, false );
	}
	}
	return readyList.promise( obj );
	};
	// Populate the class2type map
	jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
	});
	function isArraylike( obj ) {
	var length = obj.length,
	type = jQuery.type( obj );
	if ( jQuery.isWindow( obj ) ) {
	return false;
	}
	if ( obj.nodeType === 1 && length ) {
	return true;
	}
	return type === "array" || type !== "function" &&
	( length === 0 ||
	typeof length === "number" && length > 0 && ( length - 1 ) in obj );
	}
	// All jQuery objects should point back to these
	rootjQuery = jQuery(document);

view raw gistfile1.js hosted with ❤ by GitHub

private variable to Javascript object literal

	var dataset = {
	tables: {
	customers:function(){
	var privateVar = 'foo';
	return {
	cols:[ /*here*/ ],
	rows:[ /*here*/ ],
	getPrivateVar: function()
	{
	return privateVar;
	}
	};
	}(),
	orders:{
	cols:[ /*here*/ ],
	rows:[ /*here*/ ]
	}
	},
	relations: [{
	parent:'customers',
	child:'orders',
	keyparent:'custid',
	keychild:'orderid',
	onetomany:true
	}]
	};
	alert( dataset.tables.customers.getPrivateVar() );

view raw gistfile1.js hosted with ❤ by GitHub

http://stackoverflow.com/questions/1396294/how-to-add-private-variable-to-this-javascript-object-literal-snippet

#house music for work

http://www.youtube.com/watch?v=8BLupJDLR0w&list=RD02nEgbs5o_Lwo

Human Behavioral Biology StanfordUniversity

Human Behavioral Biology  StanfordUniversity

https://www.youtube.com/watch?v=NNnIGh9g6fA&list=PLFDAC8A6702C57402

S3 limit to objects in a bucket

According to Amazon:

Write, read, and delete objects containing from 1 byte to 5 terabytes of data each. The number of objects you can store is unlimited.

Source: http://aws.amazon.com/s3/ as of May 1, 2012.

http://stackoverflow.com/questions/3980968/s3-limit-to-objects-in-a-bucket

filepicker & $.post in 2 lines

	var filepicker_url = "https://www.filepicker.io/api/store/S3?key=KEY"
	var images = [
	"http://www.orangelt.us/info/wp-content/uploads/2010/08/OrangeLT_White_Background.jpg",
	"http://www.aussieapples.com.au/media/images/galleries/apple-photo-gallery/pink_lady_apple.jpg"
	];
	$.each(images, function(k, v) {
	$.post(filepicker_url, { url: v})
	.done(function(data) {
	console.log(data.url);
	window.open(data.url)
	})
	.fail(function(data) { alert("error" + data); })
	.always(function(data) { console.log("finished for:" + v + " => " + data.url); });
	});

view raw upload images with filepicker hosted with ❤ by GitHub

newrelic and heroku

If you use heroku newrelic as a add one it will create a new account so you can access it from here
heroku addons:open newrelic It will overwite the newrelic.yml file

heroku logs --tail

You may tail your logs using --tail (or -t).

$ heroku logs --tail

When you are done, press Ctrl-C to close the session.

https://devcenter.heroku.com/articles/logging