Because Sam Altman hates opening his laptop, OpenAI is merging with iPhone guy Jony Ive's design firm in the name of some mysterious new ChatGPT-enabled consumer products: Alex and Emily go full Mystery Science Theater and dissect the announcement video. Plus how tech billionaires like Sam Altman mythologize San Francisco while their money makes it less livable for everyone else.

References:

Sam Altman and Jony Ive are merging (Video)

Emplacedness, real estate, and gentrification in San Francisco

Anthropic? More like anthropomorphic

Karen Hao on her new book "Empire of AI" in conversation with Alex and Emily

Fresh AI Hell:

Don't use ChatGPT to summon demons

AI prompts accidentally left in novels

"AI" tutors are teaching fentanyl recipes

xAI's data center polluting Memphis with unpermitted methane generators

Gemini's on Bluesky - block it

Family uses "AI" generated avatar to give victim impact statement

The market for "AI friends"? Lonely losers

No, LGBTESCREAL isn't a thing

*****

You can check out future streams at on Twitch, and send us any AI Hell you see for future episodes.

Our book, The AI Con, is out! Get your copy now.

Follow Emily: Bluesky/Mastodon
Follow Alex: Bluesky/Mastodon

Music: Toby Menon.
 Production: Christie Taylor.
 Graphic Design: Naomi Pleasure-Park.

Check out future streams on Twitch. Meanwhile, send us any AI Hell you see.

Find our book The AI Con here, and MAIHT3k merch here.

Subscribe to our newsletter via Buttondown.

Follow us!

Emily

• Bluesky: emilymbender.bsky.social
• Mastodon: dair-community.social/@EmilyMBender

Alex

• Bluesky: alexhanna.bsky.social
• Mastodon: dair-community.social/@alex
• Twitter: @alexhanna

Music by Toby Menon.
Artwork by Naomi Pleasure-Park. 
Production by Ozzy Llinas Goodman.

Democracy Now! 2025-07-09 Wednesday

• Headlines for July 09, 2025
• "Netanyahu Is the Problem": Sanders's Former Adviser Matt Duss on Why Gaza Ceasefire Remains Elusive
• "Vladimir Putin Is Not Interested in a Peace Deal": Matt Duss on Trump's Stalled Ukraine Diplomacy
• "Ideological Deportation": AAUP v. Rubio Trial Challenges Trump Crackdown on Pro-Palestine Students
• Philadelphia Strike Ends: Race & Inequality at Center of Municipal Workers' Fight for a Fair Wage

Download this show

Jon Stewart covers the passage of Trump’s Big Beautiful Bill: Republicans bashing then endorsing the megabill, trading tax cuts to sway senators, giving a $40 billion infusion to ICE, boosting billionaires at the expense of Medicaid and SNAP, and more.

Former CBS “60 Minutes” correspondent and Emmy and Peabody Award-winning journalist Steve Kroft joins Jon to discuss a $16 million settlement in President Trump’s lawsuit against Paramount Global, CBS and Comedy Central’s parent company. They discuss how an incoming corporate merger and pressure from Trump’s FCC may have influenced the settlement, why journalists and legal experts consider it a “shakedown,” its impact on freedom of the press, and the one thing Trump didn’t get: an apology.

See omnystudio.com/listener for privacy information.

Learn more about your ad choices. Visit podcastchoices.com/adchoices

Ryan Grim, Jeremy Scahill, and Murtaza Hussain are joined by Jon Elmer of Electronic Intifada to break down today’s major developments.

Listen above or on the Drop Site News channel on Apple, Spotify, RSS, or wherever you get your podcasts.

Are you excited to watch England and Wales this summer?

Comedian and football obsessed Maisie Adam can’t wait for the Euros and wants to capture the magic you only get before a big international tournament. This is her ultimate guide to the Euros and guarantees to get you in the mood for the highs, the lows and the drama of the Women’s Euros 2025.

Maisie has encouraged the audience to come in their favourite footie strips, scarves and hats, the sillier the better – just no flares up any arses please. She’s joined by comedians Rhys James and Harriet Kemsley to chat about the glorious summer of footie we have ahead of us. They re-live some of their best/worst Euros moments, play games and give their predictions for the summer – is football coming home again? Plus Maisie gets some very special advice from former Lioness and Euros winner, the one and only Jill Scott MBE.

If you can't get enough of the tournament, search ‘Women’s Euros’ on BBC Sounds for more coverage and reaction. Plus you can listen live to the games, including every England and Wales match, on 5 Live and BBC Sounds.

Host: Maisie Adam Guests: Rhys James and Harriet Kemsley Producer: Georgia Keating Executive Producer: James Robinson Production Co-ordinator: Jodie Charman Production Assistant: Danita McIntyre Additional material by Matthew Crosby and Eve Delaney Sound Design by Arlie Adlington Recorded by Jerry Peal and Atharva Bankar at Backyard Comedy Club

A BBC Studios Audio Production for Radio 4.

Ciarán and Uma talk about the heat in Europe, the Spanish corruption scandal, the US trying to intervene in France and of course Glastonbury.

HOW TO SUPPORT US:

https://www.patreon.com/cornerspaeti

HOW TO REACH US:

Bluesky https://bsky.app/profile/cornerspaeti.operationglad.io

Twitter https://twitter.com/cornerspaeti

Instagram https://www.instagram.com/cornerspaeti/

Julia https://twitter.com/KMarxiana

Rob https://twitter.com/leninkraft

Nick https://bsky.app/profile/lilouzovert.bsky.social

Uma https://bsky.app/profile/umawrnkl.bsky.social

Ciarán https://bsky.app/profile/ciaran.operationglad.io

Support Corner Späti

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

In 2021, DSA candidate India Walton successfully won the Buffalo, NY primary over establishment incumbent mayor Byron Brown. She would have been the first socialist mayor of a large city since Frank Zeidler left office as mayor of Milwaukee in 1960. But she never became mayor. Brown sued to get on the ballot, failed, but then launched a successful write in campaign. Though she was backed by WFP and had secured endorsements from Chuck Schumer, Bernie Sanders, and AOC, Governor Hochul declined to endorse Walton, Echoing the current Zohran Mamdani moment. Now, Walton returns to Bad Faith to give her unique perspective on what it's like to win a Democratic Party primary, only to be beaten by the Democratic Party establishment, to offer advice to Zohran Mamdani, who once campaigned for Walton in Buffalo, and to unpack her feelings on the viability of using the Democratic Party as a vehicle for real change.

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

One influential justification for becoming Buddhist is to end suffering, starting (it seems) with the Buddhist practitioner's own suffering. Does this indicate that Buddhist practitioners are selfish? After Buddhism became popular in China, many Confucians argued that Buddhism puts personal salvation before ethics, and is thus selfish in that respect. Some Confucians also objected to the particular sort of compassion that Buddhists were supposed to adopt ("unconditioned compassion"), insisting that it was fundamentally incompatible with the special attachments needed for important human relationships between family members and close friends. 

In our first show before a live audience, Justin presents two criticisms of Buddhism, Jenny Hung 洪真如 defends Buddhism against the criticisms, and Richard moderates. The show was held at a meeting of the American Philosophical Association, and many wiser scholars in the audience weighed in as well. Join us for the lively (and quite friendly) "debate."

Many thanks to The Hong Kong Ethics Lab and the Pacific Division of the American Philosophical Association for sponsoring this podcast series. Thanks also to Dana Jae Audio Collective (especially Casey Hudson and Maüxe Madden) for staging and recording the event, and to Lena Li (LI La 李拉 ) for her editing and mixing. They are consummate professionals.

Want to continue the discussion? Need links to some of the sources mentioned? Go to the support page for this episode on Warp, Weft, and Way.

Jenny Hung's website

Want to skip to episode's primary philosophical issue? Go to
- 4:19: preface to today's discussion, or
- 5:39: part II

Co-hosts:
Richard Kim's website
Justin Tiwald's website

AI, we’re told, has the potential to free us from mundane tasks, revolutionise industries, and solve global problems. Linguistics Professor Emily Bender, warns that the big tech companies who promote AI, with an almost spiritual zeal, may be off the mark. The warning? Don’t believe the hype.

• GUEST: Dr Emily M. Bender, Professor of Linguistics, University of Washington and co-author of “The AI Con. How To Fight Big Tech’s Hype and Create the Future We Want
• PRODUCER: Ali Benton

If you've been following me on Twitter, you know I'm not a big fan of MCP (Model Context Protocol) right now. It's not that I dislike the idea; I just haven't found it to work as advertised. In my view, MCP suffers from two major flaws:

1. It isn’t truly composable. Most composition happens through inference.
2. It demands too much context. You must supply significant upfront input, and every tool invocation consumes even more context than simply writing and running code.

A quick experiment makes this clear: try completing a GitHub task with the GitHub MCP, then repeat it with the gh CLI tool. You'll almost certainly find the latter uses context far more efficiently and you get to your intended results quicker.

But MCP is the Future!

I want to address some of the feedback I've received on my stance on this. I evaluated MCP extensively in the context of agentic coding, where its limitations were easiest to observe. One piece of feedback is that MCP might not make a ton of sense for general code generation, because models are already very good at that but they make a lot of sense for end-user applications, like, say, automating a domain-specific task in a financial company. Another one is that I need to look at the world of the future, where models will be able to reach many more tools and handle much more complex tasks.

My current take is that my data indicates that current MCP will always be harder to use than writing code, primarily due to the reliance on inference. If you look at the approaches today for pushing towards higher tool counts, the proposals all include a layer of filtering. You pass all your tools to an LLM and ask it to filter it down based on the task at hand. So far, there hasn't been much better approaches proposed.

The main reason I believe this will most likely also hold true — that you shouldn't be using MCP in its current form even for non-programming, domain-specific tasks — is that even in those cases code generation just is the better choice because of the ability to compose.

Replace Yourself With A Shellscript

The way to think about this problem is that when you don't have an AI, and you're solving a problem as a software engineer, your tool of choice is code. Perhaps as a non-software engineer, code is out of reach. Many many tasks people do by hand are actually automatable through software. The challenge is finding someone to write that software. If you're working in a niche environment and you're not a programmer yourself, you might not pick up a programming book to learn how to code, and you might not find a developer willing to provide you with a custom piece of software to solve your specific problem. And yes, maybe your task requires some inference, but many do need them all the time.

There is a reason we say “to replace oneself with a shell script”, it's because that has been happening for a long time. With LLMs and programming, the idea is that rather than replacing yourself with a shell script, you're replacing yourself with an LLM. But you run into three problems: cost, speed, and general reliability. All these problems are what we need to deal with before we can even think of tool usage or MCP. We need to figure out how to ensure that our automated task actually works correctly at scale.

Automation at Scale

The key to automation is really to automate things that will happen over and over. You're not going to automate a one-shot change that will never recur. You're going to start automating the things where the machine can truly give you a productivity boost because you're going to do it once or twice, figure out how to make it work, and then have the machine repeat it a thousand times. For that repetition, there's a very strong argument to be made for always using code. That's because if we instruct the machine to use inference to do it, it might work, particularly for small tasks, but it requires validation which can take almost the same time as doing it in the first place. Getting an LLM to calculate for you sort of works, but it's much better for the LLM to write the Python code to do the calculation. Why? First, you can review the formula, not the calculated result. We can write it ourselves or we can use the LLM as a judge to figure out if the approach is correct. Don't really have to validate that Python calculates correct, you can rely on that. So, by opting for code generation for task solving, we get a little closer to being able to verify and validate the process ourselves, rather than hoping the LLM inferred correctly.

This obviously goes way beyond calculation. Take, for instance, this blog. I converted this entire blog from reStructuredText to Markdown recently. I put this conversion off for a really long time, partly because I was a little too lazy. But also, when I was lazy enough to consider deploying an LLM for it, I just didn't trust it to do the conversion itself without regressing somewhere. I was worried that if it ran out of context, it might start hallucinating text or change wording slightly. It's just that I worried about subtle regressions too much.

I still used an LLM for it, but I asked it to do that transformation in a different way: through code.

LLM to Code to LLM

1. I asked the LLM to perform the core transformation from reStructuredText to Markdown but I also asked it to do this in a way that uses the underlying AST (Abstract Syntax Tree). So, I instructed it to parse the reStructuredText into an actual reStructuredText AST, then convert that to a Markdown AST, and finally render it to HTML, just like it did before. This gave me an intermediate transformation step and a comparable end result.

2. Then, I asked it to write a script that compares the old HTML with the new HTML, performs the diffing after some basic cleanup it deemed necessary for comparison. I asked it to consider what kind of conversion errors were actually acceptable. So, it read through its own scripts to see where it might not match the original output due to known technical limitations (e.g., footnotes render differently between the Markdown library I'm using and the reStructuredText library, so even if the syntax matches correctly, the HTML would look different). I asked it to compensate for this in that script.

3. After that was done, I asked it to create a third script, which I could run over the output of hundreds of files to analyze the differece to go back into the agentic loop for another iteration tep.

Then I kicked this off in a loop. I did not provide all the posts, I started with 10 until differences were low and then had it do it for all. It did this for maybe 30 minutes or so until I came back to it and found it in a pretty acceptable state.

What's key about this transformation is not so much that the LLM was capable of pulling it off, but that I actually trusted this process at the end because I could review the approach. Not only that, I also tried to ask another LLM what it thinks of the code that another LLM wrote, and the changes. It gave me much higher confidence that what was going on would not lose data. It felt right to me. It felt like a mechanical process that was fundamentally correct, and I was able to observe it and do spot checks. At worst, the regressions were minor Markdown syntax errors, but the text itself wouldn't have been corrupted.

Another key here is also that because the inference is rather constant, the cost of inference in this process scales with the number of iteration steps and the sample size, but it doesn't depend on how many documents I'm wanting to convert overall. Eventually, I just had it run over all documents all the time but running it over 15 docs vs 150 docs is more or less the same effort, because the final LLM based analysis step did not have that many more things to review (it already skipped over all minor differences in the files).

MCP Cannot Do That

This is a long-winded way of saying that this entire transformation went through code. It's a pipeline that starts with human input, produces code, does an LLM as a judge step and iterates. And you can take this transformation and apply it to a general task as well.

To give an example, one MCP you might be using is Playwright. I find it very hard to replace Playwright with a code approach for all cases because what you're essentially doing is remotely controlling your browser. The task you're giving it largely involves reading the page, understanding what's on it, and clicking the next button. That's the kind of scenario where it's very hard to eliminate inference at each step.

However, if you already know what the page is — for instance, if you're navigating your own app you're working on — then you can actually start telling it to write a Playwright Python script instead and run that. This script can perform many of those steps sequentially without any inference. I've noticed that this approach is significantly quicker, and because it understands your code, it still generally produces correct results. It doesn't need to navigate, read page contents, find a button, or press an input in real-time. Instead, it will write a single Python script that automates the entire process in one go, requiring very little context by comparison.

This process is repeatable. Once the script is written, I can execute it 100, 200, or even 300 times without requiring any further inference. This is a significant advantage that an MCP typically cannot offer. It's incredibly challenging to get an LLM to understand generic, abstract MCP tool calls. I wish I could, for example, embed an MCP client directly into a shell script, allowing me to run remote MCP services efficiently via code generation, but actually doing that is incredibly hard because the tools are not written with non inference based automation in mind.

Also, as ironic as it is: I'm a human, not an MCP client. I can run and debug a script, I cannot even figure out how to reliably do MCP calls. It's always a gamble and incredibly hard to debug. I love using the little tools that Claude Code generates while generating code. Some of those I had it convert into long term additions to my development process.

Where does this take us?

I don't know. But it's an interesting moment to think what we could potentially do to make code generation for purposeful agentic coding better. The weird thing is that MCP is actually pretty great when it works. But it feels in the current form too much like a dead end that cannot be scaled up, particularly to automation at scale because it relies on inference too much.

So maybe we need to look at ways to find a better abstraction for what MCP is great at, and code generation. For that that we might need to build better sandboxes and maybe start looking at how we can expose APIs in ways that allow an agent to do some sort of fan out / fan in for inference. Effectively we want to do as much in generated code as we can, but then use the magic of LLMs after bulk code execution to judge what we did.

I can also imagine that it might be quite interesting to do code generation in a way that also provides enough context for an LLM to explain in human language to a non programmer what the script is doing. That might enable these flows to be used by human users that are not developers themselves.

In any case I can only encourage people to bypass MCP and to explore what else is possible. LLMs can do so much more if you give them the power to write code.

Further Reading

Here are some more posts you might want to read or videos you might want to watch:

• My Agentic Coding Talk where I go into this topic a bit.
• Drew Breunig's post “How to fix your context” which covers some attempts to improve MCP tool selection if you cannot avoid it.
• Manuel Odendahl's excellent “MCPs are Boring” talk from AI Engineer that was one of the first to point to the challenges with MCP.

Ryan discusses Republican quits Senate while trashing Trump bill, Dems smear Zohran as antisemite, death to IDF chants in the UK, Trump attacks Israeli courts over Bibi charges, Gaza aid site massacres, explosive new details on Karen Read trial.

David Dayen: https://x.com/ddayen

Dave Smith: https://x.com/ComicDaveSmith

Amir Tibon: https://x.com/amirtibon

Aidan Kearney: https://x.com/DoctorTurtleboy

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

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

See omnystudio.com/listener for privacy information.

Democracy Now! 2025-06-17 Tuesday

• Headlines for June 17, 2025
• Preemptive Strike or Act of War? Israel Attacked Iran Amid Sinking Global Support for Assault on Gaza
• "We Loved Her": MN AG Keith Ellison Mourns His Friend Melissa Hortman, Slams Republican Rhetoric
• Cuban Deputy Foreign Minister on U.S. Embargo, Trump's Deportations, Israel's War on Iran & Gaza

Download this show

Democracy Now! 2025-07-01 Tuesday

• Headlines for July 01, 2025
• "Worst Thing I've Ever Seen": U.S. Surgeon Describes Mass Starvation, Injury and Death in Gaza
• "Trying to Find Food Is a Death Sentence": Palestinian Writer Muhammad Shehada on Gaza Aid Massacres
• "Ethnic Cleansing": U.N. High Commissioner for Human Rights, Volker Türk, on Israel's War in Gaza
• "Damaging and Deadly" Heat Domes Nearly Tripled, from Europe to the U.S.: Climatologist Michael Mann

Download this show

Krystal breaks down Trump going to war with Elon over his 'big beautiful bill' opposition. 

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

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

See omnystudio.com/listener for privacy information.

Nick has on Rob from Podcasting is Praxis to talk about NATO. Daddy's home?

FIND OUR GUEST:

https://x.com/CountRthe

https://x.com/Praxiscast

HOW TO SUPPORT US:

https://www.patreon.com/cornerspaeti

HOW TO REACH US:

Bluesky https://bsky.app/profile/cornerspaeti.operationglad.io

Twitter https://twitter.com/cornerspaeti

Instagram https://www.instagram.com/cornerspaeti/

Julia https://twitter.com/KMarxiana

Rob https://twitter.com/leninkraft

Nick https://bsky.app/profile/lilouzovert.bsky.social

Uma https://bsky.app/profile/umawrnkl.bsky.social

Ciarán https://bsky.app/profile/ciaran.operationglad.io

Support Corner Späti

(NOTE: This is an UNLOCKED Patreon exclusive episode. You should really join the Patreon.)

Matt and Daniel are joined by music critic and creator of The Needle Drop, Anthony Fantano to get the knives out for Thom Yorke's muddled stance on Gaza and Israel, to declare Gen-X as jaded as Mila Kunis in a video for a third-tier Aerosmith song, and to definitively adjudicate the Kendrick-Drake beef by Roberts Rules of Order.

Please donate to Islamic Relief USA: https://irusa.org

LIVE COMEDY SHOW DATES

Friday August 1st - Francesca and Matt will be at Laughs Comedy Club in Seattle. Tickets here: https://bit.ly/4kFt1xE

Saturday August 2nd - The Bitchuation Room LIVE in Seattle. Tickets here: https://bit.ly/4khBhnK

HOUSTON AUGUST 28 - Francesca and Matt will be at The Punchline in Houston. Tickets: https://www.ticketmaster.com/event/3A0062C3F8154B3F

Visit Anthony's channel The Needle Drop: https://www.youtube.com/@theneedledrop

Find Anthony online at https://x.com/theneedledrop or https://www.instagram.com/afantano

Subscribe to the Patreon https://www.patreon.com/badhasbara

What’s The Spin playlist: https://spoti.fi/4kjO9tL

Subscribe/listen to Bad Hasbara wherever you get your podcasts.

This is a contribution to the Emacs Carnival 2025-06: Take Two collection of posts on Christian Tietze’s blog.

My first take with Eshell many years back did not leave a good impression. My early expectations was that it should act like any other shell, only to be unpleasantly surprised by it. It took a long time for me to warm up to Eshell. Upon reflection, it was because I wasn’t ready for it.

Now Eshell is an inseparable part of my Emacs experience. Paradoxically though, I find little occasion to use Eshell in the same way I’ve used shells in the past. Much of what I used to use the shell for, I do today with Emacs modes instead.

It was not always this way. Like so many users who started Unix computing in the 80’s, I started with the command line (for myself ksh and later bash), studiously internalizing command line tools and their arcane syntaxes to support file management, running programs, and systems administration. Overwhelmingly though, it was file management and running programs that I did through the command line.

For file management these days, Dired is my interface of choice. It is simply the more elegant tool for the job.

Case in point: renaming a bunch of files in a directory to arbitrary names. With a shell, my standard approach would have been to run some variant of ls -1 > foo.sh, edit foo.sh to insert mv on each line to a renamed target file, chmod u+x foo.sh to be executable, run foo.sh, delete foo.sh and call it a day.

With Dired, the above steps are replaced as such: make the buffer writable (via Wdired). Change the target filenames to a desired result, then commit the changes. This is even easier if there is a pattern you can use a regexp for. Unsurprisingly, all the basic file management operations that you would want are supported by Dired. Add Casual Dired to help make these operations discoverable and you’ll soon consider how quaint using mv, cp, rm, and ls are.

Running a simple command on a file? Again, you can do that with Dired. Move the point to the Dired line containing the file. Type “!” and enter a command in the prompt. You can optionally reference the filename in the command with the “?” character if you want to redirect its output to a file (e.g. cmd ? > outfile).

Taking file management and running simple commands out of what you would use a shell for, what’s left over? Source code management (SCM)?

Like for many others, git is my goto tool for SCM. Much has been said about the terrible user experience of the git command line and for years I suffered with its design decisions. Thankfully for Emacs users, there is Magit and VC mode which both provide a saner experience for it.

Running a Makefile? Use Emacs compile, which provides command completion for the targets defined in the Makefile and error/warning navigation if needed. (Try out Casual Make for editing Makefiles in Emacs.)

Do you need to run a command with arcane arguments repeatedly? Again, Makefile + compile to the rescue where it can be used as a task runner for that command.

Need robust terminal emulation? Eshell will fail you here and you are likely better off using a dedicated terminal emulator app, separate from Emacs. That said, I’ve found the built-in term to be good enough for many curses-style utilities.

Mining data files with piped commands? Eshell is a power tool here: used wrongly and you could figuratively cut off a limb. But used cleverly, Eshell offers great value. More on this later.

So with all these use cases described, why even use Eshell?

Using Eshell becomes a win only if you know Elisp. With that, you can think of Eshell as an Elisp REPL that can secondarily act as a shell.

Let’s not mince words. For many users this is a high bar, as it takes into account a lot of prerequisite knowledge. That said, learning basic Elisp is trivial for readers already conversant with programming and manageable for those that aren’t. Personally, I was very late (decades!) in taking the time to learn Elisp because I didn’t see the reward in it and so, prioritized accordingly. That hesitancy turned out to be unfounded. Elisp is easy to learn and the reward (or punishment) for knowing it is having the ability to really use the full capabilities of Emacs. (Know Python? Here’s a cheatsheat for Elisp that I wrote, hop in, the water’s fine…)

Once gained, bringing Elisp knowledge to using Eshell gives you a command line super power: the ability to improvise shell commands with Elisp functions.

Consider the following Eshell example where we wish to apply a command on a set of png files in a directory. Let’s start with a simple example that simply echoes filenames with suffix .png.

$ for i in *.png { echo $i }

In Eshell, you can replace echo $i with an Elisp expression.

$ for i in *.png { (format "%s" i) }

You can also mix shell commands and Elisp via dollar ($) expansion. Note that $ expansion in Eshell is different from other shells. A deeper reading is on it is recommended to avoid confusion with what works in conventional shells.

$ for i in *.png { echo $(format "%s" i) }

If you have ImageMagick, installed, you can use the convert utility to change this to a jpeg file, using the Elisp file name components functions to do the work of getting a desired target name.

$ for i in *.png { convert $i $(file-name-with-extension i "jpg") }

Contrast this with the equivalent expression in Bash which I consider to have much more forgettable syntax.

$ for i in *.png; do convert $i ${i/.png/.jpg}; done

Another significance with mixing shell commands and Elisp together is the ability to incorporate Emacs buffers into an improvised workflow. Shell commands are typically designed to work with data organized as files. In contrast, Elisp (rather, Emacs) treats files as a persisted, secondary form of data. Instead, Buffers are the primary data type in Emacs.

Recall the Dired naming example above? Consider the added steps due to using a temporary file foo.sh compared to using a writeable Dired buffer.

Eshell shifts you into thinking differently about working with a prompt, where instead of thinking of output being only a file or (stdout, stderr), the output could also be an Emacs buffer.

With that change in thinking, Eshell is better thought of as a “prompt” interface for Emacs which in turn serves as the interface to all the command line utilities made available to it. In this light, a whole swath of common shell workflows get replaced by Emacs.

Suffice to say, Eshell reinforces and rewards keeping Emacs users only in Emacs.

Another common shell workflow is using grep with pipes (|) for data mining files. For example:

$ grep {pat1} {file} | grep -v {pat2} | grep {pat3} >outfile

Using this pattern indiscriminately in Eshell is a recipe for unpleasant surprise if the file to be mined is large. This is because Eshell will ingest said file into Emacs as part of the pipeline processing. This will be slow. To avoid this, you can prefix each | with an * as follows:

$ grep {pat1} {file} *| grep -v {pat2} *| grep {pat3} >outfile

Why store a result in a file (outfile) that you have to open to see it and may not care to keep around? Here Eshell gives you the ability to redirect to a buffer.

$ grep {pat1} {file} *| grep -v {pat2} *| grep {pat3} >#<buffer "*my grep results*">

Note that Eshell supports creating/overwriting (>) and appending (>>) for redirection. Use > with care when working with an existing buffer.

What about piping shell command output to an Elisp function? At the time of this writing, you really can’t though according to this Reddit thread, this may change in the future.

If you are used to workflows that bleed out megabytes of data to stdout, you really shouldn’t use Eshell. But with some cleverness, Eshell can help you get insights to your data faster by leveraging all the tools Emacs can offer for this (occur, highlighting, grep, etc.).

Closing Thoughts

IMHO, Eshell is best thought primarily as a prompt for Elisp/Emacs functionality with the secondary benefit of running command line utilities with a “shell-like” experience. It should not be thought of as a “drop-in” replacement for an actual terminal shell. If full terminal emulation is desired, my guidance is to run a dedicated terminal emulator outside of Emacs.

To get the full benefit of using Eshell, you really need to be conversant with Elisp. That said, Eshell is actually a great way to start learning Elisp as it provides you a prompt interface (REPL) in much the same way that other languages like Python, JavaScript, Ruby, Java, Swift, etc do.¹ Especially if you are comfortable with programming, take a day to learn Elisp. You won’t regret it.

Bringing Eshell into my Emacs journey has been amazing and I’m happy to have given it a second take.

Thanks to all the contributors of Eshell.

Footnotes

¹ To clarify, these languages adopted the idea of a REPL from Lisp development which Elisp is descended from.

I found out about Harper the other day. Ever since I heard about it, I've been itching to set it up in my config and get rid of the horrible LanguageTool setup I had going. Now that I've got it working, I've gotta say I'm quite impressed. My previous LanguageTool setup was not smooth at all, and definitely not as fast as Harper is. I'm not sure how anyone else is doing spellchecking in Emacs (and particularly in org-mode) at the moment, but I recommend anyone using Emacs for most of their writing to give it a shot.

I won't embarrass myself with a comparison of my LanguageTool config. Just know that it was slow and terrible. Copied from the Harper docs, this is what my config looks like:

(when (and (not (equal system-type 'windows-nt)) (locate-file "harper-ls" exec-path))
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs
               '(org-mode . ("harper-ls" "--stdio"))))

  (setq-default eglot-workspace-configuration
              '(:harper-ls (:dialect "Australian")))

  (add-hook 'org-mode-hook 'eglot-ensure))

Some caveats: it doesn't look like Harper has support for org-mode specifically yet, but it seems to generally work OK despite that. I have however noticed that it doesn't lint property tags, so for example your #+title: won't be spellchecked. Another minorly annoying little niggle is that straight seems to misbehave with eglot, or eldoc more specifically, printing eldoc error: (invalid-function incf) in the minibuffer instead of an actual error message. I was using lsp-mode before this - although I'm beginning to like the eglot interface more and more as I write this, so I think I may swap over to it where possible - so I never realised this issue. Per that GitHub issue link, (use-package eldoc :straight (:type built-in)) seems to be the solution.

The only thing that's missing, and to be fair LanguageTool doesn't implement this either (in fact to my knowledge nothing implements this, I don't even think there's a Word plugin), is text style metrics analysis. Every so often I get the impulse to try to untangle what the source code for that website is doing, and then write a simple elisp wrapper for it, but I always get sidetracked before I start. Maybe now is the time.

(if (file-exists-p "/usr/bin/hunspell")
    (progn
      (eval-after-load "ispell"
        '(progn
         (setq ispell-program-name "hunspell"
               ispell-dictionary   "en_AU"
               ispell-alternate-dictionary (file-truename (concat user-emacs-directory "en_AU.dict"))
               ispell-local-dictionary-alist '(("en_AU" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_AU,en_AU-med") nil utf-8)))
         (defun ispell-get-coding-system () 'utf-8)))
      (eval-after-load "flyspell"
        '(progn
         (setq ispell-program-name "hunspell"
               ispell-dictionary   "en_AU"
               ispell-alternate-dictionary (file-truename (concat user-emacs-directory "en_AU.dict"))
               ispell-local-dictionary-alist '(("en_AU" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_AU,en_AU-med") nil utf-8)))
         (defun ispell-get-coding-system () 'utf-8)))))

Background

Like a lot of people I've had a long history managing passwords and secrets over the years. From a little black book, over an Excel sheet, using a GPG encoded secrets file (works really well with Emacs gpg support), 1password (till they racked up their prices), lastpass (till they got bought by the Evil LogMeIn Corp), KeepassXC and lately pass.

I was perfectly happy with KeepassXC for a very long time, except for the command line integration. So I kept ending up with passwords in .envrc files in folders and excluded in the global .gitignore to avoid too many red cheeks. While this does keep secrets out of harms way mostly, it kept nagging that I had them in plain text in those files. In theory there is keepassxc-cli to query the passwords from the command line, but let's say the experience does not spark joy. It has no easy way to cache the password between calls and it is optimized for interactive use. (AFAICT, just the giant size of the command to type gives me dread).

Some day I stumbled over pass and found that after setup I could just pass snamellit/website to get the password on stdout. I wrote about the setup and emacs integration in a previous post. Since it leverage gpg, password caching is handled by the gpg-agent and my .envrc files quickly were purged of blasphemous secrets, replace by pure bliss:

export MY_SECRET=$(pass my/secret)
export OTHER_SECRET=$(pass other/secret)

similarly in emacs I can consistently get my passwords and related info with:

(org-gcal-client-id (auth-source-pass-get 'secret "snamellit/org-gcal-client"))
(org-gcal-client-secret (auth-source-pass-get "id"
"snamellit/org-gcal-client"))

When needed the gpg-agent will launch the appropriate pin-entry program whether in terminal or in the GUI and the caching will not force me to login several times when entering the folder.

So I ended up with my interactive use covered by KeepassXC and automated use by pass.

However, after some time I ended up with hundreds of secrets in KeepassXC, hundreds in pass, it is not always clear whether use is interactive or automated so confusion and duplication starts and things become harder to manage. In addition KeepassXC was using historically Dropbox to make it available on all my devices, recently migrated to Nextcloud, which has issues with dealing with conflicts which occasionally bite me in the behind. On the other hand pass secrets are stored encrypted in git where conflict punch you in the face. I prefer the latter. And started contemplating whether to move everything to pass.

Thanks to the encouragement of SummerEmacs, one of the more enthusiastic SystemCrafters, ensuring the great experience in browsers and iOS mobile devices I had no more excuses to keep postponing it.

Preparation

I started out with keeping my pass passwords as part of my dotfiles. This was convenient when they were few. However this is weird so this will attract weirdness when configuring all integrations I'll need.

Also pass supports a git command to manage the password-store with git which is not really useful when it is part of something else. So the first order of the day is to move all secrets to a separate repository and update the dotfiles to check for presence and clone the repo if missing (and do a gently pull when it is). A quick visit to each of the machines in my machine park to apply this change. Everything still seems to be working.

Migration of the KeepassXC data

I used the pass-import tool which adds in import command to pass which supports a crazy amount of password managers, including keepassxc. For keepassxc it need the pykeepass. If you're running on Arch, everything is a yay -S away. However on Ubuntu and its derivatives it is the usual slog we start to get accustomed to. It's all in the pass-import README , note that on Ubunty the pykeepass library is available with apt install python3-pykeepass.

Once it is installed I tried a dry run (with the -d flag) to see if basic functionality is working

pass import -a -d keepassxc ~/Nextcloud/Apps/Keepassxc/Passwords.kdbx
Password for /home/pti/Nextcloud/Apps/Keepassxc/Passwords.kdbx:
  w  Data would be imported from keepassxc to pass
  .   Passwords imported from: /home/pti/Nextcloud/Apps/Keepassxc/Passwords.kdbx
  .   Passwords exported to: /home/pti/.password-store
  .   Number of password imported: 2035
  .   All data imported
  w  Weak password detected: eDGQqipE might be weak.  Score 2 (100000001 guesses).  This estimate is based on the sequence eDGQqipE(bruteforce)
  w  Weak password detected: eDGQqipE might be weak.  Score 2 (100000001 guesses).  This estimate is based on the sequence eDGQqipE(bruteforce)
  w  Weak password detected: eDGQqipE might be weak.  Score 2 (100000001 guesses).  This estimate is based on the sequence eDGQqipE(bruteforce)
...  large list of names of secrets

This asks for the password of the Keepass file and some remarks it has.

This all looks reasonable. So we can try the import. Since the password-store is a git repo no real damage can be done to it (as it is safely pushed somewhere else where the import tool cannot touch it) and any damage done can be reverted....

Now is a good time to check if the mooring lines of your laptop are properly secured as encrypting all the secrets will spin up the propellors if the number is large enough.

I run it again without the -d flag and after several minutes the noise dies down and I am left with a lot of additional folders in my ~/.password-store which match the grouping in KeepassXC. The files contain the secrets and the expected metadata. This looks good so I add/commit the things to complete the level.

Integration with iOS for my iPhone

Let's start with the most scary one : the iPhone.

Upon recommendation I had installed passforios which needs to be configured.

Configuring the host, repo and username to use for the git repository is straightforward enough.

I always use ssh to access my repos so we need to add an ssh keypair for this purpose. There is no support to generate key-pairs in passforios for reasons, so I have to do it externally and upload the key. A quick ssh-keygen , uploading the public key to the forge, allowing access to the repo and if I can get the private key on my phone we can access the repo.

passforios has a nice feature to load ascii armored keys via a QR code. A bit digging surfaced the asc-key-to-qr-code-gif tool which was made for this specific purpose. The ssh key is already in the appropriate format so this can be directly converted

./asc-to-gif.sh ~/.ssh/id-passforios ssh-pub.gif
display ssh-pub.gif

Then go to the repository settings, press the circled i on the SSH Key button, select the ASCII-Armor Key and click to scan the QR code. Point the camera to the QR code on the screen and it should appear in the key field in the app.

We have to repeat this 2 more times to get the private and public key for the password-store into the app. First exporting the keys

gpg --export -a 1234ABCD >gpg.pub
gpg --export-secret-key -a 1234ABCD >gpg.key

converting to a gif, displaying them and scanning them in *Settings -> PGP Key -> ASCII-Armor Key in the respective fields.

If, after synching, you go now to the Passwords you should be greeted with a listing of all folders and keys and the secrets should be visible if made visible by tapping the eye icon.

I needed to enable passforios as a source for autofill : Settings -> Passwords -> Autofill Passwords and slide the toggle for Pass. I also disabled the toggle for Strongbox which I was using for integration with the Keepass database.

Now I see the option to select the secrets from the passforios app. It does not narrow down to the right key, but that is a problem for future me.

Ok, the hard part is done. Or at least the most risky part, ... in my eyes... whatever. Moving on...

Integration with FireFox

Checking at the bottom of the pass website we find that passff is the good stuff for integration with FireFox. From previous adventures with KeepassXC and NativeMessaging I assumed there had to be a host part to be installed too.

Indeed we are directed to the passff-host github repo to get an install-script which generates the native messaging json for the different browsers and a small executable python script which contains remarkable clean and no-dependency code. Similarly the install script is straightforward. I do not understand why it support half a dozen browser, mostly chrome based as for the life of me I cannot find an extension which uses this host program. So either I need bigger glasses or there is some knowledge beyond my grasp.

Running the installer, installing the extension, restarting firefox for good luck and the extension appears and offers passwords on the sites I try.

Out of curiosity I check the configuration in ~.mozilla/native-messaging :

pti@tuxedo ~> ls .mozilla/native-messaging-hosts/
org.keepassxc.keepassxc_browser.json  passff.json  passff.py*
pti@tuxedo ~> cat .mozilla/native-messaging-hosts/passff.json
{
  "name": "passff",
  "description": "Host for communicating with zx2c4 pass",
  "path": "/home/pti/.mozilla/native-messaging-hosts/passff.py",
  "type": "stdio",
  "allowed_extensions": [ "passff@invicem.pro" ]
}
pti@tuxedo ~> cat .mozilla/native-messaging-hosts/passff.py
#!/usr/bin/python3
"""
    Host application of the browser extension PassFF
    that wraps around the zx2c4 pass script.
"""

import json
...

Nothing out of the ordinary, the passff.py python is the same as in the repo. My old keepassxc extension support is still there.

Firefox is installed natively on this machine, not with a flatpak which I assume will come with its own challenges.

Chromium Support

Time to tackle the Chrome family. Chrome is required to put food on the table so we have to get that going eventually. But Chrome is distributed as a flatpak (or a snap but I am NOT going to deal with that), and I can install Chromium natively, and apparently native installs are MUCH better supported than the versions in wrappers so let's start with that one first.

From the pass website we find that browserpass is the way to go for the chrome family. The browser extension installs from the usual places without drama and starts promptly complaining it cannot find the native host to talk to.

The native host in question is from the browsaerpass-native sister repo . As usual for all distro's there are packages ready to install but because Ubuntu-derivative I can compile from source. Downloading the source for version 3.1.0 from the releases page. Again this repo refers to all browsers including firefox although I cannot for the life of me find a Firefox Extension supporting this host app.

Then building and installing timelapse :

tar -xzvf ~/Downloads/browserpass-native-3.1.0.tar.gz
cd browserpass-native-3.1.0
ls
less README.md
PREFIX=/usr/local make configure
sudo make PREFIX=/usr/local install
which browserpass

which shows the executable lives at /usr/local/bin/browserpass and this totally went fine the first time (NOT!!!!).

The Makefile has support to install the magic json to enable native messaging for the different browsers.

PREFIX=/usr/local make hosts-chromium-user
PREFIX=/usr/local make hosts-chrome-user

The second invocation is a hail-mary because I already know the Chrome flatpak does not look in the same places and will require some additional finnagling

For now focus on Chromium and check if the configuration looks reasonable:

pti@tuxedo ~> cd .config/chromium/NativeMessagingHosts/
pti@tuxedo ~/.c/c/NativeMessagingHosts> ls
com.github.browserpass.native.json@
pti@tuxedo ~/.c/c/NativeMessagingHosts> cat com.github.browserpass.native.json
{
    "name": "com.github.browserpass.native",
    "description": "Browserpass native component for the Chromium extension",
    "path": "/usr/local/bin/browserpass",
    "type": "stdio",
    "allowed_origins": [
        "chrome-extension://naepdomgkenhinolocfifgehidddafch/",
        "chrome-extension://pjmbgaakjkbhpopmakjoedenlfdmcdgm/",
        "chrome-extension://klfoddkbhleoaabpmiigbmpbjfljimgb/"
    ]
}

Cool, the executable is looked at where it is installed (this is not obvious, don't ask how I know). The rest looks also like how these things should look. Let's try...

The extension settings page is no longer complaining the native host is missing and there are password entries visible. Checking with some website shows the password is injected. yay!.

Level complete, ready for the final boss.

Enabling Chrome Support, now with more Flatpak!

Ok, we have a working chromium support so repo access, host app, native host configuration et al are proven working. We can only focus on jumping over the Flatpak Firewall...

As a good cargo cultist I do a literature study and find that I should

• find the config location of the flatpak app

• use flatpak-spawn to spawn the native messaging host app

• enable D-Bus Session socket access for chrome

• Package up the calling of the host app in a single script to configure in the json.

  Not necessarily in that order....

For the permission to access D-Bus Session start up flatseal from flathub, navigate to com.google.Chrome and enable the D-Bus Session socket. This should be possible with some additional cursing in the manifest file of Chrome. I cannot find decent reference documentation in a reasonable time, so flatseal it is.

The configuration of the flatpak app is easy too, painful experience seared in my brain that flatpaks look in ~/.var/app/ folder so for Chrome this will be ~/.var/app/com.google.Chrome . From the hail-mary install for chrome done above I know that it just creates a symbolic link to /usr/local/lib/browserpass/hosts/chromium/com.github.browserpass.native so we can start from there. We will have to edit that so copy it. We also need a wrapper to call the native host app

cd ~/.var/app/com.google.Chrome/config/google-chrome/NativeMessagingHosts
cp /usr/local/lib/browserpass/hosts/chromium/com.github.browserpass.native
ec browserpass.sh

Add the content of the wrapper

#!/bin/sh
cd ~
/usr/bin/flatpak-spawn --host /usr/local/bin/browserpass 2>/tmp/browserpass-error.log

I added the optional redirect of stderr to an error logfile because from experience I know nothing ever goes wrong if you enable error reporting beforehand.

chmod +x browserpass.sh
pwd
pwd | wl-copy
ec com.github.browserpass.native.json

Installing the browserpass extension in Chrome after restarting it (I am not superstitious, just careful) and I can bask in the glory of seeing proposals for passwords when trying to log in. Most of the proposals are pretty garbage, but that is a problem for future me.

Conclusion

I have access to my password-store secrets on my phone, my browsers on laptop and desktop, and most importantly Emacs. Narrowing of the proposed secrets is, euhmmm, sub-optimal, but since it is sub-optimal in the same way on all platforms I assume that some TLC in the password-store and cleaning of the migrated secrets will fix that in time.

In the process I gained much more confidence in configuring flatpak apps. I can decommission the keepassxc system including dealing with the sync conflicts (which was admittedly super easy with the merge database feature in KeepassXC). I no longer have to deal with giving the KeepassXC window a place on the desktop and autostarting it.

I am a bit puzzled about the host-apps referring to supporting browsers for which no extensions are available. This probably might warrant some additional investigation.

Big step forward

Macau is best known now for its casinos, but it was the first European city in Asia, remained a Portuguese colony for 500 years, and contains many colourful and significant stories within its walls. 

The U.S. has officially joined Israel’s war on Iran, bombing Iranian nuclear sites and obliterating what was left of the nuclear talks. With Trump hinting at regime change, the world is now watching to see how Iran will respond.

Is this the end of diplomacy? Does Iran now view nuclear weapons as the only way to deter U.S. and Israeli aggression? Can Iran survive?

Rania Khalek is joined by Trita parsi, Executive Vice President of the Quincy Institute, for a special live episode of Dispatches to break down what the strikes mean, the geopolitical fallout, and whether the path ahead now leads to wider war.

📅 LIVE on June 24

🕑 2pm ET / 11am PT / 9pm Palestine

🔔 Set a reminder and subscribe to Breakthrough News to get notified when we go live.

Support independent media, become a Breakthrough News member today:  Patreon.com/BreakthroughNews