April 3, 2017

_useful

I often create a directory/file called _useful/_useful.org/_useful.txt. I have one in my Dropbox, for example, that contains:

My apartment lease
My car/motorcycle insurance details
A textfile with my vehicle plate numbers/VINs/insurance policy numbers.

At work, I have one with

the top visited links for logs/metrics/admin interfaces for the services I work with most
a list of links of “typical” or “exemplar” things
- links to our internal tool views for typical payments, merchants, etc
- typical size (in bytes) of various protobuf messages we use a lot, size of 1M messages, #messages in 1MB/GB
common coding idioms, like several variants of @RunWith that we use in various cases in our test code.
useful commands for doing stuff (curl/SQL/plain old shell)

Plain text is great for all the reasons it usually is. But it’s especially useful here (see what I did there?) because the file loads much faster than Google Docs or wiki pages, it’s grep-able, it’s trivial to copy to a new machine, there’s no fuss about futzing with the document to get it to format properly, and soforth.

March 31, 2017

.sqliterc

I came across Better output from sqlite3 command line. His .sqliterc file did not work for me, but the simpler

.mode "column"
.headers on

did work nicely.

I also found out that brew install sqlite3 does not install the sqlite3 binary to $PATH, which stinks.

The sqlite3 environment is still much less pleasant than the mysql cli. A few things on my wishlist:

tab completion of tables, fields, keywords, and functions.
nicer .schema output – I’ve just gotten really used to reading them in mysql output

It sounds like maybe apsw can be something useful? Or maybe Navicat? (but that’s expensive)

March 29, 2017

sprat: multiplayer solitaire

I took a quick pass at describing the rules of a card game I grew up playing, Sprat:

Each player(or team) has 1 deck of cards. initial setup is 4 cards face up (the “personal piles”), 13 cards (top card face up, others face down) in the “sprat deck”, and the remaining cards in the “flip deck”.

The center of the table is the space for the “ace piles”. A new ace pile can be started by any player with any ace; any player can play the next card of the same suit on any ace pile.

March 27, 2017

idea: transaction ordering in ledger-cli

I love ledger-cli but keeping it in sync with my bank statements drives me crazy. The problem is that the transactions can end up with an essentially arbitrary ordering, and the order they clear (and even the date they clear) is not necessarily under my direct control.

One answer to this is: stop caring about the ordering of your transactions! That’s a decent answer, except that not addressing the ordering issue means that you can only ever have “end-of-day” consistency. This means you need a different report to reconcile the transactions.

February 1, 2017

basic http requests and server handlers in clojure

I’ve been playing around a tiny bit with clojure, and wanted to document the process of doing something pretty basic: make a project that can request my website over HTTPs.

The first step is pretty easy:

brew install leiningen
lein new random-experimentation
cd random-experimentation

and add [clj-http "3.4.1"] to project.clj.

The HTTPS part is a bit trickier. The JDK doesn’t include the Letsencrypt certificates. But I found a simple script install-letsencrypt-in-jdk.sh that can set it up.

January 20, 2017

use the `locale.currency` library function

I had stupidly written a pair of functions like this:

def comma_sep(amount):
    thousands = int(amount/1000)
    remainder = int(amount%1000)
    if thousands > 0:
        return comma_sep(thousands)+","+"%.3d"%(remainder)
    else:
        return str(remainder)
def friendly_from_cents(total_cents):
    pos = total_cents >= 0
    total_cents = abs(total_cents)
    cents = int(total_cents%100)
    dollars = int(total_cents/100)
    friendly = "$"+comma_sep(dollars)+"."+str(cents)
    if pos:
        return friendly
    else:
        return "-" + friendly

This is stupid, because python has builtin support to localize currency:

import locale
locale.setlocale(locale.LC_ALL, 'en_US')
locale.currency(-1800, grouping=True)

I think it’s tempting to fall into these traps, because it always starts simpler: I had some total_cents variable and just wanted to display quick and dirty. The complexity built up gradually, until I had something pretty complicated. Oops.

January 18, 2017

filter vs spec (draft)

Consider a silly data model to store data about cities like

message City {
  optional string city_name = 1;
  optional string state = 2;
  optional int32 population = 3;
  optional int32 year_founded = 4;
  // ... presumably others :-)
}

and some sample data like:

[
  {"city_name": "Portland", "state": "OR", "population": ...},
  {"city_name": "Portland", "state": "ME", "population": ...},
  {"city_name": "Springfield", "state": "FL", "population": ...},
  {"city_name": "Springfield", "state": "IL", "population": ...},
  {"city_name": "Springfield", "state": "CO", "population": ...}
]

There are some useful entities we can define: (DRAFT NB: don’t read too much into the matcher vs filter lingo.)

December 31, 2016

korean beef recipe

Ingredients:

1/4 cup brown sugar, packed
1/4 cup reduced sodium soy sauce
2 tsp sesame oil
1/2 tsp crushed red-pepper flakes
1/4 tsp ground ginger
1 tbsp vegetable oil
3 cloves garlic, minced
1 pound ground beef
2 green onions, thinly sliced.
1/4 tsp sesame seeds

Directions

Mix brown sugar, soy sauce, sesame oil, red pepper flakes, ginger.
Sizzle garlic in the vegetable oil, then add beef and cook until brown.
Stir in soy sauce mixture.
Serve immediately.

Summarized from Korean Beef Bowl on Damn Delicious, itself summarized from Korean Beef and Rice.

December 29, 2016

christmas commute

I did a 725-mile drive yesterday from Prosser, WA to San Francisco, CA. I captured the daylight hours with a GoPro timelapse and turned it into a video!

This was the actual loop we took, including the trip up to Washington. We spent two nights in Oregon – one in Grants Pass and one in Portland.

![]({{ site.baseurl }}/assets/christmas_commute_s.png)

My GoPro mount held the pictures upside down, so I transformed all of them with a quick

December 12, 2016

CBCL: The Common Business Communication Language

I recently came across McCarthy’s CBCL paper on Hacker News. He presents a Lisp notation as a format for sharing requests between different software on different computers. He calls out

(PLEASE-RESERVE (EPSILON (x) 
  (AND
    (IS-FLIGHT x) 
    (DEPARTS MONDAY) 
    (ARRIVES (BEFORE WEDNESDAY)))))

where $\epsilon x$ is an operator maps a predicate to a value matching the predicate, and considers it an improvement on the “iota” definite description operator, which seems to be an operator that returns the unique value matching the predicate. It seems interesting to me that the unique match operator is not considered as useful as the arbitrary match operator – unique keys actually seem critical to a lot of my work with data models. Even more fascinating, though, is that this looks like an anonymous function!