warpfork

```
                        core                                                          transparent     multiple     permanent bloat 
                        approach       offline?        fast         reproducible      when library    histories    to source repo
                       ----------      --------        ----         ------------      ------------    ---------    ---------------

 script (clone         semantic        no/fail          no          yes (`checkout        yes            no             no
 at build time)                                                       -f $HASH`)

 script (clone         semantic          yes            yes             yes               yes            no             no
 once, checkout

warpfork

package main

import (
	"fmt"
	"net/http"
)

func handler(resp http.ResponseWriter, req *http.Request) {
	fmt.Printf("serving \"%s\"\n", req.URL.Path)
	http.ServeFile(resp, req, req.URL.Path[1:])

warpfork

#!/bin/bash

interests=("$@")

for x in "${interests[@]}"; do
	echo -ne "\t$x"
done
echo
while true; do
	snap=`ps -A -o rss -o cmd` # downgrade to '-a' or leave it out entirely for confined scope

warpfork

package what

import (
	"encoding/json"
	"reflect"
	"testing"
)

type testStruct struct {
	A string

warpfork

#!/bin/bash

mkdir -p "${locPath}" && \
trap '( fusermount -u "${locPath}" && rmdir "${locPath}" ) 2>/dev/null ; exit $?' INT TERM EXIT && \
(
        declare -a opts
        opts=();
        opts+=("-o sshfs_sync");        # synchronous writes
        opts+=("-o no_readahead");      # synchronous reads
        opts+=("-o reconnect");         # try harder

warpfork

#!/bin/bash

# Summary: ZFS snapshots have a variety of remarkable limitations.
#
# - "recv" has no way to just accept snapshot data without actually checking it out onto the volume working tree.
#   - it's probably going to have to be coddled by having a spare dataset off to the side that does network receives.
# - "revert" to a snapshot is unsafe for anything other than depth=1 and may destroy snapshots.
#   - it has to be replaced by forking, and figuring out how to do an atomic replace.  ("zfs rename" appears to be up to the task, but do note that it's precisely the atomicity level of any other mount operation; no more no less.)
# - "clone" operations, which you'd think would be the right choice for "forking" a dataset, are just bonkers: clone causes data dependencies (deletes get weird) and the clones aren't capable of receiving incremental updates (bake your noodle on that one).
#   - the "promote" operation screws with the persistency of the thing you cloned *from* as well as the clone; at that point, 

warpfork

#!/bin/bash
set -euo pipefail
IFS=$'\0'

#
# config
# (you'll want to fix these to your environment, or change the project auto-detect to fit.) 
#
litespace="~/liteideSpace/"
sourcespace="~/repos/"

warpfork

##
## The following configuration is a contained environment with deterministic inputs (checked by a strong hash)
## which uses the go1.5 release for linux to *build* the go1.5 binaries for linux.
## (Jump to the bash script in the middle if you're just reading and willing to take the inputs for granted.)
##
## It then hashes the results so you can easily check that they are self-consistent when you run this process
## repeatedly on your own computer.  (The use of sandboxes means we're confident there's no leakage
## of state across repetitions.)
##
## Note that this does *not* check that the results are identical to the `bin` folder in the upstream

warpfork

wise choices for plugin patterns in golang

Any time you use an interface, really -- if it's a small one, you might cram everything into one package. If it's not small... you need to decide how to lay out your packaging!

Phase 1: Declare interfaces and API data types in a top level package

Put all the interfaces (and, any other structures that are completely shared data types and part of the general API) in one package. This is the stuff that most of your program is referring to already, so this is a process of making those boundaries explicit.

warpfork

#!/bin/bash
#
# Turn on smartmon;
# ask it to do a test;
# wait an arbitrary amount of time because smartmon's api is childish;
# ask for failure reports.
#
# Pretty print the whole thing, in as much as possible, because smartmon's output is fugly to the point of impeding usability.
#