Stefan VanBuren · All Content

Sargable

2026-06-02T08:32:10-04:00

TIL of “sargable” conditions in SQL queries, which just means that an index can be used to speed up the query. One of those “you already know the concept, but the handle is useful” sort of things.

Tangenting

2026-04-26T20:03:30-04:00

Again, not something I learned today, but within the last few weeks: “tangenting”. I read about this in the wonderful Looking At Picture Books Substack, discussing one of my (and Wilhelmina’s) favorites, Goodnight Moon:

Tangenting is something you get yelled at for when you’re in art/design school. The theory is that the edges of things shouldn’t touch closely. You should instead look for large overlaps, so the different objects or elements are clearly divided — if they’re too close it feels badly planned, and harder to tell where one thing ends and the other begins, so they say. Clement Hurd… was SUPER into tangenting.

The whole thing is worth a read, if only for the tangenting discussion.

TK

2026-04-25T19:43:17-04:00

TK means “to come”. You’ll typically see it as “TKTK” or “TKTKTK”, as a simple way to search (i.e., ⌘+f) for details that haven’t been written yet. I use it when drafting blog posts to skip over a sentence or section I want to come back to write later, to avoid losing momentum.

I didn’t learn this today, but within the last year or two (not too sure where!); I was just reminded by seeing it in print¹² in my library’s edition of Jez Burrow’s Dictionary Stories, which is otherwise lovely so far.

To be fair, I get it: it’s in a footnote where the “TK” is taking the place of a page number, which I imagine is one of the last things to be solidified in a print book after all of the typesetting has taken place. ↩︎
Funny timing, but a post on Daring Fireball the day after this one mentioned a similar snafu of printing “Headline Goes Here” – “TK” may have been useful there! ↩︎

`cells` - a language server for CEL

2026-02-22T19:24:55-05:00

This weekend, I built a language server for CEL called cells. It currently supports semantic highlighting, diagnostics, documentation on hover, signature help, references, document highlighting (for variable references), completion, and formatting. CEL is a pretty simple language, so a language server for it doesn’t really need to support things like go to definition or some of the other niceties that language servers typically support. It only works on a single .cel file at a time, which is a filetype currently supported only in neovim nightly but will be supported in neovim 0.12.

Building this out, I brought over some of the ideas that I had integrated when I was building out some of the Buf LSP server at $WORK, like that tests should have separate testdata files so that they could be independently verified by opening up an LSP-powered editor and taking a look at the files themselves. On top of this, making the tests mostly table-based made it really simple for additional test cases to be added.

Of course, building this in a weekend took working with AI (using pi and amp). One thing I had in mind was trying out the other LSP “frameworks” in the go ecosystem; unfortunately, most seem to be pretty unmaintained these days. go.lsp.dev progress has largely stalled, and tliron/glsp was the only other major contender, which seemed to be in a similar state.

At the end of the day, the agent suggested that we ought to just borrow what charmbracelet had down with powernap, and vendor in the gopls protocol code while maintaining the license, and then “write” our own JSONRPC server, based on the sourcegraph implementation, but without the legacy cruft. I may end up upstreaming some of this approach to buf lsp.

I’m not sure how many other LSP features cells needs to be considered “complete”, although I’ll continue to track CEL language features (as it’s still in a pre-1.0 state as a language), and I’d like to add most of the LSP features as functionality in the CLI, similar to gopls’ CLI interface.

cells turned out to be a pretty perfect weekend project for working with agents: LSP is fairly well-specified, with existing patterns, a tight feedback loop, and a great reference library in cel-go.

Fun times to be building things. 👷‍♂️

Neovim `:Inspect`

2026-01-10T16:26:47-05:00

Yesterday, I was working on improving buf’s lsp protobuf semantic tokens, and needed to test out how my changes were working in a real LSP client.

I knew neovim had a couple of helper functions for inspecting the current position; first I tried:

:lua vim.print(vim.inspect_pos())

I figured there must be a function more specifically for semantic tokens:

:lua vim.print(vim.lsp.semantic_tokens.get_at_pos())

But finally I landed on:

:Inspect

(neovim docs)

which prints both treesitter and semantic tokens, but in a much cleaner way than the two lua functions.

I’ve keymapped the underlying vim.show_pos() function to i in neovim for easier access.

Fog of War

2025-11-01T19:45:36-04:00

Growing up playing World of Warcraft (WoW)¹, I became familiar with the concept of “Fog of War” — that is, areas of the world that your character hadn’t visited. Once you moved close enough to a certain area on the map, the fog would “lift”, and that area on your map would be filled in moving forward. Also, you’d gain experience points for clearing Fog of War — at lower levels of the game, you could level-up fairly quickly just by exploring new areas.

I’ll give my brother credit — he was the first to see this as an opportunity for exploration. He piloted his Troll Rogue, Zuljitan, on a journey across the continent of Kalimdor after reaching level 10, the level at which Rogues in those days learned their “Sprint” ability. (We figured we’d need this to escape the various mobs that would attack your character from long distance, being tens of levels above our characters. Rogues also could “stealth”, i.e. become invisible at the cost of movement speed, but mobs at such a large level differential could see through stealth.)

Setting off south from the Crossroads in the Barrens, Zuljitan traipsed through the Thousand Needles down to Tanaris to visit Gadgetzan, I believe he then made his way through Un’Goro Crater to Silithus, then over the mountains to Feralas before ultimately dying for the umpteenth time in Desolace and hearthstone-ing back $HOME.

Although I originally played Horde (a Tauren Warrior), I eventually became drawn to the Gnomes of Ironforge, and ended up on my own journey as the Gnome Rogue, Phread. I liked that Gnomes had an advantage in the Engineering profession, and thought it was neat that I could build goggles for my character at a low level, when most headgear in the game was at that time for levels 40+ (of the original level-cap at 60).

The plan was hatched: this time, on Azeroth, I’d need to make my way across the sea to Gadgetzan to get the schematics I was looking for. Phread’s journey was a little easier: taking the Deeprun Tram from Ironforge to Stormwind, he headed south through Elwynn Forest, Westfall and Duskwood down to the far south of Stranglethorn Vale’s Booty Bay, where he could catch the ship to Steamwheedle Port and continue onwards to Gadgetzan. I bought my schematic (I think?), and hearthstone’d $HOME.

Not quite Stranglethorn Vale

I’m now about 20 years removed from my WoW-playing days (wow!), but I’ve managed to find a new way to clear Fog of War: CityStrides. CityStrides is an app that lets you keep track of the streets that you’ve run (or walked, or biked) in a city. Once you’ve run an entire street (by completing all the “nodes” along it), it’s added to your completed list. Each city has a leaderboard of users ranked based on the percentage of streets they’ve completed.

I managed to make my way through 25% of Boston’s ~4,400 streets before we moved to Ipswich in late January. Ipswich has only 356 streets at the time of writing. (The smallest “city” I’ve run, Sunfield, MI, has 18 streets — running 5 of them during a 5k over 10 years ago has resulted in me being the #1 (of 1) runner there on CityStrides.) Before the move, I had nearly run 20% of Ipswich, mostly by running the various roads out on Great Neck and Little Neck. I made it my goal during paternity leave to finish as many streets in Ipswich as possible (thanks to a loving, supportive wife and a relatively reasonably well-behaved baby), hoping to possibly make it to 100% before my leave ended.

I’ve been meaning to write this for a couple months since paternity leave ended, but hadn’t quite had the gumption to get this finished. I haven’t finished the 100% I was hoping to get to: instead, I’ve been stuck at 80% for most of the summer. The remaining streets are all 5+ miles away from my typical starting point of our home, and are largely in areas that I’d classify as unfriendly to running. I’m now slowly restarting my quest for 100% (VanBurens are box checkers, after all), with an eye towards finishing by the end of the year. I remain, for now, 2nd out of 506 on the Ipswich CityStrides leaderboard.

Running the Streets

Still, it’s not about reaching 100%: it’s about understanding the area in which you’re living at a deeper level, and looking closely at things (although, maybe not when cars are screaming past you as you try to traipse down some of the unfriendly roads). Clearing the Fog of War, if you will.

🌄

We used to drive our parents crazy on weekends — we had a single shared WoW account, so the first of us to wake up would scurry quietly downstairs to log on. We each could play for an hour at a time before it was the others’ turn, so when the other eventually woke up, we’d always say that we had “just started playing 5 minutes ago” to claim our full hour. ↩︎

Neovim `:InspectTree` Tree-sitter

2025-09-10T19:50:36-04:00

I had assumed that to interact with Tree-sitter in Neovim, you still needed to use the utilities from nvim-treesitter. Apparently that’s not the case — Neovim has had a builtin :InspectTree command that brings up the AST from Tree-sitter in a split window, which is scrollbound to the original window and highlights the selected node in both windows.

It also has a query editor, which I haven’t yet had the need for, but it’s good to know it exists.

WikiGnome

2025-09-02T09:10:30-04:00

TIL about WikiGnomes:

A WikiGnome is a wiki user who makes useful incremental edits without clamoring for attention. WikiGnomes work behind the scenes of a wiki, tying up little loose ends and making things run more smoothly.

Some of the most valuable work can be the tiny changes that leave things in a better place than they were found.

Also, sounds a little like prutsen.

Small Seasons

2025-08-23T14:52:06-04:00

Since moving out to suburban Ipswich from Boston, I’ve been on a “seasons” kick — you know, those things that feel wonderful the first couple weeks they’re here and then eventually drag on until the next one comes along? (Currently waiting patiently for Autumn to get started in New England!)

Pondering my seasons

While I’m more thoroughly immersed in the seasons now than when I was in the city, I still spend a considerable chunk of time computing. Computing isn’t seasonal, unless you make it so.

Since I came across Ross Zurowski’s smallseasons.guide (which details the Japanese concept of sekki, or two-week-ish “seasons” — Ross goes into detail on this and other ponderings in “On Small Seasons and Long Calendars”), I’ve had the iCal humming along in the background, eager for a chance to put it to use.

We’ve had our first hint of Autumn weather this last week, and I saw my opportunity. Fall supposedly starts on September 21st around the equinox (and then lasts until December 21st 🙄), but everyone knows this is a hoax. Autumn actually starts much earlier: August 8th, based on the sekki. I configured neovim to change between echanovski’s mini{spring,summer,autumn,winter} colorschemes based on the change of the small seasons, and similarly updated my site’s

s and favicon to follow suit.

Just a little thing to keep me grounded in the seasons, despite the indoor setting, along with our morning stroller walks!

🍂

P.S.: Another way I’ve found to mind the seasons is to update my Living Worlds app on the first day of each month, as a reminder of the passing time.

Wrapping arrays in `jq`

2025-08-20T08:55:08-04:00

Riffing on Tom MacWright’s “Using super” post from yesterday, I saw the post and immediately thought of using jq.

I thought I might get what he was looking for with my initial attempt, something like:

$ pbpaste | jq '.[].name'
"ALGOLIA_API_KEY"
"AMAZON_AWS_ACCESS_KEY_ID"

… but that left out the wrapper array. I figured I might need some other jq function or pipe, but instead I found that you can just wrap the entire expression in square brackets to wrap the result:

$ pbpaste | jq '[.[].name]'
"ALGOLIA_API_KEY"
"AMAZON_AWS_ACCESS_KEY_ID"

Regardless, jq feels worth the investment, especially given the community (and alternative implementations) built up around it.

Internet Phonebook

2025-07-07T18:16:22-04:00

I was lucky enough to be included in the inaugural Internet Phonebook, in the “Atmosphere” section on p. 22 — I’m number #58 if you’d like to Dial-my-site.

I ordered a copy to peruse for myself, and lo and behold, I had forgotten that I had submitted on a whim. Probably the first and last time a link to this little site of mine will appear in print. Still, glad to be included in, and support, this grand directory of the poetic web.

Neovim LSP Defaults

2025-07-01T16:33:55-04:00

neovim released v0.11.0 a little while back, and in the interest of using the defaults, I removed some of my LSP-related keymaps that are now automatically mapped. These are listed at :help lsp-defaults.

Postgres `citext` type

2024-08-21T07:49:04-04:00

TIL about the Postgres citext type (that is, case-insensitive text type), from reading this schema.

Based on this tip from the Postgres docs, this might not be the right type for general text:

Consider using nondeterministic collations (see Section 24.2.2.4) instead of this module. They can be used for case-insensitive comparisons, accent-insensitive comparisons, and other combinations, and they handle more Unicode special cases correctly.

… but if you’re storing something like a username or email address that’s already limited to an ascii-ish character set, and want to keep things unique on a case-insensitive basis, it might be what you’re looking for.

Go Pass by Value or Pointer

2024-08-18T19:09:03-04:00

I’ve long struggled with the choice of how to pass around Go values, specifically structs. I was happy to find this article on the topic, specifically the conclusion, reproduced here:

Types that are not structs or arrays should be passed by value.

Struct types that don’t export their members and are clearly built as immutable value types, like time.Time, should be passed by value. Note that these types are relatively rare, and are even rarer to be defined by you.

Arrays and all other struct types should be passed by pointer, whether small, large, stateful, or whatever.

If you’re passing data that could be mutated by a concurrent process and its important to you for that data not to be mutated, explicitly make a copy of it before passing it along. Be aware that you can’t just rely on passing the data by value since that does not create a deep copy.

I’ll be referencing this moving forward, and taking the guesswork out of my passing conventions.

HTML datetime duration

2024-07-13T10:18:24-04:00

Last week I learned that an HTML datetime attribute can represent a duration.

For example:


  4 hours, 18 minutes and 3 seconds

The syntax is an ISO 8601 Duration.

GBrowse to another branch with Fugitive.vim

2024-07-11T08:28:24-04:00

Last week, I watched a coworker bring up a file on a different branch using fugitive.vim’s :GBrowse and I was floored: almost daily I find myself using it to open the URL to a file to share (or a few lines).

However, much of the time I’m working on a different branch than the one I want to share, and navigating to the same file on a different branch in the GitHub UI takes too many steps. First, you realize you’re on the wrong branch, then you change branches, then you have to navigate back to the file again.

I had always been vaguely aware of :h fugitive-object, but had never put them to use.

The object you’re looking for is :%, meaning: bring up this file (%) on branch .

For example:

:GBrowse main:%

And of course, this just works with all of the :GBrowse variants.

Neovim nfnl Directory Configuration

2024-05-31T08:16:19-04:00

I’ve long wanted to figure out how to get nfnl's directory-local configuration working, but it took me until yesterday to figure it out — mostly by opening a discussion and then realizing my mistakes. 🤡

First, exrc needs to be enabled. This will ultimately load the contents of the generated .nvim.lua file, as described in :help 'exrc'

Next, create an .nfnl.fnl file in the directory. I’ve been creating mine as:

;; .nfnl.fnl
{:source-file-patterns [:.nvim.fnl]}

… which means that nfnl only needs to compile the .nvim.fnl file into .nvim.lua.

From there, I create a .nvim.fnl file with my configuration. Often this is to set up a particular project-local formatter or linter with conform or nvim-lint, so it may look something like:

;; .nvim.fnl
(let [conform (require :conform)]
  (set conform.formatters_by_ft.json [:prettier]))

With this I’ve been able to remove a few $WORK specific formatters.

Lastly, I’ve globally gitignored these files so they aren’t accidentally committed. It’s possible to commit the .nvim.lua files to share with other neovim users that have exrc enabled, but I doubt I’ll use that very often — I’m still undecided on if I’ll commit these for my personal projects.

📁

Git Stash File(s)

2024-05-24T07:39:46-04:00

This isn’t something I’m just learning today, but I’ve looked this up enough to warrant writing it down.

I’m often working on some code, and come across something unrelated that I want to change. So I do — but it really doesn’t belong in this commit or PR/patch/etc.!

(I’ve yet to put in the reps to understand worktrees or jujutsu, which I’m assuming are the “real” answers here.)

For now, you can provide git stash push a filename (or multiple!) to come back to those changes later:

$ git stash push

I’m sure there’s also a way to do this incrementally with -p or Fugitive’s interface.

📦

Smart Speed

2023-12-30T18:00:27-05:00

My Overcast settings screen shows the following:

Smart Speed has saved you an extra 949 hours beyond speed adjustments alone.

That’s a lot of time. I’ve been using Overcast to listen to podcasts since it launched, with years now of what-I’d-call “heavy” podcast listening. I’ve spent most of that time listening on 1.5 or 2x speed, with smart speed always turned on (after all, who can resist number-go-up).

I recently read Keenan’s “Hot Take: It’s okay if we don’t consume all of the world’s information before we die”, and then subsequently also listened to the audioblog version. While listening, I turned off Smart Speed, and it really struck me the difference that I’d been missing all this time. It’s not as though I didn’t intuitively know that the audio was sped up, but there’s something different about listening to people talking to each other without pauses.

For one, you might assume that the speakers are more intelligent: they never need to consider their responses, as they’re always immediately responding. In a similar vein, there’s no context clues as to what one person said that made others on an episode take time to consider - which might be important than something that can be responded to immediately. And of course, as Keenan mentions in his post, for the producers that do edit their audio, using Smart Speed removes the potential to appreciate the pauses as they occur, whether they’re within conversation or somewhere else.

Back to Keenan’s audioblog, you can clearly hear this listening to the end of the podcast as he slows down for emphasis towards the end.

All of this is much better articulated by Simon Sarris in his thoughts on audiobooks, where he notes:

Listening is a skill … Generally the pacing of nearly all media has quickened. Possibly the delivery of “more, faster” is the result of a too-great respect for novelty as an artistic flourish.

Clearly, none of this is groundbreaking - but reconsidering using Smart Speed has been a nice change of pace.

🐢

App Defaults

2023-11-14T18:17:01-05:00

Inspired by https://defaults.rknight.me, here are my current defaults:

Mail Client: Mail.app
Mail Server: Migadu
Notes: Drafts
To-Do: Things
iPhone Photo Shooting: Camera.app
Photo Management: Photos.app
Calendar: Calendar.app
Cloud File Storage: iCloud Drive
RSS: NetNewsWire (client) + Feedbin (server)
Contacts: Cardhop
Browser: Safari
Chat: Messages
Bookmarks: Pinboard
Read It Later: Instapaper; transitioning back from Reeder’s read-it-later
Word Processing: n/a
Spreadsheets: n/a
Presentations: n/a
Shopping Lists: Grocery
Meal Planning: Drafts / Mela
Budgeting and Personal Finance: n/a
News: Hacker News / lobste.rs / text.npr.org
Music: Spotify / Doppler
Podcasts: Overcast
Password Management: 1Password

Also see my /uses page for other hardware / software!

Style Guide

2023-02-01T19:48:30-05:00

Inspired by Louie Mantia’s CSS for This Blog, I figured I’d publish the page I use locally for testing out how my CSS looks.

It’s over at /style-guide (source) and it’s basically a dump of the markdown tab on bryanbraun.com/poor-mans-styleguide. A great, simple way to see the various styles for most everything on the site.

November Review

2022-12-02T12:08:30-05:00

A quick retrospective on my November Goals post:

Run 80 miles

I fell a little short here, running just 58 miles for the month. But it was busier than I gave myself credit for: a trip to see friends and being on call for two straight weeks made things a bit tricky. I should still be in good shape to get to 1000 miles for the year, which would likely be the most I’ve clocked in a year, ever.

No drinking during the week (except Thanksgiving!)

Mostly good! I might have had ~two days where I went out with friends during the week for a beer (or several), but overall was contained to weekends and Thanksgiving. Going to keep things going into December!

Update 2022-11-03

2022-11-03T16:13:21-04:00

I’ve been a little hesitant to write here, for whatever reason. Haven’t had the gumption to write, I suppose. So I’d like to start up a bit of a habit — call it a “reverse New Years resolution”: I’d like to write something here (either a blog or TIL) each day until the end of 2022.

s/each day/each week

A bit too much, I think, to post each day. But I’m glad to have started up the habit of thinking about what to write again, even if it’s inconsequential.

Service Wrappers

2022-11-01T18:54:05-04:00

TIL of Service Wrappers a technique I’ve used in the past but have never had a name for. It’s essentially an approach to wrapping external APIs. From the article:

Methods should be named in the language of the service, not the language of the app.

Arguments should use the domain of the service, not the domain of the app.

Arguments should be whatever type is directly needed by the service, so passing in complex stuff like Active Record should be avoided.

The return value should not be a complex object from the third party, but ideally only what data a caller will need (often nothing at all). If it must be a complex object, its name or properties should be in the domain of the service.

The article is written from a Rails perspective, but is broadly useful — always nice to have a name for something useful!

Blair Witch

2022-10-31T08:10:13-04:00

Watched “The Blair Witch Project” last night as a bit of a pre-Halloween treat. Two thoughts:

Some movies are just better in theaters.
(Maybe related!): The bar for “scary” has gotten higher in the last 20 years.

Either way, worth the watch. Just don’t read the Wikipedia page first, and pay attention — the found-film effect can be jarring.

Reading the Web

2022-10-29T09:48:31-04:00

I’ve spent a decent amount of time tweaking my … “system” for reading articles and blogs on the ’net that I figured I’d jot down what I’ve tried, and what’s currently working for me.

I currently use two separate but related tools for reading the web: a feed reader, and a “read later” app. My first feed reader was Google Reader until its untimely demise, followed by a long while of using newsbeuter to intermittently follow feeds. And for “read later”, I started with Instapaper, close to the time it was initially released.

Eventually, I stumbled on Feedbin, which has hosted my feeds ever since. Feedbin is great for many reasons, including: muting feeds; the autogenerated email address for newsletters; the friendliness and speed of the interface. But I’ve never used it as a primary client for actually reading my feeds — I’ve always preferred a native client over a web client where I can get one.

And thus, to start with: Reeder.app. Reeder was my go-to feed reader since at least Reeder 3, and it paired nicely with Instapaper.

I stuck with this setup for a long time. Eventually, though, I had ended up with too many saved articles in Instapaper. I tried splitting things out into folders to make “Home” more manageable; eventually, I settled on a “Long” folder that was for anything that Instapaper deemed to be over a “10 minute read”, and everything else was left in “Home”.

I eventually declared bankruptcy on Instapaper, for a few reasons, not least of which involved Instapaper being primarily web-based (at the end, I could feel the latency of talking to the server to interact with the app at all, despite Instapaper’s “native” apps).

Next, I switched over to Reeder’s built-in “read later” feature, which let me send articles over to a more permanent archive, where they wouldn’t be cleared out after having been opened. This was great — using the same app for both “triaging” the feed and also for reading longer articles. It helped, too, that Reeder is a beautiful and thoughtfully designed app.

But the reading experience wasn’t without bugs: for longer articles, if I switched away from the app while reading, it would very regularly lose my place in the article. And with the app being developed by a single person (as far as I know) with seemingly most of their focus on their new (similarly fantastic) recipe app Mela, I wasn’t sure things would get fixed in the near future.

After trying out a few alternative clients, I settled on NetNewsWire (NNW). NNW feels native. And simple. It’s free and open source (still (reasonably) actively developed), and has apps for both macOS and iOS. Truly Mac-assed.

NNW doesn’t have a “read later” feature, but/and I’ve come to like that: I now only use Reeder as a “read later” app, and send articles to it from NNW. And funnily enough, the extra bit of friction of not having a keyboard shortcut to send to Reeder’s “read later” (instead, needing to use NNW’s share menu) has kept me from adding too many articles, and makes me more considerate of what I add to my “read later” queue.

Anyway — I wouldn’t call this setup perfect, but it’s been working out well for me over the past year or so since I’ve adopted it. Feedbin (feed sync and management) → NNW (client) → Reeder (read later).

One important caveat in this whole setup: I only use the macOS version of NNW, even though there’s an iOS version, because I like to keep the number of “inboxes” and consumption opportunities on my phone to a minimum. I’ll talk about that more in a later post!

November Goals

2022-10-28T20:00:30-04:00

Setting some November goals a little early:

Run 80 miles

I set a goal of 500 miles this year — I’m already at 864 miles for the year, most of which I ran in the early summer. I’d really like to pass 1000 for the first time in a long while, and if I’m not at 950 by December, I can tell I’m not going to make it. 20 miles a week should be reasonable, given that I was getting up to 30-40 during the summer.
No drinking during the week (except Thanksgiving!)

I’d like to drink a bit less — with the ramp up on running, and an on-call shift or two coming up, I’ll be avoiding drinking during the week, up until the holiday later on next month.

Grease the Groove

2022-10-27T19:51:21-04:00

I’ve been a little hesitant to write here, for whatever reason. Haven’t had the gumption to write, I suppose. So I’d like to start up a bit of a habit — call it a “reverse New Years resolution”: I’d like to write something here (either a blog or TIL) each day until the end of 2022.

Grease the Groove, they say. Don’t worry about who’s reading (certainly not many!), and write like I’m writing to one person.

We’ll see how it goes.

Go’s fmt package Explicit Argument Indexes

2022-06-24T15:59:17-04:00

Not sure how I hadn’t seen this before: in Go, you can specify the index of the format argument you want to use for each formatting verb.

Simply enough, from the package docs:

fmt.Sprintf("%[2]d %[1]d\n", 11, 22) // => "22 11"

In the past, I’ve actually done something along the lines of:

s := "test"
fmt.Sprintf("%s %s", s, s) // => "test test"

Instead, you can do:

s := "test"
fmt.Sprintf("%[1]s %[1]s", s) // => "test test"

This came up today at $WORK while providing a table name to a constructed SQL query - the table name needed to be supplied multiple times in an upsert, so we could simply do:

query := fmt.Sprintf(`
INSERT INTO %[1]s (...) VALUES ($1, $2)
ON CONFLICT (...) DO UPDATE SET ... = %[1]s.(...) WHERE %[1]s.(...) = $2;
`, tableName)

Instead of needing to supply tableName three times, it could be supplied once using %[1]s.

SQLite Connection Configuration

2022-04-02T10:54:44-04:00

These notes are basically cribbed from Ben Johnson’s excellent “Building Production Applications Using Go & SQLite” GopherCon talk, specifically the “Configuring SQLite” section.

Generally speaking, you’ll want to set three PRAGMAs on each SQLite connection:

PRAGMA journal_mode = WAL;
PRAGMA busy_timeout = 5000;
PRAGMA foreign_keys = ON;

In turn,

PRAGMA journal_mode = WAL; sets the database into WAL journaling mode. Unlike the others, this doesn’t necessarily need to be set on each connection; once a database is in WAL mode it’ll stay in that mode across database connections. WAL journaling mode is recommended for most SQLite server applications, because it makes writers not block readers.
PRAGMA busy_timeout = 5000; sets the busy_timeout to 5000 milliseconds (5 seconds). Without this setting, if a write transaction is running, and another write transaction starts, the second write transaction will fail immediately.
PRAGMA foreign_keys = ON; turns on SQLite’s foreign key support. Foreign Keys aren’t enabled by default in SQLite for historical reasons, but foreign keys are great for maintaining data integrity. So – use them!

Update(2024-06-30): A more complete discussion of these settings and more can be found over at kerkour.com/sqlite-for-servers

Shell in Markdown

2022-01-28T16:23:20-05:00

For a long time, I’ve used commandline as the name for the syntax of code fences in markdown whenever I’ve wanted to denote a shell command or session.

I’ve now realized that I’ve been using the wrong name, and also that there are two separate scenarios to keep in mind:

The first scenario is one-off commands, which should use the syntax sh, or shell. This would be showing something you’d enter directly at the command line.

For example:

brew install git

I leave out the command prompt, because it’s implied by the context that the line is to be entered in a command line. Also, it helps with copy-paste.

The other scenario is showing a shell session, which typically shows the command prompt, an entered command, and the response to the command. In this instance I’d use the console, or sh-session syntax.

For example:

$ git st
?? content/til/markdown-shell.md

🐚

PostgreSQL and jsonb type casts

2022-01-19T18:30:21-05:00

Found a bug in one of our systems at work that deals with jsonb data stored in Postgres today. The quick summary is that one of our systems was looking for the maximum numerical value of a jsonb integer in a table.

A very simplified example:

SELECT
  max(balances)
FROM
  unnest(ARRAY[
    '{"balance": 7}'::jsonb->>'balance',
    '{"balance": 17}'::jsonb->>'balance'
  ]) as balances

This returns 7, because while the “balance” field is a numeric JSON value, the ->> operator turns the value into text! — which makes the comparison a lexicographical one.

Instead, you need to make sure to cast the values before comparing:

SELECT
  max(balances)
FROM
  unnest(ARRAY[
    ('{"balance": 7}'::jsonb->>'balance')::integer,
    ('{"balance": 17}'::jsonb->>'balance')::integer
  ]) as balances

Which returns the expected 17.

PostgreSQL IN versus ANY

2022-01-11T08:40:46-05:00

I still feel rather new to PostgreSQL, and a few times now in Go I’ve tried to do something along the lines of:

type pgdb struct {
	db *sql.DB
}

func (db *pgdb) getEntityByID(ctx context.Context, ids []string) ([]Entity, error) {
	query := "SELECT * FROM entities WHERE entities.id IN ($1)"

	rows, err := db.db.QueryContext(ctx, query, pq.StringArray(ids))
	/// ...
}

But the query would always fail or retrieve no rows. I’ve always fixed it by switching the IN $1 for a = ANY($1), but never quite understood why.

Researching this a bit more today, I realized that the IN function takes a list of literals, whereas ANY is an array function that takes a single array literal. Thus, when I’m passing a pq.StringArray, it only works with the array function.

I found this out going through lib/pq’s issues, finding this issue with this comment explaining the difference quite well, which also pointed to a simpler case where this comment cleared things up for me.

Go’s package fmt %q verb for strings

2021-09-23T10:00:45-04:00

I wasn’t aware of the Go fmt package %q verb, for quoting strings. Typically, I’ve been escaping the quotes manually and using the %s verb:

fmt.Sprintf("this needs quoting: \"%s\"", "input")

But the %q verb obviates the need for that manual quoting.

From the package documentation:

%s the uninterpreted bytes of the string or slice

%q a double-quoted string safely escaped with Go syntax

And a quick example (on the Go Playground):

package main

import (
	"fmt"
)

func main() {
	test := "I'm a test string"

	fmt.Printf("\"%s\"", test)
	// Output: "I'm a test string"
	fmt.Println()
	fmt.Printf("%q", test)
	// Output: "I'm a test string"
}

Seven GUIs

2021-09-10T12:29:17-04:00

Recently I polished up and published my seven-guis project. It’s an implementation of the 7GUIs “GUI Programming Benchmark”, written in ClojureScript and Reagent.

It’s not quite complete - there are 7 tasks, and I finished all except for the last one (the spreadsheet - the most vaguely specified and open-ended, and the most difficult). I’ll finish it down the road, but for now I’ve hosted it at seven-guis.vanburen.xyz, and the source code is public, at github.com/stefanvanburen/seven-guis.

Go Templates Whitespace

2021-08-31T18:41:20-04:00

When writing HTML templates in Go, knowing about the whitespace modifiers is crucial for keeping both the templates and the output HTML looking good.

For example, if you had the following template, with .SomeText being "foo" and .Something being true:


  
  {{ if .Something }}
  Text
  {{ else }}
  Image
  {{ end }}
  
  {{ .SomeText }}

The actual output HTML would look something like:

 Text  foo

Which isn’t what you want, because there’s extra spaces — both around “Text” and around “foo”.

Instead, you could do:


  
  {{ if .Something }}
  {{- Text -}}
  {{ else }}
  {{- Image -}}
  {{ end }}
  
  {{- .SomeText -}}

to get

Textfoo

Which makes both the source code and HTML nice and neat.

Uses

2021-08-16T21:28:11-04:00

I’ve added a new uses page, detailing my personal computing setup. I’m hoping to make it more prose-like in the future, but for now it lists my current most commonly used hardware and software.

`time.Ticker` in Go

2021-05-21T20:25:49-04:00

The time.Ticker type in Go is incredibly useful for situations in which polling is needed.

The easiest way to use the Ticker is via the time.Tick function, which just provides access to the ticking channel, which makes it easy to range over:

package main

import (
	"fmt"
	"time"
)

func main() {
	for currentTime := range time.Tick(time.Second) {
		fmt.Println("current time: ", currentTime)
	}
}

For more control, time.NewTicker works wonders — there’s no better example than the one from the docs!

`run` vs `errgroup`

2021-05-11T10:38:26-04:00

I typically don’t do much with concurrency in Go, but messed around this morning with both oklog/run and sync/errgroup.

I’ve defaulted to using oklog/run in the past, but I realized that while they have similar interfaces, they’re useful for different things:

oklog/run is useful for long-running processes.
- think starting up http servers alongside other components, and waiting for one to finish, in which case all other components are signalled to finish.
sync/errgroup is useful for short-lived, parallel processes.
- think units of work to be done in parallel, where one process resulting in an error should stop the entire computation.

Use `jq` to see if a JSON key exists

2021-04-22T11:11:03-04:00

I’m constantly using jq to deal with JSON via the CLI.

Today I needed to figure out the difference between a key existing with a null value or not existing at all in a bit of JSON.

By default, “querying” a key via jq will return null whether the key exists and is null, or the key doesn’t exist:

△ # NOTE: the following is in fish, but should be straightforward to port to other shells

△ set json '{"test": null}'

△ echo $json | jq .test
null

△ echo $json | jq .nonexistent
null

Instead, you can use the jq’s has function to determine the difference:

△ echo $json | jq 'has("test")'
true

△ echo $json | jq 'has("nonexistent")'
false

New Domain

2021-04-16T21:07:47-04:00

A quick domain update:

svbn.me -> stefan.vanburen.xyz

and to match, an email address update:

me@svbn.me -> stefan@vanburen.xyz

Will hold on to the old domain for awhile, so it should still work, but most things are being redirected.

Hiccup Makes Writing HTML Fun

2021-03-21T19:48:36-04:00

At $work, I’ve been writing a web application that is server-side rendered via Go’s html/template package.

I’ve been writing a toy application in Clojure with a similar approach: server rendered HTML with Tailwind for styling and AlpineJS for a hint of interactivity.

With the introduction of Go’s new embed package in 1.16, I was tempted to port the application to Go. I was imagining being able to embed the templates and assets in a static binary.

And I could still do that! But I hesitated as soon as I reached the portion of rewriting my templates in Go, and for good reason: Go’s template syntax isn’t great, and Clojure has Hiccup.

Hiccup #

Hiccup is a library for writing HTML in Clojure. Writing HTML in Hiccup is a dream:

Unlike HTML, Hiccup automatically closes tags.
Hiccup doesn’t require that you remember the proper way to close an HTML element.
Hiccup has shortcuts for adding an id or class attributes.

And, more than anything, Hiccup is written within your regular Clojure functions, which makes it incredibly easy to interweave logic with your templates.

in Hiccup might look like this:

[:form {:action "/add-address"
        :method "POST"}
  [:label {:for "label-input"} "Label"]
  [:input {:type "text"
           :id "label-input"
           :name "label"
           ;; for now, label is required
           :required true}]

  [:label {:for "street-input"} "Street"]
  [:input {:type "text"
           :id "street-input"
           :name "street"}]

  [:label {:for "city-input"} "City"]
  [:input {:type "text"
           :id "city-input"
           :name "city"}]

  [:label {:for "state-input"} "State"]
  [:input {:type "text"
           :id "state-input"
           :name "state"}]]
;; …

The beauty begins when you start to weave in the logic:

(def disabled-classes "text-gray-500 …")

(defn button
  [id classes disabled?]
  [:button {:id id
            :class (if disabled?
                     (merge classes disabled-classes)
                     classes)
            :disabled disabled?}])

In this way, Hiccup is similar to the JSX syntax while writing React — and this approach has been taken to the ClojureScript side via the Reagent library. (A more thorough example of Reagent-style Hiccup code can be found in my seven-guis project).

And, when you pair Hiccup with Parinfer + Conjure, the DX is too good to pass up. While I love writing Go, the conciseness, simplicity and the REPL of Clojure have drawn me in. It’s magical.

🪄

`font-variant-numeric`

2021-01-24T12:55:27-05:00

I was reminded of the font-variant-numeric CSS property by Jim Nielsen, here, and ended up using it in a similar way for the dates on my list of blog posts.

For context, without tabular-nums enabled, numbers on this site look like this:

0123456789

And with it enabled, they look like this:

0123456789

At least on Apple platforms, where the system sans-serif font is San Francisco, the “0” and “1” characters have a little additional spacing, making them equal size to the rest of the digits.

Glad to get this changed — the previous look was somewhat off-putting, now that I look at it in comparison. There are so many neat CSS properties nowadays for all sorts of typographical situations.

Misusing go’s `fmt.Sscanf`

2020-11-09T08:12:09-05:00

Recently I was building a new website in go at $work and needed to do some URL parsing to grab some expected parameters in the URL. The URL was expected to look something like the following: /path/:id1/:id2, where I was trying to grab id1 and id2 out of the URL.

In the past, I’ve done something along the lines of:

splitPath := strings.Split(r.URL.Path, "/")

// error handling, etc.

// splitPath is ["", "path", ":id1", ":id2"],
// because of the way `strings.Split` works
id1 := splitPath[2]
id2 := splitPath[3]

However, I had come across the following code, from the source code of builds.sr.ht:

var (
	jobId int
	op    string
)
_, err := fmt.Sscanf(r.URL.Path, "/job/%d/%s", &jobId, &op)

fmt.Sscanf? Haven’t seen that in use often! But it seemed like a great fit for the exact problem I was solving.

So, I tried it:

var id1, id2 string
matchCount, err := fmt.Sscanf(r.URL.Path, "/path/%s/%s", &id1, &id2)
if err != nil {
	fmt.Printf("err: %s, match count: %d\n", err, matchCount)
	fmt.Printf("id1: %s, id2: %s", id1, id2)
} else {
	fmt.Printf("no err, id1: %s, id2: %s", id1, id2)
}

Here’s a slightly modified version on play.golang.org.

Spoiler: here's the output.

rams.vim

2020-09-15T16:38:18-04:00

A quick update: I’ve put the repository in maintenance mode, and started work on a neovim colorscheme based on the same colors. The end goal is to have a generalized colorscheme that can be exported for use elsewhere.

I published the vim colorscheme I’ve been using for the last few months publicly on GitHub. It’s called rams.vim, after the German Designer, Dieter Rams.

I had the idea for the colorscheme after watching Gary Hustwit’s Rams. It’s simple: off-black, off-white, a grey and an accent color (a medium-bright red). I also added a green and red that are specifically for showing diffs in vim.

The colorscheme is generated via vim-colortemplate, which aided the creation greatly — I have no previous experience with vim colorscheme creation, and based on the other colorschemes I surveyed, it seemed like one of the few sane ways to get an idea up and running quickly.

I’m quite happy with the colorscheme as is — I’ve been using the light colors for a couple months now. The dark mode could use some work, but I’m not using it regularly, so I’ve been mostly keeping it in sync with the light variant. I’ve also added some plugin-specific highlights for the obvious candidates (ALE, fugitive / gitgutter), but haven’t explored all of the plugins I kept around after my dotfile purge.

If you’re a vim user, give it a try, and let me know what you think!

small

2020-07-29T19:24:11-04:00

I was browsing through my GitHub repositories the other day and noticed small, a CLI tool I started working on about two years ago to convert text. I finally polished up the repo and published it for all to see.

It’s really not much, but it gave me a chance to think about the expected behaviors associated with a tool like small. In particular, support for being piped ($ command | small) is a critical bit of playing nice with other UNIX-y tools.

Anyways, it was fun getting it out there.

$ small -h
USAGE
  small [FLAGS] [TEXT...]
  command | small [FLAGS]

FLAGS
  -h         print this help message
  -l         list transform types
  -t=TYPE    specify transform type

$ small "here's some text!"
ʜᴇʀᴇ'ꜱ ꜱᴏᴍᴇ ᴛᴇxᴛ!

🤖

prutsen

2020-06-11T21:24:16-04:00

I recently learned of “prutsen”, a Dutch word meaning “to fiddle around”. In a lot of ways, I think it encompasses a lot of how I approach some of my computer diversions.

For example, this website, at the time of writing, has 135 commits on it. With a total of five published posts, and most of my posts being written within a commit or two, much of the work being done on this site is cosmetic. For example, tweaking CSS indentation or ensuring the RSS feed contains the entire content of the post.

Likewise, my dotfiles sit at a healthy 910 commits currently. I recently went through a bit of a dotfile purge that added quite a few of those, but in general, tweaking my dotfiles has been a hobby for the better part of a decade.

Prutsen gives me a name for all this tweaking and fiddling — so cathartic!

💆

Update: After this post I truly could not remember where I had found “prutsen” in the first place. I finally found it: Do Inhabit, by Sue Fan and Danielle Quigley.

From the book:

This Dutch word translates loosely to doing something of very little significance that only looks like work, or tinkering.

Page 11, Do Inhabit

Good to know where it originally came from!

`git pull --autostash`

2020-05-13T19:11:09-04:00

I’ve recently moved from a largely merge commit based git workflow to a squash and merge based one. Learning to flex my git rebase muscles has been refreshing, and I’m enjoying the cleaner git log that results.

As part of the workflow, I’ve changed my git pull to default to rebasing on pull, rather than merging (the default). The only thing that’s rough about this workflow is whenever I have local changes, git pull will fail, telling me that I have unstaged changes:

$ git pull
error: cannot pull with rebase: You have unstaged changes.
error: please commit or stash them.

To work around this, I’d typically do a compound shell command (I’m using fish — you would typically do this with && in bash):

$ git stash; and git pull; and git stash pop
Saved working directory and index state WIP on main: 79911a7 chore: Remove gemini
Already up to date.
On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git restore ..." to discard changes in working directory)
        modified:   content/blog/git-pull-autostash.md
        modified:   content/blog/small.md

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (2ecce561c9bbd9cf222848d4b225a49edb816bb2)

I recently discovered the solution to needing this: git pull --autostash! It automatically stashes your current working directory and re-applies it after the pull.

$ git pull --autostash
Created autostash: a14af18
Current branch master is up to date.
Applied autostash.

This option is so handy for my workflow that I made an alias for it.

🥳

Spring Cleaning

2020-04-18T08:11:33-04:00

Spring is in the air! Inspired by Deletion Day, I’ve been tidying up some of my physical and digital life. I’ve deleted old accounts, removed applications that I’m not using, and gotten rid of extraneous hardware. But, the cleanup I’m most proud of is my dotfiles cleanse.

the purge #

For awhile, I was a bit of a dotfiles packrat. I worried that the knowledge I had gained — the choices I had made — would be lost to the depths of time if I were to remove them from the text of the files themselves. That meant old color schemes, old key bindings, old tips and tricks, all stayed in their respective places. Perhaps moved around, but not deleted. Over the years, this meant that my vimrc had bloated up to ~1600 lines! I had also accumulated a lot of files for tools I’m no longer using, that were strewn all over my system.

I finally reached a breaking point, removing the cheat tool. There was nothing wrong with it, but I wasn’t using it as often as I thought. I used this as momentum to move on to my other configuration files, mostly my vimrc. Previously, I had been fairly lax on my git hygiene for the repo, using commit messages like “Various updates” or simply a "✨". I knew that removing all that accumulated knowledge meant that I needed to have better practices, so I started using a tool: prefix on my commit subjects, and trying to be better about abiding to atomic commits.

(neo)vim #

~~Now, my vimrc is a lean ~350 lines!~~ Update (August 2022): I’m now fully in on the Lua (actually, Fennel) neovim configuration, so the previous link is invalid. (Maybe not lean for a vanilla vim purist, but it’s reasonable for me!) You’ll also notice that I’ve converted over to neovim fully. I had a number of settings, plugins, and mappings that were working around some of vim’s weirdness, and I was using neovim 98% of the time. I removed all the settings that were the default in neovim and did a lot of :help diving to understand the settings that remained. I also dropped plugins that I used sparingly, some of the filetype specific autocommands, and the sectioning comments used for folding. I’ve added a few plugins back that I wasn’t quite able to shake (notably, I tried to learn vim’s builtin autocomplete commands, but found deoplete to be something I couldn’t avoid using).

XDG Base Dir #

Switching over to neovim meant that I could remove the hacks around neovim finding vim’s configuration directory, and move everything to ~/.config. I could also leverage neovim’s data dir for storing my plugins. Given the neovim changes, I started to look elsewhere where I could move my dotfiles in ~/.config, and managed to get everything except .tmux.conf moved over. This includes my global git configuration, which until now I didn’t realize could be anywhere but ~/.gitconfig and ~/.gitignore!

other configuration #

Alongside the effort to move everything to within ~/.config, I ended up removing language specific configuration (mypy, isort, and flake8 config for Python, profiles.clj for Clojure), tooling configuration (curlrc, editorconfig, vale.ini), old package listings (Brewfile), and unused shell configuration (zprofile, zshenv, and zshrc). Overall, I’ve reduced my dotfiles down to things that I use now.

And it feels great.

🛁

Book Review: Mr. Penumbra’s 24-hour Bookstore

2019-12-26T20:40:50-05:00

Rating: 4/5 ⭐️

Warning: Spoilers below

Mr. Penumbra’s 24-hour bookstore is an amusing and intriguing tale concerning a new clerk at a strange bookstore who uncovers the mysteries of his new place of work. Clay (the clerk and main protagonist) discovers a secret society that his employer is a part of, and seeks to bring the mystery to light.

I came into contact with the title via Robin Sloan’s blog for 2019, Year of the Meteor, which I’ve adored. The assortment of links and life commentary has been wonderful all year, and I’m looking forward to Sloan’s next project.

Overall, the book flowed well and moved quickly; I’m not a very fast reader and made it through in around 5 and a half hours total, largely over the course of two days. The writing included a lot of references for a more technical crowd — or, at least, a crowd familiar with the Silicon Valley startup scene. There were a handful of mentions of Google specific technologies, as well as allusions to computing history.

However, I felt the novel was lacking in the department of having a serious antagonist, and a bit too much feeling of Deus ex machina at the end. The novel’s antagonist, Corvina, had essentially no chance of stopping the protagonists from achieving their goal. Meanwhile, when everything seemed lost after a failed attempt at code-breaking with the entirety of Google’s compute power, and the rest of the novel being largely about the protagonist’s ability to bring together his eclectic set of friends’ talents to bear on the mystery at hand, the story is resolved by Clay on his own.

A feel-good ending was somewhat ruined by the quickness of the last third of the book. But still, I was entertained the entire way, and recommend giving it a read.

`extract` in fish

2019-11-14T10:40:55-05:00

I recently switched from zsh to fish as my shell of choice. I liked the idea of starting from scratch, with the sane defaults that fish provides, as my zsh configuration files were getting a bit out of control.

For the most part, the transition was fairly painless and straightforward. However, I still miss a few of the zsh niceties that I had been used to over the years — one being extract function provided in oh-my-zsh. Even after moving away from oh-my-zsh as my plugin manager in zsh, I had used my new manager to grab just that plugin for my usage.

After a cursory google, it seemed like a fish port of the plugin didn’t exist, so I decided to try to port over the plugin myself. You can find the whole function in my config.fish in my dotfiles.

First, we’ll define a function named extract and give it a description. I’ve also noted in a comment where this function was ported from.

function extract -d "extract files from archives"
    # largely adapted from
    # https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/extract

The function first checks if we have arguments — if we have none, there’s nothing to do, so we’ll echo a usage string to stderr and exit.

    # no arguments, write usage
    if test (count $argv) -eq 0
        echo "Usage: extract [-option] [file ...] " >&2
        echo " Options:" >&2
        echo " -r, --remove    Remove archive after unpacking." >&2
        exit 1
    end

Next, we check to see if the -r / --remove option has been supplied as the first argument. If it is, we’ll remove the archive files after they’ve been successfully unarchived. We also remove this argument so that our main loop can iterate correctly over the filenames.

    set remove_file 0
    if test $argv[1] = "-r"; or test $argv[1] = "--remove"
        set remove_file 1
        set --erase argv[1]
    end

Now comes the main loop, which iterates over the filenames supplied.

    for i in $argv[1..-1]

First, we ensure that the filename arguments are valid files:

        if test ! -f $i
            echo "extract: '$i' is not a valid file" >&2
            continue
        end

We default our success value to 0 — if the file’s extension isn’t something we can deal with, we’ll set this to 1 so that we can avoid removing the file even if the remove option is set. Then, we grab the extension via some fish regex matching, using the string match function.

        set success 0
        set extension (string match -r ".*(\.[^\.]*)\$" $i)[2]

Now, we’ve reached the main switch statement, which is largely a translation of the zsh version’s unarchiving calls to fish.

        switch $extension
            case '*.tar.gz' '*.tgz'
                tar xv; or tar zxvf "$i"
            case '*.tar.bz2' '*.tbz' '*.tbz2'
                tar xvjf "$i"
            case '*.tar.xz' '*.txz'
                tar --xz -xvf "$i"; or xzcat "$i" | tar xvf -
            case '*.tar.zma' '*.tlz'
                tar --lzma -xvf "$i"; or lzcat "$i" | tar xvf -
            case '*.tar'
                tar xvf "$i"
            case '*.gz'
                gunzip -k "$i"
            case '*.bz2'
                bunzip2 "$i"
            case '*.xz'
                unxz "$i"
            case '*.lzma'
                unlzma "$i"
            case '*.z'
                uncompress "$i"
            case '*.zip' '*.war' '*.jar' '*.sublime-package' '*.ipsw' '*.xpi' '*.apk' '*.aar' '*.whl'
                set extract_dir (string match -r "(.*)\.[^\.]*\$" $i)[2]
                unzip "$i" -d $extract_dir
            case '*.rar'
                unrar x -ad "$i"
            case '*.7z'
                7za x "$i"
            case '*'
                echo "extract: '$i' cannot be extracted" >&2
                set success 1
        end

Finally, we’ll remove the original file if we’ve successfully unarchived the file, and end the loop and the function.

        if test $success -eq 0; and test $remove_file -eq 1
            rm $i
        end
    end
end

This was my first experience trying to port a larger function from zsh to fish, and it definitely took some playing around with the various test functions to get it right. Also, the string match functions were largely cobbled together from StackOverflow. I strongly suggest aliasing this function to x, or some other short sequence, for easier usage.

And voilà, we have a working general purpose extraction function, in fish!

🐠

Hello, world!

2019-11-13T14:47:53-05:00

Just an introductory post here, nothing to see.

Stefan VanBuren · All Content

Sargable

Tangenting

TK

cells - a language server for CEL

Neovim :Inspect

Fog of War

Neovim :InspectTree Tree-sitter

WikiGnome

Small Seasons

Wrapping arrays in jq

Internet Phonebook

Neovim LSP Defaults

Postgres citext type

Go Pass by Value or Pointer

HTML datetime duration

GBrowse to another branch with Fugitive.vim

Neovim nfnl Directory Configuration

Git Stash File(s)

Smart Speed

App Defaults

Style Guide

November Review

Update 2022-11-03

Service Wrappers

Blair Witch

Reading the Web

November Goals

Grease the Groove

Go’s fmt package Explicit Argument Indexes

SQLite Connection Configuration

Shell in Markdown

PostgreSQL and jsonb type casts

PostgreSQL IN versus ANY

Go’s package fmt %q verb for strings

Seven GUIs

Go Templates Whitespace

Uses

time.Ticker in Go

run vs errgroup

Use jq to see if a JSON key exists

New Domain

Hiccup Makes Writing HTML Fun

Hiccup #

font-variant-numeric

Misusing go’s fmt.Sscanf

rams.vim

small

prutsen

git pull --autostash

Spring Cleaning

the purge #

(neo)vim #

XDG Base Dir #

other configuration #

Book Review: Mr. Penumbra’s 24-hour Bookstore

extract in fish

Hello, world!

`cells` - a language server for CEL

Neovim `:Inspect`

Neovim `:InspectTree` Tree-sitter

Wrapping arrays in `jq`

Postgres `citext` type

`time.Ticker` in Go

`run` vs `errgroup`

Use `jq` to see if a JSON key exists

`font-variant-numeric`

Misusing go’s `fmt.Sscanf`

`git pull --autostash`

`extract` in fish