Simon Thépot djcoin

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

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.

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

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).

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.

I 'm fleshing out some of these ideas here: https://github.com/lynaghk/todoFRP/tree/master/todo/angular-cljs

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

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

	// Scripts

	(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)))

	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)

	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;