jlongster

// Example code, see try/catch/throw implementation below

function bar(x) {
  if(x < 0) {
    Throw(new Error("error!"));
  }
  return x * 2;
}

function foo(x) {

jlongster

// Example code, see below for run/yield implementation. Note how we
// can even do yields across the stack, so this implements something
// more like coroutines than generators.

function foo() {
  var x = Yield();
  return x + 1;
}

var process = Run(function() {

atduskgreg

Interactive Machine Learning

Taught by Brad Knox at the MIT Media Lab in 2014. Course website. Lecture and visiting speaker notes.

• Power to the People: The Role of Humans in Interactive Machine Learning by Knox, Cakmak, Kulesza, Amershi, and Lau
• A Few Useful Things to Know about Machine Learning by Domingos
• Machine Learning that Matters by Wagstaff
• Beyond Concise and Colorful: Learning Intelligible Rules by Pazzani et al.
• [Designing Games with a Purpose] (https://www.cs.cmu.edu/~biglou/GWAP_CACM.pdf) by von Ahn and Dabbish
• [Human Model Evaluation in Interactive Supervised

NoraCodes

// Hello! I'm Leo Tindall, the SilverWingedSeraph, and this is a follow-up to my tutorial on
// using match expressions in Rust.

// In my last video, we created a finite state machine to parse and modify some simple markup.
// In this video, we'll make the machine more abstract and more concise.

// We'll start out the same way: defining the four states of the machine.
// However, we'll use a neat trick that Rust
// provides to make things easier later on. We'll ask the compiler to derive the Copy and Clone
// traits on MachineState, so we don't have to worry about borrowing and ownership.

Drup

type ('ty,'v) t =
  | Nil : ('v, 'v) t
  | Cons : 'a * ('ty, 'v) t -> ('a -> 'ty, 'v) t

let cons x l = Cons (x,l)

let plus1 l = Cons ((),l)

let one x = Cons (x,Nil)

keleshev

#! /usr/bin/env ocaml

let fprintf = Format.fprintf

type t =
  | Tag of {name: string; attributes: (string * string) list; body: t list}
  | String of string

let format_attribute f (key, value) = fprintf f " %s=\"%s\"" key value

porglezomp

-- Note: There is a more complete explanation at https://github.com/hwayne/lets-prove-leftpad/tree/master/idris
import Data.Vect

-- `minus` is saturating subtraction, so this works like we want it to
eq_max : (n, k : Nat) -> maximum k n = plus (n `minus` k) k
eq_max  n     Z    = rewrite minusZeroRight n in rewrite plusZeroRightNeutral n in Refl
eq_max  Z    (S _) = Refl
eq_max (S n) (S k) = rewrite sym $ plusSuccRightSucc (n `minus` k) k in rewrite eq_max n k in Refl

-- The type here says "the result is" padded to (maximum k n), and is padding plus the original

Leonidas-from-XIV

module Let_syntax = struct
  let return = Lwt.return
  let (>>=) = Lwt.Infix.(>>=)
  let (>>|) = Lwt.Infix.(>|=)
  module Let_syntax = struct
    let bind m ~f = Lwt.bind m f
  end
end

fnky

ANSI Escape Sequences

Standard escape codes are prefixed with Escape:

• Ctrl-Key: ^[
• Octal: \033
• Unicode: \u001b
• Hexadecimal: \x1B
• Decimal: 27

BekaValentine

import sys
from time import sleep
import random
import cursor



class Renderer:

  def __init__(self, width, height):