memo.forof

So that was cool.

2026-01-06T00:00:00Z

I realized yesterday that GoodReads was spilling my therapy-assigned reading list, SO THAT WAS GREAT! A bit of heat in my face, then deleted my 15 year old account.

Good article of the week -> https://lux-magazine.com/article/privacy-eroticism

Who is attending these conferences???

2025-09-27T00:00:00Z

In this environment of tech-labor melancholy, is anybody actually excited to attend a conference centered on a SaaS? Github Universe, Cloudfare-whatever-their-thing-is-called, etc.

Links #

a very nice read

UX vs. good sense

2025-08-08T00:00:00Z

Just a quick note. I've been living and breathing a lot of UX ideation, and it occurs to me that as apps infiltrate our lives (in both good ways and bad), the UX for apps is increasingly infected by the org-chart.

While doom-scrolling this morning, I saw a rare ad that interested me enough that I clicked on it. The ad was for an audio app designed to help people focus, somehow with "science".

I've tried apps like it before; decent white noise.

During on-boarding, I was confronted with a multiple choice quiz. Later on, when I wanted to try out the "autoplay" feature, another quiz. For an app purportedly designed to help salve a drifting attention span, to inject these quizes before any engagement is a fucking insane UX choice. I can almost imagine the disparate teams making these decisions without ever talking to one another, or considering the overall impression this might make.

Links #

a very nice read

loader v. clientLoader

2025-06-25T00:00:00Z

Scenario: I want to use clientLoader for "snappier" navigation in a #reactrouter application, but still need to check authentication at the route. If authentication is persisted by an HTTP-only cookie, then we can't check it from Request in a clientLoader.

So we'll just call serverLoader from clientLoader, and trust that react-router will take care to reduce the number of fetches per-page-load.


export async function loader({ request }: Route.LoaderArgs) {
  const cookie = request.headers.get("cookie")

  const { isAuthenticated } = await checkAuthentication(request) // checks a cookie
  if (!isAuthenticated) {
    throw Error("User is not authenticated")
  }

  // ...
}

// we can call the server-side loader like so.
export async function clientLoader({ serverLoader }: Route.ClientLoaderArgs) {
  return serverLoader()
}

P.S. It's best-practice to check authentication at every route, rather than rely on a wrapper route/layout.

P.S.P.S

Per react-router documentation, you don't actually need to call serverLoader unless you intend to fetch additional data beyond what loader is already doing, since the framework will automatically dispatch a fetch to the loader on client navigation.

When server rendering, loader is used for both initial page loads and client
navigations. Client navigations call the loader through an automatic fetch by
React Router from the browser to your server.

1password wrecking ball

2025-03-30T00:00:00Z

An app I recently built has a degraded UX due to 1password's browser extension. The extension is very aggressive in auto-filling any form field by rendering a dropdown menu where the user can select a relevant auto-complete. This renders over the top of my auto-complete box.

I've punted on fixing this issue until realizing this make form UX very difficult on small screens.

The fix is to add a data-attr to <input />:

<input data-1p-ignore />

I'll likely need to extend similar fixes for other password managers as well, but 1password's subversion of intended UX is particularly egregious.

Links #

https://developer.1password.com/docs/web/compatible-website-design/

notes from underground

2025-01-20T00:00:00Z

vite #

#vite is the defacto JS bundler now. It contains a useful feature for build-time configuration using environment variables via import.meta.env, by which you can serialize variables that begin with VITE_.

An obvious outcome is that this is build time only, which means that accessing runtime configuration via VITE_ variables is useless if you're building #docker containers to deploy to multiple environments. e.g. a variable called VITE_API, where one might set localhost:123 vs. api.domain.com.

This completely makes sense, but it is a bit of a drag. Call me old-school, but I still think the same artifacts should be deployed across environments, modified by runtime configuration.

trump #

My well of surprise/disappointment/etc is dry-as-a-bone, but I'm still mildly surprised to see the posting optimism about the incoming administration. My primary memory of the last Trump administration is that it ended with Covid, and that Trump dissolved a government function to combat pandemics.

a few snaps

2024-12-30T00:00:00Z

I found this dead crow. The blood-from-the-beak indicates poisoning by rodenticide. A coward's solution.

I saw these while visiting my step-father's grave.

My blind cat, sunning himself.

eslint vs. react-router

2024-12-22T00:00:00Z

Mildly embarrassed thinking about how long I thrashed on this...

After creating a bee-u-tiful #eslint configuration, running it on my project, ensuring it hooked up to my editor etc.

Lint began failing when executed in CI. This left me so completely vexed that I dusted off my Fedora laptop to see if it was some arcane difference between MacOS and Linux.

It wasn't.

I realized that #rr7 needs to generate types before lint runs, or it rightfully explodes.

// package.json
{
  ...

  "scripts": {
    "check:lint": "react-router typegen && eslint .",
  }
}

React Router v7 and Vitest

2024-12-16T00:00:00Z

Wiring up #vitest and #rr7 for tests is not obvious.

Requires a separate vitest.config.ts
Requires createRoutesStub

discord

vitest.config.ts: #

We need a separate vite.config that omits @react-router/dev/vite, and then configures the typical test features.

import react from "@vitejs/plugin-react"
import autoprefixer from "autoprefixer"
import tailwindcss from "tailwindcss"
import { defineConfig, loadEnv } from "vite"
import tsconfigPaths from "vite-tsconfig-paths"

// -----------------------------------------------------------------------------

export default defineConfig({
  css: {
    postcss: {
      plugins: [tailwindcss, autoprefixer],
    },
  },

  // using `@vitejs/plugin-react` instead of `@react-router/dev/vite`
  plugins: [react(), tsconfigPaths()],

  test: {
    env: loadEnv("test", process.cwd(), ""),
    environment: "happy-dom",
    // @NOTE: https://testing-library.com/docs/react-testing-library/setup#auto-cleanup-in-vitest
    setupFiles: ["./vite.cleanup.ts"],
  },
})

A test: #

Now, we need to use createRoutesStub anywhere a component renders anything to do with #reactrouter. Alternatively, we could build a "wrapper" utility, similar to mocking a redux provider, but in practice we'll be passing createRoutesStub to a wrapper utility anyways.

import userEvent from "@testing-library/user-event"
import { Link } from "react-router"
import { createRoutesStub } from "react-router"
import { render, screen, waitFor } from "@testing-library/react"
import { test } from "vitest"

// -----------------------------------------------------------------------------

const Welcome: React.FC = () => {
  return <Link to="/login">Log In</Link>
}

const Success: React.FC = () => {
  return <>you did it!</>
}

test("Welcome screen navigates to /login", async () => {
  const Stub = createRoutesStub([
    { Component: Welcome, path: "/" },
    { Component: Success, path: "/login" },
  ])

  render(<Stub />)

  await userEvent.click(screen.getByText("Log In"))
  await waitFor(() => screen.findByText("you did it!"))
})

React Router v7 actions()

2024-12-13T00:00:00Z

Also known as #remix.

throw from actions will naturally be caught by the nearest ErrorBoundary.
Route.ComponentProps['actionData'] is only useful client-side. Don't spend x-minutes wondering why your console.log insists on being undefined.
Instead of throwing from an action, you can try/catch and return data() with a status: 400.

export async function action({ request }: Route.ActionArgs) {
  const formData = await request.formData()
  const emailAddress = formData.get("email_address")

  if (typeof emailAddress !== "string") {
    throw new Error("Expected a string value, but received a File.")
  }

  try {
    const validEmailAddress = z.string().email().parse(emailAddress)

    await someSideEffect(validEmailAddress) // like authentication

    return data({ ok: true as const, emailAddress }, { status: 200 })
  } catch (error) {
    if (error instanceof ZodError) {
      return data(
        { ok: false as const, emailAddress, error: "validation" as const },
        { status: 400 },
      )
    }

    return data(
      { ok: false as const, emailAddress, error: "unknown" as const },
      { status: 400 },
    )
  }
}

export default function Route({
  loaderData,
  actionData,
}: Route.ComponentProps) {

  // @NOTE: actionData only exists client-side
  return (
    <>
      {actionData?.ok ? (
        <p>hooray!</p>
      ) : (
      <Form method="post">
        <input
          name="email_address"
          placeholder="Email address"
          required type="email"
        />
        <button>submit</button>
      </Form>
      )}
    </>
  )
}

Notes #

I think it is bizarre that react-router documentation uses let everywhere.
It's also weird to throw their redirect from actions. That ain't an error.

mat missive.

2024-12-12T00:00:00Z

a checkpoint #

I received my BJJ brown belt last night.

aside #

I've nothing particularly caffeinated to add to the "discourse" on the subject of measuring the productive output of a software engineer, but I continue to be bemused by the various attempts maximizevalueextraction.biz like DORA, SPACE, DEVEX et al.

Imagine a framework for measuring the delusions of these biz-analysis freaks.

tmux etc.

2024-12-11T00:00:00Z

tmux #

I get weird about multiple tabs and splits in my workflow, and I really like to have the same layout across #tmux sessions.

In the distant-in-dog-years past, I spend too many hours building custom layout templates, etc, but have since given up tmux as a hobby. Now, I just hit prefix and then smash <SPACE> until the layout looks nice enough.

However... When I have a giant screen, e.g. 3840 x 2160, the layouts look weird to me. So, back to scripting:

#!/bin/bash
# $HOME/.config/tmux/big-split.sh

TERMINAL_WIDTH=$(tmux display-message -p "#{window_width}")
TERMINAL_HEIGHT=$(tmux display-message -p "#{window_height}")
PERCENTAGE=70
OFFSET=10
PANE_WIDTH=$((TERMINAL_WIDTH * PERCENTAGE / 100 + OFFSET))

tmux split-window -h -l "$PANE_WIDTH"

Then a small amendment to tmux.conf so that I can set the layout with :bigsplit:

# $HOME/.config/tmux/tmux.conf

set -g command-alias[0] bigsplit="run-shell '$HOME/.config/tmux/big-split.sh'"

The c9 fiasco

2024-11-26T00:00:00Z

These look good, but putting them up sucks.

NextJS, but probably not

2024-11-26T00:00:00Z

Wading back into the JS framework pool. Though I've been building quite a few side-projects recently using a variety of approaches (Deno, Hono, Fresh, etc.), those projects are all to my own peculiar taste.

The calculations change when building an application that someone else is paying for, and particularly if that application needs to be supported long-term by a team of varied skill-sets and expertises. Peril avoided.

The framework du jour is inarguably #nextjs. It's an unavoidable #react-ism, and has to be considered.

But, context. gcp and cloudrun is where this application will be deployed, which is, evidently, hard with NextJS. While there will always be an "ahem, actually", anecdote, blog post, and conversation seem to converge on the point that NextJS just doesn't work as well unless you're deploying to Vercel. This seems doubly reinforced by the existence of shim-projects to leverage bespoke features of NextJS in non-Vercel clouds.

My hesitation also relates to #wordpress, and chaos currently visible in that developer community, due to commercial strong-arming by wordpress.com.

Then there's this.

So I'll be looking pretty hard at react-router v7 instead... Signs point to it working well from gcp.

Chapter, end.

2024-11-14T00:00:00Z

Tomorrow is my last day with my current company. I just want to note that, here.

Late-winter, 2018, only so many people that you could count us with a single hand. Up to much larger headcount, acquisition, and sun-setting.

A job is a job is a job, but I've been in this one chair for long enough that it just has me feeling nostalgic.

postgres.app

2024-11-10T00:00:00Z

If you're using macOS, just use postgres.app - homebrew installations of #postgres are too much heartache.

(or use a containerized postgres)

Be sure to add psql to $PATH in .zshrc or whichever flavor you're using:

PATH="/Applications/Postgres.app/Contents/Versions/latest/bin:$PATH"

hono ohno

2024-11-06T00:00:00Z

A few notes on #hono

If you install hono from jsr, using hono extensions from npm will not work, e.g. @hono/zod-validator.

If you're curling and stuff is weird (validator("json", ...)), probably forgot to add -H "Content-Type: application/json".

Dang, it's already November

2024-11-04T00:00:00Z

...And it's this kind of November. America, an anxiety disorder. Violent backlash almost certain, varietals both comic and tragic.

Something entirely unrelated. eslint version 9.

Upgrading `eslint`, or "make-work" #

I love tooling. #eslint has been ubiquitous for so long, the standard and the standard. But OSS is evolve or die, and sometimes both.

The upgrade path between eslint 8 -> 9 is rocky enough that it simply doesn't look worth the squeeze, to me. For a new project, the choice is obvious (9), but I've had little success using the migration tools.

$ npx @eslint/migrate-config .eslintrc.json

Attempts #

Given the scope of linting configuration, I'm probably better off declaring linter bankruptcy and simply starting over. Yeah, that's it, this is make-work.

// @ts-check

import eslint from '@eslint/js'
import tseslint from 'typescript-eslint'

export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.recommended,
  ...tseslint.configs.recommendedTypeChecked,
  {
    rules: {
      '@typescript-eslint/no-unsafe-assignment': 'warn',
      '@typescript-eslint/no-unused-vars': [
        'warn',
        { argsIgnorePattern: '^_' },
      ],
    },
  },
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  },
  {
    files: ['**/*.js', '**/*.mjs'],
    ...tseslint.configs.disableTypeChecked,
  }
)

Text editing #

Given the advent of mjs and cjs, make sure your tooling recognizes those file extensions when looking for configuration files.

Links #

Beefed-up 5-alarm chili beans, and quick

2024-10-28T00:00:00Z

Wanted cornbread, needed chili. A #recipe.

Convey thyself to the supermarket.
Grab 1 lbs meat, likely beef.
2 cans beans, likely pinto.
4 cans hatch chile. The little yellow cans.
You know what you like. Grab some other chili adjacent ingredients. Probably a white onion for dicing. Tomato paste. You have chili powder at home, yeah? Shredded cheese. Crushed tomatoes or diced, even sauce? No sauce, but get a can anyways. Garlic... A red pepper. So strange that they lock the laundry detergent up now. There's not many people here, this time of night. Get followed around by 3 security guards, conspicuous in their plate carriers.
Allons-y, and mise en place. This is quick chili.
Brown the meat. Freestyle a bit. Various powders and spices.
Tomato paste, into the stew.
Etc. This isn't a soup. Use the too-expensive salt to season.
Forget to prepare the cornbread. This is less-than-quick chili now.

SentryBoy

2024-10-28T00:00:00Z

I've been wondering why my fly machines weren't auto-suspending after I added #sentry to a project. From the logs, I could see / was being requested every second... Smells like a bot.

So I added more logging to catch the user-agent from request headers, and was surprised to see the following:

user-agent: SentryUptimeBot/1.0 (+http://docs.sentry.io/product/alerts/uptime-monitoring/)

I guess #sentry has a new feature (beta) that does a healthcheck on URLs that have thrown exceptions. I need to read the docs more closely, but a GET every second seems a bit excessive. To disable it, I just revised my robots.txt:

User-agent: SentryUptimeBot
Disallow: *

Links #

https://docs.sentry.io/product/alerts/uptime-monitoring

GenServers and Phoenix.PubSubs and Task.Supervisors

2024-10-26T00:00:00Z

I've been looking for an #elixir redux-alike (primarly the event-bus stuff), and have found that Phoenix.PubSub paired with a GenServer and a Task supervisor seems to get the job done.

I did chase a few different constructions, like using Task.start with callbacks, but found that GenServer doesn't have a predicable state when callbacks are executed.

The following is scratched out, as there's opportunity to make it a bit more generic, like sending messages back to the original caller, etc.

objective: Schedule async work that can crash.

defmodule MyApp.Dispatcher do
  use GenServer

  @topic "MY_TOPIC"

  def start_link(_) do
    GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
  end

  def init(state \\ %{}) do
    # subscribe to events emitted elsewhere
    Phoenix.PubSub.subscribe(MyApp.PubSub, @topic)

    # Start a Task.Supervisor
    Task.Supervisor.start_link(name: MyApp.Dispatcher.TaskSupervisor)

    {:ok, state}
  end

  # handle messages sent from dispatched tasks
  def handle_info({:DOWN, _ref, :process, pid, _reason}, state) do
    next = Map.delete(state, pid)

    # broadcast that a task is complete
    PubSub.broadcast(MyApp.PubSub, @topic, {:tasks?, next})

    {:noreply, next}
  end

  def handle_info({_event, %{id: _id}} = msg, state) do
    task =
      Task.Supervisor.async_nolink(MyApp.Dispatcher.TaskSupervisor, fn ->
        # doing something async. It may or may not crash
        # For instance, maybe this does a database write
      end)

    {:noreply, Map.put(state, task.pid, task)}
  end

  def handle_info(_, state) do
    {:noreply, state}
  end
end

Reader modes are insane

2024-10-25T00:00:00Z

I've been fiddling with content extraction using @mozilla/readability. As a data-source, what better candidate than this very-here website, so I made some revisions.

The basic question is "what components must my webpage have in order to trigger reader mode". Surely, this is standardized.

Well... extremely no, it seems. Having done some reading, the best I've come up with is that adding schema attributes won't hurt anything, but the ways in which browser reader modes parse content is highly eccentric. For instance, the following qualifies for reader mode using Firefox, but @mozilla/readability fails to extract a publishedTime.

<article itemscope itemtype="https://schema.org/Article">
  <h1 class="post-title" itemprop="headline">Reader modes are insane</h1>

    <time datetime="2024-10-25" itemprop="datePublished">
      2024-10-25
    </time>

  <section class="post-content" itemprop="articleBody">
    <p>...</p>
  </section>
</article>

Links: #

component libraries

2024-10-23T00:00:00Z

A non-comprehensive list of #component libraries:

elixir-ls bozo-mode

2024-10-22T00:00:00Z

#neovim #elixir formatter got you down? As in, not working no-sir?

Unable to find formatter for /path/to/file.exs:
** (Mix.Error) Formatter plugin Phoenix.LiveView.HTMLFormatter cannot be found

Fix:

$ rm .elixir-ls/build

Links #

neovim messages

2024-10-21T00:00:00Z

#neovim messages are often hard to grab. If you see an error near the status-line, print it out with :messages

docker, nginx, and root

2024-10-18T00:00:00Z

Need #nginx to run as non-root? Just use the unprivileged #docker image.

FROM nginxinc/nginx-unprivileged:1.27.2-alpine
WORKDIR /

COPY ./my-html    /usr/share/nginx/html/
COPY ./nginx.conf /etc/nginx/nginx.conf

Since non-root can't use :80, the above image defaults to :8080, so any nginx configuration will need to reflect that, as well as any other infrastructure, like istio or kubernetes.

# nginx.conf

worker_processes  1;
pid               /tmp/nginx.pid;

events {
  worker_connections 1024;
}

http {
  server {
    listen 8080;
  }
}

Links #

GenServer and concurrency

2024-10-17T00:00:00Z

I've built a GenServer pub/sub to handle async effects from my #phoenix application, but have been wondering how it handles multiple broadcasts. Given that a GenServer processes messages from a queue, how can I concurrently handle those messages.

Answer: by dispatching to Task

defmodule Subscriber do
  use GenServer

  alias Handler

  def start_link(_opts) do
    GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
  end

  @impl true
  def init(_) do
    Phoenix.PubSub.subscribe(MyPubSub, "my-topic")

    {:ok, nil}
  end

  @impl true
  def handle_info(msg, _) do
    # Task.start for fire-and-forget
    Task.start(Handler, :handle, [msg])

    {:noreply, nil}
  end
end

defmodule Handler do
  def handle({:foo, %{url: url }}) do
    # Maybe this is an API request to another service
  end

  def handle({:bar, %{url: url }}) do
    # ...
  end
end

Links #

https://elixirforum.com/t/whats-the-best-pattern-for-a-pubsub-event-listener-genserver-seems-like-the-wrong-choice/35703

robots.txt and AI crawlers

2024-10-16T00:00:00Z

staaaaahp #

Trying a variety of incantations to block the #ai crawlers, though it'll take constant revision. May build a lil' generator for it.

User-agent: GPTBot
Disallow: /
User-agent: ChatGPT-User
Disallow: /
User-agent: Google-Extended
Disallow: /
User-agent: PerplexityBot
Disallow: /
User-agent: Amazonbot
Disallow: /
User-agent: ClaudeBot
Disallow: /
User-agent: Omgilibot
Disallow: /
User-Agent: FacebookBot
Disallow: /
User-Agent: Applebot
Disallow: /
User-agent: anthropic-ai
Disallow: /
User-agent: Bytespider
Disallow: /
User-agent: Claude-Web
Disallow: /
User-agent: Diffbot
Disallow: /
User-agent: ImagesiftBot
Disallow: /
User-agent: Omgilibot
Disallow: /
User-agent: Omgili
Disallow: /
User-agent: YouBot
Disallow: /

#deno install #

Seems deno continues to converge towards v2 node - there's an install command in v2. Will revise some deno.json to see how the lockfiles work in CI.

Links #

On parsing, and also private networks

2024-10-15T00:00:00Z

#fly.io and flycast #

I've been working on some html -> markdown conversions with #elixir. It's been quite tricky to build a general-purpose utility for this, and so I've despaired by deciding to just do it with #deno. This means deploying a small deno app that accepts API requests from an elixir app. I don't want it on the public internet, and fly.io has a pretty simple way to support non-public facing apps that still benefit from fly proxy features, like auto-starting machines.

fly ips allocate-v6 --private

Now, from my other fly machines, I can simply make requests to http://my-fly-app.flycast.

#finch vs ipv6 #

Blurgh, because these requests are on an #ipv6 private network, I had to swap out #finch for #req, as there's no obvious way (to me) by which I can set finch's connection options. I also had to revise the deno app to use :: as a host.

Links #

An Ollama cheatsheet

2024-10-14T00:00:00Z

An #ollama cheatsheet...

Also, I saw a hero trailer on netflix that had obviously been AI dubbed... sounded totally demented.

links #

https://secretdatascientist.com/ollama-cheatsheet/

It's pronounced `queue_target`

2024-10-10T00:00:00Z

#til I mixed up #ecto queue_target for queue_interval

links #

CAPSLOCK IS STUCCCCCCCK

2024-10-09T00:00:00Z

#til how to turn capslock off when I magically get it stuck under #windows:

Ctrl + ALT then Ctrl + k

I am occasionally mired in using an Ubuntu guest with a Windows host. I swap back and forth quickly, and something about the way I type yields a state where capslock is just... stuck... worth mentioning that I remap capslock to ctrl anywhere that I can, so when I get into this state, I can't simply hit capslock.

bigfiles

2024-10-08T00:00:00Z

#vim bigfiles #

#til a sweet lil' hack to disable #neovim plugins and features that might make things sluggish... this has definitely not happened to me 100 times before.

local bigfile = vim.api.nvim_create_augroup('bigfile', { clear = true })

vim.g.bigfile_size = 1024 * 1024 * 1.5

vim.filetype.add({
  pattern = {
    [".*"] = {
      function(path, buf)
        return vim.bo[buf].filetype ~= "bigfile" and path and vim.fn.getfsize(path) > vim.g.bigfile_size and "bigfile"
          or nil
      end,
    },
  },
})

vim.api.nvim_create_autocmd({ "FileType" }, {
  group = bigfile,
  pattern = "bigfile",
  callback = function(ev)
    vim.b.minianimate_disable = true
    vim.schedule(function()
      vim.bo[ev.buf].syntax = vim.filetype.match({ buf = ev.buf }) or ""
    end)
  end,
})

trigger actions on events with `vim.api.nvim_create_autocommand` #

-- vim.api.nvim_create_autocmd({event}, {opts})

vim.api.nvim_create_autocmd(
  -- the event
  "BufWritePost",

  -- the effect
  {
    pattern = "*.js",
    command = "silent! !prettier --write %",
  }
)

organizing autocommands with `vim.api.nvim_create_augroup` #

local myGroup = vim.api.nvim_create_augroup("MyAutoGroup", { clear = true })

vim.api.nvim_create_autocmd(
  "BufWritePost",

  {
    -- the group
    group = myGroup,
    pattern = "*.js",
    command = "silent! !prettier --write %",
  }
)

links #

https://github.com/LazyVim/LazyVim/commit/938a6718c6f0d5c6716a34bd3383758907820c52

head in hand, vmware carnage

2024-10-07T00:00:00Z

#vmware disk going berserker-mode #

Had to tear down my long-lived guest VM today. After bumping to Ubuntu 24 LTS, the disk inexplicably grew to 390gb...

i'd set a disk size... way smaller than 390gb
no snapshots...
no space to triage
corporate security that kills usb
having to virtualize my daily-dev env is, uh... productive

#fly.io, #phoenix & `queue_interval` #

Found a helpful thread for tuning how phoenix will talk to the db, in my case supabase. queue_interval: 500 is pretty long, but seems to help with the machine resume thing...

Emojis

2024-10-04T00:00:00Z

emoji keyboard #macos #

beep beep: Control (⌃) + Command (⌘) + Space

#phoenix minus #tailwind #

I've been deleting most of the default tailwind classes attached to the core components that Phoenix generates. Think I'll start my next #phoenix project with --no-tailwind.

Links #

While parsing markdown...

2024-10-03T00:00:00Z

vim-test #

Using vim-test with #vim, #til how to scroll the :terminal. Just hit <C-o>. Scroll a bit. Then i to get back into insert mode.

On Neovim the "basic" and "neovim" strategies will run test commands using Neovim's terminal, and leave you in insert mode, so that you can just press "Enter" to close the terminal session and go back to editing. If you want to scroll through the test command output, you'll have to first switch to normal mode. The built-in mapping for exiting terminal insert mode is CTRL-\ CTRL-n, which is difficult to press, so I recommend mapping it to CTRL-o:

Enum.find |> Enum.into #

Instead of doing a series of Enum.find across an #elixir list, pipe the contents of the find straight into Enum.into to produce a %{} that's easier to pluck values out of.

list = [
  {
    "img",
    [
      {"alt", "a shadow"},
      {"src", "..."},
      {"width", "792"},
      {"height", "528"}
    ],
    []
  }
]

with {"img", attrs, _} <- Enum.find(list, fn {tag, _, _} -> tag == "img" end),
     %{"alt" => alt, "src" => src} <- Enum.into(attrs, %{}) do
  "![#{alt}](#{src})"
end

supabase and fly.io

2024-10-02T00:00:00Z

#supabase vs. #fly #

Kicking out some toy apps, and fiddling with a #phoenix app deployed to fly.io — they have an alpha integration back to supabase, nice. I don't want to manage #postgres. BUT when my fly machines are suspended, I'll frequently hit an #ecto issue whereby the database times out, and the user is presented with a disappointing "internal server error" screen. Refresh the page, everything is fine...

The internet is a series of tubes. The tubes are clogged when my fly machines are stopped. Guess I'll set fly.toml to always have one machine up. #til

[http_service]
  ...
  min_machines_running = 1

pending... fly.io may have a more bespoke approach for managed postgres soon. Surely there's a way to have these cold-boot machines more quickly connect to supabase.

Remembering that I've forgotten how to type an em—dash #

Option + Shift + Hyphen = lol

etc. #

hamhock/hipbone hambone/legbone

Links #

October, unsurprisingly.

2024-10-01T00:00:00Z

#11ty images #

#til how to use @11ty/eleventy-img on this very blog. It'll slurp media from elsewhere. Also, flickr makes it damn-near impossible to find the static links to your pictures these days. More internet bitrot.

{% image "http://killtheliterate.com/zines/the-grackles-seething/img/helicopter.jpg", "a shadow" %}

Clarifying "ballistics" #

Probably obvious to a lot of people, but given Israel's invasion of Lebanon, and Iran's "preparation" to launch ballistic missiles ostensibly to somewhere within Israel, I wondered "when is a missile not ballistic?". #til the answer is when it's a cruise missile. Ballistic missiles are delivered along (ahem) gravity's rainbow, and cruise missiles are unpiloted kamikaze jets.

devcontainers #

One of the things I've heard about, and chose to ignore. Encountered a #devcontainer (.devcontainer) file after cloning a file, so #til what it actually is. Seems like a pragma for operating an IDE within the context of a container, so that one doesn't have to install all the stuff, e.g. black or prettier or node.

soup beans #

A post elsewhere sent me on a journey learning about pellagra, salmon cakes and therefore #til what soup beans are.

The bees made honey in the lion's skull.

2024-09-30T00:00:00Z

Kicking things off. #til about a few #11ty and #nunjucks incantations. A few observations as well:

MDN is highly involved with nunjucks?
Eleventy feels way behind with regard to modern tooling. esm, type-checking, that sort of thing.
I've immediately collided with the eleventy API. The documentation is not that easy to navigate, and lack of typing means that it's a bit more difficult to interrogate the user-facing API directly.

This all seems a bit odious. However, I'm probably not the target audience for a tool like 11ty (eleventy?). It seems like it has the same core "I'm a big loop" as CMSs I've used before.

To get the following to print, I've had to wrap the fenced block with a nunjucks raw tag.

{#
  nunjucks will render some very strange stuff if you don't do variable
  assignments properly.
#}

{# this #}
{% set hashtags = post.data.hashtagMap | getHashtags %}

{# not this #}
{% set hashtags %}{{post.data.hashtagMap | getHashtags}}{% endset %}

memo.forof

So that was cool.

Who is attending these conferences???

Links #

UX vs. good sense

Links #

loader v. clientLoader

1password wrecking ball

Links #

notes from underground

vite #

trump #

a few snaps

eslint vs. react-router

React Router v7 and Vitest

vitest.config.ts: #

A test: #

React Router v7 actions()

Notes #

mat missive.

a checkpoint #

aside #

tmux etc.

tmux #

The c9 fiasco

NextJS, but probably not

Chapter, end.

postgres.app

hono ohno

Dang, it's already November

Upgrading eslint, or "make-work" #

Attempts #

Text editing #

Links #

Beefed-up 5-alarm chili beans, and quick

SentryBoy

Links #

GenServers and Phoenix.PubSubs and Task.Supervisors

Reader modes are insane

Links: #

component libraries

elixir-ls bozo-mode

Links #

neovim messages

docker, nginx, and root

Links #

GenServer and concurrency

Links #

robots.txt and AI crawlers

staaaaahp #

#deno install #

Links #

On parsing, and also private networks

#fly.io and flycast #

#finch vs ipv6 #

Links #

An Ollama cheatsheet

links #

It's pronounced `queue_target`

links #

CAPSLOCK IS STUCCCCCCCK

bigfiles

#vim bigfiles #

trigger actions on events with vim.api.nvim_create_autocommand #

organizing autocommands with vim.api.nvim_create_augroup #

links #

head in hand, vmware carnage

#vmware disk going berserker-mode #

#fly.io, #phoenix & queue_interval #

Emojis

emoji keyboard #macos #

#phoenix minus #tailwind #

Links #

While parsing markdown...

vim-test #

Enum.find |> Enum.into #

supabase and fly.io

#supabase vs. #fly #

Remembering that I've forgotten how to type an em—dash #

etc. #

Upgrading `eslint`, or "make-work" #

trigger actions on events with `vim.api.nvim_create_autocommand` #

organizing autocommands with `vim.api.nvim_create_augroup` #

#fly.io, #phoenix & `queue_interval` #