Tyler Cipriani: pages tagged computing

Home temperature monitoring on the cheap

2022-12-01T03:26:08Z

One accurate measurement is worth a thousand expert opinions

– Grace Hopper

As I meandered around our new house, it was apparent some rooms were sweltering, others were freezing, and the thermostat was lying about everything.

I could feel it.

But I felt compelled to measure it. I was struck by the need to know:

The temperature of each room
How it changed throughout the day
And how to monitor changes over time

And I fulfilled my weird compulsion with a few simple tools:

Cheap temperature and humidity sensors from Home Depot
Home Assistant
The original internet of things protocol: radio.

Cheap temperature sensors

I have a handful of AcuRite sensors sprinkled throughout my house.

These sensors are $16 today, but I bought mine around 2017 for $12 each at Home Depot.

I know I could cobble together a cheaper temperature sensor:

SHT30 temperature/humidity sensor	$1
WeMos esp8266	$5
D1Mini OLED screen	$2
Shipping	~$2
A month of waiting for shipping	priceless

So for like $10 + solder + a weekend fiddling, you could make a craptastic internet-equipped temperature/humidity sensor.

But I dreaded building it.

Tinkering with electronic doodads is a fun hobby. But I just wanted something cheapish that would work.

And the AcuRites work.

Plus, the AcuRites work forever on a couple AAAs because they eschew power-hungry wifi in favor of squawking data on 433 MHz.

433 MHz, the original IoT protocol

Even though 433.92 MHz sits squarely in the 70cm ham band, tons of electronic junk spews signals on that frequency.

And with a $25 USB dongle and free software, it’s easy to decode messages chirped out by your AcuRite temperature sensors.

So far, this project had been cheap and simple. But the next step, gathering the data into a time-series database, required more fiddling than I’d expected.

Home Assistant, MQTT, Prometheus, and Grafana.

It was a pain to get rtl_433 data into Home Assistant.

Maybe I’m missing something. But I ended up with a more complex system than I wanted:

a systemd unit running rtl_433 with syslog output over UDP: rtl_433 -F syslog:127.0.0.1:1433
a systemd unit relaying and filtering syslog output to MQTT (based on this upstream example)
a systemd timer to restart rtl_433 when it unexpectedly hangs (often)

After endless fiddling, the relay has an uptime measured in months—it’s stable.

From there, pushing data to Home Assistant, exposing it via the Prometheus plugin, and graphing it with Grafana was a breeze.

Given all this work I’m happy to confirm what I’d long suspected: some rooms in my house are hot while others are cold.

Git Notes: git's coolest, most unloved feature

2022-11-27T20:11:22Z

the short of it is: they’re cool for appending notes from automated systems (like ticket or build systems) but not really for having interactive conversations with other developers (at least not yet)

– Scott Chacon, GitHub.blog, Aug. 2010

Git notes are almost a secret.

They’re buried by their own distressing usability.

But git notes are continually rediscovered by engineers trying to stash metadata inside git.

Git notes are powerful tools. And they could solve so many problems—if only they were better known and easier to use.

🧐 What are git notes?

A common use of git notes is tacking metadata onto commits.

Once a commit cements itself in git’s history—that’s it. It’s impossible to amend a commit message buried deep in a repo’s log¹.

But git notes enable you to amend new information about old commits in a special namespace. And they’re capable of so much more.

Notes stow metadata about anything tracked by git—any object: commits, blobs, and trees. All without futzing with the object itself.

You add notes to the latest commit in a repo like this:

git notes add -m 'Acked-by: <tyler@tylercipriani.com>'

And then it shows up in git log:

commit 1ef8b30ab7fc218ccc85c9a6411b1d2dd2925a16
Author: Tyler Cipriani <thcipriani@gmail.com>
Date:   Thu Nov 17 16:51:43 2022 -0700

    Initial commit

    Notes:
        Acked-by: <tyler@tylercipriani.com>

🥾 Git notes in the wild

The git project itself offers an example of git notes in the wild. They link each commit to its discussion on their mailing list.

For example:

commit 00f09d0e4b1826ee0519ea64e919515032966450
Author: <redacted>
Date:   Thu Jan 28 02:05:55 2010 +0100

    bash: support 'git notes' and its subcommands
    ...

Notes (amlog):
    Message-Id: <1264640755-22447-1-git-send-email-szeder@ira.uka.de>

This commit’s notes point intrepid users to the thread where this patch was discussed.

Other folks are using notes for things like:

Tracking time spent per commit or branch
Adding review and testing information to git log
And even fully distributed code review

📦 Storing code reviews and test results in git notes

Here is a plea for all forges: make code review metadata available offline, inside git.

The reviewnotes plugin for Gerrit² is an example of how to do this well. It makes it easy to see who reviewed code in git log:

git fetch origin refs/notes/review:refs/notes/review
git log --show-notes=review

The command above shows me all the standard git log info alongside information about what tests ran and who reviewed the code. All without forcing me into my browser.

commit d1d17908d2a97f057887a4afbd99f6c40be56849
Author: User <user@example.com>
Date:   Sun Mar 27 18:10:51 2022 +0200

    Change the thing

Notes (review):
    Verified+1: SonarQube Bot
    Verified+2: jenkins-bot
    Code-Review+2: Reviewer Human <reviewerhuman@wikimedia.org>
    Submitted-by: jenkins-bot
    Submitted-at: Tue, 14 Jun 2022 21:59:58 +0000
    Reviewed-on: https://gerrit.wikimedia.org/r/c/mediawiki/core/+/774005
    Project: mediawiki/core
    Branch: refs/heads/master

💠 Distributed code review inside git notes

Motivated hackers can knead and extend git notes. Using them as distributed storage for any madcap idea.

Someone at Google cobbled together a full-on code review system teetering atop git notes called git-appraise.

Its authors have declared it a “fully distributed code review”—independent of GitHub, GitLab, or any other code forge.

This system lets you:

Request review of a change
Comment on a change
Review and merge a change

And you can do all this from your local computer, even if GitHub is down.

Plus, it’s equipped with an affectedly unaesthetic web interface, if that’s your thing.

😭 No one uses git notes

Git notes are a pain to use.

And GitHub opted to stop displaying commit notes in 2014 without much explanation.

For commits, you can make viewing and adding notes easier using fancy options in your gitconfig³. But for storing notes about blobs or trees? Forget it. You’d need to be comfortable rooting around in git’s plumbing first.

So, for now: git notes are relegated to obscurity. Forever hamstrung by an obscure and clunky interface and limited adoption—I often forget they’re there.

🗽 Forge independence

Git is a distributed code review system. But much of the value of git repos ends up locked into forges, like GitHub.

Git notes are a path toward an alternative.

Git distributes the history of a piece of code. Git notes could make it possible to distribute the history of an entire project.

Without having to endure the perils of a force push, anyway.↩︎
The code review system used for a couple of bigish projects.↩︎

Noteably by automagically fetching notes and displaying them in git log via:

$ git config --add \
remote.origin.fetch \
'+refs/notes/*:refs/notes/*'
$ git config \
notes.displayRef \
'refs/notes/*'

↩︎

f.lux, but for your house

2022-10-18T21:35:21Z

Artificial lighting is omnipresent in contemporary society with disruptive consequences for human sleep

– Sarah L Chellappa, https://doi.org/10.1093/sleep/zsaa214

Light messes with my sleep, mood, and alertness.

My house lights should auto-adjust themselves—like f.lux or redshift on my laptop:

🌞 White/Blue, bright light during the day
🌛 Red/Yellow, dim light at night

I was worried that getting this to work for my whole house meant endless fiddling with “smart” devices.

But Home Assistant papered over the vendor and hardware woes and made setup simple.

The goals of my house lighting

I had the following goals for this project:

Circadian lighting in all rooms – Bright, blue/white light during the day; dim, red/yellow light after sunset.
Control by switches – I disdain fiddling with tablets/phones to turn lights on and off. I’d also hoped to avoid an always-on speaker listening to me.
Automatic – Light should shift temperature and brightness automatically throughout the day.
Ability to override – I should be able to override the automatic settings quickly with a switch. Sometimes it’s nice to be able to see what you’re doing late at night—circadian rhythm be damned.
Platform independent – Because hue bulbs are expensive, I need to be able to add to the system over time. Everything from DIY light strips to hue bulbs to random smart bulbs from Alibaba.com should work together.
Self-hosted – All software should live on my home network and work with only a local network.

The Results

The effects have been subtle but noticeable.

During the day, I’m sharp, and at night I’m ready to sleep.

In the evenings, after the sun sets, the lights dim, and it gets harder to read and work on projects—that’s a feature. It’s a signal that it’s time for bed.

The most significant benefit I’ve noticed is that I can get back to sleep after getting up in the middle of the night—now that I’m no longer blinded by harsh overhead light in the bathroom.

Home Assistant setup

Home Assistant made this possible.

The Circadian lighting component (available via Home Assistant Community Store (HACS)) computes solar noon based on my location and auto-adjusts the brightness of my lights and the color temperature based on the time of day.

I use Zigbee2MQTT to capture events from my switches and send them to Home Assistant over MQTT—I found this easier than adding a Zigbee gateway to Home Assistant directly.

I have automation that allows me to override circadian lighting when I need maximum brightness or when I want the nightlight.

The hardware setup

Lights:

Hue bulbs – I have a lot of hue bulbs.
- Some are full-color bulbs, while others do color temperature.
- Three different form factors—A19 bulbs, GU10s for the Ikea Tidig in our kitchen, and the Edison bulb for our fancy dining room light.
- These are good light bulbs.
Taloya smart ceiling light – this is the bathroom light, integrated with Home Assistant via LocalTuya.

Buttons:

Aqara mini switch – one each for me and my partner for controlling the bedroom lamps.
MOES Zigbee 4-gang switch – bathroom lights—one button for on/off, one button for bright, one for dim, one for the red nightlight.

Other hardware:

Conbee II Zigbee Gateway – Handles the incoming Zigbee signals.

TODO: finish lighting

House lighting is never done. I have ideas for my lights that I’m still pondering.

SAD office light – I’m lacking an extremely bright office light—this is especially noticeable when winter brings darkness at 4:30pm. I’m pondering building something that I can attach to this system.
Hyperion media lighting – Ambiant bias lighting for the TV via Hyperion. This is neat, but it’s a low priority since I don’t watch much TV (and my TV is from 2012, anyway. I’m not fancy).
Moar WLED – I added WLED strip lighting over the sink (which works perfectly with Home Assistant), but I need more to brighten up the whole space.

GitHub's missing merge option

2022-09-30T23:24:26Z

github is a perfectly fine hosting site, and it does a number of other things well too, but merges is not one of those things.

– Linus Torvalds

Git possesses parts of a decent software forge.

When git was developed by the Linux kernel community, they already had bug tracking, documentation, and a mailing list, so (unlike fossil) git has none of those things.

Enter GitHub. It uses “issues” for bug tracking and discussion, and its code browser is unrivaled.

But for all of its features, GitHub implements only a subset of git. For instance, GitHub lacks the default merge strategy of git—the fast-forward merge.

And after some pondering I realized there’s a good reason for that: it’s a cop-out.

`git log` can be clean or accurate, not both

I want clean history, but that really means (a) clean and (b) history.

– Linus Torvalds

Git log will always suck for someone.

An eternal war rages between team “git log should be clean” vs. team “git log should have an accurate history.”

📚 Team History
- Method: git merge --no-ff
- 🟢 Pros: A complete history of how everything was developed
- 🔴 Cons: You’ve opened a pandoras box of strange git situations. And your git log looks like this now¹:
```
* (refs/heads/B)
* * Merge 'C' into 'B'
* |\
* | | * (refs/heads/C -- git revert B8)
* | | * Merge 'B' into 'C'
* | |/|
* | |/
* |/|
* * | B8
* | * C3
* |/
* * A (refs/heads/A)
```

Team history uses git merge --no-ff to ensure a merge commit is always created

✨ Team Clean
- Methods: git merge --ff-only or git rebase && git merge (extreme clean freaks add the --squash option)
- 🟢 Pros: Linear history, git log is easy to read, git revert requires no thought.
- 🔴 Cons: You’re erasing history—you can no longer tell if two commits were written together on a single feature branch.

Team clean uses git rebase && git merge --ff-only to make it appear there was never a feature branch at all

Why is `git merge` bad?

git merge opted out.

If a branch can be fast-forwarded, git merge sticks the commits on the end of the branch and never tells you there was a merge—team clean.

But if a branch has conflicts, you’ll need to fix them and create a merge commit to say what you did—team history.

Sometimes there’s a merge commit; sometimes not: Madness.

What does GitHub do?

When you mash “merge” in GitHub it never executes plain git merge.

And sussing out what git command it will run is kafkaesque. I spent some time mapping all the checkboxes and merge strategies into something you could type into bash.

command	GitHub	Alignment
`git merge`	not implemented	`¯\_(ツ)_/¯`
`git merge --ff-only`	not implemented	✨ Team Clean
`git rebase && git merge --ff-only`	Rebase and Merge	✨ Team Clean
`git merge --no-ff`	Create a merge commit	📚 Team History
`git merge --squash --ff-only BRANCH`	Squash and merge	✨ Team Clean
`git merge --is-ancestor && git merge --no-ff`	Create a merge commit + Require linear history	✨ Team Clean²

There is a distinction between git rebase && git merge --ff-only and git merge --ff-only. Rebasing modifies the commit—you end up with a different SHA1.

By not using the “merge if necessary” strategy of git merge, GitHub forces you to choose a side in the eternal war. And that’s a good thing.

This is a contrived example of a “criss-cross merge”↩︎
In GitLab this is “Merge Commit with Semi-linear history” which seems like a nicer UI vs the buried option to “Require linear history”. This option mitigates some of the pain of an ugly git log.↩︎

Staging is a trap

2022-09-16T17:38:11Z

Software staging clusters only grow.

As production accrues more services, staging’s costs ramp up.

And maintaining a single, massive, production-like staging may no longer be the right answer.

But several, small staging clusters—each fit for their purpose—offers a more maintainable, cheaper alternative.

🍝 There is no perfect staging; there are only perfect stagings

Each reason for having a staging cluster requires a different level of “production-likeness” to fit its use.

You could put Apache and PHP on raspberry pi and call it Wikipedia’s “staging.”

And that’d be a fine place to demo a MediaWiki patch. But to be confident deploying that patch into Wikipedia’s production: (to paraphrase “Jaws” 🦈): you’re gonna need a bigger staging .

In the 1970s, the pasta sauce brand Ragu tasked the psychophysicist Howard Moskowitz with finding the perfect pasta sauce.¹

Moskowitz concluded the perfect pasta sauce doesn’t exist—it depends on each individual’s wants and needs. There is no perfect pasta sauce; there are only perfect pasta sauces.

Howard’s work is why you’ll find Ragu Old World Style® next to Ragu Chunky Garden Vegetable next to 10s of other Ragus.

And much like pasta sauce²: there can be no perfect staging; only perfect stagings.

💱 Staging trades cost vs. production-likeness

The requirements for a staging cluster depend on its use.

Demos – Demoing new code requires the same software, maybe a few microservices, and (possibly) a subset of production data.
- 🟢 Low cost
- 🟢 Low production-likeness
Exploratory testing – QA requires the same software, services, and a subset of production data. It’d be nice to run it on the same type of infrastructure, too.
- 🟡 Medium cost
- 🟡 Medium production-likeness
Deployment confidence – 100% confidence requires a parallel universe you destroy whenever a deployment goes wrong.
- 🔴 High cost
- 🔴 High production-likeness

Staging is a trade-off: resources (money, people, time) against asymptotically approaching actual production.

The closer you get to production, the higher the costs and complexity.

🔁 Production should be reproducable

Setting up a staging server should be easy. If it is not easy, you already have a problem in your infrastructure, you just don’t know it yet

– Patrick McKenzie 🐉, Staging Servers, Source Control & Deploy Workflows, And Other Stuff Nobody Teaches You

Configuration management should make it easy to rebuild production from scratch. Otherwise, you’ve got a disaster in the offing.

This creates an environment suitable for demos and end-to-end test automation.

But organizations are evolving away from using pre-production staging to build deployment confidence.

They’ve replaced their high-cost staging with a mix of canary deployments and advanced feature flagging.

Small environments with narrow scope—like testing or demoing—seem like a reasonable trade-off of cost vs. benefit.

But using pre-production staging as insurance for your deployments—requiring snapshots of production data and maybe even replayed traffic—seems too. darn. expensive.

📚 Further reading

This is an anecdote related by Malcolm Gladwell in a 2007 Ted Talk, “Choice, Happiness, and Spaghetti Sauce ↩︎
There’s a joke here about “spaghetti code” that I’m too lazy to find.↩︎

Meshtastic: A Review

2022-08-01T01:55:54Z

The Meshtastic is my solarpunk dream—a cheap, encrypted, offgrid communicator. But the project is still in the alpha stages (and it shows).

Meshtastic is a communication system. Its firmware runs on bare-bones “T-Beam” devices. T-Beams are available fully-assembled and pre-flashed for about $35.

The devices enable encrypted, text-message-style communication via an app on your smartphone. No cell service required.

I bought two Meshtastic T-Beams for a recent trip to Yellowstone National Park. The devices worked as advertised—we could share texts and locations between our Android phones even though we had no service.

Problems Meshtastic solves

Communication infrastructure fails. Whether an earthquake in Puerto Rico or a trip to a national park—it’s easy to imagine a situation where your smartphone is useless.

And it’s trivial to surveil your communications—AT&T established room 641A to funnel communication to the NSA. And there are reports of “stingrays”—devices that masquerade as cell towers—intercepting the text messages of protestors.

Meshtastic attempts to solve these problems using cheap, readily available parts and open-source software.

Shut up and take my money.

What I dislike

There’s no way around it: this is an alpha quality project. Right now, it’s only usable by nerds (like me 🌠). You’ll probably have a bad time if you’re not a tinkerer or a hobbyist.

Alpha quality – The project is hard to use, even for the basics. During our trip to Yellowstone, we repeatedly lost our bluetooth connection to the devices—they kept going to sleep. And the interface is sometimes unclear—I ended up holding down buttons, waiting for something (anything) to happen.
iOS requires Testflight – The Android mobile app worked well, but the iOS app requires Testflight to install—which seems like a pain.
Batteries/small bombs – The T-Beams run off big honkin’ 18650 batteries—the same lithium-ion cells used in Tesla battery packs. While the batteries last all day, I had to make extra purchases. Later I realized they run fine off of USB battery packs, but I was uncertain about that when I bought it. These things added to my costs:
- Opus BT-C3100 battery charger
- Sanyo NCR18650GA 3500mAh 10A Battery
PCBs are intimidating – Holding a PCB (printed circuit board) intimidates electronics neophytes. There are stickers available on the discourse that read: “Meshtastic: this is not a bomb” (for base stations in the field).
“Meshtastic” – My brain refuses to type “meshtastic” on the first try; this may be a personal problem.

What I love

There is a lot to love about this project.

FOSS – Meshtastic is free software—the firmware is GPL-3.0 licensed—the four software freedoms are essential for users to trust this device.
Encryption – Data moving between T-Beam devices is encrypted via AES256—an as-yet unbroken standard. Although, the documentation on this worries me a little: “It is pretty likely that the AES256 security is implemented ‘correctly’ and an observer will not be able to decode your messages.”¹ 😅
LoRa – The Meshtastic devices work via LoRa (Long Range) radio. In the US, LoRa uses the ISM band (on 915mHz). The ISM band has no license requirement—which means it’s legal to encrypt traffic, unlike ham radio. In testing, LoRa works up to a few miles away with a good line of sight.
Community – There’s a vibrant community on GitHub, Thingiverse, Discourse, and Discord. There’s excellent Documentation and folks blogging (and vlogging).

The verdict

I’m thrilled with this project. The talented people bolstering this community experiment with setting up base stations at Burning Man and running ssh tunnels via LoRa—they’re doing awesome things.

I’ve not yet begun to nerd out on this.

https://meshtastic.org/docs/developers/Firmware/encryption ↩︎

Cool desktops don’t change 😎

2022-06-16T18:52:30Z

Tools can be a subtle trap.

– Neil Gaiman, The Sandman

Working on my old ThinkPad x220 feels easy because I’ve used the same software for over a decade.

And while it’s tempting to switch to one of the endless new apps out there, there are good reasons to trust old tools.

The Lindy Effect

The Lindy effect posits the older something is, the longer it’ll be around.

According to the Lindy Effect, you can assume most software is halfway through its lifespan.

So, Vi will be around in 2068, whereas Visual Studio Code will be defunct before the end of this decade.¹

Debian	1993	28 years old
Bash	1989	33 years old
XMonad	2007	15 years old
URXvt	2001	20 years old
Tmux	2007	15 years old
Vim	1991	30 years old

The average software running my laptop is 24 years old. So, 24 more years of this desktop (right!? 😅).

Preserve your flow state

My desktop has features that are missing from other people’s computers.

These features whisk me into a flow state and keep me there; they preserve my limited attention, willpower, and (frankly) mental capacity.

Vim instead of a new notetaking app

The problem with most notetaking apps is editing text outside Vim breaks my brain.

Vimwiki has piqued my interest, but I have yet to use it.

Meanwhile, I keep boring notes in Vim using a bash script, Pandoc, markdown, and a distraction-free writing environment.

In the end, I get a bunch of webpages available on http://localhost/~thcipriani/brain:

Bash instead of DuckDuckGo

Some folks rely on DuckDuckGo (or, worse yet, Google) for basic utilities:

Calculator
Dictionary
Spell check
Unit conversion

But you can achieve the same thing faster, without breaking your concentration.

Calculator

I stole the calc bash function from Addy Osmani in 2012 and have used it daily since.
```
(/^ヮ^)/*:・ﾟ✧ calc 6922251*8
55378008
```

Dictionary

I 😍 dictionaries.

One of the best dictionaries for writers is available as the gcide-dict package in Debian:

(/^ヮ^)/*:・ﾟ✧ dict fustian
  Fustian \Fus"tian\, n.
     1. A kind of coarse twilled cotton or cotton and linen stuff,
        including corduroy, velveteen, etc.
        [1913 Webster]

     2. An inflated style of writing; a kind of writing in which
        high-sounding words are used, above the dignity of the
        thoughts or subject; bombast.
        [1913 Webster]

              Claudius . . . has run his description into the most
              wretched fustian.                              --Addison.
        [1913 Webster]

Spell checker

Spellcheck is available almost everywhere, but when it isn’t, people tend to search for whatever word they’re spelling. I wrote a script called spell which uses aspell to improve my spelling:
Temperature conversion

units is a unit conversion and calculation program. And its database is one of my favorite sources of trivia.

You can make scripts for the most common functions. I made one called temp, which uses units to show temp in both °C and °F—handy for talking about the weather.
```
(/^ヮ^)/*:・ﾟ✧ temp 100
37.777778°C
212°F
```

Scratchpads instead of pinned tabs

Scratchpads are little windows you summon with a keyboard shortcut. I’ve combined XMonad and Chrome to get little floating web apps all over my desktop.

⌘ + Shift + p is an ever-present notetaking terminal window.
⌘ + Shift + s is Google calendar.
⌘ + Shift + o used to bring up an org-mode capture template, but now it brings up todoist (yes, I’m suitably ashamed).

XMonad NamedScratchpads 👏

The year decade of Linux on the desktop

There’s a bitter joke that goes like this: “It’s the year of Linux on the desktop.”

People say it in video calls when they can’t get their audio to work. But, honestly, I’ve had a pleasant decade of Linux on the desktop.

And when Wayland finally happens? Well. I guess I’ll have no choice but to stop using computers forever ¯\_(ツ)_/¯².

Anyway. Here’s to the next decade and beyond.

Thanks to Brennen, Kostah, and Željko for reading an early draft of this post and making it less terrible. <3

There is precedent here: https://github.blog/2022-06-08-sunsetting-atom/↩︎
or, I suppose, I could finally figure out how to use SwayWM ↩︎

Explaining git diff to myself

2022-05-16T17:56:21Z

But try to understand
Try to understand
Try try try to understand
Git’s a magic command.

– Heart 💕

Once upon a time, I believed git was storing diffs somewhere. But then I learned I was wrong.

It’s challenging to wield git’s clunky interface when you have a broken mental model of its internals. Learning more about what’s happening inside git transformed me into a more effective git user.

In this post, I’ll attempt to explain all the deep details of git diff to my past self.

📍 Git add makes blobs

We can add files to repos using git add. But behind the porcelain, git’s busy compressing and storing this file deep in its bowels. Git terms the results of this process a “blob.”

Git stores blobs (among other things) inside the .git/objects directory.

$ git init
Initialized empty Git repository in /tmp/bar/.git/
$ echo "Hi, I'm blob" > foo
$ git add foo
$ tree .git/objects/
.git/objects/
└── 26
  └── 45aab142ef6b135a700d037e75cd9f1f1c94dc

But what’s in a blob? And why is this blob stored as ./26/45aab142ef6b135a700d037e75cd9f1f1c94dc?

🗃️ Git stores things by their hash

Why did git add foo store the contents of foo as 2645aab142ef6b135a700d037e75cd9f1f1c94dc?

Git mapped our file to a number via a hash function.

A hash function maps data to a unique number (mostly)—whenever the data changes, the hash function’s output changes dramatically.

SHA1 is the hash function git uses by default. And when we git add foo git applies SHA1 to the contents of foo—Hi, I'm blob\n—and that spits out 2645aab142ef6b135a700d037e75cd9f1f1c94dc.

Blobs are all about content. The filename “foo” doesn’t matter at all! We could have named the file “🌈”—git still would have stored it in the same place. If the file contents are EXACTLY the same, then the hash will be exactly the same.

🌱 Git commit creates commits and trees

You already know git commit creates a commit, but what is a commit?

A commit is a type of object. Git uses the word “object” to mean: a commit, a folder or directory (tree), a file (blob), or a tag. Git stores objects in its object database—everything inside the .git/objects directory.

$ git commit -m 'Initial Commit'
[main (root-commit) 0644991] Initial Commit
1 file changed, 1 insertion(+)
create mode 100644 foo
$ tree .git/objects/
.git/objects/
├── 06
│   └── 449913ac0e43b73bfbd3141f5643a4db6d47f8
├── 26
│   └── 45aab142ef6b135a700d037e75cd9f1f1c94dc
└── 41
  └── 81320a57137264d436b2ef861c31f430256bf4

After our commit, the object database has three objects: 06449913, 2645aab1, and 4181320a.

So now we’ve established that one of these three objects is our blob (2645aab1)—let’s see if we can suss out the others.

✨ The magic command

The magic command to learn about any object is git cat-file -p. We can use that command to find out more about our mystery objects:

$ git cat-file -p 06449913ac0e43b73bfbd3141f5643a4db6d47f8
tree 4181320a57137264d436b2ef861c31f430256bf4
author Tyler Cipriani <tcipriani@wikimedia.org> 1652310544 -0600
committer Tyler Cipriani <tcipriani@wikimedia.org> 1652310544 -0600

Initial Commit

This object (06449913) appears to be our commit. A commit is metadata compressed and stored inside git’s object database.

Some of the metadata is obvious, but then there’s a tree. And that tree points to our other mystery object, 418132. Let’s see what we can learn about our last remaining mystery object using our magic command:

$ git cat-file -p 4181320a57137264d436b2ef861c31f430256bf4
100644 blob 2645aab142ef6b135a700d037e75cd9f1f1c94dc    foo

So a tree is an object that stores a directory listing of objects by their SHA1s. And a commit is an object that points at a tree by recording the tree’s SHA1!

Commits point to trees, and trees point to blobs and other trees. Neat!

📈 Git’s dependency graph

So if we graphed the state of dependencies in our object database, we’d get something like this:

The commit incorporates our tree, which includes our blob—everything depends on our blob!

So if we change even a single bit inside a single file: git will notice—everything is entirely traceable from the commit down to the bit level. We get this for free by hashing objects and including those hashes in other objects.

This is the whole concept of a Merkle Directed Acyclic Graph (Merkle DAG)!

🍔 So, where’s the diff?

When we type git diff, git presents us a diff. We know there are blobs and trees and commits—so where’s the diff!?

Git doesn’t store diffs anywhere at all! It derives diffs from what’s stored in the object database.

$ echo "I'm ALSO blob" > baz
$ git add baz
$ git commit -m 'Add baz'
$ tree .git/objects/
.git/objects/
├── 06
│   └── 449913ac0e43b73bfbd3141f5643a4db6d47f8
├── 26
│   └── 45aab142ef6b135a700d037e75cd9f1f1c94dc
├── 41
│   └── 81320a57137264d436b2ef861c31f430256bf4
├── 95
│   └── 42599fac463c434456c0a16b13e346787f25da
├── 9b
│   └── 2716e4540c11e8d590e906dd8fa5a75904810a
└── e6
   └── 5a7344c46cebe61d052de6e30d33636e1cd0b4

We made a new commit, and now we have three new objects. We added a new file (blob), which made our directory different (tree), and we committed it (commit).

Our graph now looks like this:

You might be surprised by a few things in the graph:

Our new commit stores its parent commit as metadata
Our new tree points to our old blob, and our NEW blob

So now what happens when we try git diff:

$ git diff 064499..e65a73
diff --git a/baz b/baz
new file mode 100644
index 0000000..9b2716e
--- /dev/null
+++ b/baz
@@ -0,0 +1 @@
+I'm ALSO blob

Git compares the two commits, finds their trees, sees a new blob in the second commit, and shows you the diff of /dev/null and baz.

No diffs. Just Merkle DAGs. And now you know.

Thanks to Joe Swanson for providing excellent early feedback on this post. And thanks to Kostah Harlan for reading an early draft of this post and making it less terrible. <3

The Unreasonable Fight for Municipal Broadband

2022-04-20T17:31:39Z

I love Longmont’s municipal broadband, but we had to fight Comcast every step of the way to get it.

As a gracious person, I’ll dutifully pretend that the problem might be on my side of the Zoom call. But the problem is never me—my internet is just too good.

Since 2016, I’ve been using Longmont’s municipal broadband—NextLight—and it’s been objectively awesome.

It’s fast—1Gbps symmetric
It’s cheap(ish)—$49.95 per month
It’s rock-solid—I’ve never had an outage
I’ve never hit a data cap
PC Magazine ranks NextLight among the top five ISPs in the United States every year—often besting Google Fiber

And, even better, the city insists I’ll pay $49.95 forever.

But Longmont spent more than a decade fighting Comcast to provide this excellent internet. And any city working on its municipal broadband offering should prepare to do the same.

🎉 Canceling Comcast

In 2016, I was paying Comcast $150 a month for their top-tier (at the time) 100Mbps speeds. I could usually eke out a little more than 30Mbps on a good day.

I lept at the chance for gigabit internet. I signed up for NextLight as a charter member—locking in $49.95/mo for life (the current price is only $69.95 last I checked). And I took the opportunity to upgrade my $20 router from 2008 at the same time.

And when I returned my cable box to Comcast to cancel my service, the representative felt compelled to counsel me: “NextLight, huh? you know,” he said, leaning in, “if you miss even a single payment, they’ll raise your price?”

“I’ll take my chances.”

I’ve been automatically billed $49.95 every month since, and this is what my speed looks like this morning:

🥺 Why can’t we have nice things?

Big cable companies suck. Big cable companies burned hundreds of thousands of dollars to stop Longmont’s municipal broadband.

In 2005, Comcast and CenturyLink rammed through the egregious Colorado SB-05-152, prohibiting municipalities in the state of Colorado from offering telecommunication services.

Longmont had to hold two referendums on the measure—one in 2009, which failed, and another in 2011, which passed:

In 2009, “No Blank Check Longmont” (Comcast/CenturyLink) spent $250,000 to dash our dreams of municipal broadband. They framed it as a choice between fast internet vs. police and firefighters.

In 2011, “Look Before You Leap Longmont” (Comcast/CenturyLink) spent $300,000 urging us to rethink our municipal broadband plans. They stood in lone opposition to our unanimous city council and our local paper.

Comcast spent $500,000 in a tiny city of less than 100,000 people. You can be sure, Comcast will do all this again in a heartbeat.

📓 Lessons

Rather than use their vast resources to improve their service, Comcast will spend big to ensure they never have to compete.

Let Longmont be a lesson. In 2011, Longmont won because it formed an honest citizens’ advisory group: Longmont’s Future. Longmont’s Future got the word out about the vote on Facebook, its website, and the local press.

And ever since, Longmonsters (that’s right—Longmont’s demonym is “Longmonster”) have chosen NextLight over competing services.

Real competition won. Fuck Comcast. Long live municipal broadband.

My Home Assistant Music Cube

2022-03-28T00:02:13Z

Last year, I spent $17 on an Aqara cube, and it’s been one of my best purchases for enjoyment per dollar spent.

I control my multi-room audio using a gyroscopic gesture-recognition cube -- yes, this basically makes me Iron Man.

The Aqara cube is a three-inch square plastic cube that sends gestures over Zigbee to a cheap off-the-shelf dongle.

By pairing this cube with Home Assistant, I have a three-dimensional button with 45 unique interactions to control whatever I want.

And over the last six months, I’ve used it to control a small fleet of antiquated streaming devices to help me discover new music.

🎭 The Tragedy of the Logitech Squeezebox

The Logitech Squeezebox is a bygone streaming device that was too beautiful for this world. Logitech snuffed the Squeezebox in 2012.

But because others share my enthusiasm for Squeezeboxes, there’s still hope. The second-hand market persists. And there are wonderful nerds cobbling together Squeezeboxes from Raspberry Pis.

I built a DIY Squeezebox from a Pi Zero Pimoroni PirateRadio kit and Squeezelite software.

I blanket my humble abode in music by combining a DIY PirateRadio, a Squeezebox Boom, and a Squeezebox Touch.

My Dockerized Logitech Media Server perfectly synchronizes these three devices. Music from Spotify or WQXR is seamless when you walk from bedroom to kitchen to dining room.

Home Assistant is ✨magic✨

Home Assistant is open-source home automation software, and it’s the only IoT software I don’t find myself screaming at regularly.

And, of course, there’s a Logitech Squeezebox integration for Home Assistant. The integration lets you use Logitech Media Server’s (somewhat esoteric) API to control your devices from Home Assistant.

I also use a community-made Home Assistant Blueprint that automates each of the cube’s 45 unique gestures.

Currently, since my mental stack is tiny, I only use four gestures:

Shake: Turn on all players, and start playing a random album from Spotify (that’s right, album – I’m old enough to yearn for the halcyon days of Rdio).
Double-tap: Turn off all players.
Flip: Next track.
Twist: Twist right for volume up; twist left for volume down – like a volume knob.

🧐 Why would anyone do this?

In a 2011 article, “A Brief Rant on the Future of Interaction Design,” Brett Victor describes touchscreens as “pictures under glass.” I loathe pictures under glass.

It’s impossible to use a device with a touchscreen without looking at it. And touchscreen interaction is slow – traversing a menu system is all point-and-click, there are no shortcuts.

Another alternative is control via smart speakers – devices literally straight out of a dystopian novel.

While the smart speaker is the closest thing to a ubiquitous command-line interface in everyday use, I’m too weirded-out to have a smart speaker in my house.

I’ve opted for a better way: shake a cube and music appears.

The cube is a pleasant tactile experience – shake it, tap it, spin it – its a weighty and fun fidget toy. Its design affords instant access to all its features – there is no menu system to dig through.

The cube is frictionless calm technology and it’s behaved beautifully in the background of my day-to-day for months.