Kornel Kiełczewski Kornel

This is material to go along with a 2014 Boston Haskell talk.

We are going to look at a series of type signatures in Haskell and explore how parametricity (or lack thereof) lets us constrain what a function is allowed to do.

Let's start with a decidedly non-generic function signature. What are the possible implementations of this function which typecheck?

wrangle :: Int -> Int

Internet Scale Services Checklist

A checklist for designing and developing internet scale services, inspired by James Hamilton's 2007 paper "On Desgining and Deploying Internet-Scale Services."

http://mvdirona.com/jrh/talksandpapers/jamesrh_lisa.pdf

Basic tenets

Does the design expect failures to happen regularly and handle them gracefully?
Have we kept things as simple as possible?

##VGG16 model for Keras

This is the Keras model of the 16-layer network used by the VGG team in the ILSVRC-2014 competition.

It has been obtained by directly converting the Caffe model provived by the authors.

Details about the network architecture can be found in the following arXiv paper:

Very Deep Convolutional Networks for Large-Scale Image Recognition

K. Simonyan, A. Zisserman

	"""Information Retrieval metrics

	Useful Resources:
	http://www.cs.utexas.edu/~mooney/ir-course/slides/Evaluation.ppt
	http://www.nii.ac.jp/TechReports/05-014E.pdf
	http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf
	http://hal.archives-ouvertes.fr/docs/00/72/67/60/PDF/07-busa-fekete.pdf
	Learning to Rank for Information Retrieval (Tie-Yan Liu)
	"""
	import numpy as np

	package com.thoughtworks.futureeither

	import concurrent.{Await, Future}
	import scala.concurrent.ExecutionContext.Implicits.global
	import concurrent.duration.FiniteDuration
	import java.util.concurrent.TimeUnit

	class FutureEither[L, R](private val future: Future[Either[L, R]]) {

	def flatMap[R2](block: R => FutureEither[L, R2]): FutureEither[L, R2] = {

	"""
	License: BSD
	Author: Mathieu Blondel

	Implements three algorithms for projecting a vector onto the simplex: sort, pivot and bisection.

	For details and references, see the following paper:

	Large-scale Multiclass Support Vector Machine Training via Euclidean Projection onto the Simplex
	Mathieu Blondel, Akinori Fujino, and Naonori Ueda.

	import java.util.Date
	import kotlin.concurrent.*

	fun at(date: Date, func: () -> Unit) {
	val waitTime = date.getTime() - Date().getTime()
	thread {
	Thread.sleep(waitTime)
	func()
	}
	}

	#!/usr/bin/env python

	import socket, threading, sys

	class ClientThread(threading.Thread):

	def __init__(self, ip, port, socket, thread_id):
	threading.Thread.__init__(self)
	self.ip = ip
	self.port = port

	#!/usr/bin/python
	# -- coding: utf-8 --

	import math

	def calc_ab(alpha_a, beta_a, alpha_b, beta_b):
	'''
	See http://www.evanmiller.org/bayesian-ab-testing.html

	αA is one plus the number of successes for A