Summary: Building on a previous post, I layout how I’m working through curating my RSS feed. This involes creating a working document that tracks the state each RSS feed URL; and a macro that helps me consistently move through each RSS feed URL. All told, demonstrating Emacs’s keyboard macros and custom Org Mode TODO states.

Yesterday in On Blogging and Online Neighborhoods. In that post I identified that I wanted to share my blog roll.

The Task at Hand

I started on that work last night and wanted to share a bit of the process.

1. Normalize my current feed.
2. Create a Todo oriented document.
3. Do the Todo.
4. Save my progress.

Normalize My Current Feed

I keep my blog-roll in an Org-Mode 📖 document; at ~/git/org/elfeed.org. I used the elfeed-org package to store my feeds, which allows me allow me to annotate each feed. It was a bit unruly; several top-level headings and a smattering of tags.

What I wanted was a simple list of the URLs 📖 to the RSS feeds. That was relatively straight forward:

rg "^\*+\s+(http\S+)" ~/git/org/elfeed.org -r '** TODO $1' > ~/Desktop/normalized-rss-feed.org

The above Ripgrep 📖 command extracted the URLs as second level headings, with a status of Todo. Normally I would export these as checklists, but I knew I wanted to leverage Org-Mode ’s heading tags; because as I was reviewing each feed I wanted to categorize them. The categories are useful for filtering my feed; if I’m searching for something.

Create a Todo Oriented Document

With the file created at ~/Desktop/normalized-rss-feed.org, I prepended a custom Todo sequence: TODO(t) STARTED(s) | PUBLIC(p) PRIVATE(r) DROP(d). See TODO Basics (The Org Manual) for more details.

I envisioned the states as follows:

TODO

I still need to begin the work on this.

STARTED

I have opened the website and began assessing it.

PUBLIC

This is a feed that I will continue to subscribe to and share on my blog-roll.

PRIVATE

This is a feed that I will continue to subscribe to but will not share on my blog-roll.

DROP

This is a feed I will remove from my blog roll.

I added the STARTED to provide a placeholder for that moment when I begin looking at a website and could likely spend a few moments reading or jumping to other links.

I also added a first level headline above all of my second level headings. The [0/3] marker is a a tally of how many I’ve completed. See Breaking Down Tasks (The Org Manual) for more details.

Below is an example of the document before I began the work of reviewing each feed.

#+TODO: TODO(t) STARTED(s) | PUBLIC(p) PRIVATE(r) DROP(d)

* Feeds [0/3]
** TODO http://ajroach42.com/feed.xml
** TODO http://decafbad.net/feed
** TODO http://evrl.com/feed.xml

The above document gave me a checklist of work to move through.

Do the TODO

With a checklist in hand, I thought about the steps I would take to open each page. With a game plan in mind, positioned my cursor at the beginning of the line of the first feed (e.g. ** TODO http://ajroach42.com/feed.xml).

What I wanted to do was to set the line to STARTED (e.g. “start” the task) and open the homepage for that feed.

I have bound C-s to consult-line; and isearch-forward to s-f; hence the atypical binding; an homage to my first beloved editor: Textmate 📖 .

Knowing that I would be doing this a lot, I started recording a macro and typed the following keys:

C-a C-a

Ensure we are at the beginning of the line; a good pre-amble for recorded macros.

C-c C-t s

Invoke org-todo and mark the headline as STARTED.

s-f / / <return>

Move the cursor to just after the first encountered //. We’re at the beginning of the host name.

M-b

Goto the beginning of the word, we’re not at the http point of the string.

C-SPC

Set the mark (e.g. begin the selecting text)

s-f / / <return> s-f / <return>

We are now highlighting the scheme and host name (e.g. http://decafbad.net/).

s-c

Copy the highlighted text; the homepage of the feed.

M-x e w w <return>

Invoke the eww command; the web browser within Emacs 📖 .

s-v <return>

Paste the copied homepage of the feed as the URL to visit.

Once I was done reviewing I would manually return to the STARTED item and again set it’s status to either PUBLIC, PRIVATE, or DROP. In setting the status the counter would increment.

Save My Progress

Because I was working from a checklist, this was a task that I could set down and pick up as I found moments in my workday.

Knowing this, I added a section to the document; namely the recorded macro exported:

(defalias 'review-elfeed
     (kmacro "C-a C-a C-c C-t s s-f / / <return> M-b C-SPC s-f / / <return> s-f / <return> s-c M-x e w w <return> s-v <return>"))

Now, when I come back to the document I can evaluate the block of text and have access to an a review-elfeed command.

Conclusion

This is the second time this week that I’ve used something similar to the above strategy; namely creating a checklist of Todo items; each of which require decisions and routing to different status.

The first time involved building a checklist of Github issues, gathering up all of the pull requests that went into resolving those issues, then tracking down each commit for those pull requests.

The second time, the one I write about in this post, was simpler to explain and more accessible to a general audience.

I appreciate the automation of Emacs ; it took awhile for me to use keyboard macros, but now I’m spoiled. I write them by first pushing the record button F3 and then replay them by pressing F4; and when I want to run them 100 times, I just type Ctrl 1 0 0 F4.

This is one reason I am trying to bring more and more of my computering to Emacs ; because the utilities I have available for writing, reading, and navigating text. See Emacs Turbo-Charges My Writing.

When I first started recording keyboard macros, I tried to type as I normally would. But, what I found is that if I slow down, just a bit, I have a better chance of recording the correct sequence. If I need to edit it, I can do that with edit-kbd-macro.

For those reading along, I hope this was helpful; and as always please feel free to reach out to me.

Gopar, over at the Goparism YouTube channel has posted a video on how he uses Emacs Org mode and Org Roam as his GTD framework. For those not familiar with GTD it’s a methodology developed by David Allen in his book Getting Things Done for organizing your tasks in such a way as to maximize your productivity.

Org mode is ideal for handling the mechanical aspects of the GTD program. A lot of the system involves mindset and processes but there is also a large component of recording and organizing tasks as well as making daily TODO lists. Org, of course, is seemingly custom built for those functions.

Gopar’s method depends mainly upon the agenda with some custom displays. Those are easy to setup as Gopar shows. He also uses the Org capture system to make it easy for him to add and schedule tasks.

The salient fact about his method is how easy it is Mostly it’s just a few added agenda commands and some capture templates. Although I don’t follow the GTD method and don’t know a lot about it, my agenda system is very similar to Gopar’s. That’s because Org makes it natural to organize things that way.

The video is 13 minutes, 49 seconds so you’ll need to schedule some time but how else are you going to spend the holidays?

At AP headquarters, nothing brings holiday cheer quite like oil, so Danny and Derek are back with Gregory Brew, analyst at Eurasia Group in energy and Iran, to discuss Iran’s postwar “petro-state” period. They get into the country’s trajectory leading up to the 1953 coup, Shah Mohammad Reza Pahlavi and his relationship with the U.S., the 1963 White Revolution, how oil revenue supported industrialization, middle class growth, and state expansion, the rise of the clerical opposition to Pahlavi’s reign, and more.

Subscribe now

Check out Gregory’s book Petroleum and Progress in Iran: Oil, Development, and the Cold War.

Danny and Derek welcome back to the podcast Eleanor Janega, medieval historian, author, and broadcaster, to get down to brass tacks: What is Christmas? They discuss its practice in early and medieval Christian societies, mummers’ plays and gambling, Saint Nicholas providing dowries and resurrecting boys killed for their meat, the post-Reformation treatm…

Read more

Danny and Derek amble across the finish line of 2023. This week: a Gaza update including the latest UN resolution, ceasefire talks, and a potential Geneva conference (1:15); the West/North Atlantic formally responds to Houthi actions in the Red Sea (8:50); General Abdel Fattah El-Sisi wins re-election (13:22); continued fighting in Myanmar (14:29); another ICBM test from the DPRK/North Korea (15:47); the RSF captures another city in Sudan (19:39); a possible resurgence of piracy in Somalia (21:43); the latest constituional referendum in Chile (24:09); a Venezuela-U.S. prisoner swap (25:56); and a Ukraine war update (29:02).

Subscribe now

Recorded Wednesday December 20, 2023

Derek Taylor over at DistroTube has a nice introduction to reading PDFs and doing diffs from within Emacs. As Taylor says, almost all of us have standalone applications to do these things but even if you don’t belong to the Alles in Emacs camp, it’s nice to perform these tasks from within Emacs if you’re already there.

Taylor approaches the issues through his latest Emacs configuration so he discusses things like his custom keybindings that you probably won’t care about. But he does demonstrate both applications. For PDFs he uses the excellent pdf-tools package. He shows basic navigation and how to annotate PDFs. This is a great package that I use all the time. Unless a PDF comes up in my browser, it’s the only PDF reader I use.

He also demonstrates the builtin Ediff package. As I’ve written before, I’ve long had a difficult time with Ediff but Prot’s video cured me of that. Taylor’s video also helps demystify Ediff and show how easy to use if you ignore most of the fancy commands. The great thing about Ediff, of course, is that you can move any given difference from one file to the other.

It’s a nice video, especially if you’re interested in reading PDFs or performing diffs. The video is 18 minutes, 43 seconds long so you’ll have to schedule some time.

Update [2023-12-24 Sun 10:46]: Added link to video.

Hosted on Acast. See acast.com/privacy for more information.

Steve Punt and Hugh Dennis present the week via topical stand-up and sketches. They're joined by Ria Lina looking into changes in the NHS, Fin Taylor on the Royals, and with an original song from Ed MacArthur.

The show was written by the cast with additional material from Rachel E Thorn, Aidan Fitzmaurice, Joe Bates and Cody Dahler.

Voice Actors: Joz Norris and Gemma Arrowsmith.

Producer: Rajiv Karia Production Coordinator: Katie Baum

A BBC Studios Production for Radio 4

Democracy Now! 2023-12-18 Monday

• Headlines for December 18, 2023
• ​​Al Jazeera's Marwan Bishara on IDF Killing AJ Journalist, the 3 Hostages & U.S. Support for Israel
• "Tragically Historic": The Guardian's Nina Lakhani on the Failure of Yet Another U.N. Climate Summit

Download this show

Democracy Now! 2023-12-21 Thursday

• Headlines for December 21, 2023
• "The Hostages Weren't Our Top Priority": Israel's "Bombing Frenzy" Endangered Hostages Held in Gaza
• "The U.S. and Israel Stand Alone": World Demands Ceasefire as Gaza Death Toll Tops 20,000
• Colorado Disqualifies Trump from Ballot, Triggering Battle over Constitution's Insurrection Clause
• "Fascism Out Loud": Trump's Escalating Racist Rhetoric & the Far Right's Plan for a Slow Civil War

Download this show

Raw link: https://www.youtube.com/watch?v=ycyxytk1NAQ

In this ~25 minute video, I present my new Emacs configuration. It is an advanced setup that starts with a literate Org program as the “source of truth”. This file generates all the individual modules and custom libraries of my setup. I explain all the technicalities and why this approach is the best of both worlds to (i) document the rich corpus of work found in my dotfiles while (ii) not compromising on code excellence.

• Website: https://protesilaos.com/emacs/dotemacs
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/dotfiles
  • Mirrors:
    • GitHub: https://github.com/protesilaos/dotfiles
    • GitLab: https://gitlab.com/protesilaos/dotfiles
• Mailing list: https://lists.sr.ht/~protesilaos/dotfiles
• Backronym: Do Observe, Transpose, Examine, or Mirror All Configurations, Stranger (dotemacs); Dotfiles Operate Transparently For the Included Linux and Emacs Setups (dotfiles).

W. Bush - Obama - Trump - Biden

Party rocking against the dying of the light.

Hosted on Acast. See acast.com/privacy for more information.

Reagan - H.W. Bush - Clinton

Don't stop thinkin' about tomorrow.

Hosted on Acast. See acast.com/privacy for more information.

The Bush administration unleashes the first war of the 21st century.

Learn more about your ad choices. Visit megaphone.fm/adchoices

Ben and Hesse from Seeking Derrangements stop by to cover a slew of gay-related news stories, from gay sex in the senate hearing room, to the downfall of George Santos, sex crimes among the sex-panicked Moms For Liberty, and some guys trying to build a libertarian utopia in the Mediterranean.

Subscribe to Seeking Derrangements at: https://www.patreon.com/seekingderangements

Hosted on Acast. See acast.com/privacy for more information.

This is a quick demonstration of using Deepgram's streaming API to do speech recognition live. It isn't as accurate as OpenAI Whisper but since Whisper doesn't have a streaming API, it'll do for now. I can correct misrecognized words manually. I tend to talk really quickly, so it displays the words per minute in my modeline. I put the words into an Org Mode buffer so I can toggle headings with avy and cycle visibility. When I'm done, it saves the text, JSON, and WAV for further processing. I think it'll be handy to have a quick way to take live notes during interviews or when I'm thinking out loud. Could be fun!

I'm still getting some weirdness when the mode turns on when I don't expect it, so that's something to look into. Maybe I won't use it as a mode for now. I'll just use my-live-speech-start and my-live-speech-stop.

(defvar my-live-speech-buffer "*Speech*")
(defvar my-live-speech-process nil)
(defvar my-live-speech-output-buffer "*Speech JSON*")

(defvar my-live-speech-functions
  '(my-live-speech-display-in-speech-buffer
    my-live-speech-display-wpm
    my-live-speech-append-to-etherpad)
  "Functions to call with one argument, the recognition results.")

(defun my-live-speech-start ()
  "Turn on live captions."
  (interactive)
  (with-current-buffer (get-buffer-create my-live-speech-buffer)
    (unless (process-live-p my-live-speech-process)
      (let ((default-directory "~/proj/deepgram-live"))
        (message "%s" default-directory)
        (with-current-buffer (get-buffer-create my-live-speech-output-buffer)
          (erase-buffer))
        (setq my-live-speech-recent-words nil
              my-live-speech-wpm-string "READY ")
        (setq my-deepgram-process
              (make-process
               :command '("bash" "run.sh")
               :name "speech"
               :filter 'my-live-speech-json-filter
               :sentinel #'my-live-speech-process-sentinel
               :buffer my-live-speech-output-buffer)))
      (org-mode))
    (display-buffer (current-buffer))))

(defun my-live-speech-stop ()
  (interactive)
  (if (process-live-p my-live-speech-process)
      (kill-process my-live-speech-process))
  (setq my-live-speech-wpm-string nil))

;; (define-minor-mode my-live-speech-mode
;;  "Show live speech and display WPM.
;; Need to check how to reliably turn this on and off."
;;  :global t :group 'sachac
;;  (if my-live-speech-mode
;;      (my-live-speech-start)
;;    (my-live-speech-stop)
;;    (setq my-live-speech-wpm-string nil)))

;; based on subed-mpv::client-filter
(defun my-live-speech-handle-json (line-object)
  "Process the JSON object in LINE."
  (run-hook-with-args 'my-live-speech-functions (json-parse-string line :object-type 'alist)))

(defun my-live-speech-process-sentinel (proc event)
  (when (string-match "finished" event)
    (my-live-speech-stop)
    ;(my-live-speech-mode -1)
    ))

(defun my-live-speech-json-filter (proc string)
  (when (buffer-live-p (process-buffer proc))
    (with-current-buffer (process-buffer proc)
      (let* ((proc-mark (process-mark proc))
             (moving (= (point) proc-mark)))
        ;;  insert the output
        (save-excursion
          (goto-char proc-mark)
          (insert string)
          (set-marker proc-mark (point)))
        (if moving (goto-char proc-mark))
        ;; process and remove all complete lines of JSON (lines are complete if ending with \n)
        (let ((pos (point-min)))
          (while (progn (goto-char pos)
                        (end-of-line)
                        (equal (following-char) ?\n))
            (let* ((end (point))
                   (line (buffer-substring pos end)))
              (delete-region pos (+ end 1))
              (with-current-buffer (get-buffer my-live-speech-buffer)
                (my-live-speech-handle-json line)))))))))

# Based on streaming-test-suite
# https://developers.deepgram.com/docs/getting-started-with-the-streaming-test-suite

import pyaudio
import asyncio
import json
import os
import websockets
from datetime import datetime
import wave
import sys

startTime = datetime.now()
key = os.environ['DEEPGRAM_API_KEY']
live_json = os.environ.get('LIVE_CAPTIONS_JSON', True)
all_mic_data = []
all_transcripts = []
all_words = []
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
CHUNK = 8000

audio_queue = asyncio.Queue()
REALTIME_RESOLUTION = 0.250
SAMPLE_SIZE = 0

def save_info():
    global SAMPLE_SIZE
    base = startTime.strftime('%Y%m%d%H%M')
    wave_file_path = os.path.abspath(f"{base}.wav")
    wave_file = wave.open(wave_file_path, "wb")
    wave_file.setnchannels(CHANNELS)
    wave_file.setsampwidth(SAMPLE_SIZE)
    wave_file.setframerate(RATE)
    wave_file.writeframes(b"".join(all_mic_data))
    wave_file.close()
    with open(f"{base}.txt", "w") as f:
        f.write("\n".join(all_transcripts))
    with open(f"{base}.json", "w") as f:
        f.write(json.dumps(all_words))
    if live_json:
        print(f'{{"msg": "🟢 Saved to {base}.txt , {base}.json , {base}.wav", "base": "{base}"}}')
    else:
        print(f"🟢 Saved to {base}.txt , {base}.json , {base}.wav")

# Used for microphone streaming only.
def mic_callback(input_data, frame_count, time_info, status_flag):
    audio_queue.put_nowait(input_data)
    return (input_data, pyaudio.paContinue)

async def run(key, method="mic", format="text", **kwargs):
    deepgram_url = f'wss://api.deepgram.com/v1/listen?punctuate=true&smart_format=true&utterances=true&encoding=linear16&sample_rate=16000'
    async with websockets.connect(
        deepgram_url, extra_headers={"Authorization": "Token {}".format(key)}
    ) as ws:
        async def sender(ws):
            try:
                while True:
                    mic_data = await audio_queue.get()
                    all_mic_data.append(mic_data)
                    await ws.send(mic_data)
            except websockets.exceptions.ConnectionClosedOK:
                await ws.send(json.dumps({"type": "CloseStream"}))
                if live_json:
                    print('{"msg": "Closed."}')
                else:
                    print("Closed.")
        async def receiver(ws):
            global all_words
            """Print out the messages received from the server."""
            first_message = True
            first_transcript = True
            transcript = ""
            async for msg in ws:
                res = json.loads(msg)
                if first_message:
                    first_message = False
                try:
                    # handle local server messages
                    if res.get("msg"):
                        if live_json:
                            print(json.dumps(res))
                        else:
                            print(res["msg"])
                    if res.get("is_final"):
                        transcript = (
                            res.get("channel", {})
                            .get("alternatives", [{}])[0]
                            .get("transcript", "")
                        )
                        if transcript != "":
                            if first_transcript:
                                first_transcript = False
                            if live_json:
                                print(json.dumps(res.get("channel", {}).get("alternatives", [{}])[0]))
                            else:
                                print(transcript)
                            all_transcripts.append(transcript)
                            all_words = all_words + res.get("channel", {}).get("alternatives", [{}])[0].get("words", [])
                        # if using the microphone, close stream if user says "goodbye"
                        if method == "mic" and "goodbye" in transcript.lower():
                            await ws.send(json.dumps({"type": "CloseStream"}))
                            if live_json:
                                print('{"msg": "Done."}')
                            else:
                                print("Done.")
                    # handle end of stream
                    if res.get("created"):
                        save_info()
                except KeyError:
                    print(f"🔴 ERROR: Received unexpected API response! {msg}")

        # Set up microphone if streaming from mic
        async def microphone():
            audio = pyaudio.PyAudio()
            stream = audio.open(
                format=FORMAT,
                channels=CHANNELS,
                rate=RATE,
                input=True,
                frames_per_buffer=CHUNK,
                stream_callback=mic_callback,
            )

            stream.start_stream()

            global SAMPLE_SIZE
            SAMPLE_SIZE = audio.get_sample_size(FORMAT)

            while stream.is_active():
                await asyncio.sleep(0.1)

            stream.stop_stream()
            stream.close()

        functions = [
            asyncio.ensure_future(sender(ws)),
            asyncio.ensure_future(receiver(ws)),
        ]

        functions.append(asyncio.ensure_future(microphone()))
        if live_json:
            print('{"msg": "Ready."}')
        else:
            print("🟢 Ready.")
        await asyncio.gather(*functions)

def main():
    """Entrypoint for the example."""
    # Parse the command-line arguments.
    try:
        asyncio.run(run(key, "mic", "text"))
    except websockets.exceptions.InvalidStatusCode as e:
        print(f'🔴 ERROR: Could not connect to Deepgram! {e.headers.get("dg-error")}')
        print(
            f'🔴 Please contact Deepgram Support (developers@deepgram.com) with request ID {e.headers.get("dg-request-id")}'
        )
        return
    except websockets.exceptions.ConnectionClosedError as e:
        error_description = f"Unknown websocket error."
        print(
            f"🔴 ERROR: Deepgram connection unexpectedly closed with code {e.code} and payload {e.reason}"
        )

        if e.reason == "DATA-0000":
            error_description = "The payload cannot be decoded as audio. It is either not audio data or is a codec unsupported by Deepgram."
        elif e.reason == "NET-0000":
            error_description = "The service has not transmitted a Text frame to the client within the timeout window. This may indicate an issue internally in Deepgram's systems or could be due to Deepgram not receiving enough audio data to transcribe a frame."
        elif e.reason == "NET-0001":
            error_description = "The service has not received a Binary frame from the client within the timeout window. This may indicate an internal issue in Deepgram's systems, the client's systems, or the network connecting them."

        print(f"🔴 {error_description}")
        # TODO: update with link to streaming troubleshooting page once available
        # print(f'🔴 Refer to our troubleshooting suggestions: ')
        print(
            f"🔴 Please contact Deepgram Support (developers@deepgram.com) with the request ID listed above."
        )
        return

    except websockets.exceptions.ConnectionClosedOK:
        return

    except Exception as e:
        print(f"🔴 ERROR: Something went wrong! {e}")
        save_info()
        return


if __name__ == "__main__":
    sys.exit(main() or 0)

(defun my-live-speech-display-in-speech-buffer (recognition-results)
  (with-current-buffer (get-buffer-create my-live-speech-buffer)
    (let-alist recognition-results
      (let* ((pos (point))
             (at-end (eobp)))
        (goto-char (point-max))
        (unless (eolp) (insert "\n"))
        (when .msg
          (insert .msg "\n"))
        (when .transcript
          (insert .transcript "\n"))
        ;; scroll to the bottom if being displayed
        (if at-end
            (when (get-buffer-window (current-buffer))
              (set-window-point (get-buffer-window (current-buffer)) (point)))
          (goto-char pos))))))

(defun my-live-speech-toggle-heading ()
  "Toggle a line as a heading."
  (interactive)
  (with-current-buffer (get-buffer my-live-speech-buffer)
    (display-buffer (current-buffer))
    (with-selected-window (get-buffer-window (get-buffer my-live-speech-buffer))
      (let ((avy-all-windows nil))
        (avy-goto-line 1))
      (org-toggle-heading 1))))

(defun my-live-speech-cycle-visibility ()
  "Get a quick overview."
  (interactive)
  (with-current-buffer (get-buffer my-live-speech-buffer)
    (display-buffer (current-buffer))
    (if (eq org-cycle-global-status 'contents)
        (progn
          (run-hook-with-args 'org-cycle-pre-hook 'all)
          (org-fold-show-all '(headings blocks))
          (setq org-cycle-global-status 'all)
          (run-hook-with-args 'org-cycle-hook 'all))
      (run-hook-with-args 'org-cycle-pre-hook 'contents)
      (org-cycle-content)
      (setq org-cycle-global-status 'contents)
      (run-hook-with-args 'org-cycle-hook 'contents))))

(defvar my-live-speech-wpm-window-seconds 15 "How many seconds to calculate WPM for.")
(defvar my-live-speech-recent-words nil "Words spoken in `my-live-speech-wpm-window-minutes'.")
(defvar my-live-speech-wpm nil "Current WPM.")
(defvar my-live-speech-wpm-colors  ; haven't figured out how to make these work yet
  '((180 :foreground "red")
    (170 :foreground "yellow")
    (160 :foreground "green")))
(defvar my-live-speech-wpm-string nil "Add this somewhere in `mode-line-format'.")
(defun my-live-speech-wpm-string ()
  (propertize
   (format "%d WPM " my-live-speech-wpm)
   'face
   (cdr (seq-find (lambda (row) (> my-live-speech-wpm (car row))) my-live-speech-wpm-colors))))

(defun my-live-speech-display-wpm (recognition-results)
  (let-alist recognition-results
    (when .words
      ;; calculate WPM
      (setq my-live-speech-recent-words
            (append my-live-speech-recent-words .words nil))
      (let ((threshold (- (assoc-default 'end (aref .words (1- (length .words))))
                          my-live-speech-wpm-window-seconds)))
        (setq my-live-speech-recent-words
              (seq-filter
               (lambda (o)
                 (>= (assoc-default 'start o)
                     threshold))
               my-live-speech-recent-words))
        (setq my-live-speech-wpm
              (/
               (length my-live-speech-recent-words)
               (/ (- (assoc-default 'end (aref .words (1- (length .words))))
                     (assoc-default 'start (car my-live-speech-recent-words)))
                  60.0)))
        (setq my-live-speech-wpm-string (my-live-speech-wpm-string))))))

(defvar my-live-speech-etherpad-id nil)
(defun my-live-speech-append-to-etherpad (recognition-results)
  (when my-live-speech-etherpad-id
    (emacsconf-pad-append-text my-live-speech-etherpad-id (concat " " (assoc-default 'transcript recognition-results)))))

Krystal and Saagar discuss protests erupting in Israel after the IDF shot 3 hostages, shipping crisis amid escalating Yemen US tensions, Trump uses 'Nazi' immigrant rhetoric, Nikki Haley sweats when pressed on Trump support, Ukraine kidnaps disabled people for war service, Fetterman says he isn't a progressive, Senate staffer fired for gay sex tape in Congress, and Bibi admits two state solution is dead. 

To become a Breaking Points Premium Member and watch/listen to the show uncut and 1 hour early visit: https://breakingpoints.supercast.com/

Merch Store: https://shop.breakingpoints.com/

See omnystudio.com/listener for privacy information.

Fermin gave an interesting talk to the 2023 EmacsConf. The title of the talk was The Emacsen family, the design of an Emacs and the importance of Lisp. He starts with the premise that Lisp is the right language for Emacs implementation and extension.

That takes him to Elisp. It was, he says, a pretty nice language when Stallman designed it and today it’s still “good enough”. But that brings up the question, “Why not Common Lisp?” As we all know, RMS is not a fan but there’s more to it. When Emacs was being developed, a final specification was still 10 years away and there weren’t any (or at least any “free”) implementations available so RMS rolled his own.

But, Fermin says, we can do much better today with Common Lisp. In particular, the SBCL implementation is fast, compiles to native code, and is stable. That brings him to Lem. Lem is Emacs reimagined and implemented in Common Lisp.

The developers have made a conscious effort to make Lem familiar to Emacs users but also to make it more general and easier to extend. Take a look at the video or read to transcript for the details.

One thing I like about it is that it’s 100% Common Lisp. There’s no C core; just Lisp all the way down. That makes it easier to customize or extend any part of the editor.

It’s an interesting project but I doubt it will gain much traction among Emacsians. Using Common Lisp solves at lot of problems with Emacs but Emacs users are famously conservative about such things. Just consider the fury that a small change to how registers work provoked (see this reddit post and the Emacs-devel thread about it starting here).

In any event, it’s an interesting talk and worth watching. The video is 18 minutes 27 seconds so plan accordingly.

A State Department official resigned on October 14, writing in a letter that the U.S. support for Israel’s assault on Gaza “will only lead to more and deeper suffering for both the Israeli and Palestinian people.” The director of the New York office of the United Nations High Commissioner for Human Rights resigned on October 31, stating that “once again we are seeing a genocide unfolding before our eyes and the organization we serve appears powerless to stop it.”

With over 20,000 now dead in Gaza, there’s one government official who you’d assume — at least if you take her own words seriously — would join them. That is Samantha Power, current head of the U.S. Agency for International Development. Before that, she was the U.S. ambassador to the U.N. during the Obama administration.

But Power first rose to prominence with her 2002 book “‘A Problem From Hell’: America and the Age of Genocide.” It won the Pulitzer Prize for nonfiction, with the citation reading, “Samantha Power poses a question that haunts our nation’s past: Why do American leaders who vow ‘never again’ repeatedly fail to marshal the will and the might to stop genocide?”

In the book’s introduction, Power makes this observation: “This country’s consistent policy of nonintervention in the face of genocide offers sad testimony not to a broken American political system but to one that is ruthlessly effective. The system, as it stands now, is working.”

There is no sign of Power taking a principled stand on Gaza, however. Rather, she is spending her time proudly tweeting about all the good the U.S. is doing in the world, such as the arrival in Egypt of 147,000 pounds of humanitarian aid. This is approximately one ounce per person in Gaza. 

In her book, Power depicts a grim history of U.S. realpolitik — during the Armenian genocide, the Holocaust, Cambodia, Rwanda, Bosnia, and more — that is totally indifferent to human suffering. In her telling, the ranks of the government are filled with cowardly, faceless apparatchiks who consistently choose their careers over humanity. Power describes them as “those who sat before their computers or bumped into one another in the [State] department’s drab cafeteria … [bureaucrats] who were protective of turf and career and not at all in the habit of rocking the boat.”

The book would be unbearably bleak if it weren’t for various heroes that Power locates in the labyrinthian halls of government, individuals who are so sick at heart at U.S. policy that they can no longer carry it out and publicly resign.

First, Power celebrates George Kenney, the State Department’s acting Yugoslav desk officer, who stepped down in 1992. Kenney decried George H.W. Bush’s disinterest in various massacres during the dissolution of Yugoslavia, with his cri de coeur making the front page of the Washington Post. When Power later covered the Balkans as a journalist, she wore a camouflage vest and helmet given to her by Kenney.

Then, in August 1993, Marshall Freeman Harris, the State Department’s Bosnia desk officer, resigned. Power interviewed him and quotes him as saying, “When you are in a bureaucracy, you can either put your head down and become cynical, tired and inured, or you can stick your head up and try to do something.”

Then, two more State officials left. Power cites a letter from one of them, Steven Walker, in which Walker wrote, “I can no longer countenance U.S. support for a diplomatic process that legitimizes aggression and genocide.”

So you might believe that Power herself would obviously step down now in the face of Israel’s actions in Gaza. After all, what’s happening now is arguably a greater indictment of the U.S. than what she writes about in “‘A Problem From Hell,’” which covers examples in which the U.S. government took little or no action to intervene to halt mass death. Here the U.S. is directly and unyieldingly supporting mass death.

Read our complete coverage

Israel’s War on Gaza

At the end of the book, Power considers the past century and asks some cogent questions: “How many of us do not believe that the presidents, senators, bureaucrats, journalists, and ordinary citizens who did nothing, choosing to look away rather than to face hard choices and wrenching moral dilemmas, were wrong? And how can something so clear in retrospect become so muddled at the time by rationalizations, institutional constraints, and a lack of imagination? How can it be that those who fight on behalf of these principles are the ones deemed unreasonable?”

How indeed. For now, however, Power shows no signs of asking herself any such questions about the present and her role in it. If she did, she might see herself in these lines from a poem by Joseph Brodsky that she tweeted out four years ago:

Time, whose sharp blood-thirsty quill
Parts the killed from those who kill,
Will pronounce the latter tribe
As your type.

The post Samantha Power Calls on Samantha Power to Resign Over Gaza appeared first on The Intercept.

When Bernie Sanders launched his first presidential campaign in early 2015, the political world could not have been more different than it is today. His run set in motion a movement — or, really, a series of movements that clashed and blended over the ensuing years, reshaping both the Democratic Party and the country. On today’s episode of Deconstructed, we’re trying something new: Host Ryan Grim narrates the audio version of his new book “The Squad: AOC and the Hope of a Political Revolution.” Macmillan Audio has allowed Deconstructed to run edited excerpts. But we’ve spliced Grim’s audiobook with interviews, speeches, and newscasts, making it into an audio documentary for the podcast. Our first episode takes you inside the first Sanders campaign, where we explore the tension between the right wing of the Democratic Party and Sanders’s “political revolution.” Part 2, coming out later this week, will look back at the historical forces that pushed members of the Squad into politics — and the spotlight. And Part 3, coming out next week, jumps further into the book, exploring the big-money pushback against the new insurgent energy.

You can find Grim's book here: https://us.macmillan.com/books/9781250869074/thesquad

If you’d like to support our work, go to theintercept.com/give, where your donation, no matter what the amount, makes a real difference.

And if you haven’t already, please subscribe to the show so you can hear it every week. And please go and leave us a rating or a review — it helps people find the show. If you want to give us additional feedback, email us at Podcasts@theintercept.com.

Hosted on Acast. See acast.com/privacy for more information.

The 2008 economic crisis changed the world. In the United States, the meager response by Barack Obama and the Democratic Party produced a recovery that was far too slow, drove an eviction crisis, and fueled a populist backlash. On the left, it took the form of Occupy Wall Street, which put the problem of wealth and income inequality — the 99 percent versus the 1 percent — into the national political conversation for the first time since the Great Depression. Followed a few years later by the Movement for Black Lives and an upsurge of climate activism, the new radical energy among young people prepped the ground for the first Bernie Sanders campaign. In 2016, the Vermont senator came shockingly close to the presidential nomination, but as he faded, a chunk of his staff that focused on organizing grassroots supporters decided to quit and try something new: They would recruit and support Bernie-style populists and take over the House. On this episode of Deconstructed, Ryan Grim brings us another audio documentary, adapted from an excerpt of his newest book, “The Squad: AOC and the Hope of a Political Revolution.” This episode chronicles the 2008 economic crisis, Obama’s election, and zeroes in on how individual members of the Squad became politicized. Thanks to Macmillan Audio for the excerpt.

You can find Grim's book here: https://us.macmillan.com/books/9781250869074/thesquad

If you’d like to support our work, go to theintercept.com/give, where your donation, no matter what the amount, makes a real difference.

And if you haven’t already, please subscribe to the show so you can hear it every week. And please go and leave us a rating or a review — it helps people find the show. If you want to give us additional feedback, email us at Podcasts@theintercept.com.

Hosted on Acast. See acast.com/privacy for more information.

More than 18,600 people have been killed in Gaza since Israel’s latest wave of attacks began just over two months ago, following the October 7 Hamas attack that killed some 1,200 Israelis. While the Biden administration continues to support Israel in its devastation, politicians and heads of state around the world are calling for a ceasefire. The last extended war on Gaza, in 2021, would reshape the Democratic Party's posture toward Israel and Palestine. 

On this episode of Deconstructed, Ryan Grim brings us another audio documentary, adapted from an excerpt of his new book, “The Squad: AOC and the Hope of a Political Revolution.” In this episode, Grim revisits the 2021 Gaza war. When members of the Squad and their allies began speaking out about the U.S. government’s support for Israel, the debates in Washington grew extremely messy. The Squad’s opposition led to a political showdown, with special interest groups and other politicians applying pressure on those critical of Israel’s attacks. It threatened a government shutdown and further pushed the conversation on the U.S.’s unconditional support for the Israeli military, setting the stage for the widespread opposition seen today, as well as the highly organized and well-funded reaction from supporters of Israel. Thanks to Macmillan Audio for the excerpt.

You can find Grim's book here: https://us.macmillan.com/books/9781250869074/thesquad

This is the last episode of 2023. Thank you for listening this year. We will be back with more episodes in 2024.

If you’d like to support our work, go to theintercept.com/give, where your donation, no matter what the amount, makes a real difference.

And if you haven’t already, please subscribe to the show so you can hear it every week. And please go and leave us a rating or a review — it helps people find the show. If you want to give us additional feedback, email us at Podcasts@theintercept.com.

Hosted on Acast. See acast.com/privacy for more information.

Today, we’re sharing an episode of our sister podcast, Deconstructed, hosted by Ryan Grim.

More than 18,600 people have been killed in Gaza since Israel’s latest wave of attacks began just over two months ago, following the October 7 Hamas attack that killed some 1,200 Israelis. While the Biden administration continues to support Israel in its devastation, politicians and heads of state around the world are calling for a ceasefire. The last extended war on Gaza, in 2021, would reshape the Democratic Party's posture toward Israel and Palestine. 

On this episode of Deconstructed, Ryan Grim brings us another audio documentary, adapted from an excerpt of his new book, “The Squad: AOC and the Hope of a Political Revolution.” In this episode, Grim revisits the 2021 Gaza war. When members of the Squad and their allies began speaking out about the U.S. government’s support for Israel, the debates in Washington grew extremely messy. The Squad’s opposition led to a political showdown, with special interest groups and other politicians applying pressure on those critical of Israel’s attacks. It threatened a government shutdown and further pushed the conversation on the U.S.’s unconditional support for the Israeli military, setting the stage for the widespread opposition seen today, as well as the highly organized and well-funded reaction from supporters of Israel.

You can find Grim's book here: https://us.macmillan.com/books/9781250869074/thesquad

If you’d like to support our work, go to theintercept.com/give, where your donation, no matter what the amount, makes a real difference.

And if you haven’t already, please subscribe to the show so you can hear it every week. And please go and leave us a rating or a review — it helps people find the show. If you want to give us additional feedback, email us at Podcasts@theintercept.com.

Hosted on Acast. See acast.com/privacy for more information.

"Aging population to hit U.S. economy like a 'ton of bricks'," Reuters reported in 2021. "Aging Is The Real Population Bomb," the International Monetary Fund cautioned earlier this year. "How an aging population poses challenges for U.S. economy, workforce and social programs," PBS declared in June. "Why we're borrowing to fund the elderly while neglecting everyone else," The Washington Post's Catherine Rampell wrote just this past November.

Year after year, it seems, American media issues the same warning: The population of the US, due to - among other factors - rising life expectancy and falling birthrates, is getting older, which spells doom for our economy. A graying public, we're told, will inevitably upend the labor force, destroy productivity, bleed programs like Medicare and Social Security dry, and thus place an undue burden on the younger population.

But the premises for this panic are based on misleading stats, goofy non-sequiturs, and misdirected faux class warfare. So, why do media keep insisting the olds are out for your hard-earned money? Who gets to shape our understanding of what an aging population actually means economically or socially? How does this narrative shift the burden from the state to the individual in terms of managing retirement benefits and systems of care? And what are the real harms of treating people over the age of 65 like they're a cancer on society?

On this episode, we examine the narrative that an aging population is necessarily dire, looking at how it's instrumentalized to gut public benefits for seniors and thus for everyone, advance the financialization of retirement, and reframe the conflict between rich and poor as one between young and old.

Our guest is social security expert Nancy Altman.

This week, hosts Jim DeRogatis and Greg Kot talk with biographer Will Hermes about his recent book on Lou Reed, as well as Lou’s music, persona, legacy and more.

Join our Facebook Group: https://bit.ly/3sivr9T

Become a member on Patreon: https://bit.ly/3slWZvc

Sign up for our newsletter: https://bit.ly/3eEvRnG

Make a donation via PayPal: https://bit.ly/3dmt9lU

Send us a Voice Memo: Desktop: bit.ly/2RyD5Ah  Mobile: sayhi.chat/soundops

Featured Songs:

Lou Reed, "Walk on the Wild Side," Transformer, RCA, 1972

The Beatles, "With A Little Help From My Friends," Sgt. Pepper's Lonely Hearts Club Band, Parlophone, 1967

The Velvet Underground and Nico, "Sunday Morning," The Velvet Underground & Nico, Verve, 1967

The Velvet Underground and Nico, "Heroin," The Velvet Underground & Nico, Verve, 1967

The Velvet Underground, "Pale Blue Eyes," The Velvet Underground, MGM, 1969

Lou Reed, "Coney Island Baby," Coney Island Baby, RCA, 1975

The Velvet Underground, "Some Kinda Love," The Velvet Underground, MGM, 1969

Lou Reed, "How Do You Think It Feels," Berlin, RCA, 1973

Lou Reed, "Perfect Day," Transformer, RCA, 1972

The Velvet Underground, "Sweet Jane," Loaded, Cotillion, 1970

The Velvet Underground and Nico, "I'll Be Your Mirror," The Velvet Underground & Nico, Verve, 1967

The Velvet Underground, "Candy Says," The Velvet Underground, MGM, 1969

John Prine, "Hello In There," John Prine, Atlantic, 1971

See Privacy Policy at https://art19.com/privacy and California Privacy Notice at https://art19.com/privacy#do-not-sell-my-info.