Daniel Yokomizo dyokomizo

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.

Mathematics: What do grad students in math do all day?

by Yasha Berchenko-Kogan

A lot of math grad school is reading books and papers and trying to understand what's going on. The difficulty is that reading math is not like reading a mystery thriller, and it's not even like reading a history book or a New York Times article.

The main issue is that, by the time you get to the frontiers of math, the words to describe the concepts don't really exist yet. Communicating these ideas is a bit like trying to explain a vacuum cleaner to someone who has never seen one, except you're only allowed to use words that are four letters long or shorter.

What can you say?

Below is some cute code that I wrote for the OLPC Openfirmware HD Audio driver.

The firmware is allowed to hard-code knowledge of the physical design of the laptop and motherboard. This firmware code tells the audio chip explicit details such as the size and colour of each physical audio jack in the laptop. The operating system can later query the chip for this information and present it to a user, for example in an audio mixer application.

porta  config(  1/8" green left hp-out jack     )config
porta  config(  1/8" green left hp-out jack     )config
portb  config(  1/8" pink left mic-in jack      )config
portc  config(  builtin internal top mic-in no-detect other-analog )config
portd  config(  unused line-out no-detect       )config

	#lang racket/base

	(define tasklist (list (list 'root (box 'no-continuation))))
	(define currtask tasklist)

	(define call/cc call-with-current-continuation)

	(define fork
	(lambda (name)
	(call/cc

	// needs -fnested-functions. Can be done without, but makes the whole thing a lot more cumbersome
	// and less useful.
	#include <stdio.h>

	#define my_data_alts ( void (A)(int) , void (B)(int, int) , void (*C)(char, int) )
	#define make_my_data(n) void n my_data_alts
	typedef void (*my_data) my_data_alts;


	void show(my_data match) {

	How do we add extra information to a tree? This has been called [The
	AST Typing
	Problem](http://blog.ezyang.com/2013/05/the-ast-typing-problem/).

	After being hit with this problem in Roy's new type-inference engine,
	I tried figuring out how to represent the algorithm. I eventually
	realised that it looked like a comonadic operation. Turns out it's
	been done before but I couldn't find any complete example.

	Below is some literate Haskell to show how to use the Cofree Comonad

	After spending the better part of the month implementing date support
	in RethinkDB, Mike Lucy sent the team the following e-mail. It would
	have been funny, if it didn't cause thousands of programmers so much
	pain. Read it, laugh, and weep!

	-----

	So, it turns out that we're only going to support dates between the
	year 1400 and the year 10000 (inclusive), because that's what boost
	supports.

	{-# LANGUAGE QuantifiedConstraints, ScopedTypeVariables #-}

	import Data.Monoid

	-- Note: fails for instances that don't need the Monoid a or Semigroup a

	pureDefault :: forall f a. (Functor f, forall a. Monoid a => Monoid (f a)) => a -> f a
	pureDefault a = a <$ (mempty :: f ())

	apDefault :: (Functor f, forall a. Semigroup a => Semigroup (f a)) => f (a -> b) -> f a -> f b

	> {-# LANGUAGE Rank2Types #-}
	>
	> import Prelude hiding (id)
	> import Data.Functor.Constant (Constant(Constant), getConstant)
	> import Control.Arrow (Arrow, arr, first, Kleisli(Kleisli), runKleisli, (&&&))
	> import Control.Category ((<<<))
	> import Control.Lens (sequenceAOf)
	> import qualified Control.Lens as L
	> import qualified Control.Lens.Internal.Setter as LS
	> import Data.Profunctor (Profunctor, rmap)