Krystal and Saagar discuss Israel freaks as Egypt joins ICJ genocide case, Blinken admits Israel war crimes says it's okay.

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

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

See omnystudio.com/listener for privacy information.

The AP trifecta once again reunites to answer your thoughts, queries, and, in one case, riddles. This edition broaches such topics as which nations would respectively sanction Jake and Derek, how Danny maintains such a prolific output, whether we’re already in a regional war in the Middle East, Kurt Cobain as a proxy for the end of history, and more.

Subscribe now

Tha…

Read more

Ryan and Emily host a debate on free speech at college campus protests between Glenn Greenwald and Ilya Shapiro.

Glenn Greenwald: https://twitter.com/ggreenwald

Ilya Shapiro: https://twitter.com/ishapiro

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

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

See omnystudio.com/listener for privacy information.

Rania Khalek was joined by Jon Elmer, a contributing editor at The Electronic Intifada, to discuss the battles, tactics and weapons of the Palestinian resistance groups.

This is just part of this episode. The full interview is available for Breakthrough News Members only. Become a member at Patreon.com/BreakthroughNews to access the full episode and other exclusive content.

Window management in Emacs gets a bad rap.

Some of this is deserved, but mostly this is a consequence of combining a very flexible and granular layout system with rather coarse controls. This leaves the door open to creating and using tools for handling windows that employ and provide better metaphors and affordances.

As someone who’s spent an unnecessary amount of time trying different approaches to window management in Emacs over the decades, I decided to summarize them here. Almanac might be overstating it a bit – this is a primer to and a collection of window management resources and tips.

Window management in Emacs bleeds into buffer, state, workspace and frame management, so it’s difficult to contain the scope of any article that aims to be comprehensive. To that end,

• this write-up assumes that you’ve finished at least the Emacs tutorial and are familiar with basic Emacs terminology (what’s a buffer, window and a frame) and with window actions: splitting windows, deleting them or deleting other windows, and switching focus.
• There are only a few brief mentions of tabs, as they are primarily a tool for workspace management, as opposed to window management.
• I’m focusing on window/buffer management within an Emacs frame. Many of the below tools work across frames just as well, but you’ll have to find the right switches to flip to enable cross-frame support.
• Finally, this is more my almanac than a wiki: It covers only tools or ideas I’ve personally explored over the years, with brief mentions of potentially useful packages that I haven’t tried. Any omissions are not value judgments, please let me know if I miss something useful.

At some point this transitions from listing well known tools to tips, then hacks, and finally unvarnished opinions. It’s front-loaded: the first chunk of the write-up gives you a 70% solution. If you are new to Emacs, feel free to stop at 30%. If you are an old hand, feel free to skip the first 30%. It also lists substitutes: several ways to do the same things, so you can pick just one method and ignore the rest. Things get progressively more opinionated and idiosyncratic in the second half.

If you are reading this in the future, this write-up is probably out of date. The Emacs core is very stable, but the package ecosystem tends to drift around as packages are developed and abandoned. The built-in solutions will still be around, but there are no guarantees on the third-party packages! That said, the longer a package has been around the more likely it’s going to stick around in a functional state – even if only as a frozen entry in the Emacs Orphanage.

As new ideas emerge, there will be new approaches to window management that aren’t covered here. These innovations don’t need to happen in the Emacs sphere – Emacs likes to steal reinvent ideas that originate elsewhere, much as other applications rediscover ideas that Emacs introduced in the 1990s. So this topic might be worth revisiting afresh in a few years.

What we mean by “window management”

Emacs separates the idea of a window (a “viewport” or “pane” in the frame) from the buffer, a contiguous chunk of text that may or may not be the contents of a file. These concepts are usually fused in IDEs and text editors – this reduces the cognitive load of using the application, but closes the door on more flexible behavior and free-form arrangments. For example, many editors don’t let you have two views of the same file, which is trivial in Emacs. They’re often uncomfortable even with the idea of a dissociated buffer – a buffer that does not represent the (possibly edited) contents of a file. Reified concepts like Emacs’ indirect buffers are completely foreign to them Unfortunately for Emacs, its current design rules out some clever ideas that other editors have implemented. One example of this is the 4coder’s yeetsheet or Dion systems’ views: You can have buffers whose contents are “live” substrings of multiple other buffers, i.e. you can mix and match pieces of buffers. In Emacs the most you can have is indirect buffers, i.e. full “live” copies of a buffer. .

Emacs allows you to do a lot more, but users have to contend with this cognitive cost. New users pay thrice: they have to deal with getting windows into the right places in the frame, getting buffers into the right windows, and they miss out on the upside because they don’t yet realize what this decoupling makes possible. Hopefully this write-up can address two of these costs.

For reference in the rest of this article, here’s a non-exploded schematic of an Emacs frame, with the left window selected:

• Each colored block is a window, the numbers represent buffers being shown in them.
• The active window is the one with a black border.

This article is not about…

Since actions with or on windows in Emacs are primitive, common and unavoidable operations at any level of Emacs usage, this topic is suprisingly subtle, broad and deep, and there’s only so much I can explore in 15,000 words. So we begin with some disambiguation and a narrowing of focus. This article is not about the following things.

So what’s left? In this article, we mean window management in the manual and mundane sense: switching window focus, moving buffers around windows, splitting or closing them and so on. Even if you’ve got display-buffer all sorted out and your windows grouped into workspaces, these are the kinds of things you have to do with windows – repeatedly and often – in the course of minute-to-minute, regular editing.

Let’s address a couple of common concerns and dismissals before we get started in earnest.

Warming up

Our appetizer: a short run-through of the most popular and commonly recommended window management options. These cover changing the focused window, moving windows around and undoing oopsies, with a side of buffer management and bespoke window actions This is the part you can skip if you’ve been around the block a few times. Jump ahead to digging in. .

other-window and the “next window” (built-in)

other-window offers: selecting windows

The other-window (C-x o) command is the baseline window switching experience. It’s what the Emacs tutorial teaches you, and it works well enough when you have a small number of windows:

The window selection cycles (roughly) clockwise across the frame. The advantage of this approach is simplicity – it’s a single command and keybinding. As you might expect or have experienced, it takes progressively more invocations to get somewhere as you accumulate more windows, and works best if you rarely have more than two windows showing at once.

If you only ever have two windows showing in Emacs, or if you don’t mind punching o a few extra times, you can stop here. The rest is just varying degrees of optimization applied to a problem that you probably (and perhaps realistically) don’t believe needs solving!

windmove (built-in)

windmove offers: selecting windows, swapping buffers in windows, deleting them

Windmove is a built-in Emacs library for moving the focus across windows – and for moving buffers across windows – by direction. Vim users, this is what you expected. evil-mode users, you already use Windmove, you just don’t know it.

If other-window is the alt-tab of Emacs, Windmove is the tiling window manager equivalent. It makes the spatial arrangement of windows in the frame relevant to the selection, which I imagine is the most natural way to do it short of using the mouse.

Using Windmove is simple: bind windmove-left (resp -right, -up and -down) to a modifier or leader key plus whatever keys you associate with directions: WASD, HJKL or the arrow keys perhaps.

The fork: movement to the right in this schematic depends on what window is exactly to the right of the cursor. Calling windmove-right from near the top of buffer 1 moves the focus to buffer 2, starting near the bottom moves the focus to 3.

You can also swap the buffers of windows directionally with Windmove, a handy way of rearranging windows on the frame Again, Windmove is how evil-mode does this. . The relevant commands are windmove-swap-states-left, -right, -up and -down.

Note that the focus moves along with the buffer when you do this.

There’s more yet to Windmove, you can delete the window next along any direction with windmove-delete-*, for example. But we cover better ways to do this below.

frames-only-mode

frames-only-mode offers: to leave Emacs window handling to the OS.

While we’re on the subject of tiling, another resolution to the nested window manager situation – Emacs inside a tiling WM – is to simply not bother with Emacs’ window management. Opening every buffer in a new frame instead of window makes corralling them the window manager’s job. This puts Emacs buffers on par with OS windows, and you can manage both with the same keys.

Most other commands described in this write-up (such as Avy, winum, ace-window or scroll-other-window) can work across frames just as easily as windows, meaning that you can have the best of both approaches. There are bound to be edge cases with other Emacs commands though – many of them make assumptions about being able to split the frame at will This is especially true of org-mode commands! Thankfully the Org situation is slowly improving. .

winum-mode

winum offers: Selecting and deleting windows

Winum is next in the natural progression of the effort to switch between n windows: From O(n) (other-window) to O(√n) (windmove) to O(1). It adds window numbers to the mode-line so you can select windows by number:

There are two convenient bonus features:

• Invoking the command to switch to a window with a negative prefix argument deletes the window, and
• when the minibuffer is active, it is always assigned the number 0.

It’s simple and short, and works across Emacs frames. winum-mode is the method I use the most for switching windows.

(defvar-keymap winum-keymap
  :doc "Keymap for winum-mode actions."
  "M-0" 'winum-select-window-0-or-10
  "M-1" 'winum-select-window-1
  "M-2" 'winum-select-window-2
  "M-3" 'winum-select-window-3
  "M-4" 'winum-select-window-4
  "M-5" 'winum-select-window-5
  "M-6" 'winum-select-window-6
  "M-7" 'winum-select-window-7
  "M-8" 'winum-select-window-8
  "M-9" 'winum-select-window-9)
(require 'winum)
(winum-mode)

While it is possible to extend winum-mode to include other actions on windows (or on buffers displayed in them) besides switching to or deleting them, there’s little reason to, thanks to the existence of…

ace-window

Offers: Any window or buffer management action

ace-window is the endgame for keyboard-driven Emacs window control.

The ace-window command places “hints” at the top of each window, and typing in the key switches focus to the corresponding one:

So far it’s a slightly slower, two-stage version of winum. You can turn on ace-window-display-mode to have the hints always showing in the mode-line like winum’s window numbers, which speeds up the process a bit:

ace-window is to windows what Avy is to characters on screen The similar design is not a coincidence. They’re both authored by Oleh Krehel. . But jumping to a character on screen is the least useful of the many things you can do with Avy. Similarly, if all ace-window could do was switch windows, there wouldn’t be much to recommend it. Instead, it offers a generic method to “pick” a window, across all visible Emacs frames if necessary. What you do with this window is up to you. Similar to Avy, ace-window can dispatch actions on any window on the screen. So you can delete windows, move or swap them around, split them, show buffers in them and more – without moving away from your selected window. These are just the built-in actions, provided as part of ace-window:

Pressing ? when using ace-window brings up the dispatch menu See Fifteen ways to use Embark for further explorations of this idea. .

Mousing around (built-in)

The mouse offers: Any window or buffer management action

So, the pointer. Finally.

The advantanges of using the mouse for window management are immediate and obvious. Window selection is a natural extension of basic mouse usage. Resizing windows is a snap. Context (right-click) menus and drag and drop support, which improve with each new Emacs release, are very intuitive See context-menu-mode. Also, while not limited to window management, discoverability via Emacs’ menu-bar is surprisingly good. . Unfortunately, I have to address the rodent in the room before we can talk about mitigating the disadvantages, since Emacs users tend to be very opinionated about mouse usage.

I never use the mouse in Emacs… until I’m already using the mouse for something else. Then driving Emacs with the mouse is actually the path of least resistance. If your hand’s already off the keyboard, it’s pretty easy to drive Emacs with the mouse:

You may want to turn on focus-follows-mouse behavior:

;; Consider setting this to a negative number
(setq mouse-autoselect-window t)

transpose-frame (rotation, flip and flop)

transpose-frame offers: easy window layout transformations.

What it says on the tin: transpose-frame offers commands to rotate or mirror the window layout on the frame. I found myself using these often enough to bind rotate-frame, flip-frame and flop-frame to suitable keys. Ironically, the transpose-frame command itself is rarely useful – it transposes along the main diagonal of the frame.

rotate-frame

flip-frame

flop-frame

The window-prefix-map (built-in)

window-prefix-map offers: Bespoke window management commands

The window-prefix-map, bound to C-x w by default in Emacs, collects a few useful window-management commands:

split-root-window-right and split-root-window-below

Split the root window of the frame. Better illustrated than explained:

These are bound to C-x w 3 and C-x w 2 respectively.

These are the only built-in Emacs commands, to my knowledge, that allow you to modify the tree structure at a non-leaf level that doesn’t just clear the whole tree (as delete-other-windows does). Practically speaking, these are often useful to create a space for a logically separate task in the frame – the default splitting commands only further dice up existing windows.

Getting to grips with the tree arrangment should make a lot more fine-grained control available, but the tooling isn’t there yet – see below for a proposal.

tab-window-detach and tear-off-window

Handy commands to move a window into a new tab or a new frame.

Like splitting the root window, these are quite handy for logical window management: grab a window and move it into a new tab or frame to start a new task.

These are bound to C-x w ^ t and C-x w ^ f, which sheesh. You can do these as ace-window dispatch actions instead, since you can do anything with ace-window. Alternatively you can rebind these to the slightly saner C-x w t and C-x w f, which are currently unbound. I prefer to just use the mouse when I need to tear off a window:

;; mouse-9 is the "forward" button on my mousee
(keymap-global-set "M-<mouse-9>" 'tear-off-window)

The other-window-prefix (built-in)

other-window-prefix offers a method to decouple window selection from buffer display, and solves three window-related annoyances.

Annoyance I

Many Emacs commands tightly couple a primary action, a buffer and a window. For example, running find-file involves selecting a file, creating a buffer and displaying it in the current window. If you want to decouple the choice of window from the command, you have to pick one of several alternate commands: find-file-other-window, find-file-other-tab or find-file-other-frame, each with its own keybinding. If you want to open the file in read-only mode, you’ve got find-file-read-only, find-file-read-only-other-window, find-file-read-only-other-tab and find-file-read-only-other-frame. More keybindings.

Want the same choices when selecting a buffer? You’ve got switch-to-buffer-⋆, another constellation of commands. Opening a bookmark with bookmark-jump? Pick one of several bookmark-jump-* commands. This is the road to insanity.

The problem is the coupling: picking a window to display a buffer should be a separable action from the command’s primary function: opening a file, in this example. The solution is to call other-window-prefix, bound to (C-x 4 4). This makes it so that the next command – any command that involves displaying a buffer in a window – is shown in the next window, creating one if necessary. Now you only need find-file, find-file-read-only and switch-to-buffer, and can use the prefix to redirect the resulting buffer to another window when required:

1. Call other-window-prefix (C-x 4 4)
2. Call find-file, find-file-read-only, switch-to-buffer, bookmark-jump, or any command that shows a buffer.
3. Result: the buffer is shown in the next window.

In a past write-up I’ve mentioned Embark as the way. Indeed, Embark solves this problem more elegantly than the built-in other-window-prefix. But avoiding command proliferation is only the first of three problems other-window-prefix solves.

Annoyance II

In the above examples, we at least have the choice of calling *command*-other-window instead of *command*. There are just too many options. More often there are none, and we’re at the mercy of fixed, undesirable behavior. This is typically the case when activating a link-like object. In this example (from the Forge package), pressing RET on an issue title opens the issue in the current buffer:

Forge provides no way, as of this writing, to “open a link” in another window. other-window-prefix to the rescue:

Annoyance III

The third problem it solves is the combination of the first two. Consider: Magit, the sibling package to Forge, does provide a way to do this. It generally opens “links” in the next window if you use a universal arg (C-u) before RET. Org mode, Notmuch, Elfeed and EWW all provide either no way or mutually distinct ways of opening links in a different window. If Forge did provide a way, it would actually make things worse in a sense. With other-window-prefix, you’re blessedly free from having to customize or conform to each package author’s idea of how this should work. Run other-window-prefix, then activate the “link” object – click on it with the mouse if you’d like. It’s going to uniformly open in the next window.

See also: same-window-prefix (C-x 4 1), which forces the next command’s buffer (if there is one) to use the current window, and other-frame-prefix (C-x 5 5) and other-tab-prefix (C-x t t), which open the next command’s buffer in a new frame and tab respectively.

Further below we take this approach to its logical extreme with (what else) ace-window, redirecting the next command’s buffer to any window, including ones we create just-in-time.

Saving and restoring window configurations

window-configuration-to-register is a bit of a blunt instrument, but perfect as a big red reset button, especially if you’re new to Emacs. At any point, you can save the current window configuration to a register A register is a named bucket that can hold many kinds of data. Each register is assigned to a character (like a through z), and operations on register are available under the C-x r prefix. with this command, bound to C-x r w by default. After Emacs predictably messes up the frame, you can restore your saved configuration with jump-to-register (C-x r j). That’s it.

One issue with this method is that it restores the window arrangement down to each window’s cursor position, which is rarely what you want.

Another problem is that it requires an unreasonable level of foresight to remember to save window configurations at appropriate times. If only Emacs could do this automatically for us every time the window configuration changed…

The “oops” options

…which of course it can. You can ask Emacs to maintain a stack of your past window arrangements, and cycle through them as you would through changes in a buffer with undo/redo. You’ve got three minor-modes depending on how you use Emacs, and you can turn them on independently.

winner-mode

If you don’t use tabs. Call winner-undo and winner-redo to undo/redo window configuration changes. It maintains a separate window configuration history for each frame.

tab-bar-history-mode

If you use tabs. Each tab gets its own history stack. The relevant commands are tab-bar-history-back and tab-bar-history-forward.

undelete-frame-mode and tab-undo

If you use create and delete frames or tabs all the time. If you close a frame by accident, you can call undelete-frame, bound to C-x 5 u. Ditto tab-undo, bound to C-x t u.

These options are handy for going on excursions, such as when you want to maximize the selected window temporarily before reverting to the previous arrangement.

But winner-mode & co are also frequently recommended as a band-aid for when Emacs messes up your careful manual window arrangement, for instance by popping up windows in the wrong places, or resizing your window splits. I think of this as an antipattern. If you find yourself using winner-undo (or equivalent) all the time to fix Emacs’ behavior, the problem is Emacs displaying buffers in the wrong windows in the first place, a result of frustrating defaults. See the whack-a-mole problem.

Digging in

With our appetite whetted, we can move onto our main course: Tweaks, customization and variations of the above tools that I’ve found to work better.

Emacs can be frustrating on two levels. It’s frustrating at first because you don’t know your way around the place, the keybindings and terminology are obtuse, and nothing works the way it does in other software. Your attempts at mitigating its perceived shortcomings by installing packages leads to mysterious, cryptic errors. The single-threadedness makes it too easy to accidentally slow things down to a crawl. The garbage collector fires at the worst times. Things that should just work, don’t. The perceived shortcomings of Emacs are frustrating: Window management shouldn’t be this complicated!

Over time (years, decades?) you can develop a better mental model of what’s happening under the hood: how Emacs’ event loop works, the anatomy of buffers, windows, keymaps, text properties and overlays – the data structures Emacs is built on. Perhaps you even steal some sneaking glances at the lumbering behemoth that is redisplay. You’re familiar with common Elisp idioms and macros, as well as the common traps. Now the actual shortcomings of Emacs’ API are frustrating: Window management shouldn’t be this complicated!

Oops.

So here we are. The rest of this write-up is aimed at someone in between these two kinds of frustration. It’s mostly me throwing out suggestions, many of them mutually exclusive, that might give you ideas of your own to work with windows. Implementing these ideas will require a little tweaking, copying code verbatim might not give you the results you expect. For this reason, I suggest coming back here with a little more Emacs mileage if you’re new to Emacs.

The back-and-forth method

Offers: Quick window selection

An observation: no matter how many simultaneous windows you have or require on screen, most of the time you only need to switch between two of them. Examples include the Code & REPL setup, the Code & Grep (search results) setup, and the Prose & Notes setup. The Listing & Item pattern is an example outside of programming or prose: this includes a calendar or agenda window with an expanded entry window, or an email inbox window with an opened email.

The other windows on screen usually show useful information – documentation, debugging info, messages, logs or command output, table of contents, a file explorer, document previews – things you glance at often but switch to rarely.

Usually major-modes provide semi-consistent keybindings to switch back and forth between two associated windows – a common example is C-c C-z, used by several programming modes in Emacs to switch between a code window and an associated REPL This works for Org-babel blocks too via org-babel-switch-to-session, bound via org-babel-map to the slightly different C-c C-v C-z. .

But we can generalize the idea and provide a command to switch between any pair of windows:

(defun other-window-mru ()
  "Select the most recently used window on this frame."
  (interactive)
  (when-let ((mru-window
              (get-mru-window
               nil nil 'not-this-one-dummy)))
    (select-window mru-window)))

(keymap-global-set "M-o" 'other-window-mru)

It doesn’t matter how you select the second window for the back-and-forth – you could use the mouse, ace-window, winum or any other method. other-window-mru’s got you covered from then on.

Improving other-window

We can retain the basic idea of other-window – move between windows in the frame in some cyclic ordering – but improve the ordering to be more of a DWIM affair Do-What-I-Mean .

other-window is a simple idea – the simplest you’ll find in this write-up – but you can play around with the order in which windows are selected to better fit how you work.

Double duty

First, you could make other-window split the frame when there’s only one window, giving the command a use when it has none.

(advice-add 'other-window :before
            (defun other-window-split-if-single (&rest _)
              "Split the frame if there is a single window."
              (when (one-window-p) (split-window-sensibly))))

switchy-window

Another modification that you might find intuitive is to cycle through windows in order of last use instead of in clockwise spatial order, similar to alt-tab or how some web browsers cycle through tabs. This is possible with some elbow grease, but this work has been done for us by the switchy-window package, which provides a switchy-window substitute command for other-window.

When cycling through windows, switchy-window waits for a window to stay selected for a couple of seconds before marking it as used and updating the recency list. In practice this works quite seamlessly – calling switchy-window moves you to to where you need to be most of the time.

That said, I usually prefer the simpler variant described in the back-and-forth method.

other-window-alternating

And speaking of back-and-forth, here’s another other-window variant – it might sound confusing at first, but turns out to be a pleasingly DWIM affair. Except when chaining other-window, reverse the window-switching direction after each call. With just two windows, this makes no difference. With more, this makes alternating between two windows natural, even when the windows are not adjacent in the cyclic ordering.

(defalias 'other-window-alternating
    (let ((direction 1))
      (lambda (&optional arg)
        "Call `other-window', switching directions each time."
        (interactive)
        (if (equal last-command 'other-window-alternating)
            (other-window (* direction (or arg 1)))
          (setq direction (- direction))
          (other-window (* direction (or arg 1)))))))

(keymap-global-set "M-o" 'other-window-alternating)

;; repeat-mode integration
(put 'other-window-alternating 'repeat-map 'other-window-repeat-map)
(keymap-set other-window-repeat-map "o" 'other-window-alternating)

Window magic with ace-window dispatch

ace-window is to windows what completing-read is to lists of strings, or Avy to characters on screen. This makes it ideal as the first two of a three-step process to invoke any action on any window: the filter and selection steps:

aw-select, the completing-read for Emacs windows

The way ace-window is designed to be extended is by defining an “ace-window action” and adding a binding for it in aw-dispatch-alist It ships with several predefined actions, captured in this schematic above. . This function accepts a window and does something useful with it. The ace-window command acts as the entry point:

This control flow is generally similar to how Avy works. But as a completing-read alternative, this is somewhat lacking – we’d like to flip the pattern around and use ace-window’s selection method in our commands. Conveniently, aw-select does exactly that.

The basic pattern is very simple: the call (aw-select nil) The argument to aw-select is for adding a message to the mode-line during the selection process, we don’t bother with that. returns the window we select, which we can use for our task. One example of such a task is to set the window that scroll-other-window should scroll. Here are a couple more, but don’t try them just yet! We’re going to generalize the idea a little further below.

tear-off-window or tab-window-detach

Every interactive window command in Emacs acts on the current window. Here we make a couple of commands in the window-prefix-map (C-x w) something you can apply interactively to any window.

(defun ace-tear-off-window ()
  "Select a window with ace-window and tear it off the frame.

This displays the window in a new frame, see `tear-off-window'."
  (interactive)
  (when-let ((win (aw-select " ACE"))
             (buf (window-buffer win))
             (frame (make-frame)))
    (select-frame frame)
    (pop-to-buffer-same-window buf)
    (delete-window win)))

(defun ace-tab-window-detach ()
  "Select a window with ace-window and move it to a new tab."
  (interactive)
  (when-let ((win (aw-select " ACE")))
    (with-selected-window win
      (tab-window-detach))))

Of course, defining one ace-window-based command for each action isn’t a scalable or useful way to go about this. It would be preferable to decouple the window selection step from the action step and generalize the latter. We explore two distinct approaches to do this, starting with…

ace-window-one-command: Any command with ace-window

Generalizing the above examples gives us a pretty good idea of what the flipped ace-window pattern should look like. The most general and composable version would be the following:

1. Call aw-select to pick a window (the completing-read step)
2. Run any action in this window
3. Switch back to the original window.

We can do this by simulating Emacs’ event loop, but in the chosen window: Switch windows, then read any key sequence and execute it before switching back.

(defun ace-window-one-command ()
  (interactive)
  (let ((win (aw-select " ACE")))
    (when (windowp win)
      (with-selected-window win
        (let* ((command (key-binding
                         (read-key-sequence
                          (format "Run in %s..." (buffer-name)))))
               (this-command command))
          (call-interactively command))))))

(keymap-global-set "C-x O" 'ace-window-one-command)

In a demo, this looks the same as ace-window, except that you select the window before executing the action. The win here is the action: it works with any simple command, there is no need to pre-configure actions in aw-dispatch-alist. There’s nothing to set up or memorize. In this demo I use ace-window-run-command to shrink an unselected window with C-x - (the descriptively named shrink-window-if-larger-than-buffer)

ace-window-one-command is a convenient way to quickly run any command in a different window, an idea we explore in more detail below.

A window-prefix command for ace-window

Handy as it is, the other-window-prefix system has the same problem as the other-window command: it enforces a rigid cyclic ordering on the window it will pick, and about the most we can consistently expect is that the active window will not be taken over by the next command. We can do better.

aw-select gives us a bespoke solution with more control: we select the window that should be used if the next command involves displaying a buffer in a window. In this example, we explicitly pick a window to show a man page in, since the “next window” is not where we want it:

Here’s the example from above of viewing a Forge link in a busy frame with many windows. We compare the result of using other-window-prefix, where a random window is chosen, to using ace-window-prefix, where we can pick a specific window:

ace-window works across visible frames, so we can pick any Emacs window on our screen. Even better, we can use ace-window actions to create new windows on the fly and use them instead. Here I use an ace-window action to create a new window to be used by the next command:

The implementation of ace-window-prefix is actually simpler than other-window-prefix:

(defun ace-window-prefix ()
  "Use `ace-window' to display the buffer of the next command.
The next buffer is the buffer displayed by the next command invoked
immediately after this command (ignoring reading from the minibuffer).
Creates a new window before displaying the buffer.
When `switch-to-buffer-obey-display-actions' is non-nil,
`switch-to-buffer' commands are also supported."
  (interactive)
  (display-buffer-override-next-command
   (lambda (buffer _)
     (let (window type)
       (setq
        window (aw-select (propertize " ACE" 'face 'mode-line-highlight))
        type 'reuse)
       (cons window type)))
   nil "[ace-window]")
  (message "Use `ace-window' to display next command buffer..."))

In keeping with the keybinding pattern for the ⋆-window-prefix commands, we bind it to C-x 4 o

(keymap-global-set "C-x 4 o" 'ace-window-prefix)

Do you need to switch windows?

Let’s pause for a moment to ask a basic question: why do you need to switch windows in the first place? A little reductive thinking distills the answer down to two – and only two – possibilities:

1. Switch and stay: To work persistently in the destination window, for some measure of “work”: this covers text editing in all its forms. In this event the window we switch to becomes our primary work area.
2. Switch and return: To interact with the window or its contents briefly. Perhaps we want to scroll through, or copy some text before moving back, or to delete the window. In this event the window is a temporary destination, for auxiliary purposes.

In either case, switching windows is a cost, not our objective. Ideally this should happen automatically as part of our editing process. So why not just “fold” this little chore into our primary editing action?

Switch and stay: Avy as a window switcher

Eventually any kind of navigation in Emacs comes down to Avy. If you are switching windows to edit (or select) text, you intend to move to a specific point on the screen. Getting the cursor there is a two step process: switch windows, move the cursor to the right location. Avy short-circuits this process into a single action. It treats the frame as a single pool of jump locations: in helping you jump to any character(s) on the screen, it moves you across windows seamlessly:

With a slight mental shift you can stop thinking of windows as distinct objects entirely, at least for the purposes of navigation. Any character(s) – across all visible Emacs windows and frames – is a couple of keypresses away. And it’s not the only way to jump across windows: you can jump back to your starting point (switching windows in the process) with pop-global-mark, for instance:

Of course, this only scratches the surface of what you can do with Avy, but that’s well tread ground at this point.

Switch and return: Actions in other windows

And here’s the other case. Often the reason you switch windows is to run a single logical action – perhaps a compound action like isearching to focus the view somewhere, before switching back to your main buffer. This is the switch → act → switch-back dance.

We’re going to automate this dance away in steps, working through solutions obvious and specific, through to repeatable and general, ending at the abstract and generic.

The obvious first: if you find yourself performing this dance repeatedly, you can automate it with a keyboard macro (left as an exercise for the reader). If the action is something you do all the time, you can go a step further and write a general-purpose command. ace-window-one-command above would be one way to do it. Emacs paves the way for us with…

scroll-other-window (built-in)

scroll-other-window and scroll-other-window-down have been part of Emacs for ages, perhaps because it fits neatly into the two-window paradigm that Emacs’ default settings are suited for: editing in one window while using the contents of the other one as a reference. You can scroll up and down in the other window without leaving this one. Note that this works with any number of windows: the window that is scrolled is the “next window”, clockwise from the current one. In this schematic, the selected window is the one with the border, the one that scroll-other-window scrolls is the one with the arrows:

With more than two windows this requires careful placement of windows to work as expected. For instance, you cannot have three side-by-side buffers (1-3 above) and use 1 as a reference when working in both 2 and 3, since scroll-other-window in 2 will scroll 3. Thankfully, we can specify the rule by which to select the window for scrolling. One option is

(setq other-window-scroll-default #'get-lru-window)

which will always scroll the least-recently-used window, since you won’t be wading into buffer 1 – the reference – often. Alternatively, you might want scroll-other-window in buffers 2 and 3 to scroll each other as you switch between them and ignore buffer 1. You’d then use the most-recently-used window:

(setq other-window-scroll-default
      (lambda ()
        (or (get-mru-window nil nil 'not-this-one-dummy)
            (next-window)               ;fall back to next window
            (next-window nil nil 'visible))))

This works great with The back-and-forth method.

(defun ace-set-other-window ()
  "Select a window with ace-window and set it as the \"other
window\" for the current one."
  (when-let* ((win (aw-select " ACE"))
              (buf (window-buffer buf)))
    (setq-local other-window-scroll-buffer buf)))

isearch-other-window

Continuing with the idea of using a buffer in another window as a reference, a straightforward extension of scroll-other-window is to search the “next window” instead isearch is a fantastic navigational tool. . We make sure to search in the same window that we’ve configured to scroll with scroll-other-window above.

(defun isearch-other-window (regexp-p)
    "Function to isearch-forward in the next window.

With prefix arg REGEXP-P, perform a regular expression search."
    (interactive "P")
    (unless (one-window-p)
      (with-selected-window (other-window-for-scrolling)
        (isearch-forward regexp-p))))

(keymap-global-set "C-M-s" #'isearch-other-window)

The function other-window-for-scrolling returns a suitable window, respecting our choice of other-window-scroll-default above.

Here’s an example of using isearch-other-window to work in a shell and a documentation (Man) buffer together:

The keybinding C-M-s is already bound to isearch-forward-regexp, but there are many other ways to call that command: via a prefix arg to isearch-forward (C-u C-s), or by toggling regexp search with M-r when isearching, for instance.

Switch buffers in the next window.

You can have hundreds of buffers in Emacs but only a handful of windows. This is, in fact, the source of the window management problem. So any comprehensive solution has to involve changing buffers shown in existing windows. The ace-window dispatch system is one solution. But the built-in next-buffer and previous-buffer commands offer another easy 80% solution to changing buffers shown in other windows: we just automate away the window switching dance. We don’t need a dedicated next-buffer-other-window command for this – we can just replace next-buffer with the new function.

(defun my/next-buffer (&optional arg)
  "Switch to the next ARGth buffer.

With a universal prefix arg, run in the next window."
  (interactive "P")
  (if-let (((equal arg '(4)))
           (win (other-window-for-scrolling)))
      (with-selected-window win
        (next-buffer)
        (setq prefix-arg current-prefix-arg))
    (next-buffer arg)))

(

We’ve been having great weather this past week in San Francisco, where the days have been balmy. I enjoy being outside in the early evening, and often wonder when sunset is. As it turns out, Emacs has a command to help answer that: sunrise-sunset. Running it will display the sunrise and sunset times for the current day in the mini-buffer.

Before you use sunrise-sunset, you’ll need to customize two variables to establish your location:

• calendar-latitude
• calendar-longitude

Use your maps app/website to help find those values and set them appropriately with either the command customize-variable or your configuration method of choice.

Once done, run M-x sunrise-sunset to get the sunrise and sunset times for the current day.

If you want the sunrise and sunset times for a different date, use C-u M-x sunrise-sunset. You’ll be prompted for the year, month, and day.

If you are in an Org Agenda or Calendar (calendar) window, you can get the sunrise and sunset times for the day the point is on by pressing S.

In the rare event of Emacs not being able to get the correct time zone from your operating system, you can set some variables manually as described in the Emacs manual. Regardless, use your favorite weather app/website to confirm that the sunrise and sunset times being returned by Emacs are correct.

Hope that this knowledge brings you as much joy as its done for me. I’ve used this to plan for many a great day.

References

• Sunrise/Sunset (GNU Emacs Manual)

We’re joined by Theda Hammel & John Early to revisit director Howard Hawks, this time look at two of his classic screwball comedies: 1940’s His Girl Friday and 1938’s Bringing Up Baby. Both feature Cary Grant in complete goofball-mode bedeviled by brassy women who refuse to give him a dang break. His Girl Friday adds the levity of newsroom hijinks while reporting on the impending execution of an accused murderer, while Baby brings us the hilarious light touch of Grant and Katharine Hepburn dealing with a live leopard. 

Theda & John’s new movie Stress Positions is in theaters now!

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

Enlarge / The Environmental Working Group published a new analysis on Wednesday outlining its efforts to push the USDA for more transparency, including asking for specific rationale in allowing brands to label beef as “climate friendly.” (credit: Carolyn Van Houten/Washington Post via Getty)

About five miles south of Broken Bow, in the heart of central Nebraska, thousands of cattle stand in feedlots at Adams Land & Cattle Co., a supplier of beef to the meat giant Tyson Foods.

From the air, the feedlots look dusty brown and packed with cows—not a vision of happy animals grazing on open pastureland, enriching the soil with carbon. But when the animals are slaughtered, processed, and sent onward to consumers, labels on the final product can claim that they were raised in a “climate friendly” way.

In late 2022, Tyson—one of the country’s “big four” meat packers—applied to the US Department of Agriculture (USDA), seeking a “climate friendly” label for its Brazen Beef brand. The production of Brazen Beef, the label claims, achieves a “10 percent greenhouse gas reduction.” Soon after, the USDA approved the label.

Read 48 remaining paragraphs | Comments

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

The average farmer in America is no longer someone in gumboots mending fences and riding tractors. Barons is the story of seven corporate titans who now dominate the American food system. Many of them are still family-run companies worth billions. Austin Frerick says there are similar approaches to the industrialised food system that include political donations, cases of animal cruelty, worker abuses, corrupted academic research and the use of trade associations and shell companies to obscure links to their operations. And those companies are also operating in Australia.

Guest: Austin Frerick, fellow of the Thurman Arnold Project at Yale, and author, Barons: money, power, and the corruption of America’s food industry, published by Island Press.

Danny and Derek talk about the ceasefire proposal that Hamas accepted and the attack on Rafah that Israel seems intent on carrying out.

Read more

Tom, Tarence and (welcome to the show!) Aaron from the Trillbillies join us for another week of horror and spectacle around the War in Gaza. We touch on the ceasefire agreement being rejected basically as we were recording, some of the clumsy NYPD PR response to last week’s Columbia raid, and the pundit class tantrum over being denied free access to interviews with protesting students. But we also have some levity, in John Fetterman’s freakout over vat meat, the Biden admin’s flaccid signaling over marijuana legalization, and Patrick Bet-David’s praise for future God-Emperor Barron.

Find Trillbillies wherever you get podcasts, and subscribe here: https://www.patreon.com/trillbillyworkersparty

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

Ciarán is joined by João and Guilherme to have a pretty comprehensive talk about Portugal after the election and what lead to the rise of Chega

FIND OUR GUESTS:
https://twitter.com/certezamente
https://twitter.com/SexoGratweeto

GYROVISION is sold out, but you can watch on twitch.tv/cornerpaeti

HOW TO SUPPORT US:
https://www.patreon.com/cornerspaeti

HOW TO REACH US:
Corner Späti https://twitter.com/cornerspaeti
Julia https://twitter.com/KMarxiana
Rob https://twitter.com/leninkraft
Nick https://twitter.com/sternburgpapi
Uma https://twitter.com/umawrnkl
Ciarán https://twitter.com/CiaranDold

Support Corner Späti

Danny and Derek are back with Bryan Pitts, assistant director of the Latin American Institute at UCLA, talking about the history of Brazil. We’re now into the 19th century and Brazilian independence. The group discusses what led to this moment, the changing racial dynamics, liberalism in Brazil vs its European form, the emergence of coffee as its predom…

Read more

Emacs Elements is back with a useful video on Org mode internal links. If most of your Org documents are short—a blog post, say—you probably haven’t felt the need for internal links but if you, even occasionally, write longer form documents they can really help you navigate within your text.

The subject is a bit more complicated than you might think. There are five type of internal links that serve slightly different purposes. They are:

Headline Links

These links point to a particular headline. They aren’t necessarily precise. For example, if the section they point to is long and the information you’re interested in buried within the section, a more precise type of link may be called for.

Custom ID Links

These links point to whatever section has the Custom ID that the link points to. You can put them anywhere you can put a drawer.

Dedicated Target Links

These are the most precise links of all. They’re sort of like HTML anchors. They can be put anywhere in the text.

Radio Links

These are sort of like dedicated target links except that you don’t need a specially formatted reference. The idea is that anytime you use the name of the link in your text, a link reference is created. Their main use is for definitions. You tag the definition as a radio link and anytime you use the term in your text, a link is created to the definition.

The video does a good job of explaining the mechanics of using the various types of links so spend a few minutes with it or the documentation for the details. My only issue with the video is that it doesn’t discuss the shortcuts for entering links. They’re just like those for external links except that you choose a different link type.

The video is 11 minutes, 36 seconds so you shouldn’t have any problem finding time for it. It’s an excellent introduction to internal links and well worth a few minutes of your time.

We're almost back.

Article: https://www.theleftberlin.com/why-you-should-boycott-eurovision-if-israel-is-allowed-to-compete/

Links for Watching the songs this year in a boycott friendly way:
https://docs.google.com/document/d/e/2PACX-1vSpwhINbt71pnaPSs8jEkVs6llJmjX94shvsLTTyXfbPkPN90-XBVGQAn3OpUk3K-Q1qh6IkIMxPEq2/pub

There's a handful of tickets for Gyrovision left:
https://www.eventbrite.com/e/gyrovision-2024-tickets-840280269907

HOW TO SUPPORT US:
https://www.patreon.com/cornerspaeti

HOW TO REACH US:
Corner Späti https://twitter.com/cornerspaeti
Julia https://twitter.com/KMarxiana
Rob https://twitter.com/leninkraft
Nick https://twitter.com/sternburgpapi
Uma https://twitter.com/umawrnkl
Ciarán https://twitter.com/CiaranDold

Support Corner Späti

Riley from the Trashfuture podcast joins us to examine one of the few countries possibly even more benighted than our own, the dear old United Kingdom. After some brief remarks from Will & Felix touching on the ongoing incidents with university pro-Palestine encampments across the country (and we hope to do more on these events in the near future), Riley guides us through the UK’s slowly unraveling public infrastructure, domestic politics, and increasingly buffoonish elites.

Find Trashfuture wherever you get pods, and all things Trashfuture here: https://www.trashfuture.co.uk/

LAST CHANCE: join Will & Hesse this Saturday, May 4th for a screening and talkback of DEATH WISH 3 at Littlefield in NYC: https://www.eventbrite.com/e/chapo-trap-houses-movie-mindset-screening-of-death-wish-3-w-will-hesse-tickets-877569192077

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

Last week I wrote about Marcin Borkowski’s post on Emacs Everywhere, an application that lets you edit text in other applications with Emacs. As I said then, I’ve been using it for about a year but, shamefully, usually forget to invoke it.

That burning shame has motivated me to do better and I’ve been making a real effort to always use it when I have to write outside Emacs. What I’ve found is that I hardly ever write anything outside of Emacs. The two main exceptions are:

1. Responding to Irreal comments in WordPress
2. Writing texts in Apple’s iMessage

Happily, Emacs Everywhere handles both those cases beautifully. My only problem with it is that it doesn’t fill the Emacs buffer with whatever is already in the other application’s text buffer. That’s not much of a problem because I usually want to start de novo anyway. If I do need the text from the application’s text buffer, I can simply cut and paste it.

Installation is simple. Here’s my configuration:

(use-package emacs-everywhere
  :ensure t)

The harder part is getting your OS to call it when needed. The repository has some suggestions but whatever you usually use for this type of thing should work.

I’m writing about this again to encourage those who also hate writing outside of Emacs to give Emacs Everywhere a try. It works really well and, if you’re like me, will save you the stress of leaving the one true writing environment.

Alex joins us again to catch up on the ongoing pro-Palestinian protests and the range of responses to them, from blatant attempts to provoke the protesters, to complaining about encampments ruining your teaching of silence. Then, Kristi Noem killed her dog, the defrocking of an AI priest, and Trump expressions that live in our heads.

Tickets to Will & Hesse’s Movie Mindset screening & talkback of Death Wish 3 in NYC on May 4: https://www.eventbrite.com/e/chapo-trap-houses-movie-mindset-screening-of-death-wish-3-w-will-hesse-tickets-877569192077

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

Melvyn Bragg and guests discuss the Serbian-American inventor Nikola Tesla (1856-1943) and his role in the development of electrical systems towards the end of the nineteenth century. He made his name in New York in the contest over which current should flow into homes and factories in America. Some such as Edison backed direct current or DC while others such as Westinghouse backed alternating current or AC and Nikola Tesla’s invention of a motor that worked on AC swung it for the alternating system that went on to power the modern age. He ensured his reputation and ideas burnt brightly for the next decades, making him synonymous with the lone, genius inventor of the new science fiction.

With

Simon Schaffer Emeritus Fellow of Darwin College, University of Cambridge

Jill Jonnes Historian and author of “Empires of Light: Edison, Tesla, Westinghouse and the Race to Electrify the World”

And

Iwan Morus Professor of History at Aberystwyth University

Producer: Simon Tillotson

Reading list:

W. Bernard Carlson, Tesla: Inventor of the Electrical Age (Princeton University Press, 2013)

Margaret Cheney and Robert Uth, Tesla: Master of Lightning (Barnes & Noble Books, 1999)

Thomas P. Hughes, Networks of Power: Electrification in Western Society, 1880-1930 (Johns Hopkins University Press, 1983)

Carolyn Marvin, When Old Technologies Were New (Open University Press, 1988)

Iwan Rhys Morus, Nikola Tesla and the Electrical Future (Icon Books, 2019)

Iwan Rhys Morus, How The Victorians Took Us To The Moon (Icon, 2022)

David E. Nye, Electrifying America: Social Meanings of a New Technology (MIT Press, 1991)

John J. O’Neill, Prodigal Genius: The Life of Nikola Tesla (first published 1944; Cosimo Classics, 2006)

Marc J. Seifer, Wizard: The Life and Times of Nikola Tesla, Biography of a Genius (first published 1996; Citadel Press, 2016)

Nikola Tesla, My Inventions: The Autobiography of Nikola Tesla (first published 1919; Martino Fine Books, 2011)

Nikola Tesla, My Inventions and other Writings (Penguin, 2012)

In Our Time is a BBC Studios Audio production

Jonathan Hunt, assistant professor at the U.S. Naval War College and a fellow of the Nuclear Security Program at Yale University, joins Danny and Derek to talk about his book covering the efforts of a select few world powers to maintain exclusive access to nuclear weapons. In this first part, they discuss US efforts to maintain nuclear supremacy in the early Cold War, nuclear threshold states, nuclear propaganda, and more up until Eisenhower’s “Atoms for Peace” speech.

Subscribe now

Note: The views expressed here are those of the author alone and do not necessarily represent the views, policies, or positions of the U.S. Department of Defense or its components, to include the Department of the Navy or the U.S. Naval War College.

Emacs has long had a computer algebra system (CAS) packaged within it via Calc, but for many is unused because of its user interface design. Casual aims to provide a much easier CAS user experience and this post aims to illustrate this by example. With Casual you can focus more on math and less on tooling.

Let’s start with the polynomial expression f(x) = x³ - 4 x² - 11 x + 30.

With f(x) we will perform the following tasks:

1. Factor and expand f(x).
2. Determine the root values of f(x).
3. Find the derivative d(f(x))/dx. Integrate d(f(x))/dx and compare with f(x).
4. Plot both f(x) and d(f(x))/dx.
5. Determine minimum and maximum values of f(x) and d(f(x))/dx.

Factor and Expand f(x)

First start Calc and use algebraic entry (') to enter the following expression on the stack.

'x^3 - 4 x^2 - 11 x + 30

Let’s store this expression in the variable named f.

To do this invoke the Casual Main Menu (typically C-o) as shown below.

Under the Stack section, press z for the Variables menu.

Press s to store the expression. You will be prompted to name the variable to store. Enter f.

Enter C-g to go back to the main menu. Press a to invoke the Algebra menu as shown below.

With this menu raised, let’s factor the expression f(x) with respect to x by pressing f. The following result is put on the stack.

1

1:  (x + 3) (x - 2) (x - 5)

To return to the previous form, let’s expand this expression by pressing e.

1

1:  x^3 - 4 x^2 - 11 x + 30

Determine the root values of f(x)

To determine (or solve) for the root values of f(x), we can use the commands in the Symbolic Solutions menu navigated to via (a) Algebra ➡︎ (s) Symbolic as shown below.

Choosing s will provide a solution for f(x), but not all its solutions. To get all solutions, use p. You will be prompted in the mini-buffer for a variable to solve for. Enter x. The solution is returned as a vector with each element being a value of x that satisfies f(x) = 0.

1

1:  [5, 2, -3]

This result is consistent with the factored representation of f(x) determined above.

Derivation and Integration

To demonstrate derivation and integration, we will recall the saved variable f with the keypress sequence (z) Variables ➡︎ (r) Recall in the Algebra menu (or alternately, from the Casual Main Menu). Enter f in the prompt.

From the Algebra menu, press (d) Derivative and when prompted, enter x.

The result will be:

1

1:  3 x^2 - 8 x - 11

Store this in variable dfx.

To get the integral of dfx, from the Algebra menu press (i) Integral and when prompted, enter x.

The result will be:

1

1:  x^3 - 4 x^2 - 11 x

Note that the original constant of 30 in f(x) is lost due to derivation.

Plot f(x) and d(f(x))/dx

Casual can help you visualize these expressions. Given the solution vector, let’s plot both f(x) and d(f(x)) over the interval x ∈ [-4..6] which includes all solutions for x.

First we will plot f(x). Recall the variable f onto the stack. From either the Casual Algebra or Main menu, press g to raise the Graphics menu.

Press e to add a 2D equation to the plot. You will be prompted for an interval. Enter “[-4..6]”. Next you will be prompted for a title. Enter “f(x)”. A plot of the function should be displayed in a separate Gnuplot window. By default, Calc uses 15 points to draw a curve. We can make the curve smoother by choosing n for # Data Points and entering 50.

We can style the plot further by pressing S. This presents the following menu:

Press k to show the key (a.k.a. legend). Other options like setting the labels for the x and y axis are available from this menu.

Go back to the Casual Main menu and recall the function dfx. Plot dfx using the same interval and enter d(f(x))/dx for its title.

The resulting plot should look as shown below:

Find Minimum and Maximum

Looking at the plot can see there is a minimum for the d(f(x))/dx between [0..3]. We can find this minimum value from the Algebra menu: (n) Numeric ➡︎ (m) Find Minimum. Make sure that the expression dfx is at the top of the stack. You will be prompted for the interval and variable ([0..3], x). Calc will compute this value to be [1.33333, -16.3333], where the first element is x and the second f(x).

A similar exercise can be done to find the maximum value of f(x). Recall the expression f to the top of the stack. Use the interval [-2..0]. The computed result should be [-1., 36.].

Saving Work

You can save the variables you have defined by going back to the Variables menu and entering p to persist them. Both f and dfx will be available across restarts of Emacs.

Closing Thoughts

If you enjoy math as I do, hopefully this post will raise awareness of the CAS features of Calc and the ease of which Casual can provide access to them. A benefit to being an Emacs user is to know that these capabilities are only a few keystrokes away.

Krystal and Saagar discuss young voters abandoning Biden over Israel, Biden approval hits 70 year low, heated debate on campus protests, Israel deems all men in Rafah Hamas, John Mearsheimer wrecks Piers Morgan, professor claims Gaza protests are caused by lack of sex, and Jill Stein joins to discuss her 2024 campaign.

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

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

See omnystudio.com/listener for privacy information.

Krystal and Saagar discuss a new documentary from Jordan Chariton on Flint Michigan 10 years later, then we talk to Dana Mattioli about her new book on Amazon's monopoly "The Everything War", and James Li talks to Jen Perelman who is running for Congress against Debbie Wasserman-Schulz about AIPAC and student protests.

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

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

See omnystudio.com/listener for privacy information.

Krystal and Saagar discuss exclusive BP polling showing cable viewers brainwashed on Israel, Jill Stein arrested at protests, Howard Stern tongue bathes Biden, SCOTUS fatal blow to Trump case, Trump loses it on RFK over vaccines, Biden blocking ICC Bibi arrest warrants, ADL freaks on Ilhan Omar, Kristi Noem brags about puppy murder, Colin Jost fawns over Biden decency amid genocide.

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

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

See omnystudio.com/listener for privacy information.

In this week's case Alfie turns bounty hunter and goes on the hunt for a wanted man (an infamous bike thief).

Join Alfie and his audience of sworn-in deputies as they decide how to get their man.

Written and presented by Alfie Moore Script Editor: Will Ing Production Co-ordinator: Katie Baum Producer: Sam Holmes

An EcoAudio Certified Production A BBC Studios Audio Production