Yuji Kiriki yujikiriki

Every so often I have to restore my gpg keys and I'm never sure how best to do it. So, I've spent some time playing around with the various ways to export/import (backup/restore) keys.

Method 1

Backup the public and secret keyrings and trust database

cp ~/.gnupg/pubring.gpg /path/to/backups/
cp ~/.gnupg/secring.gpg /path/to/backups/
cp ~/.gnupg/trustdb.gpg /path/to/backups/

or, instead of backing up trustdb...

Each of these commands will run an ad hoc http static server in your current (or specified) directory, available at http://localhost:8000. Use this power wisely.

Discussion on reddit.

Python 2.x

$ python -m SimpleHTTPServer 8000

Production Ready Process Monitoring

Install docker-manger.conf and docker-instance.conf in /etc/init
Create a containers file in /etc/docker/ with the following format
```
 name: image cmd
```
The name must be unique.
sudo service docker-manager start

Advanced Scala:

Monad intros:

A nice intro: Scala Monads: Declutter Your Code With Monadic Design [YouTube]

	global
	log 127.0.0.1 local0 notice
	maxconn 50000
	daemon
	stats socket /tmp/proxystats level admin
	defaults
	log global
	mode http
	option httplog
	option dontlognull

	Latency Comparison Numbers (~2012)
	----------------------------------
	L1 cache reference 0.5 ns
	Branch mispredict 5 ns
	L2 cache reference 7 ns 14x L1 cache
	Mutex lock/unlock 25 ns
	Main memory reference 100 ns 20x L2 cache, 200x L1 cache
	Compress 1K bytes with Zippy 3,000 ns 3 us
	Send 1K bytes over 1 Gbps network 10,000 ns 10 us
	Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD

	from fabric.api import *
	from fabric.colors import green as _green, yellow as _yellow
	import boto
	import boto.ec2
	from config import *
	import time

	def create_server():
	"""
	Creates EC2 Instance

	/**
	* A monad to abstract dependencies in the code, see https://coderwall.com/p/kh_z5g
	*/
	object Reader {

	/**
	* an implicit to convert a function A => B in a Reader[A, B]
	*/
	implicit def reader[C, R](block: C => R): Reader[C, R] = Reader(block)

	package core.dao

	import scala.concurrent.Future

	import play.api.Logger

	import reactivemongo.core.commands.LastError
	import reactivemongo.core.errors.DatabaseException

	import core.db.MongoHelper

	Versioning is an anti-pattern
	=============================

	We often say "use the right tool for the job", but when managing change
	in software systems, we always use versioning. Hypermedia APIs are
	actually hindered by introducing versioning and manage change in a
	different way. With that in mind, there are also a lot of options for
	managing change in a Hypermedia API. We'd like to change our service and
	break as few clients as possible. Versioning is only one way to manage
	change, though... and my contention is that it's not appropriate for