Lukasz Piatkowski op1ekun

An ongoing project to catalogue all of these sneaky, hidden, bleeding edge selectors as I prepare my JSConf EU 2012 talk.

Everything is broken up by tag, but within each the selectors aren't particularly ordered.

I have not tested/verified all of these. Have I missed some or got it wrong? Let me know. - A

A friendly reminder that you may need to set this property on your target/selected element to get the styling results you want:

-webkit-appearance:none;

This article has been given a more permanent home on my blog. Also, since it was first written, the development of the Promises/A+ specification has made the original emphasis on Promises/A seem somewhat outdated.

You're Missing the Point of Promises

Promises are a software abstraction that makes working with asynchronous operations much more pleasant. In the most basic definition, your code will move from continuation-passing style:

getTweetsFor("domenic", function (err, results) {
 // the rest of your code goes here.

Basic JavaScript MVC Implementation

Despite being derived from classical MVC pattern JavaScript and the environment it runs in makes Javascript MVC implementation have its own twists. Lets see how typical web MVC functions and then dive into simple, concrete JavaScript MVC implementation.

How Web MVC typically works

Typical server-side MVC implementation has one MVC stack layered behind the singe point of entry. This single point of entry means that all HTTP requests, e.g. http://www.example.com or http://www.example.com/whichever-page/ etc., are routed, by a server configuration, through one point or, to be bold, one file, e.g. index.php.

At that point, there would be an implementation of Front Controller pattern which analyzes HTTP request (URI at first place) and based on it decides which class (Controller) and its method (Action) are to be invoked as a response to the request (method is name for function and member is name for a variable when part of the class/object).

	// This assumes the file names are directly mappable to the module names declared
	// in the YUI.add() calls inside those files.
	YUI({
	modules: {
	'myapp.tests.core': { fullpath: '/path/to/core.js' }
	}
	}).use('myapp.tests.core', function (Y) {
	var tests = [ '0001','0002', ... ],
	i, len;

	<!DOCTYPE html>
	<html>
	<head>
	<title>Box Shadow</title>

	<style>
	.box {
	height: 150px;
	width: 300px;
	margin: 20px;

	var pubsub = {};
	(function(q) {
	var topics = {}, subUid = -1;
	q.subscribe = function(topic, func) {
	if (!topics[topic]) {
	topics[topic] = [];
	}
	var token = (++subUid).toString();
	topics[topic].push({
	token: token,

	// ==UserScript==
	// @name YouTube Couch Mode
	// @author David Wittman <[email protected]>
	// @namespace nowhere
	// @description Adds a full-screen "Couch Mode" button to YouTube
	// @include http://www.youtube.com/watch?*
	// ==/UserScript==


	// iframe detection

	// simple dsl just wrapping angular's dsl, just providing higher abstraction
	angular.scenario.dsl('submitMessage', function() {
	return function(message) {
	// these dsl already register futures (add fn into the queue),
	// so you don't wrap them into addFutureAction
	input('modelValue').enter(message);
	element('button.submit').click();
	};
	});

	"use strict";

	// `f` is assumed to sporadically fail with `TemporaryNetworkError` instances.
	// If one of those happens, we want to retry until it doesn't.
	// If `f` fails with something else, then we should re-throw: we don't know how to handle that, and it's a
	// sign something went wrong. Since `f` is a good promise-returning function, it only ever fulfills or rejects;
	// it has no synchronous behavior (e.g. throwing).
	function dontGiveUp(f) {
	return f().then(
	undefined, // pass through success

	In the scenario below task2 depends on the result from task1 which is stored
	in value property of the meta object(this is just an example) which does not initially exist but is created from within
	task1. task2 can later have access to the value using <%= meta.value %> at a later time.
	This way two tasks can share data..
	There may be better ways of doing this, if you have come across please share