This is a swapcast with Kristaps Andrejsons, host of the Eastern Border podcast. We talk about  life in Latvia, what it’s like to be a small former Soviet republic country with a big neighbor like Russia, and the Ukraine war from a Baltic perspective. In a bonus segment we discuss the increase in NATO troops in Europe and the Baltic countries. 

Kristaps Andrejsons is an historian and a podcaster from Riga, Latvia, He hosts a podcast called Eastern Border about the politics and the history of the eastern Europe and the USSR and the Baltic region but which is now mostly focused on the war in neighboring Ukraine. 

FOLLOW Kris and the podcast on Twitter at @Eastern_Border and find the podcast on podcast apps and Youtube and the website theeasternborder.lv. 

Around the Empire aroundtheempire.com is listener supported, independent media.

SUBSCRIBE/FOLLOW on Rokfin rokfin.com/aroundtheempire, Patreon patreon.com/aroundtheempire, Paypal paypal.me/aroundtheempirepod, YouTube youtube.com/aroundtheempire, Spotify, iTunes, iHeart, Google Podcasts

FOLLOW @aroundtheempire and @joanneleon.  Join us on TELEGRAM https://t.me/AroundtheEmpire

Find everything on http://aroundtheempire.com  and linktr.ee/aroundtheempire

Recorded on June 29, 2022. Music by Fluorescent Grey.

Reference Links:

1. Baltic Citizens Worry They’re Next on Russia’s Menu: Moscow’s aggression has stirred old fears in its neighbors, Kristaps Andrejsons
2. Russia and Ukraine Are Trapped in Medieval Myths: A shared past underpins—and worsens—the conflict.
3. Putin’s Speech Laid Out a Dark Vision of Russian History: There’s no room for Ukraine in the Russian leader’s distorted telling of the past.
4. Eastern Border Podcast: War in Ukraine: Famine

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

Melvyn Bragg and guests discuss the abrupt transformation of stars after shining brightly for millions or billions of years, once they lack the fuel to counter the force of gravity. Those like our own star, the Sun, become red giants, expanding outwards and consuming nearby planets, only to collapse into dense white dwarves. The massive stars, up to fifty times the mass of the Sun, burst into supernovas, visible from Earth in daytime, and become incredibly dense neutron stars or black holes. In these moments of collapse, the intense heat and pressure can create all the known elements to form gases and dust which may eventually combine to form new stars, new planets and, as on Earth, new life.

The image above is of the supernova remnant Cassiopeia A, approximately 10,000 light years away, from a once massive star that died in a supernova explosion that was first seen from Earth in 1690

With

Martin Rees Astronomer Royal, Fellow of Trinity College, Cambridge

Carolin Crawford Emeritus Member of the Institute of Astronomy and Emeritus Fellow of Emmanuel College, University of Cambridge

And

Mark Sullivan Professor of Astrophysics at the University of Southampton

Producer: Simon Tillotson

It's an extremely discouraging political moment for our neighbors in the United States, so we decided the time was right to finally examine one of the quintessential cinematic articulations of American exceptionalism, FORREST GUMP (1994). Is life, in fact, like a box of chocolates? We investigate.

"The Man Who Loved Presidents: On John Meacham" by Thomas Frank - https://harpers.org/archive/2021/07/jon-meacham-thomas-frank-soul-of-america/

"Tom Hanks Explains It All" by David Marchese - https://www.nytimes.com/interactive/2022/06/13/magazine/tom-hanks-interview.html

Michael and Us is a podcast about political cinema and our crumbling world hosted by Will Sloan and Luke Savage.

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

What would Emacs be without Emacs Lisp? Elisp is there to help you with the bugbears that bedevil your daily life.

And I think that’s great! Knowing elisp greatly expands your capabilities in Emacs. But, but, maybe you don’t know it — it’s yet another thing to learn. You may not have the time or the inclination. That’s especially true if you just want to customize or automate simple tasks.

Not everyone who uses Emacs is a programmer. It has a wide audience, and that’s a really good thing, too. But that also ratchets up the difficulty if you have to pick up a programming language – possibly your first ever – to get simple things done. It’d be nice if you didn’t have to do that for simpler tasks. That’s where keyboard macros enter the frame. In Emacs they are very powerful, and as I’ll show you in a moment, more than capable of great feats of automation.

Keyboard macros are misunderstood, and they can do an awful lot more than most people think they can do. They’re amazing for text editing. But they can do so much more than that. And the reason for this knowledge gap – even in people possessing much Emacs-fu – is that it’s hiding its capabilities in plain sight. That, and the siren song of elisp: it calls out to all of us, but you need not heed its call if you just want to do simple automation!

Emacs’s keyboard macros can do pretty much everything you can do, except make human decisions about what to do next – but even here Emacs’s macro system has a few tricks up its sleeve.

Because Emacs is able to record and play back nearly anything in a keyboard macro, you can leverage that to do things you wouldn’t normally think a keyboard macro should do, like:

Modifying your window layout

Like your windows split a certain way, with certain buffers in certain places? Why not record a macro to do it for you. You can make it resize the windows, too.

And if you need it, you can create several macros. Each one turns your window layout into something specialized and specific to your immediate needs. You can mix in some frame and tab action, too!

Just make sure you start with a call to C-x 1 to reset the windows back to one when you start the recording.

Heck, you can even tell your macro to store the idealized window configuration in a register before it stops, if you’d rather recall your setup from one of those. (Window configurations are registers and they don’t persist between Emacs sessions.)

Visit files and Special Buffers

Combined with custom window layouts, you can have Emacs open a particular file in each window. Open up a magit buffer, maybe M-x calendar, or something else entirely.

Speed up interactions with Org mode

Do you regularly open up the Org mode agenda, only to apply filters and settings? Sure, you can customize it, but maybe you can get by with a macro.

Call up a Shell and execute commands in it

Make it run C-u M-x shell (or Eshell, or Vterm, or…) and run some commands that you frequently need to do.

Or just call out to M-x comint-run or M-x compile for those one-off programs that you want to run. The possibilities are endless.

Search & replace common terms

If you find yourself having to bulk edit buffers, you can record a macro to do this for you. Maybe you have to make multiple passes, or you actually have to do some text editing with a macro. (Yes, it’s obviously great at that too.)

Why not combine it with tools like M-x rgrep or Xref to find text matches across a large swathe of files, and use M-g M-n in a keyboard macro to bulk edit? Record the macro so it does one file, and then play it back and watch as it churns its way through the list of matches in your *Grep* buffer.

OK, so those are just some of the things you can do with keyboard macros. And you know what, this approach will solve 80% of those annoying “I wish I knew elisp so I could solve this one problem” questions that frequently dog newer Emacs users. Window management is especially hard for beginners, particularly for those who come from IDEs with fixed layouts.

What keeps people from using macros for serious work is the mistaken impression that macros are impermanent and go away when Emacs does. By default they are impermanent, but you can tell Emacs to persist them with a couple of commands. More on that in a second. That makes ’em far more useful for repeat use.

But let me just quickly get the macro basics out of the way if you’re new to them.

Keyboard Macro Basics

If you’re new to them, here’s a very quick table to get you started. I’m just scratching the surface here. You can do a lot of crazy stuff with them. Just know that keyboard macro commands are named either kmacro- or they contain the word kbd. Many kmacro- commands are bound to the prefix key map C-x C-k. Explore it with C-x C-k C-h.

You can optionally give a prefix argument to C-x e or F4 to make it repeat the macro that many times. Use 0 to tell Emacs to run the macro until it gets an error signal. A macro plays back until it encounters an error (end of buffer, end of matches in *Grep* if you advance with M-g M-n, and so on.) Watch out if you’re waving C-g around in a macro — it terminates the recording!

If you call F3 when you’re recording, it’ll insert a number from a counter and increment it. Use a universal arg (C-u) and it’ll repeat the last number without incrementing it. You can pass a numeric arg to F3 to start the recording with a different number.

This feature’s obviously great for numerating lists.

But call F3 with C-u twice and you’ll instead append to your last macro.

You can do way more than this, but that’s the gist of it.

Naming and Saving Keyboard Macros

In order to persist a macro you have to name it first. You do that with C-x C-k n, or M-x kmacro-name-last-macro. Recorded macros enter a macro ring – much like the kill, history or undo rings – but I recommend you name them if you think you’ll use them again later. Much easier than trying to find it again with C-x C-k C-n and C-x C-k C-p. Try running a named macro by invoking it with M-x.

I strongly urge you to name your macros sensibly – ideally with a prefix. I use mp-.

To persist it, you can ask Emacs to spit out an interactive function (a command) that is a like-for-like Elisp representation of the macro. To do this call M-x insert-kbd-macro. Emacs will ask for a named macro and insert a code-generated, interactive function at point. I recommend you insert it in your init.el file. It’s already named and evaluated at this point.

One thing that annoys me, and maybe it annoys you too, is the inconsistent command naming. The logical answer is because the kbd-named commands predate the kmacro- ones by many years.

The naming scheme is inconsistent and it lacks a key binding. So let’s fix that:

(require 'kmacro)
(defalias 'kmacro-insert-macro 'insert-kbd-macro)
(define-key kmacro-keymap (kbd "I") #'kmacro-insert-macro)

Much better. Now you can find it again easily under kmacro- and it also has as its own key: C-x C-k I.

There’s also a way to bind macros to keys (with C-x C-k b) or registers (with C-x C-k x) but they won’t persist. I recommend that you instead just call M-x global-set-key or M-x local-set-key if you want commands temporarily bound to keys, notwithstanding the register stuff, which is a great feature, if you are already familiar with it. But the global/local set key commands have the added advantage that you can bind keys to any command you like, and not just keyboard macro commands.

Interactive Keyboard Macros

One neat, little feature is the ability to insert a macro query flag when you are recording a macro. A macro query is only triggered when you play it back. Emacs detects the query and pauses execution and cedes control back to you. To use it, type C-x q when you’re recording. There is no visual indicator when you type it, though.

On playback you are then asked to pick from one of these options when the macro reaches the query flag:

That makes it excellent for what I call interactive macros that require user input. You can place the macro query anywhere you like — even in a prompt, like query replace regexp with C-M-%. You can even prefill the prompt; Emacs will remember that also.

As the table shows, you’ve a number of options when control is ceded to you. I like C-r as it breaks out of the macro into a recursive edit session. Recursive editing is Emacs’s way of letting you pause something mid-way through, only to resume it later as though you were never gone. You can nest recursive editing levels more or less as much as you’d reasonably like.

You can even run a whole new macro inside a recursive editing step. You can even run the same one! It’s macros all the way down.

Emacs takes you back from whence you came when you back out of a recursive edit level with C-M-c. It’ll pick up where you left off when you entered it. You can tell you’re in a recurive editing step if you see [ ] in your mode line. ESC ESC ESC breaks out of all of them, if you just want to bail out now.

Lossage & Step-Editing Macros

When you type stuff Emacs keeps a record of it. Check it out: C-h l. You can turn parts of your lossage into a keyboard macro also with C-x C-k l. You can edit the buffer and use C-c C-c to commit the contents to a macro that you can then play back.

You can also edit the last macro you have set with C-x C-k C-e. Occasionally useful if you’re doing something complex and you made a slight mistake. It works the same as the lossage interface. Heck, you can create brand new macros this way also, if you’re crazy enough.

The pièce de résistance is the ability to step-wise edit a macro with C-x C-k SPC. Much like a debugger, you step through each playback step and you can decide what you want to do each step of the way.

The step editor is loosely modeled on the query replace interfaces (like M-% and C-M-%) so if you have some familiarity with that, your knowledge applies here too.

Stepping and editing is a supremely powerful feature that you should at least know about, even if you never use it. I find buffer editing a macro a bit easier to do as it’s easy to make a mistake step editing your macro, and before you know it you’re step editing your step edited macros. But the power of being able to step through and correct errors and insert or replace missing commands is undeniably powerful, and I’ve not even included all the commands you can use!

Conclusion

Macros are great. And you don’t need elisp to get started either. Being able to configure your window layout with a quick keyboard macro is actually a bit of a super power. If you want to do that in a way that is persistent and stable and easily interchangeable you don’t have many options beyond elisp; maybe the frameset library; and third-party packages.

And that’s to say nothing, of course, of the ability of keyboard macros to edit text. They’re definitely amazing at that also. But I think it’s all too easy to only look at them in that light. And if you’re new or unfamiliar with Elisp then it’s an easy way to supercharge your Emacs by recording how you want it done.

Oh, and believe me, I haven’t even scratched the surface of what you can do with keyboard macros in Emacs. So, if you do something cool with macros, I’d love to hear about it!

First thing is to set up emms.

I could simply enable all the emms features in one line,

(with-eval-after-load 'emms (emms-all))

But above setup makes filtering tracks very slow because it's too heavy weight.

So I use below setup,

(with-eval-after-load 'emms
  ;; minimum setup is more robust
  (emms-minimalistic)

  ;; `emms-info-native' supports mp3,flac and requires NO cli tools
  (unless (memq 'emms-info-native emms-info-functions)
    (require 'emms-info-native)
    (push 'emms-info-native emms-info-functions))

  ;; extract track info when loading the playlist
  (push 'emms-info-initialize-track emms-track-initialize-functions)

  ;; I also use emms to manage tv shows, so I use mplayer only
  (setq emms-player-list '(emms-player-mplayer)))

Play mp3&flac in "~/Dropbox/music",

(defun my-music ()
  "My music."
  (interactive)
  (emms-stop)
  (when (bufferp emms-playlist-buffer-name)
    (kill-buffer emms-playlist-buffer-name))
  (emms-play-directory-tree "~/Dropbox/music")
  (emms-shuffle)
  (emms-next))

Sometimes I need focus on challenge programming tasks and emms should play only Mozart&Bach.

(defvar my-emms-playlist-filter-keyword "mozart|bach"
  "Keyword to filter tracks in emms playlist.
Space in the keyword matches any characters.
 \"|\" means OR operator in regexp.")

(defun my-strip-path (path strip-count)
  "Strip PATH with STRIP-COUNT."
  (let* ((i (1- (length path)))
         str)
    (while (and (> strip-count 0)
                (> i 0))
      (when (= (aref path i) ?/)
        (setq strip-count (1- strip-count)))
      (setq i (1- i)))
    (setq str (if (= 0 strip-count) (substring path (1+ i)) path))
    (replace-regexp-in-string "^/" "" str)))

(defun my-emms-track-description (track)
  "Description of TRACK."
  (let ((desc (emms-track-simple-description track))
        (type (emms-track-type track)))
    (when (eq 'file type)
      (setq desc (my-strip-path desc 2)))
    desc))

(defvar my-emms-track-regexp-function #'my-emms-track-regexp-internal
  "Get regexp to search track.")

(defun my-emms-track-regexp-internal (keyword)
  "Convert KEYWORD into regexp for matching tracks."
  (let* ((re (replace-regexp-in-string "|" "\\\\|" keyword)))
    (setq re (replace-regexp-in-string " +" ".*" re))))

(defun my-emms-track-match-p (track keyword)
  "Test if TRACK's information match KEYWORD."
  (let* ((case-fold-search t)
         (regexp (funcall my-emms-track-regexp-function keyword))
         s)
    (or (string-match regexp (emms-track-force-description track))
        (and (setq s (emms-track-get track 'info-genre)) (string-match regexp s))
        (and (setq s (emms-track-get track 'info-title)) (string-match regexp s))
        (and (setq s (emms-track-get track 'info-album)) (string-match regexp s))
        (and (setq s (emms-track-get track 'info-composer)) (string-match regexp s))
        (and (setq s (emms-track-get track 'info-artist)) (string-match regexp s)))))

(defun my-emms-show ()
  "Show information of current track."
  (interactive)
  (let* ((emms-track-description-function (lambda (track)
                                            (let ((composer (emms-track-get track 'info-composer))
                                                  (artist (emms-track-get track 'info-artist)))
                                              (concat (if composer (format "%s(C) => " composer))
                                                      (if artist (format "%s(A) => " artist))
                                                      (my-emms-track-description track))))))
    (emms-show)))

(defun my-emms-playlist-filter (&optional input-p)
  "Filter tracks in emms playlist.
If INPUT-P is t, `my-emms-playlist-random-track-keyword' is input by user."
  (interactive "P")
  ;; shuffle the playlist
  (when input-p
    (setq my-emms-playlist-filter-keyword
          (read-string "Keyword to filter tracks in playlist: ")))
  (with-current-buffer emms-playlist-buffer-name
    (goto-char (point-min))
    (let* ((case-fold-search t)
           track)
      (while (setq track (emms-playlist-track-at))
        (cond
         ((my-emms-track-match-p track my-emms-playlist-filter-keyword)
          (forward-line 1))
         (t
          (emms-playlist-mode-kill-track))))))

  (emms-random)
  ;; show current track info
  (my-emms-show))

As you can see, a little EMMS api knowledge could go a long way.

If you want to study EMMS API by practice, run M-x emms-playlist-mode-go, then M-x eval-expression RETURN (emms-playlist-track-at) to get the information of the track at point.

Here is my real world emms setup where you can see below code,

(defvar my-emms-track-regexp-function
  (lambda (str)
    ;; can search track with Chinese information
    (my-emms-track-regexp-internal (my-extended-regexp str)))
  "Get regexp to search track.")

So I can use Pinyin to search track's Chinese information. I don't know any other multimedia manager can do the same thing.

On this week’s episode of Lever Time: David speaks with Democratic strategist Mark Longabaugh about what a potential Biden 2024 presidential run could mean for the future of the Democratic Party (7:46). Then, he’s joined by the hosts of 5-4 Pod for an in-depth conversation about how the Supreme Court methodically legalized corruption, culminating in the recent decision in FEC v. Ted Cruz For Senate (32:24). Finally, David chats with president of Planned Parenthood, Alexis McGill Johnson, to discuss the overturning of Roe and the organization’s plan for dealing with the fallout (1:02:25). 

If you'd like access to Lever Time Premium, which includes extended interviews and bonus content, head over to LeverNews.com to become a supporting subscriber.

If you’d like to leave a tip for The Lever click the following link. It helps us do this kind of independent journalism. levernews.com/tipjar

A rough transcript of this episode is available here.

PlannedParenthood.org

AbortionFinder.org

Subscribe to Bad Faith on Patreon to instantly unlock our full premium episode library: http://patreon.com/badfaithpodcast   

Last week, Sam Adler-Bell's provocative New York Magazine piece on the problem with contemporary "wokeness" discourse launched a thousand Twitter threads and response pieces. Many were critical, but does he have a point? Is there something toxic about how resistant some on the left are to talking to people who don't already agree with us? And if the goal is to reach a wider audience, doesn't that require us to use different language than we do when preaching to the choir? At what point does changing our language implicate the underlying morals and values? And does abandoning woke language mean abandoning the populations it's meant to serve? Pascal Robert of This is Revolution & Freddie deBoer of his eponymous blog join Briahna to talk Lizzo's lyric change, that NPR tweet about "menstruating people," the viral "What Is a Woman" film, and more.

Subscribe to Bad Faith on YouTube for video of this episode. Find Bad Faith on Twitter (@badfaithpod) and Instagram (@badfaithpod).

Produced by Armand Aviram.

Theme by Nick Thorburn (@nickfromislands).

It's a long one! We talk G7, Spain and then wind Nick up to talk about the recent NATO summit in Madrid. Also, offically welcome Uma to the show!

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
Ciarán https://twitter.com/CiaranDold

Support Corner Späti

Click here for the full episode, including the extended interview with Professor Wolff on how to stop inflation.

Finally! A Marxist economist you can show to your parents and say “See?”

Class is in session with economics Professor Emeritus Richard Wolff. He’s here to teach us about inflation, what steps could be taken to tame it, and why the hell no one’s doing anything about it.

He doesn’t want to scare you with the alarming future our leaders are pushing us toward, but if he didn’t, he’d be lying. So buckle in for a fantastic lecture in which Wolff uses economic history to shine a light on the dark road ahead.

And subscribe for the full interview, where Professor Wolff shares what can stop inflation: “I’m gonna give you two things that we could do that will get us through the worst of it; one from a conservative Republican and one from a progressive Democrat.” Can you guess who?

Plus, Biden wants you to earn the right to not get shot, Laura Ingraham discovers that mass shootings are because the kids are all smoking weed, and another Kamala stoned moment.

It’s all this, and more, on this week’s episode of Useful Idiots. Check it out.

Subscribe now

Democracy Now! 2022-07-08 Friday

• Headlines for July 08, 2022
• Assassination: Former Japanese PM Shinzo Abe Shot Dead. Will Killing Push Japan Further to the Right?
• As Brittney Griner Pleads Guilty in Russia, Biden Pressured to Help Free "State-Sponsored Hostage"
• U.S. Accused of Whitewashing Israel's Killing of Shireen Abu Akleh Ahead of Biden's Middle East Trip

Download this show

The boys tip a hot ‘n frothy pint farewell to the boy Boris. Then, Will is joined by journalist Ollie Vargas to discuss the current rising tide of leftist leadership in Central and South America, including energy independence, nationalization of resources, the future of oil and narcotics trade, and the possibility of countering American hegemony in the region.

Find Ollie’s new podcast here: https://linktr.ee/latinamericareview

And we’ve got 25% off everything in our merch store here: shop.chapotraphouse.com

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

Rania Khalek was joined by Arnaud Bertrand, a commentator on economics and geopolitics based in Shanghai, to discuss the sanctions blowback on the West, the narrative management surrounding it, and growing tensions between the US and China. 

Arnaud on Twitter: https://twitter.com/RnaudBertrand 

TIME CODES:

0:00 Intro

1:32 Is the West isolating itself?

6:09 Russia & China can survive US sanctions

11:51 US-led West weaker today than in 1st cold war

14:59 How Arnaud ended up in China

17:56 Who’s really responsible for global food insecurity?

22:16 The latest McCarthyist list

26:11 Western aggression unites its adversaries 

32:16 US warmongering over Taiwan

41:36 Perception over US vs China in Africa

46:10 Democracy perception in China vs the West

52:45 Xinjiang genocide accusation falling apart 

TMR is an Emacs package that provides facilities for setting timers using a convenient notation. Lots of commands are available to operate on timers, while there also exists a tabulated view to display all timers in a nice grid.

• Package name (GNU ELPA): tmr
• Official manual: https://protesilaos.com/emacs/tmr
• Change log: https://protesilaos.com/emacs/tmr-changelog
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/tmr
  • Mirrors:
    • GitHub: https://github.com/protesilaos/tmr
    • GitLab: https://gitlab.com/protesilaos/tmr
• Mailing list: https://lists.sr.ht/~protesilaos/tmr

The general theme of this release is that TMR became simpler, better, and more robust. Daniel Mendler provided lots of patches and is now recognised as co-author of the package together with Damien Cassou and me (Protesilaos). With the exception of documentation changes and other accompanying tweaks, all of the following are courtesy of Daniel Mendler. Consult the git log for the minutia.

• Timers can also be set using an absolute time input. For example, 21:45 will set a timer from now until the specified time. The familiar ways of starting timers with relative values, work as they did before. This is part of a wider internal revision to make the parsing of input more strict.

• TMR no longer maintains distinct feature sets between its minibuffer and tabulated interfaces. What works in one context, works equally in the other. All commands that were formerly available only in the tmr-tabulated-mode (accessed via tmr-tabulated-view) are now implemented anew to provide the requisite minibuffer capabilities. When called from inside the tmr-tabulated-mode, the commands operate on the timer at point. Otherwise they prompt for completion among the available timers (where relevant). This covers all operations for creating, cloning, [re-]describing, rescheduling, and removing timers. The tmr-tabulated-mode-map is updated thus:

  (defvar tmr-tabulated-mode-map
    (let ((map (make-sparse-keymap)))
      (define-key map "k" #'tmr-remove)
      (define-key map "r" #'tmr-remove)
      (define-key map "R" #'tmr-remove-finished)
      (define-key map "+" #'tmr)
      (define-key map "t" #'tmr)
      (define-key map "*" #'tmr-with-description)
      (define-key map "T" #'tmr-with-description)
      (define-key map "c" #'tmr-clone)
      (define-key map "e" #'tmr-edit-description)
      (define-key map "s" #'tmr-reschedule)
      map)
    "Keybindings for `tmr-tabulated-mode-map'.")
  

  Similarly, our sample key bindings are these:

  ;; OPTIONALLY set your own global key bindings:
  (let ((map global-map))
    (define-key map (kbd "C-c t t") #'tmr)
    (define-key map (kbd "C-c t T") #'tmr-with-description)
    (define-key map (kbd "C-c t l") #'tmr-tabulated-view) ; "list timers" mnemonic
    (define-key map (kbd "C-c t c") #'tmr-clone)
    (define-key map (kbd "C-c t k") #'tmr-cancel)
    (define-key map (kbd "C-c t s") #'tmr-reschedule)
    (define-key map (kbd "C-c t e") #'tmr-edit-description)
    (define-key map (kbd "C-c t r") #'tmr-remove)
    (define-key map (kbd "C-c t R") #'tmr-remove-finished))
  

• The tabulated view now shows the remaining time for all timer objects. This is how the *tmr-tabulated-view* buffer is formatted:

  Start      End        Remaining  Description
  10:11:49   10:11:54   ✔
  10:11:36   10:31:36   19m 35s
  10:11:32   10:26:32   14m 31s    Yet another test
  10:11:16   10:21:16   9m 14s     Testing how it works
  

• All timer objects are refactored to expose a properly formatted completion table. The completion category is tmr-timer. In practical terms, embark (and other standards-compliant packages) can operate on them. The manual provides sample glue code for Embark:

  (defvar tmr-action-map
    (let ((map (make-sparse-keymap)))
      (define-key map "k" #'tmr-remove)
      (define-key map "r" #'tmr-remove)
      (define-key map "R" #'tmr-remove-finished)
      (define-key map "c" #'tmr-clone)
      (define-key map "e" #'tmr-edit-description)
      (define-key map "s" #'tmr-reschedule)
      map))
      
  (with-eval-after-load 'embark
    (add-to-list 'embark-keymap-alist '(tmr-timer . tmr-action-map))
    (cl-loop
     for cmd the key-bindings of tmr-action-map
     if (commandp cmd) do
     (add-to-list 'embark-post-action-hooks (list cmd 'embark--restart))))
  

  The Embark Wiki is updated accordingly.

• The new user option tmr-confirm-single-timer governs how TMR should behave while operating on the sole timer. If non-nil (the default), TMR will always use the minibuffer to select a timer object to operate on, even when there is only one candidate available. If set to nil, TMR will not ask for confirmation when there is one timer available: the operation will be carried out outright. The default value is optimal for use with Embark.

• The existing user option tmr-description-list is revised to accept either a list of strings (the old approach) or a symbol of a variable that holds a list of strings. In the latter case, this can be the tmr-description-history, which is a variable that stores the user’s input at the relevant minibuffer prompt. We have made this the new default value, as it grows naturally to reflect one’s usage of TMR. Minibuffer histories can persist between sessions if the user enables the built-in savehist library. Sample configuration:

  (require 'savehist)
  (setq savehist-file (locate-user-emacs-file "savehist"))
  (setq history-length 10000)
  (setq history-delete-duplicates t)
  (setq savehist-save-minibuffer-history t)
  (add-hook 'after-init-hook #'savehist-mode)
  

• Fixed an edge case where a when-let* form did not return the expected value. Thanks to Nathan R. DeGruchy for the patch. The patch is below the ~15 line threshold and thus does not require copyright assignment to the Free Software Foundation.

• Named the mailing list address as the Maintainer: of Denote. Together with the other package headers, they help the user find our primary sources and/or communication channels. This change conforms with work being done upstream in package.el by Philip Kaludercic. I was informed about it here: https://lists.sr.ht/~protesilaos/general-issues/%3C875ykl84yi.fsf%40posteo.net%3E.

• Updated the manual to reflect the aforementioned.

Krystal and Saagar talk about Boris Johnson resigning, Biden administration's incompetence, Highland Park shooting revelations, airlines lying, Dem rigging against Green party, Steve Bannon vs Rogan, natural gas crisis, GOP crazies, & oil market volatility!

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

To listen to Breaking Points as a podcast, check them out on Apple and Spotify

Apple: https://podcasts.apple.com/us/podcast/breaking-points-with-krystal-and-saagar/id1570045623 

Spotify: https://open.spotify.com/show/4Kbsy61zJSzPxNZZ3PKbXl 

Merch: https://breaking-points.myshopify.com/

Rory Johnston: https://www.commoditycontext.com/ 

Highland Park Fundraiser: https://www.gofundme.com/f/irina-and-kevin-mccarthy 

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

Torstein Krause Johansen runs Emacs in terminl mode on Linux. He likes to have several terminal sessions and switch between them. Previously, he used tmux to multiplex those terminal sessions onto a single screen but then tmux started crashing on him and he didn’t have the time or inclination to track down the problem.

Instead, he realized that he could do everything he wanted from within Emacs. That had the advantage of using the same key bindings that he was already using in Emacs and, less importantly, he didn’t have to worry about keeping the Emacs and tmux color schemes in sync. To accomplish that, he use vterm, multi-vterm, the built-in Emacs shell command, and a bit of custom Elisp, that he calls spawn-shell that allows him to create shells in named buffers the way he would in tmux.

Johansen has a video that explains how he does all this using just the packages and code above. It’s a really nice set up for those who like to run Emacs in terminal mode, of course, but even if you’re running Emacs in GUI mode, you can use the same strategy to provide multiple named shells all running from within Emacs. That’s pretty much what I do and it works well for me.

The video is short, only 5 and a quarter minutes so you can watch it pretty much any time you like. The slides are available but probably not too useful unless you want to copy the spawn-shell code. Definitely worth a few minutes of your time.

Democracy Now! 2022-07-07 Thursday

• Headlines for July 07, 2022
• "The Inevitable Has Happened": Boris Johnson to Resign as PM After Mounting Scandals, Resignations
• Sri Lanka Is "Grinding to a Halt" Amid Fuel Shortage, Inflation & Austerity, Prompting Mass Protests
• Global South Is Facing a "Complete Energy Crisis" from Oil to Natural Gas Amid Ukraine War & Pandemic
• "Left Internationalism in the Heart of Empire": Aziz Rana & Darryl Li on Building a New Foreign Policy

Download this show

To understand why the European Union exists and how it is changing due to the financial crisis and the war in Ukraine, Rania Khalek was joined by Costas Lapavitsas, a professor of economics at SOAS, author of “The Left Case Against the EU” and a former Syriza MP. He also has a forthcoming book out in 2023 called “The State of Capitalism” published by Verso Books. 

Listen to every episode of Rania Khalek Dispatches anywhere you get podcasts.

Apple: https://apple.co/3zeYpeW 

Spotify: https://spoti.fi/3za9DRK

TIME CODES: 

0:00 Intro

2:08 What is the EU?

6:24 What happens if Ukraine joins the EU?

10:32 Evolution of European left’s view of the EU

18:48 EU as an anti-democratic arrangement 

26:41 EU creates European periphery and core

30:55 Common currency: the Euro

33:42 How Germany came out on top

39:38 Germany’s conditional hegemony 

45:16 American hegemony over Europe

52:05 Freedom of capital to move cheap labor 

1:03:18 Far right vs the EU?

1:08:25 How the left responds

1:12:06 The state of capitalism today

Krystal and Saagar talk about the recession arriving, persistent inflation, Highland Park shooting, 2024 election moves, Ukraine battle updates, Karine Jean-Pierre's rough start as Press Sec, Pete Buttigieg's inaction on airlines, Biden's indefinitely timeline for high gas prices, and the large increase in corporate markups!

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

To listen to Breaking Points as a podcast, check them out on Apple and Spotify

Apple: https://podcasts.apple.com/us/podcast/breaking-points-with-krystal-and-saagar/id1570045623 

Spotify: https://open.spotify.com/show/4Kbsy61zJSzPxNZZ3PKbXl 

Merch: https://breaking-points.myshopify.com/

Niko Lusiani: https://rooseveltinstitute.org/publications/prices-profits-and-power/ 

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

The Buzz Lightyear origin movie LIGHTYEAR (2022) has become a cultural lightning-rod in the right-wing moral panic over "grooming." We discuss this controversy (which is ridiculous, by the way), and then discuss the movie, in which we can learn a little bit about how the Disney Company views itself.

Support the National Network of Abortion Funds - https://abortionfunds.org/

Abortion Funds in Every State - https://donations4abortion.com/

The Repro Legal Defense Fund - https://reprolegaldefensefund.org/

Michael and Us is a podcast about political cinema and our crumbling world hosted by Will Sloan and Luke Savage.

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