stackdump stackdump

With Docker 1.8.0 shipped new log-driver for GELF via UDP, this means that the logs from Docker Container(s) can be shipped directly to the ELK stack for further analysis.
This tutorial will illustrate how to use the GELF log-driver with Docker engine.
Step 1: Setup ELK Stack:
- docker run -d --name es elasticsearch
- docker run -d --name logstash --link es:elasticsearch logstash -v /tmp/logstash.conf:/config-dir/logstash.conf logstash logstash -f /config-dir/logstash.conf
- Note the config for Logstash can be found at this link
- docker run --link es:elasticsearch -d kibana
Once the ELK stack is up now let's fire up our nginx container which ships its logs to ELK stack.

LOGSTASH_ADDRESS=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' logstash)
`docker run -d --net=host --log-driver=gelf --log-opt gelf-address=u

If anyone is interested in setting up their system to automatically (or manually) sign their git commits with their GPG key, here are the steps:

Generate and add your key to GitHub
$ git config --global commit.gpgsign true ([OPTIONAL] every commit will now be signed)
$ git config --global user.signingkey ABCDEF01 (where ABCDEF01 is the fingerprint of the key to use)
$ git config --global alias.logs "log --show-signature" (now available as $ git logs)
$ git config --global alias.cis "commit -S" (optional if global signing is false)
$ echo "Some content" >> example.txt
$ git add example.txt
$ git cis -m "This commit is signed by a GPG key." (regular commit will work if global signing is enabled)

In this video we come across about 50 online resources for category theory:

https://youtu.be/hEW42ARKNoE

I quickly comment on about 20 major ones. I link to the university sites, arXiv sites or Amazon page - most of the mentioned books are online available.

Here's another category theory list on github

https://github.com/prathyvsh/category-theory-resources

Solving SAT via interaction net superpositions

I've recently been amazed, if not mind-blown, by how a very simple, "one-line" SAT solver on Interaction Nets can outperform brute-force by orders of magnitude by exploiting "superposed booleans" and optimal evaluation of λ-expressions. In this brief note, I'll provide some background for you to understand how this works, and then I'll present a simple code you can run in your own computer to observe and replicate this effect. Note this is a new observation, so I know little about how this algorithm behaves asymptotically, but I find it quite

	VAGRANTFILE_API_VERSION = '2'

	$install = <<SCRIPT
	curl -L https://github.com/docker/fig/releases/download/1.0.1/fig-`uname -s`-`uname -m` > /usr/local/bin/fig
	chmod +x /usr/local/bin/fig
	SCRIPT

	$build = <<SCRIPT
	cd /vagrant
	fig build

	#cloud-config

	coreos:
	etcd2:
	# generate a new token for each unique cluster from https://discovery.etcd.io/new?size=3
	# specify the initial size of your cluster with ?size=X
	discovery: https://discovery.etcd.io/<token>
	# multi-region and multi-cloud deployments need to use $public_ipv4
	advertise-client-urls: http://$private_ipv4:2379,http://$private_ipv4:4001
	initial-advertise-peer-urls: http://$private_ipv4:2380

	import asyncio
	from concurrent import futures
	import functools
	import inspect
	import threading

	from grpc import _server

	def _loop_mgr(loop: asyncio.AbstractEventLoop):