mudge

# Based off chruby's auto.sh: https://github.com/postmodern/chruby#auto-switching
unset NODE_AUTO_VERSION

function chnode_auto() {
	local dir="$PWD/" version

	until [[ -z "$dir" ]]; do
		dir="${dir%/*}"

		if { read -r version <"$dir/.node-version"; } 2>/dev/null || [[ -n "$version" ]]; then

mudge

/*
 * Inspired by Dan Abramov's "Making setInterval Declarative with React Hooks",
 * this is a custom hook for debouncing a callback (e.g. for click handlers) such
 * that a callback will not be fired until some delay has passed since the last click.
 * The callback will automatically be updated with the latest props and state on every
 * render meaning that users don't need to worry about stale information being used.
 *
 * See https://overreacted.io/making-setinterval-declarative-with-react-hooks/ for the
 * original inspiration.
 */

mudge

Keynote

• https://statsbot.co
• https://github.com/pact-foundation/pact_broker
• https://detectify.com
• https://www.microfocus.com/en-us/products/static-code-analysis-sast/overview
• https://f5.com/products/modules/global-traffic-manager

Testing Infrastructure in 2019

mudge

On macOS:

$ brew install golang
$ go get github.com/cloudflare/cloudflared/cmd/cloudflared
$ cd ~/go/src/github.com/cloudflare/cloudflared/
$ env GOOS=linux GOARCH=arm GOARM=5 make cloudflared
$ scp cloudflared pi@pi.hole:

Then you can follow the instructions from https://docs.pi-hole.net/guides/dns-over-https/#arm-architecture-raspberry-pi

mudge

require 'fibonacci_heap'

# Assuming `graph` is an object with the following interface that stores vertices as `FibonacciHeap::Node`
# instances and `source` is a `FibonacciHeap::Node`:
#
# * `graph.vertices`: return an Enumerable of all vertices in the graph
# * `graph.neighbours(u)`: return an Enumerable of all vertices that neighbour a given vertex `u`
# * `graph.length(u, v)`: return the numeric weight of the edge between two given vertices `u` and `v`
def dijkstra(graph, source)
  dist = Hash.new(Float::INFINITY)

mudge

class CircularDoublyLinkedList
  include Enumerable

  class Node
    include Comparable

    attr_accessor :key, :next, :prev
    alias right next
    alias left prev

mudge

# A pure Ruby implementation of https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
#
# Takes a graph in hash form, e.g. { 'A' => ['B', 'C'], 'B' => ['D'], 'C' => ['D'] },
# and a source node, e.g. 'A', and returns the distances to every reachable node and a hash of "next hops" for each node.
def dijkstra(graph, source)
  q = graph.keys
  prev = {}

  dist = Hash.new(Float::INFINITY)
  dist[source] = 0

mudge

# snitch = Snitch.new('A string')
#=> #<Snitch:0x00007fe53a1964b0 @obj="A string">
# snitch.empty?
# Calling empty? on A string with []
#=> false

class Snitch
  attr_reader :obj

  def initialize(obj)

mudge

domains = ARGF.readlines.map(&:chomp)
queries = domains.map { |domain| %[url_contains:"/#{domain}" OR url_contains:".#{domain}"] }
queries.sort_by!(&:size)

rule_limit = 1024
operator_limit = 30

rules = [queries.pop]

queries.reverse_each do |query|

mudge

enum Error {
    NoRuleApplies,
}

enum Term {
    TmTrue,
    TmFalse,
    TmIf(Box<Term>, Box<Term>, Box<Term>),
    TmZero,
    TmSucc(Box<Term>),