llimllib's notes

otter.nvim

2024-02-21T19:33:23Z

https://github.com/jmbuhr/otter.nvim/
https://github.com/jmbuhr/otter.nvim/blob/main/doc/otter.nvim.txt

Otter.nvim provides lsp features and a code completion source for code embedded in other documents

When messing around with Observable Framework I really missed having code completion available in the markdown docs you end up writing.

Setting up otter.nvim lets me do autocompletion inside fenced code blocks in markdown documents.

It's not perfect, because often you are writing javascript inside HTML inside the markdown block, and that doesn't work, but it's a pretty big improvement with a reasonably low cost.

Here's what it looks like, editing a plot inside a javascript code block in a markdown document:

It was reasonably easy to add it to my vim config: commit 1 commit 2

Okay, color spaces

2024-02-21T15:43:40Z

https://ericportis.com/posts/2024/okay-color-spaces/

Lovely 3d interactive visualizations of color spaces, in this case with a responsive 2d slice of the color space displayed beside it

The first attempt at “it” (a perceptually-uniform color space) was made by Albert Munsell, who described his space in 1905 (charmingly, as a “COLOR TREE”) and published an “Atlas” to it in 1913.

The central “trunk” of Munsell’s TREE goes from black at the bottom, through grey in the middle, to white at the top. The middle expands outwards into a rainbow of “branches”, with each angle around the trunk representing a particular hue. Each branch starts off desaturated near the middle, and gets more and more saturated the further out it goes.

But – tragically! – CIELAB isn’t exactly perceptually uniform. Worse, the more experiments people did, the clearer it became that no three-dimensional space could ever be perceptually uniform; three dimensions just cannot capture all of the weird and wonderful ways that our eyes and brains process color comparisons.

Thankfully – turns out! – Oklab was explicitly designed so that movement up/down, in/out, and around the L axis works exactly like navigating Munsell’s COLOR TREE. Each type of movement changes just one, psychologically-independent thing: the lightness, chroma, or hue of the color. In order to navigate Oklab like this, we need to use a polar coordinate system, instead of a rectangular one. When we do, we refer to the space by another name: OKLCH

OKLCH color picker

2024-02-21T15:43:40Z

https://oklch.com/#70,0.1,307,100

via a link from Okay, color spaces, which explains what the OKLCH color scheme is and how it came to be, as well as why you might want to use it.

Babel - RF Kuang

2024-02-21T15:43:40Z

Robbery, butchery, and theft – they call these things empire, and where they create a desert, they call it peace.

Pike on dependencies, Knuth on software

2024-02-21T14:52:28Z

if you look at almost any significant open source project you will see hundreds, even thousands of dependencies in the fully realized import tree, dependencies that are never checked, updates that are never verified as safe. Essentially no one maintains their dependency tree as they should, because it is infeasible to do so. We have built a machine that cannot be fixed.

Rob Pike

Somebody below that toot links to this 2008 interview with Knuth. Some excerpts:

the idea of immediate compilation and "unit tests" appeals to me only rarely, when I’m feeling my way in a totally unknown environment and need feedback about what works and what doesn’t. Otherwise, lots of time is wasted on activities that I simply never need to perform or even think about. Nothing needs to be "mocked up."

...

Let me put it this way: During the past 50 years, I’ve written well over a thousand programs, many of which have substantial size. I can’t think of even five of those programs that would have been enhanced noticeably by parallelism or multithreading. Surely, for example, multiple processors are no help to TeX.[

...

literate programming is certainly the most important thing that came out of the TeX project. Not only has it enabled me to write and maintain programs faster and more reliably than ever before, and been one of my greatest sources of joy since the 1980s—it has actually been indispensable at times. Some of my major programs, such as the MMIX meta-simulator, could not have been written with any other methodology that I’ve ever heard of. The complexity was simply too daunting for my limited brain to handle; without literate programming, the whole enterprise would have flopped miserably.

...

I also must confess to a strong bias against the fashion for reusable code. To me, "re-editable code" is much, much better than an untouchable black box or toolkit. I could go on and on about this. If you’re totally convinced that reusable code is wonderful, I probably won’t be able to sway you anyway, but you’ll never convince me that reusable code isn’t mostly a menace.

(emphasis mine)

How I write HTTP services in Go after 13 years

2024-02-20T17:34:53Z

https://grafana.com/blog/2024/02/09/how-i-write-http-services-in-go-after-13-years/

Lots of useful production experience with golang services distilled into a blog post.

Especially interesting to me that they have changed their own pattern to not making server structs; my own pattern does do so.

Money - Barrett Strong

2024-02-20T15:09:03Z

Woke up this morning with this song stuck in my head.

The first single from Barry Gordy's first record label (Tamla) in 1959, you're probably more familiar with the Liverpool version released a few years later in 1963:

Wikipedia linked me to this pretty hilarious new wave version from 1979 by The Flying Lizards:

In defense of simple architectures

2024-02-20T15:00:51Z

https://danluu.com/simple-architectures/

for most kinds of applications, even at top-100 site levels of traffic, computers are fast enough that high-traffic apps can be served with simple architectures, which can generally be created more cheaply and easily than complex architectures.

It's interesting that he argues that a Kubernetes-backed app running graphql is a "simple architecture"; I'm not disagreeing but it reinforces to me that what "simple" means is extremely context-dependent.

"Simple" often means "things that are reasonably common knowledge on our team".

A corollary of that is that, by education and practice, you can change what it means for something to be simple! Simple is what you do, and what you do is what's simple as long as it's well understood.

If it's not well understood, by which I mean that deep understanding of the system is either not present at all, or not well-distributed among your team, then that's what complexity is.

brace expansion

2024-02-20T14:21:00Z

https://matttproud.com/blog/posts/tip-shell-brace-expansion.html
https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html

brace expansion is the name for the bash syntax often used for something like listing what files to prettify:

prettier *.{js,jsx,ts}

the article above gives some neat usages of it, I especially hadn't considered that you can use it to make a cartesian product of expansions:

$ echo {a,b,c}{1,2,3}{α,β,γ}
a1α a1β a1γ a2α a2β a2γ a3α a3β a3γ b1α b1β b1γ b2α b2β b2γ b3α b3β b3γ c1α c1β c1γ c2α c2β c2γ c3α c3β c3γ

You can use a variable in a brace expansion:

$ ext=md; ls *.{$ext,js}
CHANGELOG.md       README.md          babel.config.js    jest.config.js     migrate.js*        postcss.config.js  tracing.js

as far as I know, however, you can't do brace expansion on an array, which is unfortunate. I'd love to be able to say:

extensions=(js jsx md ts tsx)
prettier *.{${extensions[@]}}

but that doesn't work: *.{js: No such file or directory

jql

2024-02-18T19:19:33Z

https://github.com/yamafaktory/jql

Another jq or jp-like json query tool, with another new syntax.

Seems to be going for faster and simpler than either jq or jp.

Paying people to work on open source is good actually

2024-02-16T22:05:45Z

https://jacobian.org/2024/feb/16/paying-maintainers-is-good/

I have some minor quibbles, but I largely agree. Unfortunately because of the phrasing of the post I don't feel comfortable sharing my quibbles, the author (whom I respect and have talked to, for what it's worth) hasn't left any room with their tone for productive disagreement.

Lime Garden - One More Thing

2024-02-16T19:19:46Z

fun pop-rock album:

jq

2023-10-20T13:54:09Z

https://stedolan.github.io/jq/

Great tool for filtering, formatting, and outputting json.

A bit cryptic though.

The manual is complete but not very thorough: https://stedolan.github.io/jq/manual/
There's a lot more information on the wiki: https://github.com/stedolan/jq/wiki/jq-Language-Description
Good intro article: https://earthly.dev/blog/jq-select/
I like that article better than the bit I wrote for work: https://gist.github.com/llimllib/84a4345e87c5bc0758597c2052cbc680

jq appears to be largely unmaintained at this point, which is sad

update: jq is alive again!
convert json to csv, something I modified from stack overflow:

cat some.json | jq -r '(map(keys) | add | unique) as $cols | map(. as $row | $cols | map($row[.])) as $rows | $cols, $rows[] | @csv'

JBOL is a collection of jq modules you can install. this is an example of some of the powerful stuff you can do with jq, I understand very little of it

Find every package.json file in a monorepo (using fd), and update the react version in dependencies or in peerDependencies, if it exists:

#!/usr/bin/env bash
# update react in all package.json files
#
# To install dependencies on a mac:
# brew install fd jq sponge

dep='if .dependencies.react != null then .dependencies.react = "^18.2.0" else . end'
depDom='if .dependencies."react-dom" != null then .dependencies."react-dom" = "^18.2.0" else . end'
peerDep='if .peerDependencies.react != null then .peerDependencies.react = "18.x" else . end'
peerDepDom='if .peerDependencies."react-dom" != null then .peerDependencies."react-dom" = "18.x" else . end'

for p in $(fd package.json --exclude bower_components); do
    jq "$dep" "$p" | 
        jq "$depDom" | 
        jq "$peerDep" | 
        jq "$peerDepDom" | 
        sponge "$p"
done

EffVer

2024-02-16T14:01:14Z

https://jacobtomlinson.dev/effver/

EffVer follows the same pattern of incrementing numbers to communicate with users that SemVer does, and is forward and backward compatible with SemVer (you don’t need to use something like a Python version epoch to switch between the two schemes). The difference is that instead of quantifying the orthogonality of a change EffVer tries to quantify the intended work required to adopt the change.

In a world where somebody relies on every observable behavior of your program, there's no sense in trying to guess if you've broken backwards compatibility or not.

I think this scheme captures the reality of semantic versioning pretty well, and doesn't promise what it can't deliver. Fun idea.

clack

2024-02-16T03:11:37Z

https://github.com/natemoo-re/clack
https://www.clack.cc/

Effortlessly build beautiful command-line apps 🪄

@clack/core: unstyled, extensible primitives for CLIs
@clack/prompts: beautiful, ready-to-use CLI prompt components

I just released a render CLI tool today, and it uses a much simpler system for prompts. Possibly I should use this to polish that up.

Found via Observable Framework, which uses it to good effect.