
Today I learned about Bash [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), a convenient way to generate multiple command arguments without repeating yourself.

It's especially handy when creating sibling directories:

```bash
mkdir /some/path/{a,b,c}
```

Which expands to:

```bash
mkdir /some/path/a /some/path/b /some/path/c
```

It also works nicely when renaming something without retyping the directory:

```bash
mv /some/path/{c,d}
```

Which expands to:

```bash
mv /some/path/c /some/path/d
```


2026-05-01


[`gitleaks`](https://github.com/gitleaks/gitleaks) catches secrets before they become "oh $%#!" commits.

Use `gitleaks detect --source . --verbose` to scan an entire repo, or `gitleaks protect --staged --verbose` in a pre-commit hook to scan only staged changes.

You can make it a global git hook for all repos:

```bash
mkdir -p ~/.githooks

# Note: this will overwrite any existing ~/.githooks/pre-commit
cat > ~/.githooks/pre-commit <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

if command -v gitleaks >/dev/null 2>&1; then
  gitleaks protect --staged --verbose
else
  echo "gitleaks not found; skipping secret scan"
fi
EOF

chmod +x ~/.githooks/pre-commit
git config --global core.hooksPath ~/.githooks
```

Insurance against those "oh $%#!" moments when you accidentally stage an API token.


2026-04-04


Today I learned about [Devbox](https://github.com/jetify-com/devbox) — it uses Nix under the hood to give you per-project, isolated development shells without having to learn Nix itself.

```bash
curl -fsSL https://get.jetify.com/devbox | bash
cd your-project
devbox init
devbox add nodejs@20 python@3.12 just
devbox shell
```

You declare tools in a `devbox.json`, run `devbox shell`, and you're dropped into an environment with exactly those versions — no containers, no VMs, no system-wide installs. Exit the shell and your system is unchanged.

I've always wanted an excuse to use Nix for local development and this is it. 400,000+ packages, pinned versions via a lockfile, and zero Nix code required.


2026-03-10


Today I learned there is a lorem ipsum CLI you can install via homebrew.

```bash
brew install lorem
```

```bash
$ lorem --spook -n 10
Asset csystems BATF Blowpipe Soviet South Africa wire transfer. NSA
```

How handy is that?


2025-11-25


Today I learned that you can upgrade your local golang version using `go env`. You can do this by writing to go's environment key=value store like so: `go env -w KEY=VALUE`.

```bash
go env -w GOTOOLCHAIN=go1.25.4+auto
# then run to apply
go version
go: downloading go1.25.4 (darwin/amd64)
```


2025-11-15


## 🕸💍

Today I learned some new(to me) native html elements via this [post](https://harrisonbroadbent.com/blog/cool-native-html-elements/).

It led me to discover [the IndieWeb Ring project](https://indieweb.org/IndieWeb_Webring). Which I've now added to my blog.
Have a look and [discover something new!](https://xn--sr8hvo.ws/random)


2025-06-27


Did you know that you can use [`closest`](https://developer.mozilla.org/en-US/docs/Web/API/Element/closest) to find an element's nearest ancestor that matches a specific selector (including the element itself, which it checks first)?

```jsx
;<article class="post">
  <div class="content">
    <h1 class="title">hello</h1>
    <div class="cta">
      <p>call to action</p>
      <button id="button">click me</button>
    </div>
  </div>
</article>

const button = document.querySelector('#button')
// Find the nearest article ancestor
const article = button.closest('article')
// Find the nearest element with class 'content'
const content = button.closest('.content')
```

There is also [matches](https://developer.mozilla.org/en-US/docs/Web/API/Element/matches) for checking if an element matches a selector. This is useful for conditional logic based on element properties.

```js
const button = document.querySelector("#button");

// Check if the button is inside an article
if (button.closest("article")?.matches(".post")) { ... }

// Check if the button itself has specific classes
if (button.matches(".cta button")) { ... }
```


2025-05-09


Today I discovered `go doc <type|func|pkg>`; a useful tool for learning about the Go standard library or anything in your own project.

```shell
go help doc
```

```shell
# Example 1: Standard library function
go doc json.decode

package json // import "encoding/json"

func (dec *Decoder) Decode(v any) error
    Decode reads the next JSON-encoded value from its input and stores it in the
    value pointed to by v.
...

# Example 2: Your own project
cd path/to/project/types
go doc HomePageAsset
...
type HomePageAsset struct {
	NotionFiles []notionapi.File `json:"notionFiles,omitempty"`
	UUID        string           `json:"uuid,omitempty"`
	Type        string           `json:"type,omitempty"`
	Files       []File           `json:"files,omitempty"`
	Align       string           `json:"align,omitempty"`
	Width       int              `json:"width,omitempty"`
}
```

I don't do as much Go development these days but I always enjoy finding new tools in Go's standard tooling. Unlike some languages that require external tools or web browsers to access documentation, Go's approach of embedding documentation in the command line makes the development experience more efficient. This is especially helpful when working offline or when you need quick reference.

There is also [`godoc`](https://pkg.go.dev/golang.org/x/tools/cmd/godoc) for serving your own documentation.


2025-04-19


**[2026.10.17] Update**: Thanks to Peter for writing in to correct my first example, where I had omitted the trailing `\n`. I confirmed the correct output using [this YAML formatter](https://aarrange.com/yaml-formatter).

---

In YAML synxax, `|` means "literal block scalar", which produces a multiline string with no special formatting

```yaml
run:
  command: |
    npm run dev
    npm run test
```

translates to:

`npm run dev\nnpm run test\n`

The cool one I learned about today is `>-`, a "folded block scalar". It preserves line breaks as spaces (folding them into a single line). The `-` modifier tells YAML to "chomp" (remove) any trailing newlines at the end of the block.

### Example YAML

```yaml
services:
  postgres:
    image: postgres
    restart: always
    options: >-
      --health-cmd pg_isready
      --health-interval 10s
      --health-timeout 5s
      --health-retries 5
```

translates to

```shell
... --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
```


TIL