Workflows

Workflows described elsewhere:

Most of the functions are in my Emacs configuration.

On this page:

Capture and process thoughts

On the go:

  1. I add the thought as a note in my Inbox.org using Orgzly Revived.
  2. Syncthing synchronizes it with my laptop.

From within Emacs, I use org-capture to save the note to my Inbox.org.

From my web browser, I select the text and use org-capture-extension to save it.

Eventually, I review my Inbox.org:

  • I flesh out some thoughts or delete them.
  • Sometimes I use org-refile to move a thought somewhere.
  • Sometimes I turn something into a blog post right in my inbox.

Read books

The Toronto Public Library has sooooo many books. I rarely buy books since my backlog of borrowable books is pretty much infinite.

Reading e-books:

  1. I like using Libby to read books on my iPad. I highlight interesting quotes and key concepts as I read.
  2. Then I export the book highlights as JSON and format them as Org Mode so that I can add them to my books.org file. This organizes them by chapter.

When I read paper books, I type or handwrite short quotes. If I want to save a long quote and I don't feel like typing it in:

  1. I use the camera on my Android phone to focus on the text.
  2. I use Google Lens to recognize the text.
  3. I select the text and share it with Orgzly Revived.
  4. Syncthing synchronizes my phone with my computer.
  5. When I'm back in Org Mode in Emacs, I copy it to my books.org file.

Once I have the raw notes in books.org:

  • I select quotes to share in Mastodon toots or blog posts.
  • I often make a book sketchnote. Sometimes I draw these as I read the book, and sometimes I do them afterwards.

I have a script to help me manage the three library cards we have. It renews library books and lists the ones I need to return.

NodeJS+Puppeteer script for renewing Toronto Public Library books
const puppeteer = require('puppeteer');
const moment = require('moment');
const process = require('process');
const fetch = require('node-fetch');
const cheerio = require('cheerio');
const readline = require('readline');

require('dotenv').config();

const cards = [{id: '27131039151693', abbrev: 'S', pin: '2669', limit: 50},
               {id: '27131014320362', abbrev: 'W', pin: '2669', limit: 25},
               {id: '27131041984909', abbrev: 'A', pin: '2669', limit: 50}];

var command = process.argv[2];
var threshold = process.env['LIBRARY_THRESHOLD'];
var debug = process.env['DEBUG'];
var today = moment().format('YYYY-MM-DD');
const fs = require('fs');

if (!threshold) { threshold = '2'; }
if (threshold.match(/^[0-9]+$/)) {
  threshold = moment().add(threshold, 'days').format('YYYY-MM-DD');
}

exports.login = async function(page, card) {
  await page.goto('https://account.torontopubliclibrary.ca/signin?redirect=%2Fcheckouts');
  await page.waitForSelector('#userID');
  try {
    await page.click('#userID');
    await page.keyboard.type(card.id);
    await page.click('#password');
    await page.keyboard.type(card.pin);
    await page.click('#form_signin .button');
    await page.waitForNavigation({ waitUntil: 'networkidle2' }).catch(err => {});
    if (await page.$('#sign-out-link').catch(err => {})) {
      return true;
    }
  } catch (err) {
      console.log(err);
  }
};

exports.renew = async function(page, itemIDs) {
  if (itemIDs.length == 0) return [];
  let list = [];
  for (let i = 0; i < itemIDs.length; i++) {
    let selector = 'label[for=item_' + itemIDs[i] + ']';
    await page.waitForSelector(selector);
    await page.evaluate((selector) => {
      document.querySelector(selector).closest('tr').querySelector('button').click();
    }, selector);
    await page.waitForResponse((resp) => resp.url().match(/renewals/)).then(async (res) => {
      let data = await res.json();
      list.push(data);
    });
  }
  return list;
};

function sortByDue(a, b) {
  if (a.dueDate < b.dueDate) return -1;
  if (a.dueDate > b.dueDate) return 1;
  return 0;
}

function summarizeData(card) {
  if (!card.data) { card.data = {}; }
  if (card.data.holds) {
    card.data.readyForPickup = card.data.holds.filter((o) => o.status == 'READY');
  } else {
    card.data.readyForPickup = [];
  }
  if (card.data.checkouts) {
    card.data.checkouts = card.data.checkouts.map((o) => {
      o.abbrev = card.abbrev;
      o.toReturn = (o.dueDate <= ((o.item.format.type == 'DVD') ? today : threshold));
      return o;
    });
    card.data.returns = card.data.checkouts.filter(o => o.toReturn).sort(sortByDue);
  } else {
    card.data.returns = [];
  }
  return card;
}

async function logInAndGetData(page, card) {
  let userData = {};
  const getUserData = new Promise((resolve, reject) => {
    page.on('response', async (resp) => {
      if (!resp.url().match(/rest/)) {
        return false;
      }
      const url = resp.url();
      if (url.match(/charges$/)) {
        let m = url.match(/users\/([0-9]+)\//);
        userData.systemID = m[1];
        userData.charges = await resp.json();
      } else if (url.match(/notifications$/)) {
        userData.notifications = await resp.json();
      } else if (url.match(/holds\/current$/)) {
        userData.holds = await resp.json();
      } else if (url.match(/checkouts$/)) {
        userData.checkouts = await resp.json();
      } else if (url.match(/renewals$/)) {
        let data = await resp.json();
        if (!data?.errorCode) {
          userData.checkouts = userData.checkouts.map((o) => {
            if (o.id == data.id) {
              return data;
            } else {
              return o;
            }
          });
        }
      }
      if (userData.charges && userData.notifications && userData.holds && userData.checkouts) {
        card.data = userData;
        resolve(card);
      }
      return true;
    });
  });
  await exports.login(page, card);
  return await getUserData;
}

async function processUser(page, card) {
  const data = logInAndGetData(page, card);
  card = summarizeData(card);
  if (card.data.returns?.length > 0) {
    let renewals = await exports.renew(page, card.data.returns.filter((o) => o.renewalsRemaining > 0).map((o) => o.id));
    console.log(renewals);
  }
  return summarizeData(card);
}

const checkoutLimit = 50;
function url(item) {
  return 'https://torontopubliclibrary.ca' + (item.url || item.item.url);
}

function formatReport(cards) {
  cards = cards.map(summarizeData);
  let totalPickups = cards.reduce((prev, o) => prev + o.data.readyForPickup.length, 0);
  let totalReturns = cards.reduce((prev, o) => prev + o.data.returns.length, 0);
  let earliestPickup = cards.reduce((prev, o) => {
    return o.data.readyForPickup.reduce((p2, hold) => {
      if (!p2 || hold.readyDateExpiration < p2) {
        return hold.readyDateExpiration;
      } else {
        return p2;
      }
    }, prev);
  }, undefined);
  let otherReturns = cards.reduce((prev, c) => {
    return prev.concat(c.data.checkouts?.filter((o) => !o.toReturn));
  }, []).sort(sortByDue).map(formatCheckout).join("\n");
  let allCheckouts = cards.reduce((prev, o) => prev + o.data?.checkouts?.length, 0);
  let inTransit = cards.reduce((prev, card) => prev.concat(card.data?.holds?.filter((h) => h.intransit).map((o) => { o.abbrev = card.abbrev; return o; })), [])
      .map((o) => `${o.abbrev} ${o.item?.title} ${url(o)}`).join("\n");
  let holds = cards.reduce((prev, o) => prev.concat(o.data?.holds.map((h) => { h.abbrev = o.abbrev; return h; })), []);
  let pickupByUser = cards.map((c) => {
    let space = c.limit - c.data.checkouts?.length || 0;
    let spaceReport = (c.data.checkouts ? ((space > 0) ? space : ' NO SPACE') : 'UNKNOWN');
    let holds = c.data.readyForPickup?.map((hold) => `${moment(hold.readyDateExpiration).diff(today, 'days')} ${hold.item.title} ${url(hold)}`).join("\n") || '';
    let returns = c.data.returns?.map(formatCheckout).join("\n") || '';
    let activeHolds = c.data?.holds?.filter((h) => h.status == 'PENDING');
    return `* ${c.abbrev}: ${c.data.readyForPickup.length} / ${space} - transit ${c.data?.holds?.filter((h) => h.intransit).length} - active ${activeHolds.length} - return ${c.data.returns.length} - checked out ${c.data.checkouts.length}${holds ? "\n** Pick up\n" + holds : ''}${returns ? "\n** Returns\n" + returns : ''}`;
  }).join("\n\n");
  return `* ${today} Total for pickup: ${totalPickups}${earliestPickup ? ' in ' + moment(earliestPickup).diff(today, 'days') : ''} - return ${totalReturns} - checked out: ${allCheckouts}
${pickupByUser}${inTransit ? `\n* In transit\n${inTransit}` : ''}
* Other returns
${otherReturns}
* Active holds
${holds.filter((o) => o.status == 'PENDING').map((o) => `${o.abbrev} ${o.item.title} ${o.queuePosition}/${o.queueLength}x${o.item.circulatingCopies} ${url(o)}`).join("\n")}
`;
}

function formatCheckout(o) {
  return `${o.abbrev} ${moment(o.dueDate).diff(today, 'days')}-${o.renewalsRemaining || 'X'} ${o.item.title} ${o.id} https://torontopubliclibrary.ca${o?.item?.url}`;
}

async function scrapeData() {
  const browser = await puppeteer.launch({ headless: process.env.DEBUG != 'chrome',
                                           args: ['--no-sandbox']});
  for (let card of cards) {
    const context = await browser.createIncognitoBrowserContext();
    const page = await context.newPage();
    await processUser(page, card);
  }
  browser.close();
  fs.writeFileSync('data.json', JSON.stringify(cards));
  return cards;
}

async function search(text) {
  const body = await fetch('https://www.torontopubliclibrary.ca/search.jsp?N=37918+20206&Ntt=' + encodeURIComponent(text)).then((res) => res.text());
  const $ = cheerio.load(body);
  console.log($('.title a').map(function() {
    return $(this).attr('href') + "\t" + $(this).text().trim().replace(' : ', ': ');
  }).toArray().join('\n'));
}

function readTitleIDs() {
  return [...fs.readFileSync(process.stdin.fd, 'utf-8').matchAll(/R=([0-9]+)/g)].map((m) => m[1]);
}

async function requestItems(card) {
  const titleIDs = readTitleIDs();
  const browser = await puppeteer.launch({ headless: process.env.DEBUG != 'chrome',
                                           args: ['--no-sandbox']});
  const page = await browser.newPage();
  const data = await logInAndGetData(page, card);
  await titleIDs.reduce(async (prev, val) => {
    await prev;
    await page.goto('https://www.torontopubliclibrary.ca/placehold?titleId=' + val);
    await page.waitForSelector('#hold-button input');
    await page.click('#hold-button input');
    return await page.waitForNavigation({ waitUntil: 'networkidle2' }).catch(err => {});
  }, Promise.resolve());
  await browser.close();
}

if (require.main === module) {
  (async () => {
    if (command == 'org') {
      writeOrg();
      return;
    }
    if (command == 'scrape') {
       await scrapeData();
    }
    if (command == 'search') {
      await search(process.argv.slice(3).join(' '));
    }
    else if (command == 'request') {
      const abbrev = process.argv[3] || 'S';
      await requestItems(cards.find((o) => o.abbrev == abbrev));
    } 
    else {
      let cards = require('./data.json');
      let report = formatReport(cards);
      if (process.env['ORG_FILE']) {
        fs.writeFileSync(process.env['ORG_FILE'], report);
      }
      console.log(report);
    }
  })();
}

Read blogs

I've been using NetNewsWire on my iPad. It's easy to add new blogs to it with the share command. When I come across an interesting quote, I:

  1. Use the Share menu to open the post in Google Chrome.
  2. Select the text and use "Copy Link with Highlight".
  3. I share the selected text to Ice Cubes for Mastodon.
  4. I format it as a blockquote with > and add quotation marks.
  5. I paste in the URL to the text fragment.
  6. I post the toot.

I set up NetNewsWire to synchronize with FreshRSS in a Docker container. Sometimes I use FreshRSS's web interface on my Linux laptop. I haven't yet figured out how to get elfeed and elfeed-protocol to properly synchronize with FreshRSS via the Fever protocol.

I like using minifeed.net and indieblog.page/all to find new blogs.

Draw my sketches, process them, and write about them

Lately, I've been drawing my sketches using Noteful on my iPad. I use this coloured dot grid as a background.

I use a sketch ID of the form YYYY-MM-DD-NN. The number comes from my journaling system and allows me to uniquely identify the images.

I usually export the current page as an image (JPG) and save it to Dropbox so that it gets synchronized with my laptop. Sometimes if I want to be able to resize, recolour, or animate elements, I'll export it as a PDF so that I can convert it to SVG.

Once I have the image file, I process it using Emacs Lisp. The code is generally in the Supernote section of my configuration. I can open the latest sketch with the sacha-latest-sketch function that checks my ~/Dropbox/sketches and ~/Dropbox/Supernote/EXPORT directories for the latest sketch, or I can just process it directly with sacha-supernote-process-latest. Here's how the code processes the sketch:

  1. sacha-image-recognize: Use Google Cloud Vision to recognize the handwriting and convert it to text. Save the results in a .txt with the same base name as the image file. Alternatively, I can specify the ID with sacha-image-rename-current-image-based-on-id.
  2. sacha-sketch-rename: If the file has an ID, rename the file based on the journal entry with that ID.
  3. Is it an SVG or PDF? (Convert PDFs to SVG using pdftocairo)
    • sacha-sketch-svg-prepare:
      1. Remove backgrounds
      2. Change colour references to hex
      3. Add a solid white background
      4. Change fill attributes to style
      5. Replace colours (useful for converting grayscale sketches from the Supernote)
  4. Rotate and crop as needed.
  5. sacha-image-store: If the file is properly renamed and tagged, store the fileset in my ~/sync/private-sketches directory if it has the private tag, or in my ~/sync/sketches directory otherwise. Syncthing copies the public directory to the server.
  6. Recreate the JSON for sketches.sachachua.com based on the synchronized sketches so that it's available from my sketch viewer.

Once the JSON has been recreated, sketches.sachachua.com/YYYY-MM-DD-NN can redirect to sketches based on their IDs (ex: https://sachachua.com/2025-02-26-06).

sacha-supernote-process-latest also opens the associated .txt file with the converted text. I edit that. Useful shortcuts:

  • M-<up> and M-<down>: move paragraphs around
  • M-S-<up> and M-S-<down>: move lines around
  • M-O: I've mapped this to join-line.

After I correct the text, I usually draft a blog post using sacha-write-about-sketch. This creates an Org Mode subtree in my posts.org file with a reference to the image and a details block that includes the text. I use the custom my_details block I defined using org-special-block-extras so that the text is inside a <details><summary>...</summary>...</details> element.

From there, it's just the usual blog post workflow. After I publish the blog, sachachua.com/YYYY-MM-DD-NN redirects to the blog post instead. (ex: https://sachachua.com/2025-03-26-01)

Sometimes PDFs don't get converted to SVGs properly, so in that case, I need to open them with Inkscape.

Related:

Write a blog post

I draft blog posts using Org Mode in Emacs. I usually start writing them in either my posts.org or my inbox.org.

I like to add lots of links. I have custom Org Mode link types to make it easy to link to blog posts, sections of my Emacs configuration, project files, sketches, Emacs Lisp functions, and more. Then I can use C-c l (which I've bound to org-store-link) to store the link and C-c C-l to insert it.

When I'm ready to post, I use C-c e s 1 1 to export using sacha-org-11ty-export, which wraps around ox-11ty.el.

I use the 11ty static site generator to turn those HTML and JSON files into a blog with reverse-chronological archives, category pages, feeds, and so on.

Here's my rough workflow:

  1. Keep npx eleventy --serve running in the background, using .eleventyignore to make rebuilds reasonably fast. (serve in this Makefile)
  2. Export the subtree with C-c e s 1 1, which uses org-export-dispatch to call sacha-org-11ty-export with the subtree.
  3. After about 10 seconds, use sacha-org-11ty-copy-just-this-post and verify.
  4. Use sacha-mastodon-11ty-toot-post to compose a toot. Edit the toot and post it.
  5. Check that the EXPORT_MASTODON property has been set.
  6. Export the subtree again, this time with the front matter.
  7. Publish my whole blog: (generate-all in this Makefile)
    1. Replace the contents of .eleventyignore file with a shorter one.
    2. Generate the blog.
    3. Update the index using Pagefind.
    4. Rsync to the server.
    5. Restart the Nginx server just in case.
    6. Restore the longer .eleventyignore file so that dev builds are faster.

Adding a comment from e-mail: sacha-message-add-blog-comment

Write my journal entries

  1. Write short journal entries in French using my web-based journaling system.
  2. Use sacha-insert-journal-entries-for-french to insert the entries for the week.
  3. Edit the entries.
  4. Use learn-lang-flycheck-gptel-setup or learn-lang-spookfox-ai-flycheck-send to help me correct the grammar.
  5. Copy the changes back to my web-based journal with https://codeberg.org/sachac/.emacs.d/src/branch/gh-pages/lisp/.user-lisp-autoloads.el.
  6. Use sacha-learn-lang-write-journal-entries-for-subtree
  7. Publish the post to my blog with sacha-org-11ty-copy-just-this-post. Check it, and then use my publish-my-blog shell script to post the rest.

Compile Emacs News

For Emacs News, my workflow goes like this:

  1. Upvote posts on Reddit.
  2. Add YouTube videos to a playlist. I search for emacs | "org mode" | orgmode | eshell | "org roam" and sort by upload date, but I don't think the results are comprehensive, and I have to wade through a number of low-effort or irrelevant videos, so I might miss some good ones.
  3. Update the Emacs Calendar.
  4. Generate the Emacs News list for the week by evaluating the block after "Actually generate the section".
  5. Announce GNU ELPA packages on info-gnu-emacs using sacha-announce-elpa-package.
  6. Collect links from Mastodon.
  7. Collect links from other sites.
  8. Check for duplicates with sacha-emacs-news-check-duplicates.
  9. Categorize links with sacha-org-categorize-emacs-news/body.
  10. Review and incorporate some of the emacs-devel links e-mailed by Andrés Ramiréz.
  11. Publish the Emacs News blog post.
  12. Publish the news as plain text, HTML, and attached Org file using emacs-news-share.
  13. Use emacs-news-tweet-emacs-news to post on Mastodon.
  14. Use emacstv-add-from-org to add the videos to emacs.tv.

Emacs News functions are generally defined in sachac/emacs-news: Weekly Emacs news (index.org).

Set up a live meeting for recording

  1. (Run) Start OBS.
  2. Confirm that OBS audio levels change.
  3. Close OBS.
  4. (Run) Use Google Chrome to go to https://meet.google.com or https://bbb.emacsverse.org depending on the meeting.
  5. Confirm that the audio and video work. If not, double-check volume control setup and setup-mic scripts.
  6. (Run) When you're in the meeting, start OBS again.
  7. Streaming: See livestream workflow
  8. Just recording: Click on Start recording.

Livestream Emacs stuff - spontaneous or scheduled

  1. Clean up my windows and browser tabs.
  2. Set my Firefox to dark mode.
  3. In Emacs:
    1. Update Live. (C-z is my new shortcut for it.)
    2. Check what number of Yay Emacs we're on (videos or live)
    3. Create a task with the :stream: tag and clock into it.
    4. If needed:

             gcloud auth application-default login \
                    --client-id-file=/home/sacha/sync/cloud/personal/credentials.json \
                    --scopes="https://www.googleapis.com/auth/youtube,https://www.googleapis.com/auth/youtube.force-ssl"
      

,https://www.googleapis.com/auth/cloud-platform

  1. Use sacha-google-clear-cache and sacha-stream-org-schedule-livestream-for-entry-at-point to create it as a livestream.
  2. (Run) Enable sacha-stream-or-video-global-mode.
  1. (Run) Go to the livestreaming dashboard in Google Chrome.
  2. Pop out the chat and position it.
  3. If using a web meeting, join that one and confirm microphone and camera are working.
  4. (Run) Open OBS.
    1. Switch to "Current task and webcam". Confirm that the task is displayed.
    2. (Run) Start recording, say something, stop recording. In Emacs, use M-x sacha-play-latest-recording to confirm that the audio is working.
    3. (Run) Start streaming. (My shortcut: S-s-s)
  5. (Run) In the Youtube live dashboard, check the audio quality.

"Hi stream! This is Yay Emacs number ###, I'm Sacha Chua, and today I'll …"

"I'll post my notes on my blog so you can get the code. Look for Yay Emacs 11 at yayemacs.com."

After:

  1. (Run) Turn stream mode off.
  2. (Run) Use sacha-google-clear-cache to reset the livestream data.
  3. Use process-stream <url> <id> to download and transcribe the recording.
  4. Use sacha-stream-org-convert-timestamps to convert the clock-based timestamps to video offsets.
  5. Copy the chat and use sacha-stream-org-reformat-chat to neaten it up.
  6. (Run) sacha-stream-regenerate-stream-pages to update emacs-chat and live.
  7. Edit the .txt of the transcript.
    1. Use subed-remove-duplicate-speakers to simplify the speaker tags.
    2. Use subed-fill-subtitles to wrap the text.
    3. Use subed-align to get the timestamps.
    4. Use subed-vtt-insert-chapter-comments to insert chapters as comments.
    5. Adjust the chapter timing.
    6. Doublecheck chapter timing with subed-mpv-vtt-skim-subtitles-with-comments.
    7. Doublecheck speaker turn timing with subed-mpv-skim-speaker-changes.
    8. Upload the transcript.
  8. Upload the video to https://archive.org/upload using a command like ia upload ec21-amin-bandali ec21-amin-bandali.mp4 ec21-amin-bandali.tsv --metadata"mediatype:movies" –metadata="title:Emacs Chat 21: Amin Bandali"=

Schedule an Emacs Chat

  1. Update emacs-chat#scheduling
  2. Put my point on the timestamp and use sacha-emacs-chat-schedule to create the Google calendar invite.
  3. Add the person's name to the title and their e-mail as a guest.
  4. Create a blog post. Use C-. (embark-act) on the timestamp to call sacha-org-timestamp-in-time-zones. Paste in the time translation.
  5. Create a thumbnail and add it as the :THUMBNAIL: property. Ex:

       (sacha-stream-show-string "Emacs Chat:
    Omar Antolin Camarena
    
    sach.ac/emacs-chat" nil)
    
  6. Use sacha-stream-org-schedule-livestream-for-entry-at-point to create the YouTube event.
  7. Use sacha-google-clear-cache to clear the saved entries.
  8. (Run) sacha-stream-regenerate-live-pages to update emacs-chat and live.

Process a two-speaker recording

Setup: Configure OBS to record audio to different tracks.

  1. Audio source - Advanced Audio Properties - Tracks
    1. Mic: track 1 and track 2
    2. System audio: track 1 and track 3
  2. Settings - Output
    1. Output Mode: Advanced
    2. Recording settings - Audio track: check 1, 2, 3

After recording:

  1. Split the audio into separate WAVs and transcribe them separately with file:///home/sacha/bin/split-audio.
  2. Edit the VTT files for each track:
    1. Use file:///home/sacha/bin/subseg to resplit the TXT.
    2. Regenerate timestamps with subed-align.
    3. Correct transcript timing with subed-word-data-fix-subtitle-timing.
    4. Trim the timestamps as needed, using subed-waveform-show-all as reference.
    5. Edit the text and add NOTE comments to mark chapters.
    6. Use subed-word-data-add-word-timestamps if desired.
  3. Use subed-vtt-combine-separate-speaker-files to combine the two VTT files into one file sorted by timestamps.
  4. Use subed-section-comments-as-chapters to copy the chapters to the kill ring.
  5. To make a clean copy without word timestamps, save the combined VTT to another file and then use subed-word-data-remove-word-timestamps.
  6. Format the other speaker in a different way with sacha-subed-format-second-speaker.
  7. Use sacha-subed-as-org-list-with-times to insert the transcript into the Org Mode notes.

Analyze my French conversation lessons

  1. Transcribe the session with whisperx-tutor $(latest-recording): file:///home/sacha/bin/whisperx-tutor
  2. Copy the -sacha.vtt to ~/proj/french/conversation/sacha-only
  3. cd ~/proj/french; uv run python analyze-conversations.py (file:///home/sacha/proj/french/analyze-conversations.py)
  4. uv run python visualize.py

Extract my French pronunciation lessons (tongue-twisters/virelangues)

I want to create a short video with burned-in subtitles so that I can quickly review the tongue-twisters that I worked on with my tutor. Examples:

Prerequisites: Configure OBS to separate my audio from the system audio. This needs to be done in two places: Settings - Output - Advanced - Recording, and Advanced Audio Properties.

  • Track 1: Combined
  • Track 2: Just me
  • Track 3: Just system audio

Recording:

  1. Start Google Chrome and go to https://meet.google.com. Start an instant meeting to confirm that sound and video work in the browser.
    • If things don't work, kill all the google-chrome processes and restart the browser. Possibly restart PulseAudio.
  2. Start OBS to confirm that both mic and system audio are captured. Close OBS.
  3. Check iTalki for the link. Open the meeting, then start OBS. Start recording.

Steps:

  1. (Run) Use file:///home/sacha/bin/whisperx-tutor to transcribe the session into ~/proj/french/analysis/virelangues.
  2. Create a text region with the text of the sections to extract, one per line.
  3. Select the region of tonguetwisters. Use subed-record-extract-last-phrases to create a VTT with the phrases.
  4. Adjust the timestamps of the subtitles.
  5. Add a header of the form:

    NOTE
    [[~/recordings/2026-07-14_07-16-36.mkv]]
    #+AUDIO: ~/proj/french/analysis/virelangues/2026-07-14-virelangues-sacha.opus
    #+OUTPUT: ~/proj/french/analysis/virelangues/2026-07-14-virelangues-clips.webm
    #+OPEN_CAPTIONS
    #+OPTIONS: same-edits
    #+CROP: 1666 685 1912 921
    #+WIDTH: 1080
    #+HEIGHT: 1920
    

    Add more crop directives as needed.

  6. Use subed-record-set-up and subed-record-compile.
  7. After confirming the video, upload it to https://studio.youtube.com. Use C-u M-x subed-section-comments-as-chapters for the chapter descriptions.

Work on the Bike Brigade newsletter

  • Mondays: cd ~/proj/bike-brigade; node convert-newsletter.js sketch
  • Thursdays: Add entries, schedule the announcement
  • Saturdays:
    • sacha-bike-brigade-create-or-update-campaign
    • sacha-brigade-send-test-to-me
    • sacha-brigade-send-test
    • mailchimp-campaign-schedule

Update emacs.tv

https://emacs.tv

  1. Select the subtree for the latest Emacs News.
  2. Call M-x emacstv-add-from-org.
  3. Open videos.org.
  4. Add tags if I feel like organizing things.
  5. Use M-x emacstv-build to sort the file and update various feeds.
  6. npm run build
  7. git commit -m "update" -a; git push

Bisect my Emacs configuration file for errors

(setq bug-hunter-header
      '(progn
         (load-file "~/.config/emacs/early-init.el")
         (prepare-user-lisp)))

Copy Minecraft mods from the kiddo's GDLauncher instance

I use Syncthing to synchronize the GDLauncher instances on her computer with my ~/sync/gdlauncher-instances directory.ocg

Routines

  • Daily
    • Get the kiddo through the day
    • Play the piano
    • Go for a long walk or bike ride
    • Write or draw
    • Draw moment of the day using Noteful on my iPad
    • Update my web-based journal
    • Check on my mom
  • Weekly
    • Mondays:
      1. Update Emacs News
      2. Update emacs.tv
    • Saturdays:
      1. Make sure my time records look sensible (no open-ended records, etc.)
      2. sacha-org-prepare-weekly-review
      3. Send Bike Brigade newsletter draft
    • Other time during the week
      • Check in with my consulting client
  • Monthly
    • sacha-org-prepare-monthly-review
    • Update now page
    • Add blog posts to my index
    • Prepare invoice for consulting
    • Check out IndieWeb Carnival for writing ideas
  • Yearly
    • August:
      • Write and draw an annual review
    • February:
      • Write and draw an annual review for A+
      • Celebrate A+'s birthday

Life

  • I like using a Load 75 cargo bike to get around with the kiddo. I usually bring a Bakkie Bag so that I can tow A+'s bike when she gets tired.
  • I'm slowly working on an Org Mode inventory of various things in the house.
  • W- and I use OurGroceries to coordinate the grocery list.
View Org source for this post
You can e-mail me at sacha@sachachua.com.