timruffles

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdint.h>
#include <string.h>

/**
 * So, plan is to store the values for the JS compiler
 * in a union, nicking Lua's idea. That way immediate
 * values like numbers live inside the JSValue wrapper,

timruffles

// cast the strings as any
enum StringEnum {
	a = 'a' as any,
	b = 'b' as any,
}

const a = StringEnum.a;
const x = 'a';
const y = 1;

timruffles

The docs for .share() state: 'Returns a new Observable that multicasts (shares) the original Observable.'.

This sounds like share() is a lovely simple method that'll make your life easier. However share() is really a trap, for if you have the hubris to use .share() the angry complexity bees that live inside RxJS will swarm out and sting you in the eye (in a rate-limited fashion).

Let's see why. Our goal is to take a cold observable, take only the first item from it, do something to it, and share the resulting observable between 2 subscribers. They should both share the values from our new observable. Easy huh?

{
const coldObservable = Rx.Observable.create(function(observer) {
  console.log('observable created')

timruffles

scratch=# create table "delete from account;" ("""id""" text primary key, "sutff %\n" text, "&" text, "1" text, U&"\+01F600" text);
CREATE TABLE
scratch=# \d "delete from account;"
Table "public.delete from account;"
  Column   | Type | Modifiers
-----------+------+-----------
 "id"      | text | not null
 sutff %\n | text |
 &         | text |
 1         | text |

timruffles

{


    /* 
    interface Observer<T> {
        next(t: T): void;
        error(e: Error): void
        complete(): void;
    }
    */

timruffles

// Difference between lintability/RTE of hoisting vs non-hoisted code

// ReferenceError: foo is not defined
//    at <anonymous>:3:5
try {
    foo()
    const x = 1;
    const foo = () => x;
} catch(e) {
    console.log(e)

timruffles

// (a -> a) -> (a -> b) -> (a -> b)
var mapValue = transform => fn => v => fn(transform(v));

// (string -> string)  - so string is a above
var louder = x => x.toUpperCase();
// (string -> Element)  - so element is b above
var hi = (m) => ({ type: 'h1', value: m })

// (string -> Element)  - so we end up with a (a -> b) again
var titleLoud = mapValue(louder)(h1);

timruffles

Proper client-side auth

At the mo we have the boilerplate project's getCurrentUser() method, that synchronously returns the user. If it's not fetched yet, bad luck!

This isn't good. We should handle:

1. waiting to confirm if we're logged in or not. (unless we block the rest of app startup till we know, not too much of a UX cost)
2. currently this happens at startup
3. we could embed this on app startup, as we generate the index.html client-side now, e.g window.USER = { id: 15, name: "bob... }
4. expiration (i.e starting to get 401 Unauthorized responses)

timruffles

const hashBits = parseInt(process.env.bits || 32);
const hashValues = Math.pow(2, hashBits);

const checkPoints = Array.from({ length: 9 }, (e, i) => 1 - (i+1)/10);

for(var uniqueHashValuesRemaining = hashValues, p = 1;
	 	p > 0.1; 
		uniqueHashValuesRemaining -= 1, p *= uniqueHashValuesRemaining/hashValues

timruffles

var m = new Map;
var o = {};
var value;

var rs = [];
var i = 1e5;
while(i--) rs.push(Math.random().toString())

var i = 1e5; console.time("es6"); 
while(i--) {