Hemanth HM hemanth

Lazy Programmer

A Lazy programming is the best hire you can make. Lazy programmers are ideal for a startup. They will be the reason a project will be successful.

Lazy programmers hate manual work. They will always automate anything that needs to be done manually. This creates a smarter solution which is less error-prone to the human action.
Lazy programmers hate talking to others. They will produce better code so that it works in all cases to avoid being questioned by others on their work.

nodeconf slides - 2012

##day one

Inﬂuences of Node - Ryan Dahl
Oh the Places You'll Node - Matthew Podwysocki
Two Years of node in yammer : Matthew Eernisse
State of the Node - Isaac Z. Schlueter
Guillermo Rauch
node knockout

I love Coffeescript, but write Javascript

This is an example of why even though I love coffeescript, I still frequently write code in raw javascript.

This is the coffeescript I originally had:

pairs = []

GETTING STARTED

What's wrong with Netmag's "Optimize your JavaScript" post

Update: The original post on Netmag has been updated since this was written.

I tweeted earlier that this should be retracted. Generally, these performance-related articles are essentially little more than linkbait -- there are perhaps an infinite number of things you should do to improve a page's performance before worrying about the purported perf hit of multiplication vs. division -- but this post went further than most in this genre: it offered patently inaccurate and misleading advice.

Here are a few examples, assembled by some people who actually know what they're talking about (largely Rick Waldron and Ben Alman, with some help from myself and several others from the place that shall be unnamed).

Things that are just plain wrong

Native Javascript :

Greet User: http://jsfiddle.net/endeepak/6FdSS/

Greet User if Name is Entered: http://jsfiddle.net/endeepak/BDuxr/2/

Knockout:

Greet User: http://jsfiddle.net/endeepak/mmtQH/2/

	require = function(paths, callback) {

	// Check if the path param is of the required type.
	if (!paths instanceof Array \|\| !paths instanceof String){
	console.log('Please check the useage');
	return;
	}

	// If paths param is a single param, convert it to an Array.
	paths = typeof paths === 'string' ? paths.split() : paths

	print - lets you output numbers and characters to the console.

	if - let's you choose which statements are executed if an expression is true
	else - denotes the statements that execute if the expression isn't true
	elif - let's you combine if statements
	while - is a way of repeating statements in a loop until an expression is false.
	break - is a way to jump out of the statement flow of a loop.
	continue - let's you skip a cycle of the flow without ending it.
	for - is used to iterate over items of a collection in the order they appear in a container

	var u = (function() {
	var id = function(x) { return x; }
	, single = function(x) { return [x]; }
	, constant = function(x) { return function() { return x; }}
	, $ = function(f, x) { return f(x); };

	var curried = function(f, n, args) {
	return (args.length >= n)
	? f.apply(null, args)
	: function() { return curried(f, n, args.concat(slice(arguments))); }; };

	#!/usr/bin/env ruby

	# checkout the readme from the master branch
	`git checkout gh-pages; git checkout master README.md`

	path = `pwd`.gsub(/\n/, "")
	readme_path = File.join(path, "README.md")
	index_path = File.join(path, "index.md")

	# write the index readme file