Sam Elliott lenary

Monads and delimited control are very closely related, so it isn’t too hard to understand them in terms of one another. From a monadic point of view, the big idea is that if you have the computation m >>= f, then f is m’s continuation. It’s the function that is called with m’s result to continue execution after m returns.

If you have a long chain of binds, the continuation is just the composition of all of them. So, for example, if you have

m >>= f >>= g >>= h

then the continuation of m is f >=> g >=> h. Likewise, the continuation of m >>= f is g >=> h.

Foreward

This document was originally written several years ago. At the time I was working as an execution core verification engineer at Arm. The following points are coloured heavily by working in and around the execution cores of various processors. Apply a pinch of salt; points contain varying degrees of opinion.

It is still my opinion that RISC-V could be much better designed; though I will also say that if I was building a 32 or 64-bit CPU today I'd likely implement the architecture to benefit from the existing tooling.

Mostly based upon the RISC-V ISA spec v2.0. Some updates have been made for v2.2

Original Foreword: Some Opinion

The RISC-V ISA has pursued minimalism to a fault. There is a large emphasis on minimizing instruction count, normalizing encoding, etc. This pursuit of minimalism has resulted in false orthogonalities (such as reusing the same instruction for branches, calls and returns) and a requirement for superfluous instructions which impacts code density both in terms of size and

ELF

ELF Header

The first portion of any ELF file is the ELF header. This generally provides offsets to other headers (program headers and section headers) within an ELF.

typedef struct {
  unsigned char e_ident[EI_NIDENT];
 uint16_t e_type;

JXA Resources

Revised: 2019-11-28 16:16 GMT-6

This is a list of the key resources I have found useful. If you know of others, please post in a comment below, and I will add to this list.

I have tried to order this list in the order that, to me, is best for learning JXA from scratch. We all learn a bit diferently, so adjust to suit your style/needs. Please post if you have suggestions on learning JXA.

Experimental feature: copatterns. (Activated with option --copatterns)

We can now define a record by explaining what happens if you project the record. For instance:

{-# OPTIONS --copatterns #-}

record _×_ (A B : Set) : Set where
 constructor _,_

Geek Feminism: http://geekfeminism.org/
Philip Guo's writing: http://www.pgbovine.net/writings.htm
Mel Chua: http://blog.melchua.com/
Pointers Gone Wild (by Maxime Chevalier): http://pointersgonewild.wordpress.com/ (compiler fun!)
Sumana's blog: http://www.harihareswara.net/ces.shtml
Lindsey Kuper's great research blog: http://composition.al/
Kelly Sommers is so inquisitive and thoughtful and amazing: http://kellabyte.com/
Selena Deckelmann: http://www.chesnok.com/daily/
Dan Luu: http://danluu.com/
http://planet.mozillaopennews.org/

CvRDTs are (almost?) as general as they can be

What are you talking about, and why should I care?

Now that we live in the Big Data, Web 3.14159 era, lots of people want to build databases that are too big to fit on a single machine. But there's a problem in the form of the CAP theorem, which states that if your network ever partitions (a machine goes down, or part of the network loses its connection to the rest) then you can keep consistency (all machines return the same answer to

Counters are expected to land in Riak 1.4! See this pull-request.

h/t to @russelldb for the demo code.

	module Main

	import Prelude.Algebra

	record GCounter : Type where
	MkGCounter : (value : Nat) -> GCounter

	gcjoin : GCounter -> GCounter -> GCounter
	gcjoin l r = (MkGCounter (maximum (value l) (value r)))