George Brown g0xA52A2A

Delimited Continuations

Delimited continuations manipulate the control flow of programs. Similar to control structures like conditionals or loops they allow to deviate from a sequential flow of control.

We use exception handling as another example for control flow manipulation and later show how to implement it using delimited continuations. Finally, we show that nondeterminism can also be expressed using delimited continuations.

Exception Handling

"A little bit of slope makes up for a lot of y-intercept"

01/13/2012. From a lecture by Professor John Ousterhout at Stanford, class CS140

Here's today's thought for the weekend. A little bit of slope makes up for a lot of Y-intercept.

[Laughter]

Listpack specification

Version 1.0, 1 Feb 2017: Intial specification.

Version 1.1, 2 Feb 2017: Integer encoding simplified. Appendix A added.

Version 1.2, 3 Feb 2017: Better specify the meaning of the num-elements
                         field with value of 65535. The two 12 bits

positive/negative integers encodings were

async/await is just the do-notation of the Promise monad

CertSimple just wrote a blog post arguing ES2017's async/await was the best thing to happen with JavaScript. I wholeheartedly agree.

In short, one of the (few?) good things about JavaScript used to be how well it handled asynchronous requests. This was mostly thanks to its Scheme-inherited implementation of functions and closures. That, though, was also one of its worst faults, because it led to the "callback hell", an seemingly unavoidable pattern that made highly asynchronous JS code almost unreadable. Many solutions attempted to solve that, but most failed. Promises almost did it, but failed too. Finally, async/await is here and, combined with Promises, it solves the problem for good. On this post, I'll explain why that is the case and trace a link between promises, async/await, the do-notation and monads.

First, let's illustrate the 3 styles by implementing

Swift Concurrency Manifesto

Author: Chris Lattner

Chinese Translation by Jason Yu

	#define _CRT_SECURE_NO_DEPRECATE

	#include <stdio.h>
	#include <string.h>
	#include <Windows.h>

	// This allocates a "magic ring buffer" that is mapped twice, with the two
	// copies being contiguous in (virtual) memory. The advantage of this is
	// that this allows any function that expects data to be contiguous in
	// memory to read from (or write to) such a buffer. It also means that

	#!/usr/bin/env python
	import numpy
	import sys
	import timeit

	try:
	import numpy.core._dotblas
	print 'FAST BLAS'
	except ImportError:
	print 'slow blas'

	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

	colorscheme apprentice
	highlight Type ctermfg=103
	highlight cssClassName ctermfg=6
	highlight cssClassNameDot ctermfg=6
	highlight link jsFuncCall Type
	highlight cssBraces ctermfg=fg
	highlight htmlLink ctermfg=fg
	highlight Function ctermfg=182
	highlight MatchParen ctermfg=182 ctermbg=232
	highlight Constant ctermfg=210

	if exists('g:loaded_qfsign')
	finish
	endif
	let g:loaded_qfsign=1

	sign define QFErr texthl=QFErrMarker text=E
	sign define QFWarn texthl=QFWarnMarker text=W
	sign define QFInfo texthl=QFInfoMarker text=I

	augroup qfsign