Forem: Elsa Gonsiorowski

RSS Feeds by Email

Elsa Gonsiorowski — Tue, 16 Feb 2021 00:00:00 +0000

While RSS is great, it’s not easy to explain to those who haven’t heard of it before. Plus, it’s hard to get someone started on using RSS since it requires a separate application. TwoBitHistory has an great post on the history of RSS that covers it’s fall from grace.

Without RSS, keeping up-to-date on your favorite websites from the independent web becomes a bit more difficult. Most sites now feature a newsletter and email is a great alternative to RSS. Julia Evans describes the MailChimp process to turn an RSS feed into a weekly digest.

I’ve decided to use something even simpler: the RSSby.email service. RSSby.email provides a daily email with posts from this (or any) RSS feed. It is entirely managed by the subscriber via email (see the website for details on how to subscribe and various preferences you can set).

To facilitate the subscription process, I added an HTML mailto link to create the subscribe email for this site:

<a href="mailto:add@rssby.email?subject=subscribe&body=https://www.gonsie.com/blorg/feed.xml"><img src="/images/rss-email.png" id="rss"></a>

RSSby.email will automatically unsubscribe any websites that are not updated within 90 days… which should inspire me to post with some frequency.

Automatic Dark Mode for Your Website

Elsa Gonsiorowski — Fri, 22 Jan 2021 00:00:00 +0000

With HTML5 filters and media quieries, it’s simple to enable an automatic dark mode on your website. Use the following CSS snippet:

@media (prefers-color-scheme: dark) {
  html {
    filter: invert(1) hue-rotate(180deg);
  }
}

It’s not perfect, but rather a quick and dirty way to stop blinding yourself when you’re editing your website at 2 am.

My iPad Setup

Elsa Gonsiorowski — Thu, 29 Aug 2019 00:00:00 +0000

For almost a year now, my iPad has been my main computing device while traveling (the only other device being my phone). Making the switch has been relatively easy, once I decided to buy any (and every) app I thought would make my life easier.Any downsides I’ve come across have been more than compensated by not having to carry around 5 extra pounds of laptop. In this post I’ll detail some challenges and highlight the best apps that I’ve found.

My Recommendations

Before I get too into the weeds, here is the bottom line up front. These are my must-have apps. The prices may be higher than most apps, but I guarantee that they are worth every dollar.

Name	Price	Description
Texpad	$19.99	TeX and LaTeX editing and compiling
GoodNotes 5	$7.99	Digital notebook, for the Apple pencil
Working Copy	Pro $15.99	Git & GitHub
Blink Shell	$19.99	SSH terminal
Prompt by Panic	$19.99	SSH terminal
iA Writer	$8.99	Plain text writing app
PCalc	$9.99	Calculator with all the bells and whistles
Terminology	$1.99	Dictionary & Thesaurus

Hardware Setup

Of course, it all starts with an iPad.I have a 9.7-inch iPad Pro (generation 1), with 32 GB of space. It’s small and light. The small screen means that it’s not great for multitasking / split-screen, but it’s usable when I need it. I also have the Apple keyboard cover (approximately 1 pound). I also have an Apple Pencil, but I don’t usually carry that with me. I would consider the next generation iPad just for the Pencil magnets.

Some thoughts on the Apple Pencil

I often take handwritten notes, but digital notes just aren’t quite the same. That said, I did give it a shot and found GoodNotes to be an absolutely stunning app. It allows you to create different notebooks and comes equipped with great page templates. As a bonus, users of GoodNotes 4 (which I purchased back in 2016 when I first got my iPad) were given a free or subsidized upgrade to GoodNotes 5 when it was released earlier this year.

Some other fun apps, just to use the pencil:

The Holy Grail

I already told my story of compiling slides at 30,000 feet and I cannot recommend Texpad enough. If you need to do any TeX at all, get Texpad, it works. The TeX/LaTeX suite is such a beast, with tons of packages, and archaic flags. I’m a CLI person, but I still use MacTex’s provided TexShop GUI app to actually compile my tex files. What even is the comiple command, pdflatex --some --flag? I don’t actually know the magical incantation. But Texpad knows. And Texpad works.

Coding

The technical aspects of my day job are coding. Heck, with Emacs and Org-mode, even writing, text editing, building a poster, making slides, etc. is coding. Coding on an iPad can happen in two ways:

SSH into a remote machine (say, a desktop sitting back in your office)
Download source to the iPad and edit it directly.

My preferred method is (1) SSH-ing back to my office desktop machine. This means that any work I do is waiting for me when I return from my trip, plus I have access to emacs, compilers, Unix, the office intranet… There are two very good apps for this: Panic’s Prompt and Blink. While I love and support the folks over at Panic, my go to is Blink. Blink allows key remapping, meaning caps-lock is control and ` is Esc. Thank goodness because typing on a plane is RSI-inducing enough. Blink also supports MOSH, which I haven’t yet tried.

Sometimes, I don’t want to SSH anywhere, or I want to do some git work without internet access. For that there is Working Copy (unlock all the features with an in-app-purchase). This app is a dream. It has fully functioning support for git, with built in code editing and diff viewing (including an image diff viewer). The built-in text editor is great and did I mention it does all of git!? Pushing to GitHub does require some set up: you have to request permission for the app from any organizations that you want to push to.

Plain Text Editing

It’s taken me a long time to figure out a good text editing app, one that works great for plain text, not necessarily code. Of course, org-mode has spoiled me.I really want plain text… but with some syntax highlighting. I’d also really like the readline shortcuts to work (C-a, C-e, C-f, C-b, etc.). And a dark mode with fixed width fonts (Inconsolata or Fira Code please). With these “simple” requirements, it’s taken me quite a while to find a text editing app that I like.

The best plain app I’ve found is iA Writer. I’ve heard good things about this app for a long time, but with emacs on my Mac I’ve never had a good reason to invest. These folks really understand plain text. Doesn’t get in the way or force markdown on me, smooth to use, and files are stored as .txt (or even .org) which are easily accessed by the File browser.

Missing Essentials

There are two basics that are completely missing on the iPad: a calculator and a stand-alone dictionary/thesaurus app.

For a calculator I use PCalc, based on recommendation from Daring Fireball. PCalc is great and has every feature you’d ever need: unit conversions, paper tape, hexadecimal/octal/binary conversions, color themes, and more. Plus, it gives you a chance to practice your reverse Polish notation.

I frequently use the built-in MacOS dictionary when writing, mostly for the thesaurus. On the iPad, I’ve found Terminology. It has great support for keyboard shortcuts, works offline, and provides tons of related words (from the Princeton WordNet lexical database).

The Rest

If your are gearing up to use your iPad as a main computing device, there are a bunch of apps you should have just in case. Mostly, they are the typical suites of office software and video conferencing platforms. Personally, I wouldn’t choose to use any of these, but no one asks me. That said, when I have had to use these office-suite apps, I have been surprised at how seamlessly they work. It is completely possible to edit a budget spreadsheet (full of advanced macros) while waiting for your flight.

Don’t be afraid of eshell

Elsa Gonsiorowski — Wed, 31 Jul 2019 00:00:00 +0000

One of the reasons I decided to switch to emacs was the ability to embed a terminal window directly within my editor. Before last week, I never got the embedded terminal working and never really gave eshell much of a try. Initially, I tried to setup my regular shell (fish), but that never quite worked correctly.I also learned the power of dired and haven’t had the need to use the command line quite as much. Then, last week, I found myself editing and re-compiling code in a tight loop. I wanted access to the terminal, to trigger compilation, without leaving emacs. I created a quick-and-dirty eshell setup… and then wondered why I hadn’t done this sooner.

What is eshell?

Emacs shell, or eshell, presents bash-like command line interface built directly on emacs. It tries to be the best of two worlds:

An elisp REPL wherein elisp commands can be directly executed
A command line interface similar to bash

By understanding that eshell is presenting emacs in a terminal/shell sort of way, I can choose if I want to execute a command the elisp or bash way. More details can be found on the eshell page in the emacs manual.

Bare Minimum

First things first: to launch an eshell terminal, run M-x eshell.

Next, there are 2 things I need to have a basic, functioning shell environment:

Have the correct PATH
Have my most used aliases

Path

The PATH variable used by eshell is exposed through the addpath command.Without any arguments, addpath simply prints out the directories currently in PATH. When called with one or more arguments, addpath will append these paths to your PATH. There is no need to include the current PATH contents, as addpath always appends.

Aliases

Eshell has a number of built in commands, which are similar to the bash builtins. The most useful command is alias, which can be used to create any commands that you are used to using in your regular shell. The first step for me was to figure out which aliases I use most often and add them to eshell.

First, I needed the ls alternative that I use. Luckily, there is an ls provided by eshell (shown by running which ls). It takes the same arguments as my Mac’s builtin version.

Next, I needed a way to open an emacs buffer with a specific file. I use the command em to launch a new emacs session within my terminal window (emacs -nw). The alias for eshell is slightly different, since I am already running an emacs session. I simply want to start editing a particular file. Thus, the alias makes a call to the emacs function find-file.

My alias file (~/.emacs.d/eshell/alias) looks like this:

alias la ls -AFGhl $1
alias em find-file $1

Next Steps

The bare minimum takes care of my most frequent use case. Now, I can compile code without switching away from emacs!

The next step for me is to add the aliases to dotfiles and continue to improve my eshell setup. A quick web search lead me to a literate config for eshell in howardabrams/dot-files. There are several settings here that I will have to add for myself.

Highlighting in Org-Mode

Elsa Gonsiorowski — Sun, 09 Jun 2019 00:00:00 +0000

I use org-mode to take a lot of notes and I frequently want to highlight some terms that I’m defining or a key sentence. Overall, I want two things:

I would like to add some markup syntax which will highlight a word or phrase, using ':' to mark the start and end of the phrase (similar to bold or italic markup).
When I export this markup through HTML (or markdown) it the markup should get converted to the HTML5 <mark> tag.

Extending Org Syntax

Extending the org syntax isn’t the most straightforward. At first, I tried to modify the org-emphasis-alist variable, but that didn’t seem to work. Instead, I was able to extend org-font-lock with an extra regex.

(defun org-add-my-extra-markup ()
  "Add highlight emphasis."
  (add-to-list 'org-font-lock-extra-keywords
               '("[^\\w]\\(:\\[^\n\r\t]+:\\)[^\\w]"
                 (1 '(face highlight invisible nil)))))

(add-hook 'org-font-lock-set-keywords-hook #'org-add-my-extra-markup)

The elisp regular expression isn’t the easiest to understand, but this is what it matches:

Regex	Explanation
`[^\\w]`	something that’s not a word
`\\(`	start of a capture group (not matching)
`:`	a colon
`[^\n\r\t]+`	a string of 1 or more characters that doesn’t contain new-lines or tabs
`:`	a colon
`\\)`	end of the capture group (not matching)
`[^\\w]`	something that’s not a word

The start-and-end matching of something that’s not a word means that colons in the middle of a URL are not matched and that the highlighted text can be followed by punctuation. The parenthesis create a capture group, which is used later to define what has the highlight face.Here is a diagram to try and explain the different pieces:

'("[^\\w]\\(:\\[^\n\r\t]+:\\)[^\\w]" (1 '(face highlight invisible nil)))
  |      '--capture group---'      |  | '--face definition-----------'
  '--regular expression to match---'  '--capture group number

Exporting HTML

The next step is to extend the org-exporter. This is easily done and a working example is even provided by export engine manual. I simply create a filter for any backend built on top of html (which should include my markdown and jekyll-md exporters).

(defun my-html-mark-tag (text backend info)
  "Transcode :blah: into <mark>blah</mark> in body text."
  (when (org-export-derived-backend-p backend 'html)
    (let ((text (replace-regexp-in-string "[^\\w]\\(:\\)[^\n\t\r]+\\(:\\)[^\\w]" "<mark>" text nil nil 1 nil)))
      (replace-regexp-in-string "[^\\w]\\(<mark>\\)[^\n\t\r]+\\(:\\)[^\\w]" "</mark>" text nil nil 2 nil))))

(add-to-list 'org-export-filter-plain-text-fucntions 'my-html-mark-tag)

I add this to my org-config.el file and success!

Alternatives

Of course, org-mode already ships with some built-in highlighting functionality; namely, the syntax for defining a description list (which is a native HTML concept). The following org formatting can be used to create a description list:

- Emacs :: an extensible ,customizable, free/libre text editor
- Org mode :: keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system

Which becomes the following HTML:

<dl>
<dt>Emacs</dt><dd>an extensible ,customizable, free/libre text editor</dd>
<dt>Org mode</dt><dd>keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system</dd>
</dl>

While this is a common use-case for highlighting, I don’t always want my highlights to be in a list.

Final Example

Here is a very brief example of a highlighted phrase which was exported properly. I can also use this method to highlight a longer sentence, such as: Should I implement this highlighting syntax and export functionality into Orgmode itself?

Sending Email from Org Mode

Elsa Gonsiorowski — Wed, 01 May 2019 00:00:00 +0000

Every so often, I need to generate a bunch of form emails. Often, I’m sending the same email to multiple groups of people and I want use variables, such as $first_name, in the text. While I’m sure there a number of online services which could achieve this for me, I really don’t need to set up a fancy campaign or use tracking. Plus, I’m wary of submitting others’ emails to a third party.

Of course, I’ve used Emacs to do this, using org mode and AppleScript.

Overview

To approach this task I start with a single org file. Getting AppleScript executing from an org block is trickier than I would like. Instead, I write the script whole cloth in my org file and tangle it out to a separate .scpt file. I store the data in my file as a table. I then use a bash block, which takes the data through :var, to loop over running the script.

AppleScript for Email

I’ve never formally learned AppleScript, but some searching on StackOverFlow and trial-and-error can get you pretty far. Mac OS X has a built in editor found in /Applications/Utilities/Script Editor. Once you’ve opened the editor, you can browse the dictionary with File > Open Dictionary.... This dictionary lists all the classes and commands for different applications. The AppleScript language itself looks like natural language and is relatively easy to understand… especially once someone else has properly constructed the program.

For my email-sender script, I store the AppleScript source is as a block. This block is tangled (C-c C-v C-t) to a .scpt file. The first half of this script sets some variables, including the body of the email message. The second half creates the message and sets a “to” recipient (could also set a “cc” recipient).

#+NAME: script
#+BEGIN_SRC apples :tangle email.scpt
on run argv
   set varName to item 1 of argv
   set varEmail to item 2 of argv
   set varBody to "Hello " & varName & ",

Blah blah blah. Lor ipsum, etc.

Sincerely,
Elsa"

   tell application "Mail"
        set theMessage to make new outgoing message with properties {subject: "Email", content: varBody, visible:true}
        tell theMessage
             make new to recipient with properties {name:varName, address:varEmail}
             #send
        end tell
   end tell
end run
#+END_SRC

Note that I’ve commented out the send command and set the message property visible: true. This means that the draft emails appear in the Mail GUI, but do not get automatically sent. This allows me to do trial runs before spamming my recipients.

Filling the Variables

Once I have the script and email body written, I know what variables I’ll need to fill in. The next step is to put all the data into a named org table. I usually do this data formatting by hand since I’m bringing together data items from many different sources.

#+NAME: data
|    Name    |      Email      |
|------------|-----------------|
| Mx. Person | person@test.com |

Since I tangle the email sending AppleScript program, I need to run it from the command line. I call the script once for each row in the data table using a bash loop and variable arrays. Then, I use C-c C-c to run the bash loop and generate the emails.

#+BEGIN_SRC bash :var name=data[,0] email=data[,1]
for i in `seq 0 0`; do
osascript email.scpt "${name[$i]}" "${email[$i]}"
done
#+END_SRC

Note that I do not calculate the total number of data items / rows. That would take way too much bash magic for this simple example. Also, if you want to test the variables with an echo statement, use :results output as an argument to the org block.

Hitting Send

I usually choose to manually hit send on each individual email once I’m satisfied with the script.

I keep all of these org commands in a single notes.org file so that I can remember how to recreate the emails (usually a year later when it’s time to send them again). For example, this notes.org file sends introduction emails for a mentoring program I organized with Women in HPC.

Verify git sign-off with TravisCI

Elsa Gonsiorowski — Mon, 15 Apr 2019 00:00:00 +0000

I don’t know how to explain my role as a contributor to the mpiFileUtils project. I joined because these tools are so incredibly useful and just plain cool! I also wanted to represent HPC users and contribute documentation to get more people using them. While I haven’t touched the “core” code, I have converted the build system to CMake, created distinct user and developer documentation, and begun acting as scrum master for the team’s development process.

One thing I noticed recently is that our documented contributing requirements did not match what we were doing in practice. Namely, our team had agreed to use ‘signed-off’ commits as part of our project (inspired by OpenMPI). But, since we hadn’t automated the check for it, the sign-off wasn’t always happening.

So, today I set about remedying the situation.

Verifying a git sign-off

We use a less strict form of git signatures, simply a “Signed-off-by” line in the commit message (rather than a full-blown gpg key signature). This can/should be automatically added to a commit message with the git commit -s flag. The check to see if the latest commit has the sign-off is simple:

git show --summary HEAD | grep -q "Signed-off-by:"

Integration with TravisCI

We already run some automated tests with TravisCI. Travis offers a before_script step which triggers before the build of our project. This is the perfect place for the git-show + grep one liner! Everything seemed to work… until I actually created the pull request for this change. Strange.

Turns out, TravisCI not only checks that a branch passes the tests, but it also checks that a branch merged with master passes the tests. Travis was doing a merge, thus changing the HEAD, before running the verify line. So, the verify should only trigger for testing the branch. Luckily, Travis provides an environment variable set to if the tests are running on a PR or not.

Thus, the one-liner becomes:

'if ["$TRAVIS_PULL_REQUEST" = "false"]; then git show --summary HEAD | grep -q "Signed-off-by:"; fi'

With this small change it is now easy and automatic for our team to hold ourselves to the standards we’ve set.

Caveats

The mpifileutils team has agreed that we won’t enforce a sign-off on every commit, just the final commit of a pull request. Therefore, this check only looks at HEAD, the last commit that was made.

Beautifying the Mode Line

Elsa Gonsiorowski — Sun, 17 Feb 2019 00:00:00 +0000

There are some beautiful Emacs mode line packages out there, including the gorgeous doom-modeline. Since I don’t want my themeing to depend on any external packages, I’ve implemented some of features that I like. The results of all this can be found in my dotfiles.

Size

One of the great things about the doom-modeline is its size. This can be approximated by forming a box around the mode line face (be sure to set it for both the active and inactive mode line). I used an online gradient generator to pick colors close to what I use as the background.



(set-face-attribute 'mode-line nil
                    :background "#353644"
                    :foreground "white"
                    :box '(:line-width 8 :color "#353644")
                    :overline nil
                    :underline nil)

(set-face-attribute 'mode-line-inactive nil
                    :background "#565063"
                    :foreground "white"
                    :box '(:line-width 8 :color "#565063")
                    :overline nil
                    :underline nil)

Git Information

Getting the git branch in the mode line was harder than it should have been. There are a bunch of emacs built-in version control variables and functions, but none that directly get the branch information. The main problem is that the vcs-hooks.el package overloads functions and variable names. This means that you have to get the elisp syntax exactly correct for calling a funciton or returning a variable.

This is a function call which does the wrong thing:



(vc-mode)

Version Control minor mode.
This minor mode is automatically activated whenever you visit a file under
control of one of the revision control systems in `vc-handled-backends'.
VC commands are globally reachable under the prefix `\[vc-prefix-map]':
\{vc-prefix-map}

This returns the value of the variable instead:



vc-mode

Git:develop

Luckily, the doom-modeline package gets it right.



(defun vc-branch ()
  (let ((backend (vc-backend buffer-file-name)))
    (substring vc-mode (+ (if (eq backend 'Hg) 2 3) 2))))
(vc-branch)

develop

This function cuts off the version control prefix (such as “Git:” or “Hg:”).

Right-Justified Text

I also like that some of the information is right-justified. This snippet fills in spaces for the same effect. Note that I only put the major mode name on the right



'(:eval (propertize
         " " 'display
         `((space :align-to (- (+ right right-fringe right-margin)
                               ,(+ 3 (string-width mode-name)))))))
```

Be sure to wrap with `'(:eval )` to ensure that this spacing is re-evaluated when mode-name changes.

## Summary

Overall, I’m very happy with this mode line. The implementation is simple, yet it looks decent in terminal Emacs and absolutely fabulous in the GUI.

A One-Webpage, Printable Resume

Elsa Gonsiorowski — Sat, 25 Aug 2018 00:00:00 +0000

I’ve had my resume as single, printable webpage for over 5 years (initial git commit in 2012). Since all of the styling and content is self contained, it is very easy to used.

I’ve made a template of the resume available on GitHub. It is based on this one page CSS tricks resume which was originally developed by Chris Coyier.

Why HTML and CSS

I’m a firm believer in the separation of style and content. Here, resume content is separated from the style that is applied (as with all well-structured HTML and CSS pages). While I do think that GUI tools are more useful for viusal design, CSS does allow the expression of visual design through programatic means. Unlike LaTeX, which hides much of the fine-grained layout control, CSS is a fully featured layout controller. Even better, it understands the difference of the media by which the content is presented, allowing this resume template to take advantage of non-printing items.

One basic improvement for this project would be to refactor the CSS and abstract some concepts. This would make it easier to change the fonts and overall proportions (rather than messing with strict pixel values).

Usefullness in Teaching Git

I use the template as an easy way to teach git to students. After a basic introduction to git concepts and command, I have the students fork the template repo and create resumes of their own. Each student can add as litte or as much information, and they can play around with the HTML formatting. Indeed, this has the added bonus of getting them on GitHub and using GitHub pages.

Emacs Delete vs. Kill

Elsa Gonsiorowski — Wed, 04 Jul 2018 00:00:00 +0000

One thing that has always vexed me is the Emacs kill ring. It’s great that it makes a list of things you’ve killed, but often I just want delete things quickly without saving it. So I need to change the default settings to enable both killing and deleting words and lines.

Basic nomenclature (for this blog post at least);

kill means removing text and putting it in the kill ring
delete means removing text and not putting it in the kill ring

Understanding Key Bindings

The default behavior of Emacs can depend on the underlying operating system. This is because key presses are first translated by the OS, then passed (if they don’t trigger an OS function) to the application, e.g., Emacs. This can be further complicated by the keyboard setup and, further still, by an Emacs instance running inside of a Terminal.

To figure out the name that Emacs itself has for each key, use C-h k KEY or M-x describe-key KEY. This internal name will come in handy when rebinding these keys.

For extended keyboards, there are often two “delete” keys, one which performs a backspace and one which does a forward delete. The forward delete is often found on the “keypad” or number pad and is thus called kp-delete by Emacs.

Mac Keyboards

Mac keyboards have the following modifier keys: Shift, Control, Option (Alt), and Command. While Shift and Control are already mapped for Emacs (known as S and C respectively), the Option and Command keys are not mapped. I use Option/Alt as a meta (M) key and Command as a super (s) key.

(setq mac-command-modifier 'super) ;; command -> s
(setq mac-option-modifier 'meta) ;; option/alt -> M

Default Commands

By default, the delete key removes a single letter (backwards). In Emacs keybindings, this is sometimes denoted as backspace (in addition to sometimes being called delete). M-delete (ALT-delete on a Mac keyboard) will remove a whole word, but place it in the kill ring. Killing a line is simple: C-k, but this kills a line forwards.

Putting the most recently killed word or line back is C-y, called yanking. Yanking previous items in the ring is achieved with M-y, which will cycle through the ring.

Combinations

There is a 3 dimensional problem to solve here, with 16 possible combinations (14 unique operations):

Removal direction (backwards or forwards)
Removal type (kill or delete)
Removal size (character, word, visual line, whole line)

Direction

I use the Mac internal for marking the direction as backwards or forwards. Even on laptop keyboards, I can use Fn-delete to get the forwards deletion.

The whole line removal does not have a direction, but must be bound to both delete and kp-delete.

Removal Type

The un-modified delete key-press should trigger a character delete. Using the meta (M) modifier triggers a word removal. Using the control (C) modifier triggers a line removal.

Saving Items to the Kill Ring

I use the Shift (S) modifier to explicitly trigger adding the removed text to the kill ring.

Binding the Keys

The following table tracks all the combinations which must be implemented. The implementation looks like:

(global-set-key (kbd "<<keybinding>>") '<<function>>)

Direction	Type	Save	Key Binding	Function
Backwards	Char	No	`<delete>`	None needed
	~~Char~~	~~Yes~~		Not implemented
	Word	No	`<M-delete>`	`backward-delete-word` *
	Word	Yes	`<M-S-backspace>`	`backward-kill-word`
	Line	No	`<C-backspace>`	`backward-delete-line` *
	Line	Yes	`<C-S-backspace>`	`backward-kill-line` *
Forwards	Char	No	`<kp-delete>`	`delete-forward-char`
	~~Char~~	~~Yes~~		Not implemented
	Word	No	`<M-kp-delete>`	`delete-word` *
	Word	Yes	`<M-S-kp-delete>`	`kill-word`
	Line	No	`<C-kp-delete>`	`delete-line` *
	Line	Yes	`<C-S-kp-delete>`	`kill-line`
Both	Line	No	`<s-backspace>` and `<s-kp-delete>`	`delete-current-line` *
Both	Line	Yes	`<s-S-backspace>` and `<s-S-kp-delete>`	`kill-whole-line`

The functions marked with a * must be implemented, as such:

;; from https://stackoverflow.com/a/12990359/1160876
(defun backward-delete-word (arg)
  "Delete characters backward until encountering the beginning of a word.
With argument ARG, do this that many times."
  (interactive "p")
  (delete-region (point) (progn (backward-word arg) (point))))

(defun delete-word (arg)
  "Delete characters forwards until encountering the beginning of a word.
With argument ARG, do this that many times."
  (interactive "p")
  (delete-region (point) (progn (forward-word arg) (point))))

(defun backward-delete-line (arg)
  "Delete (not kill) the current line, backwards from cursor.
With argument ARG, do this that many times."
  (interactive "p")
  (delete-region (point) (progn (beginning-of-visual-line arg) (point))))

(defun delete-line (arg)
  "Delete (not kill) the current line, forwards from cursor.
With argument ARG, do this that many times."
  (interactive "p")
  (delete-region (point) (progn (end-of-visual-line arg) (point))))

(defun backward-kill-line (arg)
  "Kill the current line, backwards from cursor.
With argument ARG, do this that many times."
  (interactive "p")
  (kill-region (point) (progn (beginning-of-visual-line arg) (point))))

;; from https://stackoverflow.com/a/35711240/1160876
(defun delete-current-line (arg)
  "Delete (not kill) the current line."
  (interactive "p")
  (save-excursion
    (delete-region
     (progn (forward-visible-line 0) (point))
     (progn (forward-visible-line arg) (point)))))

Summary

I am very happy with how cleanly these keybindings map to functionality.
Let's see if I can actually put these to use!

Developing ox-jekyll

Elsa Gonsiorowski — Sat, 12 May 2018 00:00:00 +0000

In a previous post, I surveyed existing org and jekyll integration workflows. This survey found two common approaches, one that is Jekyll-centric and one that uses Org-publish (Emacs-centric). Unfortunately, neither fit with my workflow and I decided to develop my own Org exporter.

I finally have some functioning code, so I figured I should share details about the project and the development process. You can find the project on GitHub.

Starting Point

In my survey I found some useful resources:

The Worg Documentation on Org Export Engine;
An existing ox-jekyll in org-octopress.

Great artists steal.

I want everything that org-octopress is doing with it’s jekyll exporter, I just want it built on markdown instead of HTML.

So, I’ve copied ox-jekyll.el and replaced “html” with “md”. After fixing a few function names, it works!

Most importantly, the front matter is in the right spot (with and without a table of contents). The next step is to make this work with the particulars of my publishing workflow.

My Publishing Workflow Details

There are a number of things I want my exporter to accomplish. Many of which are particular to my workflow.

I use a single org file per post.
Upon export, the date (YYYY-MM-DD) should get added to the file name.
Subtree level matches export heading level (this is just how I design my site’s CSS)
Code snippets should be easy to export with appropriate syntax. This is where many markdown converters differ, but jekyll currently wraps code blocks with { % highlight LANG %} / { % endhighlight %}. [Ignore the space before the first %].
Jekyll front matter should be added above org-inserted table of contents. The manual HTML source block is just hideous.
It should be easy to move the generated file to a separate location (I think this addressed in the org-publish workflow).
Org-y way to add tags to the post.
Safe export of title (colon character mucks things up for Jekyll).
Fix up links and export connected images. This one is really a nice to have, not necessary.
TOC should be an ordered list (with the option to make it unordered) WTF is the HTML exporter doing making it an unordered list with numbers in the text.

Many of these are solved with code from org-octopress, particularly the yaml front matter.

Implementing Features

Here are some notes on my implementation.

Thinking about the Table of Contents

I had been including a table of contents at the top of each of my posts. I didn’t actually label it with “table of contents” and I prefer an un-numbered list. This seems to be very contrary to what the org-exporter likes to do. It pretty much does not allow for any fine-grained control of how the table of contents appears.

While I was able to get the code to do what I wanted, it ended up being way too much of a hack. In the end, I’ve decided that I don’t want a table of contents at all. Really, it will be up to the markdown / jekyll / liquid parser to create a TOC if necessary. This makes it easy to apply separate HTML styles to the TOC (to put it in a sidebar or something).

Preserving the Headline Level

I would like :headline-offset (as described here) to work on a file level. This allows me to make sure the contents of my post match up the CSS on the web site (the content’s final destination). This is definitely a more markdown-y way to do things rather than the org way.

Unfortunately, the :headline-offset option is only supported per subtree. I can hack it with a simple function that adds an “offset by 0” property to each subtree:

(defun org-jekyll-headline-offset (headline contents info)
  "proper headline offset"
  (let* ((info (plist-put info :headline-offset 0)))
    (org-md-headline headline contents info)))

I add it to the derived backend :translate-alist like so:

(org-export-define-derived-backend 'jekyll 'md
  ;; ...
  :translate-alist
  '((headline . org-jekyll-headline-offset)
  ;; ...

Now, this function is called each time a headline is translated by the export engine and my headline level is directly translated to markdown.

Setting the Date

I have a strange workflow where I want the #+DATE: tag to be the day I started working on a post and the date in the filename to be the day I hit publish. For my exporter, I can use the option date: to trigger this behavior. The date: option takes precedence over the variable org-export-with-date.

While I would like my code to support putting the #+DATE: property into the filename, this seems impossible with the export engine. The date property is stored in the info plist which I don’t have access to at file naming time.

Instead, I’ve implemented this functionality:

The date: option controls if the value of the #+DATE property is put into the Jekyll front matter.
I’ve added a new option to the exporter: org-jekyll-use-today-date. If t, the exporter will prepend the filename with today’s date.

Results

I’m quite happy with my exporter, I even used it to export this post! I still need to figure out how to use the org-publish workflow, but for now I can successfully export my blog posts.

As with most of my projects, you can find it on GitHub. Please feel free to file an issue and share any feed back you have.

Blog Roll

Elsa Gonsiorowski — Wed, 18 Apr 2018 00:00:00 +0000

There has been a lot of talk about blogs in my sphere recently. First, Digg Reader was shut down and I was forced to transition the 40+ blogs that I follow to a new service. Around the same time Jason Kottke (of kottke.org) asked his sustaining members about their favorite blogs. He recently posted the results and included my response (link here so I can treasure this moment)!!

Let me take some more time to list of some of my favorite blogs.

Best of All time

Obviously, Jason Kottke is the best. I have been following him for probably 15 years and I enjoy his blog so much that I am a sustaining member. His blog covers the best of the internet and talks about life, technology, design, and the intersection of it all.

If you have ever been and Apple fan (and are old enough to remember when they actually were the underdogs), then you should already know about Daring Fireball. John Gruber is a prolific blogger and well know for insightful commentary on the Apple news of the day. Also, he invented Markdown. The term ‘fireballed’ refers to a website that is essentially DDOS’d when DF shares a link to it.

The Swiss-Miss blog by Tina Roth Eisenberg is another favorite. It is focused around design and creative work. She shares a ton of inspirational videos and cool products that I wish I could buy.

The last in this category is the Signal-v-Noise blog by 37signals. This is group that develops Basecamp. They are a 100% remote company and a huge inspiration for working in tech and loving your job.

Niche Favorites

Sacha Chua is an amazing blogger. Her style of writing is stream-of-thought, but she goes straight for the deep thoughts about how to improve her (and her family’s) life. She is a prolific contributor the Emacs community and includes a weekly roundup of Emacs news.

Autostraddle is a website for the LGBTQ community. This blog includes a ton of helpful resources for allies and helps me understand the community and important issues better.

The Stone Soup is the only blog on food that I follow. Jules teaches you how to cook with the ingredients you have, so that you understand how to assemble a meal rather than just follow a recipe. Plus, everything I have ever made from her is delicious.

My favorite tech-life blogger is Cate. Her style is incredibly intimate and real; I connect with so much that she writes about. My favorite project of hers are the love letters from airports (with the Technically Speaking newsletter as a close second).

A Few More

Penelope Trunk covers career management.Kate Murphy, Natasha the Robot, Julia Evans (also featured by Kottke), Beth Andres-Beck, Domesticated Engineer, and Kate Heddleston all blog about working in technology (software). And the Fancy Beans blog has left the tech industry behind and is FIRE. The Programming is Terrible blog has one of my favorite posts of all time: Write code that easy to delete.

The Kid Should See This: links to great youtube videos.Tools and Toys links to some interesting products and includes interesting links in their Friday roundup. On the more reflective side of things, zenhabits is quite popular and PatrickRhone is very personal.Irreal is an Emacs blog which posts daily, usually short snippets about Emacs or what is going on the community.The Loop and Pixel Envy are good tech and Apple blogs (see also Matt Gemmell, Derek Sivers, Dustin Curtis).

RSS App

The final piece of the puzzle is actually reading the feeds. In the very early days I would manually click on bookmarks (that was well before the iPhone). Then, I was a huge fan of Safari’s built in RSS reader. When that shut down I moved to Digg. I loved Digg reader since it synced across both an iPhone app and a website.

Currently, I’m using Inoreader. They just released a major update to the iOS app and I am really liking the new design.

While I do like the built-in ability to bookmark or save an article for later, that really backfires when the service shut down. I had about 400 saved articles in Digg, of which 300 or so made it to my pinboard.in account.