a somewhat random function:

var state = 1142311987481379417480;	

function myRandom() {
  var d = (new Date()).getTime();
  var a = state ^ d;
  state = (a + d) % 1000000000000000;
  var r = Math.sin( state ) * 2309212090.32132;
  return (r - Math.floor(r));
}

Having played around with GLSL before (which has no random function), I had some idea of how I could go about this... this is borrowed from the book of shaders:

fract(sin(x)*1000000.0);

this works for shaders since the shader is run on a per-pixel basis, and the pixel location is different every time this is called. The most obvious replacement for the 'x' / pixel location seemed to be time – but Allison's sketch obviously very cleverly draws multiple pixels at time, to by-pass time-dependent randomness. I did some more digging into javascript randomness, and realised that this would be impossible without some other number in the mix, that changed on every call – the 'seed' so to say. The following function provided some insight:

//https://hackernoon.com/how-does-javascripts-math-random-generate-random-numbers-ef0de6a20131

uint64_t state0 = 1;
uint64_t state1 = 2;
uint64_t xorshift128plus() {
  uint64_t s1 = state0;
  uint64_t s0 = state1;
  state0 = s0;
  s1 ^= s1 << 23;
  s1 ^= s1 >> 17;
  s1 ^= s0;
  s1 ^= s0 >> 26;
  state1 = s1;
  return state0 + state1;
}

The bitwise operations (vs arithmetic) seemed useful for preventing the number getting too large or too small to essentially disappear – ie addition and multiplication risked crossing the number of bits allocated for an int, and subtraction and division would reduce it to 0, or exceed number of bits for a negative integer... hence the use of the modulo operator (which is essentially just discarding some bits when the number gets to big).

looks pretty random
happy bit-shifting accident

I put this into the quick-draw-omancy project (assignment 2), and well, it felt pretty much the same.