#+END_EXPORT
- As an [[https://orgmode.org/][Org mode]] fan, so I wrote [[https://plainorg.com/][Plain Org]] for iOS. It's on the [[https://apps.apple.com/app/id1578965002][App Store]].
- Inspired by [[https://jamesclear.com/atomic-habits][Atomic Habits]], I wrote [[https://flathabits.com/][Flat Habits]] for iOS. Also on the [[https://apps.apple.com/app/id1558358855][App Store]].
- I needed an Emacs-inspired [[https://xenodium.com/scratch-a-minimal-scratch-area][*scratch*]] buffer on iOS (who doesn't?), so I [[https://xenodium.com/scratch-a-minimal-scratch-area/][built one]].
Just like the stuff I do or [[https://xenodium.com][write about]]? [[https://github.com/sponsors/xenodium][Sponsor me]].
* [2023-11-29 Wed] Building your own bookmark launcher
:PROPERTIES:
:CUSTOM_ID: building-your-own-bookmark-launcher
:END:
#+ATTR_HTML: :style text-align:right;
/✨[[https://github.com/sponsors/xenodium][sponsor]]✨ this content/
I've been toying with the idea of managing browser bookmarks from [[https://www.gnu.org/software/emacs/][you know where]]. Maybe dump a bunch of links into an org file and use that as a quick and dirty bookmark manager. We'll start with a flat list plus fuzzy searching and see how far that gets us.
The org file would look a little something like this:
#+CAPTION: bookmarks.org
#+begin_src org
My bookmarks
- [[https://lobste.rs/t/emacs][Emacs editor (Lobsters)]]
- [[https://emacs.stackexchange.com][Emacs Stack Exchange]]
- [[https://www.reddit.com/r/emacs][Emacs subreddit]]
- [[https://emacs.ch][Emacs.ch (Mastodon)]]
- [[https://www.emacswiki.org][EmacsWiki]]
- [[https://planet.emacslife.com/][Planet Emacslife]]
#+end_src
Next we need fuzzy searching, but first let's write a little elisp to extract all links from the org file:
#+begin_src emacs-lisp :lexical no
(require 'org-element)
(require 'seq)
(defun browser-bookmarks (org-file)
"Return all links from ORG-FILE."
(with-temp-buffer
(let (links)
(insert-file-contents org-file)
(org-mode)
(org-element-map (org-element-parse-buffer) 'link
(lambda (link)
(let* ((raw-link (org-element-property :raw-link link))
(content (org-element-contents link))
(title (substring-no-properties (or (seq-first content) raw-link))))
(push (concat title
"\n"
(propertize raw-link 'face 'whitespace-space)
"\n")
links)))
nil nil 'link)
(seq-sort 'string-greaterp links))))
#+end_src
The snippet uses =org-element= to iterate over links to collect/return them in a list. We join both the title and url, so searching can match either of these values. We also add a little formatting (new lines/face) to spiff things up.
#+begin_src emacs-lisp :results value code
(browser-bookmarks "/private/tmp/bookmarks.org")
#+end_src
#+RESULTS:
#+begin_src emacs-lisp
(#("Planet Emacslife\nhttps://planet.emacslife.com/\n" 17 46
(face whitespace-space))
#("EmacsWiki\nhttps://www.emacswiki.org\n" 10 35
(face whitespace-space))
#("Emacs.ch (Mastodon)\nhttps://emacs.ch\n" 20 36
(face whitespace-space))
#("Emacs (Stack Exchange)\nhttps://emacs.stackexchange.com\n" 23 54
(face whitespace-space))
#("Emacs (Reddit)\nhttps://www.reddit.com/r/emacs\n" 15 45
(face whitespace-space))
#("Emacs (Lobsters)\nhttps://lobste.rs/t/emacs\n" 17 42
(face whitespace-space)))
#+end_src
We can now feed our list to our preferred narrowing framework (ivy, helm, ido, vertico) and use it to quickly select a bookmark. In the past, I've [[https://xenodium.com/emacs-utilities-for-your-os/][used the likes of ivy-read]] directly, though have since adopted the humble but mighty =completing-read= which hooks up to any of the above frameworks.
With that in mind, let's use =completing-read= to make a selection and split the text to extract the corresponding URL. Feed it to =browse-url=, and you got your preferred browser opening your bookmark.
#+begin_src emacs-lisp :lexical no
(defun open-bookmark ()
(interactive)
(browse-url (seq-elt (split-string (completing-read "Open: " (browser-bookmarks "/private/tmp/bookmarks.org")) "\n") 1)))
#+end_src
I remain a happy ivy user, so we can see its fuzzy searching in action.
#+ATTR_HTML: :width 100%
[[file:images/building-your-own-bookmark-launcher/emacs-bookmark.gif]]
At this point, we now have our bookmark-launching Emacs utility. It's only an =M-x open-bookmark= command away, but we want to make it accessible from anywhere in our operating system, in my case macOS.
Let's enable launching from the command line, though before we do that, let's craft a dedicated frame for this purpose.
#+begin_src emacs-lisp :lexical no
(defmacro present (&rest body)
"Create a buffer with BUFFER-NAME and eval BODY in a basic frame."
(declare (indent 1) (debug t))
`(let* ((buffer (get-buffer-create (generate-new-buffer-name "*present*")))
(frame (make-frame '((auto-raise . t)
(font . "Menlo 15")
(top . 200)
(height . 20)
(width . 110)
(internal-border-width . 20)
(left . 0.33)
(left-fringe . 0)
(line-spacing . 3)
(menu-bar-lines . 0)
(minibuffer . only)
(right-fringe . 0)
(tool-bar-lines . 0)
(undecorated . t)
(unsplittable . t)
(vertical-scroll-bars . nil)))))
(set-face-attribute 'ivy-current-match frame
:background "#2a2a2a"
:foreground 'unspecified)
(select-frame frame)
(select-frame-set-input-focus frame)
(with-current-buffer buffer
(condition-case nil
(unwind-protect
,@body
(delete-frame frame)
(kill-buffer buffer))
(quit (delete-frame frame)
(kill-buffer buffer))))))
#+end_src
Most of the snippet styles our new frame and invokes the body parameter. While I don't typically resort to macros, we get a little syntatic sugar here, so we can invoke like so:
#+begin_src emacs-lisp :lexical no
(defun present-open-bookmark-frame ()
(present (browse-url (seq-elt (split-string (completing-read "Open: " (browser-bookmarks "/private/tmp/bookmarks.org")) "\n") 1))))
#+end_src
Wrapping our one-liner with the =present-open-bookmark-frame= function enables us to easily invoke from the command line, with something like
#+begin_src sh
emacsclient -ne "(present-open-bookmark-frame)"
#+end_src
#+ATTR_HTML: :width 100%
[[file:images/building-your-own-bookmark-launcher/command.gif]]
Now that we can easily invoke from the command line, we have the flexibility to summon from anywhere. We can even bind to a key shortcut, available anywhere (not just Emacs). I typically do this via [[http://www.hammerspoon.org/][Hammerspoon]], with some helpers, though there are likely simpler options out there.
#+begin_src lua
function emacsExecute(activate, elisp)
if activate then
activateFirstOf({
{
bundleID="org.gnu.Emacs",
name="Emacs"
}
})
end
local socket, found = emacsSocketPath()
if not found then
hs.alert.show("Could not get emacs socket path")
return "", false
end
local output,success = hs.execute("/opt/homebrew/bin/emacsclient -ne \""..elisp.."\" -s "..socket)
if not success then
hs.alert.show("Emacs did not execute: "..elisp)
return "", false
end
return output, success
end
function openBookmark()
appRequestingEmacs = hs.application.frontmostApplication()
emacsExecute(false, "(present-open-bookmark-frame)")
activateFirstOf({
{
bundleID="org.gnu.Emacs",
name="Emacs"
}
})
end
hs.hotkey.bind({"alt"}, "W", openBookmark)
#+end_src
With that, we have our Emacs-powered bookmark launcher, available from anywhere.
#+ATTR_HTML: :width 100%
[[file:images/building-your-own-bookmark-launcher/launcher.gif]]
While we used our Emacs frame presenter to summon our universal bookmark launcher, we can likely the same mechanism for other purposes. Maybe a clipboard (kill ring) manager?
#+ATTR_HTML: :width 100%
[[file:images/building-your-own-bookmark-launcher/kill-ring.png]]
What would you use it for? Get in touch ([[https://indieweb.social/@xenodium][Mastodon]] / [[https://twitter.com/xenodium][Twitter]] / [[https://www.reddit.com/user/xenodium][Reddit]] / [[mailto:me__AT__xenodium.com][Email]]).
/Enjoying this content? Find it useful? Consider ✨[[https://github.com/sponsors/xenodium][sponsoring]]✨./
* [2023-11-25 Sat] Native Emacs/macOS UX integrations via Swift modules
:PROPERTIES:
:CUSTOM_ID: native-emacsmacos-ux-integrations-via-swift-modules
:END:
Once you learn a little [[https://en.wikipedia.org/wiki/Emacs_Lisp][elisp]], [[https://www.gnu.org/software/emacs/][Emacs]] becomes this hyper malleable editor/platform. A live playground of sorts, where almost everything is up for grabs at runtime. Throw some elisp at it, and you can customize or extend almost anything to your heart's content. I say almost, as there's a comparatively small native core, that would typically require recompiling if you wanted to make further (native) mods. But that isn't entirely true. [[https://www.masteringemacs.org/article/whats-new-in-emacs-25-1][Emacs 25]] enabled us to further extend things by loading native [[https://www.gnu.org/software/emacs/manual/html_node/elisp/Dynamic-Modules.html][dynamic modules]], back in 2016.
Most of my Emacs-bending adventures have been powered by elisp, primarily on macOS. I also happen to have an iOS dev background, so when [[https://github.com/SavchenkoValeriy][Valeriy Savchenko]] [[https://www.reddit.com/r/emacs/comments/wemj1z/writing_emacs_dynamic_modules_in_swift/][announced]] his project bringing [[https://github.com/SavchenkoValeriy/emacs-swift-module][Emacs dynamic modules powered by Swift]], I added it to my never-ending list of things to try out.
Fast-forward to a year later, and [[https://github.com/roife][Roife]]'s [[https://www.reddit.com/r/emacs/comments/17vrmrk/emt_emacs_macos_tokenizer_for_enhanced_cjk_word/][introduction]] to [[https://github.com/roife/emt][emt]] finally gave me that much-needed nudge to give [[https://github.com/SavchenkoValeriy/emacs-swift-module][emacs-swift-module]] a try. While I wish I had done it earlier, I also wish [[https://github.com/SavchenkoValeriy/emacs-swift-module][emacs-swift-module]] had gotten more visibility. Native extensions written in Swift can open up some some neat integrations using native macOS UX/APIs.
While I'm new to Savchenko's [[https://github.com/SavchenkoValeriy/emacs-swift-module][emacs-swift-module]], the project has [[https://savchenkovaleriy.github.io/emacs-swift-module/documentation/emacsswiftmodule/][wonderful documentation]]. It quickly got me on my way to build an experimental dynamic module introducing a native context menu for sharing files from my beloved editor.
#+ATTR_HTML: :width 90%
[[file:images/native-emacsmacos-ux-integrations-via-swift-modules/emacs-share.webp]]
Most of the elisp/native bridging magic happens with fairly little Swift code:
#+begin_src swift
try env.defun(
"macos-module--share",
with: """
Share files in ARG1.
ARG1 must be a vector (not a list) of file paths.
"""
) { (env: Environment, files: [String]) in
let urls = files.map { URL(fileURLWithPath: $0) }
let picker = NSSharingServicePicker(items: urls)
guard let view = NSApp.mainWindow?.contentView else {
return
}
let x = try env.funcall("macos--emacs-point-x") as Int
let y = try env.funcall("macos--emacs-point-y") as Int
let rect = NSRect(
x: x + 15, y: Int(view.bounds.height) - y + 15, width: 1, height: 1
)
picker.show(relativeTo: rect, of: view, preferredEdge: .maxY)
}
#+end_src
This produced an elisp =macos-module--share= function I could easily access from elisp like so:
#+begin_src emacs-lisp :lexical no
(defun macos-share ()
"Share file(s) with other macOS apps.
If visiting a buffer with associated file, share it.
While in `dired', any selected files, share those. If region is
active, share files in region. Otherwise share file at point."
(interactive)
(macos-module--share (vconcat (macos--files-dwim))))
#+end_src
On a side note, =(macos--files-dwim)= chooses files depending on context. That is, [[https://xenodium.com/emacs-dwim-do-what-i-mean/][do what I mean (DWIM) style]]. If there's a file associated with current buffer, share it. When in [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Dired.html][dired]] (the directory editor, aka file manager), look at region, selected files, or default to file at point.
#+begin_src emacs-lisp :lexical no
(defun macos--files-dwim ()
"Return buffer file (if available) or marked/region files for a `dired' buffer."
(if (buffer-file-name)
(list (buffer-file-name))
(or
(macos--dired-paths-in-region)
(dired-get-marked-files))))
(defun macos--dired-paths-in-region ()
"If `dired' buffer, return region files. nil otherwise."
(when (and (equal major-mode 'dired-mode)
(use-region-p))
(let ((start (region-beginning))
(end (region-end))
(paths))
(save-excursion
(save-restriction
(goto-char start)
(while (< (point) end)
;; Skip non-file lines.
(while (and (< (point) end) (dired-between-files))
(forward-line 1))
(when (dired-get-filename nil t)
(setq paths (append paths (list (dired-get-filename nil t)))))
(forward-line 1))))
paths)))
#+end_src
I got one more example of a native macOS integration I added. Being an even simpler one, and in hindsight, I prolly should have introduced it first. In any case, this one reveals [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Dired.html][dired]] files in macOS's Finder app (including the selection itself).
#+ATTR_HTML: :width 100%
[[file:images/native-emacsmacos-ux-integrations-via-swift-modules/reveal.webp]]
#+begin_src swift
try env.defun(
"macos-module--reveal-in-finder",
with: """
Reveal (and select) files in ARG1 in macOS Finder.
ARG1 mus be a vector (not a list) of file paths.
"""
) { (env: Environment, files: [String]) in
NSWorkspace.shared.activateFileViewerSelecting(files.map { URL(fileURLWithPath: $0) })
}
#+end_src
The corresponding elisp is nearly identical to its =macos-share= sibling:
#+begin_src emacs-lisp :lexical no
(defun macos-reveal-in-finder ()
"Reveal file(s) in macOS Finder.
If visiting a buffer with associated file, reveal it.
While in `dired', any selected files, reveal those. If region is
active, reveal files in region. Otherwise reveal file at point."
(interactive)
(macos-module--reveal-in-finder (vconcat (macos--files-dwim))))
#+end_src
My Swift module experiment introduces two native macOS UX integrations, now available via =M-x macos-share= and =M-x macos-reveal-in-finder=. I've pushed all code to it's own [[https://github.com/xenodium/EmacsMacOSModule][repo]].
I hope this post brings visibility to the wonderful [[https://github.com/SavchenkoValeriy/emacs-swift-module][emacs-swift-module]] project and sparks new, native, and innovative integrations for those on macOS. Can't wait to see what others can do with it.
/Enjoying this content? Find it useful? Consider ✨[[https://github.com/sponsors/xenodium][sponsoring]]✨./
* [2023-11-16 Thu] Migrating/re-encrypting pass's password store
:PROPERTIES:
:CUSTOM_ID: migratingre-encrypting-passs-password-store
:END:
Note to self, I needed to migrate/re-encrypt someone's password store (aka pass). Straightforward:
Get the new key, probably already in gpg key chain. Try listing it:
#+begin_src sh
gpg --list-keys
#+end_src
To re-encrypt, =pass init= with new key is enough. It'll prompt for old pass key.
#+begin_src sh
cd path/to/.password-store
pass init NEW-GPG-KEY
#+end_src
* [2023-10-30 Mon] How I smash burgers
:PROPERTIES:
:CUSTOM_ID: how-i-smash-burgers
:END:
I'm neither a burger expert nor a connoisseur of any kind, yet I sure have a lot of fun smashing burgers at home. Needless to say, I shamelessly enjoy gobbling them too!
#+CAPTION: my smash burger
#+ATTR_HTML: :width 60%
[[file:images/how-i-smash-burgers/burger-cut.png]]
I'll share details on how I smash my burgers, but here's a quick ingredient list, if that's all you need.
- Mince beef (20%-30% fat).
- Streaky bacon.
- Brioche burger buns.
- American cheese slices (cheddar individual slices work too).
- Lettuce.
- Tomatoes.
- Onions.
- Pickles.
- Jalapeños.
- Garlic.
- Chipotle powder.
- Mayonnaise.
- Salt.
- Pepper.
- Oil.
- Greaseproof paper.
- Butter.
** The calling
My quest to smash burgers at home didn't start until earlier this year, while watching the [[https://www.imdb.com/title/tt9764362/][The Menu]]. I just could't stop [[https://indieweb.social/@xenodium/109734285674122246][craving the burger]] from that scene, so I set out to start smashing my own.
#+ATTR_HTML: :width 98%
[[file:images/how-i-smash-burgers/the-menu.webp]]
** The gear
Don't rush to buy anything fancy. Your existing gear will likely do the job just fine. I'd say try a few things out and only upgrade when needed. I'll share the gear I use and where I felt I needed tweaking.
** Skillet
While I didn't have a griddle at home, I did have a couple of trusty [[https://www.lodgecastiron.com/][Lodge]] *skillets* ([[https://www.lodgecastiron.com/product/round-cast-iron-classic-skillet?sku=L8SK3][cast iron]] and [[https://www.lodgecastiron.com/product/carbon-steel-skillet?sku=CRS12][carbon steel]]). Both work great for burgers, though I have a slight preference for the carbon steel one, as it's the bigger of the two and gives a little more room for manoeuvring, specially when smashing two burgers at a time.
#+ATTR_HTML: :width 250px
[[file:images/how-i-smash-burgers/cast-iron.png]]
#+ATTR_HTML: :width 250px
[[file:images/how-i-smash-burgers/carbon.png]]
Heat the skillet up and add a little oil. If the oil starts smoking, be quick to drop the patties and start smashing.
** Grill Spatula (too big/stiff for skillet)
Somewhat inspired by the film, I got myself a wide spatula so I could firmly press those patties against the skillet, and to flip of course.
While this kind of spatula may work well on a spacious griddle, I felt constrained on a relatively small cast iron. Specially when flipping. I went looking for an alternative.
#+ATTR_HTML: :width 250px
[[file:images/how-i-smash-burgers/spatula.png]]
** Spatula + smasher (my winning combo)
Over at the [[https://reddit.com/r/castiron/][r/castiron]] subreddit, I discovered fish spatulas. They are fairly agile on cast irons but also work great for loosening burger patties before flipping.
[[file:images/how-i-smash-burgers/ready.webp]]
While effective for flipping, fish spatulas are obviously no good for smashing. So I got myself a burger smasher. This combo worked well for me.
[[file:images/how-i-smash-burgers/smash.webp]]
When smashing, use greaseproof paper to prevent the patties from sticking to the smasher.
** Ingredients
While I've drawn inspiration from others, I've landed on my own preferred ingredients. I'm sure that will continue changing over time. Pick and choose as your heart desires.
** Minced/ground beef
Minced beef with higher fat content (around 20-30%) is often recommended for a couple of reasons:
- Flavour: Fat equals flavour in cooking. The higher fat content will melt during cooking and become 'self-basting', resulting in a juicier and more flavourful burger.
- Texture: The fat in the beef melts under heat, helping the burger achieve a crispy, caramelized exterior known as the [[https://en.wikipedia.org/wiki/Maillard_reaction][Maillard reaction]], which contrasts nicely against the soft, juicy interior.
In the UK, I can typically find minced beef with 15%-20% fat content at the main supermarkets.
#+ATTR_HTML: :width 200px
[[file:images/how-i-smash-burgers/pattie.png]]
Be sure to salt and pepper to taste (as in picture) on one side. Once flipped on pan, salt and pepper the other side.
** Bacon
I tend to prefer smoked streaky bacon, but hey these will be your burgers. Your burgers, your rules.
#+ATTR_HTML: :width 250px
[[file:images/how-i-smash-burgers/streaky.png]]
** Buns (brioche)
I hear potato buns are great for burgers. I've yet to try them. So far, I've settled for brioche. I happen to find these near me, so I've gone with them.
#+ATTR_HTML: :width 350px
[[file:images/how-i-smash-burgers/brioche.png]]
Butter the buns and brown on the skillet for a minute. Check the buns often. Brioche buns can burn quickly.
** American cheese
American cheese is often the burger cheese of choice.
#+ATTR_HTML: :width 98%
[[file:images/how-i-smash-burgers/american-cheese.webp]]
While American cheese isn't widely available in the UK, the individually wrapped orange-looking cheddar cheese slices work just fine.
#+ATTR_HTML: :width 250px
[[file:images/how-i-smash-burgers/cheese.png]]
** Toppings
I like my burgers with lettuce, tomatoes, onions, pickles, and occasionally jalapeños. For pickles, I typically just take cornichons and slice them up.
#+ATTR_HTML: :width 350px
[[file:images/how-i-smash-burgers/toppings_x0.30.png]]
** Burger sauce (chipotle/garlic/mayo)
While classic burger sauce is often made with mayo, ketchup, pickles, and mustard, I've gone fairly rogue here.
You see, I love chipotle mayo. I'm also a fan of garlic mayo, so I figured why not both? Turns out these three ingredients work great together.
I like to draw out the flavours by first mixing the garlic and chipotle with a little hot water.
- 1 garlic clove.
- 2 teaspoons of chipotle powder.
- 1 tablespoon of hot water.
- Pinch of salt.
#+ATTR_HTML: :width 210px
[[file:images/how-i-smash-burgers/sauce1.png]]
#+ATTR_HTML: :width 210px
[[file:images/how-i-smash-burgers/sauce2.png]]
#+ATTR_HTML: :width 210px
[[file:images/how-i-smash-burgers/sauce3.png]]
...and then thicken with mayo.
- 1/4 cup of mayo.
#+ATTR_HTML: :width 210px
[[file:images/how-i-smash-burgers/sauce4.png]]
#+ATTR_HTML: :width 210px
[[file:images/how-i-smash-burgers/sauce5.png]]
These are very rough measurements, tweak to your preference. Make more garlicky, spicier, or soften things by adding garlic, chipotle, or mayo.
** Assembling
I like to assemble in the following order from the bottom bun up.
1. Sauce on bottom bun.
2. Lettuce.
3. Tomatoes.
4. Onions.
5. 2 patties (melted cheese on both).
6. Bacon.
7. Pickles.
8. Jalapeños.
9. Sauce on top bun (oops, I forgot in the picture).
#+ATTR_HTML: :width 60%
[[file:images/how-i-smash-burgers/open.png]]
...and here's the final product.
#+ATTR_HTML: :width 60%
[[file:images/how-i-smash-burgers/burger-cut.png]]
If you gave smashing burgers a go, I'd love to hear about it. Also any tips are very much welcome. Get in touch ([[https://indieweb.social/@xenodium][Mastodon]] / [[https://twitter.com/xenodium][Twitter]] / [[https://www.reddit.com/user/xenodium][Reddit]] / [[mailto:me__AT__xenodium.com][Email]]).
* [2023-10-24 Tue] Open in Xcode at line number
:PROPERTIES:
:CUSTOM_ID: open-in-xcode-at-line-number
:END:
I live mostly in Emacs. I say mostly 'cause well, I'm fairly pragmatic about it. If there's a workflow elsewhere that's more appropriate for my needs, I'll happily use that instead. While I'd love to do my web browsing from my beloved editor, Firefox ticks the right boxes for me.
I do most of my iOS coding in Emacs. It's a hybrid of sorts between Emacs and Xcode. If I need to use the debugger, Xcode is a clear winner for me. If I happen to be visiting a Swift file in an Emacs buffer, I typically used the handy =crux-open-with= from [[https://github.com/bbatsov/crux][crux]] to open in Xcode, and continue from there. This worked OK, but I always wished opening in Xcode would also jump to the same line number as the Emacs point (cursor) location. This is particularly useful if I had just spotted where I'd like to set a breakpoint in an Emacs buffer and need to transition over to Xcode.
It turns out, there's a nifty command line utility for that. [[https://www.unix.com/man-page/osx/1/xed/][xed]], the Xcode text editor invocation tool. It enables telling Xcode what file to open and at what line number:
#+begin_src sh
xed -line 141 path/to/some/file.swift
#+end_src
With that in mind, I've added my own version of =crux-open-with=, using [[https://github.com/xenodium/dwim-shell-command][dwim-shell-command]].
When running on macOS, the function checks whether or not I'm visiting a buffer for a programming language, and opens the file in Xcode at the same line number.
#+begin_src emacs-lisp :lexical no
(defun dwim-shell-commands-open-externally ()
"Open file(s) externally."
(interactive)
(dwim-shell-command-on-marked-files
"Open externally"
(if (eq system-type 'darwin)
(if (derived-mode-p 'prog-mode)
(format "xed --line %d '<
