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--) { 

timruffles

interface Functor<T> {
  map(mapper: (x: T) => T): Functor<T>; 
  ret(x: T): Functor<T>;
}

class Maybe<T> implements Functor<T> {
	
	constructor(private value: T) {}
	
	private nowt() {

timruffles

In the DI DOCs the 'why' given for the component injector tree is to get multiple instances of a dependency. The editor component explicitly provides RestoreService to ensure it gets its own instance.

                                 providers                   instance of `RestoreService`
rootInjector                     [provide(RestoreService)]   instance A
 - heroEditorComponentInjector   [provide(RestoreService)]   instance B
   - childOfHero                 []                          instance B
 - someOtherEditor               []                          instance A

timruffles

"use strict";

/**
 * The function will use a Greedy method to solve the problem of giving
 * change.
 *
 * @param {Integer} the amount for which we have to give change
 * @param {Array} the values of the coins that are available
 *
 * @return {Array} the list of the selected coins, sorted ascending by value,