Dan Couper DanCouper

This will enable Sass+Compass with LiveReload through Guard. (Guard screen cast)

You will also need a browser component to communicate with LiveReload. (browser extension, livereload.js)

If you prefer going through a GUI, that option is available. The following instructions is specific to Mac OS X and it works through the command line.

Note that this is not specific to Rails projects. This can work for any standalone front-end project.

Instructions

ES6 what can be shimmed and what not.

Currently only lists things that can be shimmed or are experimentally implemented

Note that for any kind of decent ES6 support we need an ES6 transpiler. A few projects are attempting this [Reference SO question][3]

[traceur][4]
[Caja][5]
[ES transpiler][6]

Backstory: I decided to crowdsource static site generator recommendations, so the following are actual real world suggested-to-me results. I then took those and sorted them by language/server and, just for a decent relative metric, their Github Watcher count. If you want a heap of other projects (including other languages like Haskell and Python) Nanoc has the mother of all site generator lists. If you recommend another one, by all means add a comment.

Ruby

Jekyll 5,676
Octopress 2,696
Middleman 685
NestaCMS 664
Statis 509
Nanoc 355

Creating a Happy Git Environment on OS X

Step 1: Install Git

brew install git bash-completion

Configure things:

git config --global user.name "Your Name"

git config --global user.email "[email protected]"

You should not use OOP (in javascript)

I've been coding javascript for some time now, including interacting with several javascript VMs.

Having said that, this is just a rant about what I think could be a good approach on how to actually do things in javascript. This after looking at how other projects are dealing with it, my personal experience and finally "getting" the way javascript was meant to be used (if there's such a thing). I do not consider myself an expert in javascript, so take whatever you read here with a grain of salt and think of it as just my personal experience and of course, I'll be happy to hear what you know or your best practices around it.

The real purpose for this post is to initiate a discussion about the subject of not really using OOP when dealing with javascript, and the good way to design and think about

Avoid jQuery When Possible

jQuery does good jobs when you're dealing with browser compatibility. But we're living in an age that fewer and fewer people use old-school browsers such as IE <= 7. With the growing of DOM APIs in modern browsers (including IE 8), most functions that jQuery provides are built-in natively.

When targeting only modern browsers, it is better to avoid using jQuery's backward-compatible features. Instead, use the native DOM API, which will make your web page run much faster than you might think (native C / C++ implementaion v.s. JavaScript).

If you're making a web page for iOS (e.g. UIWebView), you should use native DOM APIs because mobile Safari is not that old-school web browser; it supports lots of native DOM APIs.

If you're making a Chrome Extension, you should always use native APIs, not only because Chrome has almost the latest DOM APIs available, but this can also avoid performance issue and unnecessary memory occupation (each jQuery-driven extension needs a separate

	ּ_בּ
	בּ_בּ
	טּ_טּ
	כּ‗כּ
	לּ_לּ
	מּ_מּ
	סּ_סּ
	תּ_תּ
	٩(×̯×)۶
	٩(̾●̮̮̃̾•̃̾)۶

	# When I posted the results of the Roman Numeral Calculator kata
	# earlier this week, I said that I felt that the evolution of the code
	# through TDD was much more interesting than the final result. Let me
	# explain.
	#
	# First, some background. The goal of this Kata is to produce a
	# RomanNumeralCalculator object that converts from arabic numbers to
	# Roman numerals, and from Roman numerals back to arabic.

	Then { calculate("1").should == "I" }

	var StateMachine = {
	// Register valid states for this object.
	__states__: {
	'success': ['failure'],
	'failure': ['success']
	},

	// Set initial state.
	__state__: 'success',

	//usage
	withAdvice.call(targetObject);

	//mixin augments target object with around, before and after methods
	//method is the base method, advice is the augmenting function
	withAdvice: function() {
	['before', 'after', 'around'].forEach(function(m) {
	this[m] = function(method, advice) {
	if (typeof this[method] == 'function') {
	return this[method] = fn[m](this[method], advice);