Josh Burgess joshburgess

The future is here: Classless object-oriented programming in JavaScript.

Douglas Crockford, author of JavaScript: The Good parts, recently gave a talk called The Better Parts, where he demonstrates how he creates objects in JavaScript nowadays. He doesn't call his approach anything, but I will refer to it as Crockford Classless.

Crockford Classless is completely free of class, new, this, prototype and even Crockfords own invention Object.create.

I think it's really, really sleek, and this is what it looks like:

function dog(spec) {

Hello, visitors! If you want an updated version of this styleguide in repo form with tons of real-life examples… check out Trellisheets! https://github.com/trello/trellisheets

Trello CSS Guide

“I perfectly understand our CSS. I never have any issues with cascading rules. I never have to use !important or inline styles. Even though somebody else wrote this bit of CSS, I know exactly how it works and how to extend it. Fixes are easy! I have a hard time breaking our CSS. I know exactly where to put new CSS. We use all of our CSS and it’s pretty small overall. When I delete a template, I know the exact corresponding CSS file and I can delete it all at once. Nothing gets left behind.”

You often hear updog saying stuff like this. Who’s updog? Not much, who is up with you?

// please comment if you know of other BOOKS (not considering blogs just yet) on ES6 that are out or coming out

Understanding ECMAScript 6 -- Nicholas Zakas
Exploring ES6 -- Axel Rauschmayer
YDKJS: ES6 & Beyond -- Kyle Simpson
JS.next: A Manager's Guide -- Aaron Frost
Expert JavaScript -- Mark E. Daggett
JavaScript Allongé, The "Six" Edition -- Reginald Braithwaite
Learning ECMAScript 6 -- Narayan Prusty

ES6 Defaults / Overrides Pattern

Combine default parameters and destructuring for a compact version of the defaults / overrides pattern.

function foo ({
    bar = 'no',
    baz = 'works!'
  } = {}) {

	-- Example usage
	module Main where

	import Union


	unionValue1 :: Union (String, (Double, ((Int, Int), ())))
	unionValue1 = mkUnion "Foo"

	unionValue2 :: Union (String, (Double, ((Int, Int), ())))

	module DapperFSharp =
	open System.Data.SqlClient
	open System.Dynamic
	open System.Collections.Generic
	open Dapper

	let dapperQuery<'Result> (query:string) (connection:SqlConnection) =
	connection.Query<'Result>(query)

	let dapperParametrizedQuery<'Result> (query:string) (param:obj) (connection:SqlConnection) : 'Result seq =

	(* -- mode: ocaml; -- *)

	module type FUNCTOR = sig
	type 'a t
	val map : ('a -> 'b) -> 'a t -> 'b t
	end

	type 'a monoid = {unit : 'a ; join : 'a -> 'a -> 'a}

	type var = string

	use std::rc::Rc;

	trait HKT<U> {
	type C; // Current type
	type T; // Type with C swapped with U
	}

	macro_rules! derive_hkt {
	($t:ident) => {
	impl<T, U> HKT<U> for $t<T> {

	/* bling.js */
	window.$ = document.querySelector.bind(document);
	window.$$ = document.querySelectorAll.bind(document);
	Node.prototype.on = window.on = function(name, fn) { this.addEventListener(name, fn); };
	NodeList.prototype.__proto__ = Array.prototype;
	NodeList.prototype.on = function(name, fn) { this.forEach((elem) => elem.on(name, fn)); };

	// Stuff needed to make C# a kind of cluttered subtyping Haskell:
	// - Higher kinded polymorphism (being able to pass Generic Type Definitions as type parameters)
	// - Static interfaces & static abstract types (this gets quite perverse at the CLR level)
	// - GADTS (easily implemented as syntactic sugar)

	namespace HKP {
	public static A<B> Create<A, B>() where A : <>, new() {
	return new A<B>(); // Can't do a whole lot of useful things here, since we know little about TFn
	}