Luis Armendariz ludwig

Channels Are Not Enough

... or Why Pipelining Is Not That Easy

Golang Concurrency Patterns for brave and smart.

Create a statically linked executable.

(I happened to do it in a docker container. You could use any method to create a statically linked executable, really)

Source:

// hello.c

#include

Ever had the need to create a branch in a repo on Github without wanting (or being able) to access a local repo?

With the aid of [the Github API][1] and [hurl.it][2] this is a piece of cake!

Just follow these steps:

Open [http://hurl.it/][2]
Find the revision you want to branch from. Either on Github itself or by doing a GET request from Hurl: https://api.github.com/repos/<AUTHOR>/<REPO>/git/refs/heads
Copy the revision hash
Do a POST request from Hurl to https://api.github.com/repos///git/refs with the following as the POST body :

	# Generates necessary certificates to ~/.docker
	#
	# Usage:
	# bundle install
	# ruby certgen.rb <domain>

	require 'certificate_authority'
	require 'fileutils'

	if ARGV.empty?

	import sys
	import numpy as np
	import matplotlib.pyplot as plt
	import theano
	import theano.tensor as T

	rs = np.random.RandomState(1234)

	def gen_spiral(label, dt, n_samples=100, noise=0.1):
	"""

	Why do compilers even bother with exploiting undefinedness signed overflow? And what are those
	mysterious cases where it helps?

	A lot of people (myself included) are against transforms that aggressively exploit undefined behavior, but
	I think it's useful to know what compiler writers are accomplishing by this.

	TL;DR: C doesn't work very well if int!=register width, but (for backwards compat) int is 32-bit on all
	major 64-bit targets, and this causes quite hairy problems for code generation and optimization in some
	fairly common cases. The signed overflow UB exploitation is an attempt to work around this.

	#!/bin/sh

	#
	# Forwards SSH agent into a Docker container running in the active
	# docker-machine
	#

	PROGNAME=$(basename $0)

	NAME=$(docker-machine active)

	#!/bin/sh

	command="${*}"
	printf "Initialized REPL for [%s]\n" "$command"
	printf "%s> " "$command"
	read -r input
	while [ "$input" != "" ];
	do
	eval "$command $input"
	printf "\n%s> " "$command"

	# Example Dockerfile
	FROM hello-world