Irreal

Mike Zamansky is working on a Web app. As with most such apps, it has a front end that provides the UI and gathers requests for the server, and a back end that runs on the server and does the “computations”. Apps like that can be tricky to develop because it’s hard to write the front end without some way of feeding it data from the server. On the other hand, it’s hard to communicate with the server without a front end.

There are plenty of workarounds of various utility but Zamansky decided to try out restclient in the 60th video of his Using Emacs Series. Using restclient is a win because you don’t have to leave your development environment and there’s very little cutting and pasting between screens. It’s a nice tool. You can type in, say, a GET request and it will send it to the server, show you what displayable data comes back, and let’s you see the transaction metadata such as the return status.

I mostly concern myself with server-side applications so I don’t have much chance to use something like restclient but I’ve been intrigued with it since I saw Magnar Sveen’s Emacs Rocks! video about restclient in 2014. If you have a need to communicate with a server interactively, be sure to watch both Sveen’s and Zamansky’s videos. They’re both entertaining and informative. The Emacs Rocks! video is 2 minutes, 23 seconds and Zamansky’s is 14 minutes, 36 seconds. They’re well worth the time to watch and may show you a way to save a lot of development time and effort.

UPDATE [2019-10-27 Sun 10:50]: Clarified the front-end/back-end relationship a bit.

Marcin Borkowski has a really handy tip that explains something that I didn’t know. I’m a big fan of Eshell and usually reach for it first when I need a shell. One long standing problem I’ve had with it is clearing the screen. Doing a clear, as you would in other shells, doesn’t work. You can do a clear in Eshell but it doesn’t do what your expecting.

To deal with this, I long ago wrote a bit of code that lets me use the universal argument to clear the screen when I finish with an Eshell session. I like to run Eshell in full screen, which I invoke with Hyper+e, so the following lets me start and stop an Eshell session optionally clearing the history (by quitting Eshell) when I exit.

(global-set-key (kbd "H-e")
                (lambda (exit)
                  "Bring up a full-screen eshell or restore previous config.
With a prefix argument, exit eshell before restoring previous config."
                  (interactive "P")
                  (if (string= "eshell-mode" major-mode)
                      (progn
                        (when exit
                          (insert "exit")
                          (eshell-send-input))
                        (jump-to-register :eshell-fullscreen))
                    (progn
                      (window-configuration-to-register :eshell-fullscreen)
                      (eshell)
                      (delete-other-windows)))))

The result of that is that Eshell forgets its previous content when I exit it with the universal argument.

Borkowski’s tip is really simple. If you want to clear the Eshell buffer, you can do it by specifying clear with an argument. Thus, clear t will clear the Eshell buffer in the way you’re expecting. That’s very nice and good to know.

Over at the GDQuest YouTube Channel, Nathan Lovato has a very nice video on navigating with Spacemacs. Most of the video discusses the Spacemacs interface to the Avy package for jumping around in your code. I’m not a Spacemacs user but I do heavily use Avy for navigation. It is by far the best system I’ve come across for this sort of thing. Once you get used to it, you’ll hardly ever navigate by moving the cursor up and down a line at a time or backwards and forwards a character at a time. It’s just so much simpler and faster to get there with Avy.

My favorite commands are avy-goto-word-1 and avy-goto-char-timer. The first marks every word that begins with the character you specify and lets you choose which one to jump to. The second lets you enter as many characters as you like. When you stop, you can jump to any of the marked sequences. Both are very useful and I call them all the time. The video covers other commands, such as jumping directly to a line, as well. There’s also a short section on using imenu. Lovato shows you how to do all this in Spacemacs so if you’re a member of that Emacs sect you should definitely take a look. The video is 12 minutes long so it should be easy to fit into your schedule.

Most people recognize that Emacs Org mode is superior to Markdown as a markup language. (Sorry Markdown partisans but it is¹.) The problem with Org mode is that as a practical matter it’s restricted to Emacs users. Mostly that doesn’t matter since you’re usually interested in the final exported version of the document. Sometimes, though, you’re collaborating with someone who’s not an Emacs user and you need a markup language that you can both use. There are many possibilities, of course, but most people settle on Markdown as a sort of lingua franca. That makes sense because the exporters are not associated with any particular editor—John Gruber’s original implementation was a Perl script—so everyone can work on the same source document.

Mike Zamansky is a perfect example of this. He prefers to write in Org mode but sometimes, when collaborating, he’s forced to use Markdown. Emacs, of course, has excellent support for Markdown so Zamansky—and the rest of us—don’t have to leave the comfort of our preferred editor.

In the latest video of his Using Emacs Series, Zamansky considers some of the Emacs tools for Markdown. There is, of course, markdown-mode major mode to help you write the actual Markdown source but Zamansky also wanted an easy way to preview his document. It turns out that there are a lot of packages for that and the video discusses many of them. Zamansky finally settled on grip-mode. It’s a very nice previewer that provides live updates so you see your changes as you make them. That met Zamansky’s goal of making the process as frictionless as possible.

The video is 11 minutes, 47 seconds long so it should be easy to find time for it. If, like most Emacs users, you sometimes find yourself needing to write in Markdown for collaboration or other reasons, you should definitely watch this video. Like all of Zamansky’s videos, you’ll learn a lot.