Simon Thépot djcoin

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.

DRAFT IN PROGESS - DO NOT CIRCULATE

Technical note

The Challenges of Packaging Bitcoin Software

Introduction

Bitcoin technology is complex. Under the hood of the decentralized virtual currency lies a novel form of decentralized, distributed database. It is critical for users, system adminstrators and packaging engineers to understand bitcoin's database consistency model, which is radically different from familiar database consistency models (MySQL, Berkeley DB, Amazon Dynamo, or Google's GPS-based doohickey).

I'm trying to get my head around all the search stuff so it's a good time to have a NodeBase call about it.

Some collected links, please add to them in comments.

level modules

In many production systems you'll want to have one module capable of talking to many potential implementations of a collaborator module (e.g a in memory cache, a redis-based cache etc). While testing it's useful to control which module the module under test is talking to.

Here are the approaches I can see. The two points that seem to divide the approaches are their tool-ability (dialyzer) and their ability to handle stateful implementations (which need a pid).

Passing modules

Modules are first class, so you can pass them in. Used in EEx, where passed module must implement a behaviour.

This is the example that comes with the reagent template converted to use HTML5 based history. This means there are no # in the urls.

I just got this working, so there might be better approaches

The changes are

use goog.history.Html5history instead of goog.History
listen to clicks on the page, extract the path from them, and push them onto the history
listen to history changes, and have secretary do its thing in response

HTTP Streaming (or Chunked vs Store & Forward)

The standard way of understanding the HTTP protocol is via the request reply pattern. Each HTTP transaction consists of a finitely bounded HTTP request and a finitely bounded HTTP response.

However it's also possible for both parts of an HTTP 1.1 transaction to stream their possibly infinitely bounded data. The advantages is that the sender can send data that is beyond the sender's memory limit, and the receiver can act on

	Intersection.intersectLineLine = function(a1, a2, b1, b2) {
	var result;

	var ua_t = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
	var ub_t = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x);
	var u_b = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);

	if ( u_b != 0 ) {
	var ua = ua_t / u_b;
	var ub = ub_t / u_b;

	import Data.Conduit
	import Control.Monad.Trans.State
	import Control.Monad.IO.Class
	import Control.Monad.Trans.Class

	main = runPipe $ yield () >+> transPipe (flip evalStateT 0) (do
	a <- lift get
	lift $ put $ a + 1
	b <- lift get
	liftIO $ print (a, b)

	(defn remove-dups [f coll]
	(vals
	(reduce (fn [m v]
	(let [applied (f v)]
	(if-not (contains? m applied)
	(assoc m applied v)
	m)))
	{}
	coll)))

	var gulp = require('gulp'),
	gutil = require('gulp-util')

	// HTML
	gulp.task('html', function() {
	return gulp.src('src/index.html')
	.pipe(gulp.dest('build'))
	})

	// Scripts