Ryan Williams ryan-williams

Edward Snowden at IETF 93

Edward Snowden answered questions after a showing of CITIZENFOUR at the IETF93 meeting; this is a transcript of the video recording.

For more information, see the Internet Society article.

Introduction
Scale of Pervasive Monitoring
Returning to the US
Preserving the Internet

Writing a program for efficient matrix multiplication is tricky. A naive implementation usually looks like this (I will use a square matrix for simplicity):

for (i = 0; i < n; ++i)
  for (j = 0; j < n; ++i)
    for (k = 0, m[i][j] = 0.; k < n; ++i)
      m[i][j] += a[i][k] * b[k][j];

The problem is the inner loop a[i][k] * b[k][j] where b[k][j] and b[k+1][j] are not adjacent in memory. This leads to frequent cache misses for large matrices. The better implementation is to transpose matrix b. The implementation will look like:

for (i = 0; i &lt; n; ++i) // transpose

Explaining Miles's Magic

Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.

But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.

For starters, here is the sort of thing that SI-2712 affects:

def foo[F[_], A](fa: F[A]): String = fa.toString

Generalized Algebraic Data Types in Scala

Basic GADTs

Here's an ADT which is not a GADT, in Haskell:

data Expr = IntExpr Int | BoolExpr Bool

collapsible markdown?

CLICK ME

yes, even hidden code blocks!

print("hello world!")

How to capture, stitch and publish a 360° timelapse

Consumer ready 360° cameras are becoming ever more accessible and many people are experimenting with a variety of 360° content. Out of the many cameras on the market the Ricoh Theta S is one of the most user-friendly, turn-key solutions with lots of built-in features. However, the camera's videos are limited 1920x960 resolution and the Theta+ app only lets you create a timelapse with up to 300 or 400 images. The workaround is to use interval shooting to capture as many images as you'd like at the 5376x2688 to full resolution and then stitch them together manually into an HD video. There are few GUI solutions (especially open-source/free) which let you do this with ease. Here's how you do it:

	sass/
	\|
	\|– base/
	\| \|– _reset.scss # Reset/normalize
	\| \|– _typography.scss # Typography rules
	\| ... # Etc…
	\|
	\|– components/
	\| \|– _buttons.scss # Buttons
	\| \|– _carousel.scss # Carousel

	package poc

	import org.scalajs.dom

	import scala.scalajs.js
	import scala.scalajs.js.annotation.JSExport

	@js.native
	object WorkerGlobal extends js.GlobalScope {
	def addEventListener(`type`: String, f: js.Function): Unit = js.native

	#!/bin/sh

	KEYDIR=~/.ssh/keys.d/github-deploy
	CONFDIR=~/.ssh/config.d/github-deploy

	github_username=noah
	github_access_token=$(cat ~/.secret/github_access_token)

	rp=$(git rev-parse --is-inside-work-tree 2>/dev/null)

	import pandas as pd
	from sqlalchemy import create_engine

	# follows django database settings format, replace with your own settings
	DATABASES = {
	'production':{
	'NAME': 'dbname',
	'USER': 'user',
	'PASSWORD': 'pass',
	'HOST': 'rdsname.clqksfdibzsj.us-east-1.rds.amazonaws.com',