Join the Darn Tough sock cult. ¶

Darn Tough makes merino wool socks prized by hikers, runners, and buy-it-for-lifers because they’re guaranteed for life.

According to my Amazon order history, I ordered five pairs of “Darn Tough Merino Wool Double Cross, No Show Tab, Light Cushion Sock Molten Large” socks in 2016. Today, six years later, I’m wearing a pair of the socks I ordered in 2016, and they’re great.

And in all this time I’ve never used their warranty program, but I decided to try it out on a particularly worn pair—we’ll see how it goes!

About compression socks ¶

Why? Because squeezy is good.

– Peter Sagal, Host of NPR’s “Wait Wait… Don’t Tell Me!”

Compression socks supply support and structure. And it makes them a joy to wear—even when you’re not running.

Initially, compression socks emerged to support circulation in the legs of diabetics. But now savvy runners sport them to capitalize on numerous studies claiming they aid performance and recovery (although who knows what the control is in those studies).

I own two colors of CEP Progressive+ Run 2.0—basic black and caution-tape yellow.

These socks are made of nylon (mostly) which massages my calves, keeping my blood flowing on my recovery days. I’ve owned these socks for years and wear them weekly.

But it’s not all cozy, compressed joy:

• 💸Compression socks are too expensive—mine cost $65 a pair!
• 🧐 The socks come with instructions about how to put them on
• 🛂 You need instructions to put them on

Avoid cotton socks ¶

90% of everything is crap

– Sturgeon’s Law

Most socks are crap for running because most socks are cotton.

But cotton is the wrong material for socks for the same reason it’s the right material for towels. Cotton is absorbent—it holds water and doesn’t release it. The sweat trapped between your foot and your cotton sock can cause blisters while running or hiking.

In contrast, technical socks tend to be made of less absorbent material that dries quickly. So when you sweat, your sweat moves to the surface of the sock and evaporates before it gives you blisters.

I believed blisters were unavoidable—I tossed a roll of Leukotape in my firstaid kit and accepted that I’d use it often. But then I realized the real problem was my cotton socks.

You think about socks every day. ¶

“I don’t want to make decisions about what I’m eating or wearing. Because I have too many other decisions to make.”

– Barack Obama

Mental energy is precious. You should avoid misspending your limited mental energy on your socks.

You could argue writing a blog post about socks is the definition of misspent mental energy. But I believe it’s when you’re spending your mental energy that matters.

If you find yourself bleary-eyed, rooting around for the one good pair of socks in the drawer, then you’re thinking about socks at the wrong time.

Spend your effort up-front.

Declare sock bankruptcy and find a brand of comfortable socks that you can wear in every situation, and then stock up.

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.¹

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).

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

🌠 The More You Know ¶

This is a public service announcement: you’re peeling your sticky notes all wrong.

But you’re not alone; I only learned how to properly peel a Post-It at an in-person offsite in 2015.

As our team worked, we noticed some of our Post-Its were curlier than others. And the curlier Post-Its tended to fall off the wall.

Our facilitator diagnosed our dispair, “If you peel post-its from the side, they don’t curl up.”

🧐 Why this works ¶

3M scientists Spencer Silver and Art Fry gifted the Post-It to humanity.

The Post-It’s magic is its microsphere adhesive, discovered in 1968 by Silver; it affords Post-Its the singular ability to stick and unstick from paper without damaging it.

A Post-It’s easy unstickability is its biggest feature and its downfall.

When you yank a note from the bottom, it curls. That curling is just enough force to lift the note off the paper, the whiteboard, or whatever it’s stuck to.

So the next time you’re slingin’ stickies, just remember: one rule you must abide: always peel a Post-It® from the side.

📍 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 <[email protected]> 1652310544 -0600
committer Tyler Cipriani <[email protected]> 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

Why take notes ¶

During meetings I race to note what’s being said. I don’t often refer back to what I’ve written—I get value from doing the writing itself.

I’m not writing it down to remember it later, I’m writing it down to remember it now

– Field Notes credo

Here’s a bad and sweeping summary of how educational psychologists categorize the purposes of taking notes:

1. Storage – you write things down so you can remember them. Birthdays, websites, movies recommendations—you can refer back to your notes and “remember” with perfect fidelity.
2. Encoding – you write things down to write things down.

Writing things down without ever reading them again can still have value. In a much cited 2014 paper titled, “the Pen is Mightier than the Keyboard,” authors Muller and Oppenheimer concluded students taking notes in physical notebooks had a better understanding of lecture material vs. their laptop-tapping counterparts. The act of writing helped them solidify complicated ideas.

How to take notes ¶

I’ve perused innumerable books and blogs on notetaking, but my system emerged independently. I do a small number of things consistently:

• dates
• lists
• todos
• marginalia

It’s also just a great habit to date every thing you handwrite

– David Allen, Getting Things Done

I start every note with an underlined, left-aligned date in ISO-8601 format. I follow this with a space and a title for the note. Something like “GitLab meeting” or “Hiring roundup” or “Gratitude”—anything I can mentally cling to later.

[The list] has an irresistible magic.

– Umberto Eco, via Der Spiegel

Most of my notes are lists. Lists capture fleeting thought quickly, but are unfit for conveying new and complex ideas—perfect for notetaking.

If I’m noting something I’ll have to do later, I’ll write TODO in all caps and put a square box around it. If I have a highlighter handy, I’ll highlight it, too. Later, I’ll transpose this list item into whatever todo list app I’m using at the moment.

Marginalia describes short notes in the margins, often in the margins of books. I provide ample margins in my notes to jot down questions and thoughts. This is handy in meetings to structure what I’m about to say.

I’ve endeavoured to strip my process until its as simple as I can make it. Complicated systems yield inconsistency—it’s not a system; it’s a mess. I always start with the dumbest system that could work—often it works forever.

Notebooks ¶

I accumulate notebooks I enjoy holding. I get a little thrill when I find a notebook that’s well made.

Notebooks I’ve tried:

My go-to notebook is the Leuchtturm1917 A5, dot-grid, 80g/sqm paper. It’s got an index, page numbers, a little pocket in the back.

But I’d love it if it were more disposable; maybe not quite as disposable as Field Notes, something like the Endless Storyboard Standard notebook with sewn binding.

I’d also love to find any notebook offering the grid pattern of the old SparkFun SFE Project Notebook—reverse grid with a thicker gridline every 8 squares.

I’ve been playing with the idea of making my own notebook. With a UUID for every notebook, page numbers, and a QR code that will let me jump from the page to some digital system.

Here’s what I’ve got so far (it’s a work in progress):