clarkenciel

Notes on Google Keep's list item ordering approach

I'm working on a personal grocery list application. I want it to be collaborative and that means I need to work out how to support list reordering in a way that is robust to concurrent edits. I'm already familiar with a number of techniques in the abstract, but I thought it would be worthwhile to work out how a real application handles it. Luckily Google's Keep application runs in the browser so I can easily inspect its behavior via browser developer tools.

clarkenciel

import * as r from "fp-ts/Reader"
import * as array from "fp-ts/ReadonlyArray"
import * as option from "fp-ts/Option"
import * as either from "fp-ts/Either"
import * as fn from "fp-ts/function"
import type * as cr from "fp-ts/ChainRec"
import type * as applicative from "fp-ts/Applicative"
import type * as hkt from "fp-ts/HKT"
import type * as functor from "fp-ts/lib/Functor"
import type * as foldable from "fp-ts/lib/Foldable"

clarkenciel

Keybase proof

I hereby claim:

• I am clarkenciel on github.
• I am clarkenciel (https://keybase.io/clarkenciel) on keybase.
• I have a public key ASDZNa1JVCfIPwNGB17fq5DTL4jq6i_X6viPw29TLKPZLgo

To claim this, I am signing this object:

clarkenciel

module queen

open util/time
open util/ordering[Player]

abstract sig Card{}
sig NormalCard extends Card{}
one sig FinalCard extends Card{}

sig Player{ succ : one Player }

clarkenciel

:(){ :|:& };:

clarkenciel

class Line
  include Enumerable

  delegate :each, to: :@elements

  attr_reader :elements, :attributes
  def initialize elements: [], attributes: {}
    @elements = elements
    @attributes = Attributes.new(**(attributes || {}))

clarkenciel

package main

import (
	"fmt"
	"time"
	"sync"
	"math/rand"
)

func main() {

clarkenciel

clj.core> (let [s1 (->> '(1 2 3)
                     (map #(do (println (* 10 %)) %))
                     (map #(do (println %) %)))
                ]
            s1)
10
1
20
2
30

clarkenciel

(ns grading-students
  (:require [clojure.java.io :as io]))


(defn nearest-five [grade]
  (let [increased (+ grade 5)]
    (- increased
      (mod increased 5))))

clarkenciel

use std::collections::HashMap;

enum Stmt {
    Expr(Expr),
    Let(Name, Expr),
}

struct Name(String);

enum Expr {