# Things that programmers don't know but should

(A book that I might eventually write!)

Gary Bernhardt

I imagine each of these chapters being about 2,000 words, making the whole book about the size of a small novel.
For comparison, articles in large papers like the New York Times average about 1,200 words.
Each topic gets whatever level of detail I can fit into that space.
For simple topics, that's a lot of space: I can probably walk through a very basic, but working, implementation of the IP protocol.
More subtle topics will get less detail: for RSA, maybe I'd (1) give a rough sketch of the number theory, (2) show that we can treat arbitrarily large byte arrays as numbers, and (3) say "combine them in the obvious way".

A queue that you can pass to IO.select.

# A queue that you can pass to IO.select.
#
# NOT THREAD SAFE: Only one thread should write; only one thread should read.
#
# Purpose:
#   Allow easy integration of data-producing threads into event loops.  The
#   queue will be readable from select's perspective as long as there are
#   objects in the queue.
#
# Implementation:
#   The queue maintains a pipe. The pipe contains a number of bytes equal to
#   the queue size.

This tool is used to compare microbenchmarks across two versions of code. It's
paranoid about nulling out timing error, so the numbers should be meaningful.
It runs the benchmarks many times, scaling the iterations up if the benchmark
is extremely short, and it nulls out its own timing overhead while doing so. It
reports results graphically with a text interface in the terminal.

You first run it with --record, which generates a JSON dotfile with runtimes
for each of your benchmarks. Then you change the code and run again with
--compare, which re-runs and generates comparison plots between your recorded
and current times. In the example output, I did a --record on the master
branch, then switched to my scoring_redesign and did a --compare. In my output,
three of the benchmarks' runtimes look to be unchanged; the other three got

require "erb"
require "pathname"

DOT_TEMPLATE=<<-END
digraph {
size="20,20";
overlap=false;
sep=0.4;
graph [fontname=Helvetica,fontsize=10];
node [fontname=Helvetica,fontsize=10];
edge [fontname=Helvetica,fontsize=10];
rankdir=TB;

# Goal: put a non-Rails-aware Ruby library using normal `require`s in
# lib/sim. Have it transparently reloaded between requests like Rails app
# code is.
#
# The code here goes inside of your configure block in
# config/environments/development.rb. There are two parts, commented inline.

# Reload code whenever the simulator changes.
config.watchable_dirs["lib/sim"] = [:rb]
config.watchable_files << "lib/sim.rb"

# Manually unload and reload the simulator before every request. This assumes

# I don't really see any services here. What I see is:
#   - Normal HTTP boundary stuff (params flash, redirect).
#   - Model creation and retrieval.
#   - Warden manipulation, which is an odd done but smells like boundary.
#
# I left all of the HTTP boundary stuff in the controller (and only the
# controller). I moved the model creation/retrieval into simple class methods
# in the models. I moved the warden manipulation stuff into
# ApplicationController (with caveats that I'll discuss inline).
#
# Commentary on each class follows:

Probably a really bad implementation of word wrapping

class Wrap
  def self.wrap(s, max_length)
    raise ArgumentError.new("Maximum wrap length can't be 0") if max_length == 0
    return [""] if s.rstrip.empty?

    # Split into words and whitespace blocks
    blocks = s.split /(\s+|\S+)\b/

    lines = []
    line = ""

    until blocks.empty?

diff --git a/app/views/devise/shared/_links.erb b/app/views/devise/shared/_links.erb
dissimilarity index 99%
index 414904b..0b0b21d 100644
--- a/app/views/devise/shared/_links.erb
+++ b/app/views/devise/shared/_links.erb
@@ -1,19 +1,15 @@
-<%- if controller_name != 'sessions' %>
-  <%= link_to "Sign in", new_session_path(resource_name) %><br />
-<% end -%>
-
-<%- if devise_mapping.registerable? && controller_name != 'registrations' %>
-  <%= link_to "Sign up", new_registration_path(resource_name) %><br />

#!/usr/bin/env bash

main() {
    if [ ! -p .test-commands ]; then
        mkfifo .test-commands
    fi

    while true; do
        cmd=$(cat .test-commands)
        if [[ $cmd == "" ]]; then
            continue
        else

(set -e && ls content/*.markdown | while read p; do DATE=$(echo $p | cut -d '/' -f 2 | cut -d '-' -f 1-3); TARGET=$(echo $p | sed 's/-/\//' | sed 's/-/\//' | sed -E 's/[0-9]+-//' | perl -pe 's/^(.*\/.*\/.*\/)(.)(.*)$/\1\u\2\3/' | sed -E 's/-|_/ /g'); echo $TARGET; mkdir -p $(dirname $TARGET); echo "<\!-- $DATE -->" > $TARGET; cat $p >> $TARGET; rm $p; done)

x = function()
    y = function()
        local table = 5
    end
    local old_table = table
    y()
    assert(table == old_table and table ~= 5)
end
x()

It's a subscription-based screencast site, where I post a new five- to
ten-minute screencast every week. For this, people pay a nominal fee
around $3 per month, giving them access to the full archives and new
screencasts as they happen. The style would be similar to the
screencasts I've posted on my blog: just me and the computer, recorded
in one take, although with much practicing. I'd focus not on new
languages and tools, but on the minute-to-minute mechanics of
effective programming practices, with an obvious bias toward the stack
and practices that I use.

bench "paths", :without_gc => true, :gc_time => true do
  PATHS[0, 1000].each { |choice| Score.score(choice, "x" * 16) }
end

Output:

...!.!.!.!..............................................
filtering paths
  Before: |                       --X-----------------------                     |
  After:  |                                   ---------X-------------------------|
          0                                                                   14.1

module RenderToHTML
  def self.book
    [title, css, body].join("\n")
  end

  private

  def self.title
    commit_hash = `git log -1 --pretty="format:%H"`
    %{
      <div class="title">
        <h1>#{TITLE}</h1>

# This is a stripped-down example based on Selecta's TTY handling. We store the
# TTY state in `tty_state`, then go into an infinite loop. When the loop is
# terminated by a ^C, we try to restore the TTY state. It's important that this
# work, but it doesn't in some subtle situations, and I don't know why.
#
# Save this file as test.rb and run it via this command, where `stty` should
# successfully restore the TTY state:
#   bash -c 'echo | ruby test.rb'
#
# Next, run it via this command, where `stty` should fail to restore the TTY
# state:
#   bash -c 'echo $(echo | ruby test.rb)'

#!/usr/bin/env ruby

# This script tests par2 recovery when the par2 files themselves are corrupted.
# Process:
#   1. Generate a file containing all 256 possible bytes.
#      (More would be better, but it gets slow fast.)
#   2. Generate par2 data for the file.
#   3. Individually corrupt each par2 file at each offset.
#      (Write byte 0 unless the offset already contains byte 0; then, write byte 255.)
#      (Writing each possible byte would be better, but it gets slow fast.)
#   4. After each corruption, verify the par2 data, then reverse the corruption.
#   5. Produce a summary of what the par2 verification commands' output, along with the frequencies of each output string.

" Remap the tab key to do snippets, autocompletion or indentation depending on
" the context (cobbled together by Gary Bernhardt; partly based on
" http://www.vim.org/tips/tip.php?tip_id=102)
"
" Because this uses the private 'Jumper' function in snippetsEmu, you'll need
" to edit '/.vim/plugin/snippetsEmu.vim' to make it public. To do that, just
" replace all occurrences of '<SID>Jumper' with just 'Jumper'. There were only
" two occurrences in my copy.
" 
" The g:snippetsEmu_key variable must be defined, but not to a function key.
" (I have no idea why function keys break it.) "  I recommend something on the
" leader prefix that you don't use.

def santa(people):
    return dict(zip(people, reversed(people)))


def describe_santa():
    bob, george, judy = 'bob jones', 'george jetson', 'judy smith'

    def takes_lists_of_people():
        santa([bob, george])

    def pairs_people_with_eachother():
        pairs = santa([bob, george])

The Limits of TDD
#date 2009-11-09 21:47
#tags python,tdd

<p>
    My <a href="/2009/11/how_i_started_tdd.html">last post</a> about TDD
    generated some great responses, some of which were skeptical. A few common
    complaints about TDD were brought up, and posed with civility, so I'd like
    to address them.
</p>

<h4>Complaint: You weren't stupid enough</h4>

def live_cell_count(x, y):
    square_coords = [(x-1, y-1),
                     (x+0, y-1),
                     (x+1, y-1),
                     (x-1, y+0),
                     (x+1, y+0),
                     (x-1, y+1),
                     (x+0, y+1),
                     (x+1, y+1)]

    count = sum(1 for x, y in square_coords
                if cell_alive_exists(x, y))

# One extra keyword needed for an RSpec clone. Just sayin.
describe('integers') do:
    it('can be added') do:
        expect(1 + 1) == 2
    it('can be subtracted') do:
        expect(2 - 1) == 1
    it('truncates on division') do:
        expect(3 / 2) == 1

# Implement blocks with plain old generators:
def describe(description):
    ... set stuff up

failbowl:temp $ rm -rf env && pip install -E env dingus && ls -l env/lib/python2.6/site-packages
Creating new virtualenv environment in env
  New python executable in env/bin/python
  Installing setuptools...done.....
Downloading/unpacking dingus
  Downloading dingus-0.2.tar.gz
  Running setup.py egg_info for package dingus
Installing collected packages: dingus
  Running setup.py install for dingus
    warning: build_py: byte-compiling is disabled, skipping.
    warning: install_lib: byte-compiling is disabled, skipping.

failbowl:temp $ deactivate; rm -rf env && pip install -E env dingus && . env/bin/activate && ls -l env/lib/python2.6/site-packages                        
zsh: command not found: deactivate
Creating new virtualenv environment in env
  New python executable in env/bin/python
  Installing setuptools...done.....
    Complete output from command /Users/grb/temp/env/bin/python /Users/grb/temp/env/bin/easy_install /opt/local/Library/Frameworks/...ar.gz:
    Processing pip-0.7.2.tar.gz
Running pip-0.7.2/setup.py -q bdist_egg --dist-dir /var/folders/Vr/Vrnubf6zGE4qOl6GIOQjh++++TI/-Tmp-/easy_install-AFWiid/pip-0.7.2/egg-dist-tmp-72Ag6W
warning: no files found matching '*.html' under directory 'docs'
warning: no previously-included files matching '*.txt' found under directory 'docs/_build'
no previously-included directories found matching 'docs/_build/_sources'
warning: build_py: byte-compiling is disabled, skipping.

whodoneit: Find who introduced a certain pattern to the code base

# Originally from Jonathan Penn, with modifications by Gary Bernhardt
function whodoneit() {
    (set -e &&
        for x in $(git grep -I --name-only $1); do
            git blame -f -- $x | grep $1;
        done
    )
}

# Setting up the graph; you can skip to the next comment.
$ hg init
$ echo 0 > 0
$ hg ci -Am 0
adding 0
$ echo 1 > 1
$ hg ci -Am 1
adding 1
$ hg co 0
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ echo 2 > 2
$ hg ci -Am 2

failbowl:destroyallsoftware.com(76m|braintree!?) $ cat Gemfile                                              
source 'http://rubygems.org'

gem 'rails', '3.0.3'

# Bundle edge Rails instead:
# gem 'rails', :git => 'git://github.com/rails/rails.git'

gem 'sqlite3-ruby', :require => 'sqlite3'

gem 'braintree', '2.7.0'
gem 'devise', '1.1.5'

set conf_name to text returned of ¬
	(display dialog ¬
		"Enter conference name:" with title ¬
		"Schedule Conference" default answer ¬
		"" default button 2)

tell application "Things"
	set newProject to make new project ¬
		with properties {name:conf_name}
end tell

tell application "Things"

$grid_column_width: 40px
$grid_column_margin: 10px
$grid_columns: 12
$grid_width: $grid_columns * ($grid_column_width + $grid_column_margin * 2)

=container
  margin-left: auto
  margin-right: auto
  width: $grid_width
	
=alpha
  margin-left: 0

  # mock-based (interaction)
  # db independent, but tied to implementation (I can change the AR call without affecting the behavior and this will fail)
  context "data gathering" do
    it "finds all indicators associated with the given sector and includes indicators not associated with any sectors" do
      sector = stub_model(Sector, :id => 6)

      Indicator.should_receive(:where).with("sector_id is null or sector_id = ?", sector.id)

      Indicator.for_sector(sector)
    end
  end

Given /^I'm subscribed as a group host for ([^ ]*) users?$/ do |users|
  users = users.to_i
  steps %Q{
    Given I'm on the account page
    Given I enter valid billing details
  }
  choose("for_many") # THIS FAILS
  fill_in "people ($9 per month each)", :with => users
  steps('And I press "Subscribe"')
end

require 'download_policy'

describe DownloadPolicy do
  let(:screencast) { stub(:free? => false) }
  let(:anonymous_user) { nil }
  let(:user_with_access) { stub(:has_screencast_access? => true) }
  let(:user_without_access) { stub(:has_screencast_access? => false) }

  it "is disallowed for anonymous users" do
    subject.allow_download_for?(screencast, anonymous_user).should be_false
  end

Python array methods:

>>> [m for m in dir([]) if not m.startswith("_")]
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']

Ruby array methods:

>> ([].methods - Object.methods).sort
=> ["&", "*", "+", "-", "<<", "[]", "[]=", "all?", "any?", "assoc", "at",
"choice", "clear", "collect", "collect!", "combination", "compact", "compact!",
"concat", "count", "cycle", "delete", "delete_at", "delete_if", "detect",

# Hash form:
{
  :current_user => "CurrentUser.current_user"
}

# Discovery form with inverted app structure:
module Injectables
  def current_user(session)
    User.find(:id => session['current_user_id'])
  end
end

#!/bin/ruby

guard 'spork' do
  watch(%r{^config/.*\.rb$})
  watch(%r{^config/environments/.*\.rb$})
  watch(%r{^config/initializers/.*\.rb$})
  watch(%r{^features/support/.*\.rb$})
  watch('spec/spec_helper.rb')
end

describe 'a' do
  it "raises an error when no source is found for an argument" do
    klass = Class.new { def f(unknown_argument); end }
    expect do
      injector.call(klass.new.method(:f))
    end.to raise_error(Syringe::UnknownInjectable)
end
end

def tweet(o)
  match(o) {
    with(o.name == "garybernhardt") { raise TrollError }
    with(Image i) { tweet ShortLink.for_image(i) }
    with(Text t) { actually_tweet_here }
  }
end

A Whole New World

Few of us have participated in the creation of our
infrastructure—operating systems, compilers, terminals, editors, etc.,
even though many of us know how to build them in theory. Collectively,
we suffer from a learned helplessness around them: to build new
high-level tools, we'd also have to rebuild some of the
infrastructure, sometimes going all the way down to the kernel. We
can't imagine triggering such a large cultural and technological
shift, so we don't even try to build truly new tools for ourselves.
I've been working on such a stack-busting tool and, though I won't
spill the beans on it here, I'll say that it's required me to

tell application "Finder"
  open file ((path to home folder as text) & "Dropbox:notes") using ((path to applications folder as text) & "MacVim.app")
end tell

tell application "MacVim"
	activate
end tell

failbowl:~(master) $ irb
>> X = 1
=> 1
>> undef_const :X
NoMethodError: undefined method `undef_const' for main:Object
  from (irb):2
>> const_undef :X
NoMethodError: undefined method `const_undef' for main:Object
	from (irb):3
>> const_delete :X
NoMethodError: undefined method `const_delete' for main:Object
	from (irb):4

--- /Users/grb/.rvm/gems/ruby-1.9.3-p194@investments/gems/values-1.5.0/lib/values.rb	2013-06-17 19:28:23.000000000 -0700
+++ values.rb	2013-06-25 17:28:17.000000000 -0700
@@ -1,7 +1,7 @@
 class Value
   def self.new(*fields)
     Class.new do
-      attr_reader *fields
+      attr_reader :hash, *fields

       define_method(:initialize) do |*values|
         raise ArgumentError.new("wrong number of arguments, #{values.size} for #{fields.size}") if fields.size != values.size
@@ -10,6 +10,8 @@

John Carmack on shadow volumes...

I recieved this in email from John on May 23rd, 2000.

- Mark Kilgard


I solved this in a way that is so elegant you just won't believe it.  Here
is a description that I posted to a private mailing list:

----------------------------------------------------------

#!/bin/bash
/usr/bin/env ruby --disable-gems <(cat <<'EOF'
puts "ruby code goes here"
EOF)

failbowl:rubies(master) $ git l
*   65cc7ef  (41 seconds)  <Gary Bernhardt>   (HEAD, master) Merge branch 'activate_command_cleanup'
|\
| * f4ced72  (2 minutes)   <Gary Bernhardt>   extract variables
| * f2760be  (3 minutes)   <Gary Bernhardt>   File.join instead of string interpolation
| * 94b8df5  (5 minutes)   <Gary Bernhardt>   activate command's imperative part is in activate!
|/
*   9291243  (7 minutes)   <Gary Bernhardt>   Merge branch 'ruby_info_cleanup'
|\
| * b7cb944  (9 minutes)   <Gary Bernhardt>   indentation
| * a3428c7  (10 minutes)  <Gary Bernhardt>   move RubyInfo field extraction into RubyInfo class
| * dff6a33  (15 minutes)  <Gary Bernhardt>   introduce ruby_info! command method

git diff --name-status head~3000..head | grep '^D' | awk '{print $2}' | while read f; do git log -1 --pretty="format:%H" -- "$f"; done > temp.txt

CyBurTaz:	i programed my comps memory to read my 	own lang
RAVERgrl34:	LoL... oh muh god!
CyBurTaz:	FOXXY STFU
RAVERgrl34:	you are a piece of shit!
RAVERgrl34:	ROFL
RAVERgrl34:	LMAO
RAVERgrl34:	oh muh god!
RAVERgrl34:	you are lamest mother fucking i have ever 	seen!
RAVERgrl34:	oh muh god, you are lame.

$ heroku pg:backups
Installing Heroku Toolbelt v4... done.
For more information on Toolbelt v4: https://github.com/heroku/heroku-cli
Setting up node-v4.1.1... done
Installing core plugins heroku-cli-addons, heroku-apps, heroku-fork, heroku-git, heroku-local, heroku-run, heroku-status...
 ▸
Error reading plugin: heroku-apps. See /Users/grb/.heroku/error.log for more information.
Error reading plugin: heroku-cli-addons. See /Users/grb/.heroku/error.log for more information.
Error reading plugin: heroku-fork. See /Users/grb/.heroku/error.log for more information.
Error reading plugin: heroku-git. See /Users/grb/.heroku/error.log for more information.
Error reading plugin: heroku-local. See /Users/grb/.heroku/error.log for more information.
Error reading plugin: heroku-run. See /Users/grb/.heroku/error.log for more information.