Emacs

• [X] Ctrl-n: this can be solved by running chrome in app mode
• [X] ctrl-p: this can be solved by adding some custom shortcuts:

{"shortcuts": [
    {
            "command": "apputils:print",
            "keys":["Accel P"],
            "selector": "body",
            "disabled": true
        },
        {
            "command": "documentsearch:start",
            "keys": [
                "Accel F"
                    ],
            "selector": ".jp-mod-searchable",
            "disabled": true
        },
    
]}

How to tell the editor to use scheme syntax for .rkt files?

• [ ] no auto-reindent functionality, and I rely on that a lot. This is going to be too hard. I'm turning to just use SSH+Emacs + jupyter notebook for simple high-level visualization. Also the boards should be written in notebooks, and I'll be manually indenting them probably.

I have trouble to use web extension manager, most likely due to permission. I cannot set up admin user account no matter the confiuguration file.

I have to install via command line.

jupyter labextension install my-extension
jupyter labextension enable my-extension
jupyter labextension list

and you seem to need to restart jupyterlab.

This actually requires the specific jupyter binary:

sudo /opt/jupyterhub/bin/jupyter install ...

Many times, you will have to install some pip packages. E.g. for installing @jupyterlab/git, I'll need:

sudo /opt/jupyterhub/bin/jupyter install @jupyterlab/git
sudo /opt/jupyterhub/bin/python3 -m pip install jupyterlab-git
sudo /opt/jupyterhub/bin/jupyter lab build
sudo systemctl restart jupyterhub

https://mybinder.org/

Turn a Git repo into a collection of interactive notebooks

• C-p C-n C-b C-f still works
• + and - to adjust scale
• n and p for page navigation
• space and delete to page up and down across pages
• M-< and M-> still works
• M-g M-g works as jump to page

sudo aptitude install libpng-dev libz-dev 
sudo aptitude install libpoppler-glib-dev 
sudo aptitude install libpoppler-private-dev
sudo aptitude install imagemagick

cd /path/to/pdf-tools
make install-server-deps # optional
make -s
make install-package
# or M-x package-install-file RET pdf-tools-${VERSION}.tar RET

activate in emacs by (pdf-tools-install)

• o: open outline
• Q: kill buffer
• q: kill window

k

kill the buffer

r

revert the buffer

n/p

nav rows

c

switch to query editor buffer

RET

show table data

SPC

show table definition

q

quit and disconnenct

n/p

c

V

show table data

q

kill buffer

C-c C-c

execute

C-c q

kill buffer

M-p/n

SQL history back/forward

n/p

SPC

display whole data at current cell, hit SPC again to dismiss

q

quit

• emms-add-file
• emms-add-directory
• emms-add-directory-tree (recursive)
• emms-add-playlist (m3u)
• emms-add-find: use regexp with find

• emms-start
• emms-stop (s)
• emms-next (n)
• emms-previous
• emms-shuffle
• emms-pause (P)
• emms-random (r): go to a randomly selected track in the playlist
• emms-sort
• emms-show (f): show the current track in minibuffer
• emms-seek-forward (>)
• emms-seek-backward (<)
• emms-playlist-mode-center-current (c): center the current song
• emms-playlist-mode-play-smart (RET): play the song under cursor
• emms-playlist-mode-bury-buffer (q): bury buffer
• emms-playlist-mode-clear (C)

In playlist mode, you can kill and yank as normal, use C-j to insert newline.

In addition to the default playlist, we also have the markable playlist. The emms-mark-mode and emms-mark-mode-disable can switch between them. In the mark mode, you can:

• emms-mark-forward (m)
• emms-mark-unmark-all (U)
• emms-mark-toggle (t)
• emms-mark-unmark-forward (u)
• emms-mark-regexp (% m)

When tracks are marked, you can

• emms-mark-delete-marked-tracks (D)
• emms-mark-kill-marked-tracks (K): like D, but put into kill ring, so we can yank it back
• emms-mark-copy-marked-tracks: just kill, ready for yank

Play Property

• emms-repeat-playlist: variable, non-nil means repeat the playlist
• emms-toggle-repeat-playlist: change emms-repeat-playlist
• emms-toggle-random-playlist: random

Play list

• emms-playlist-new
• emms-playlist-save (C-x C-s): just use m3u format

• emms-tag-editor-edit (E): need to have software support. E.g mp3info
• emms-tag-editor-rename-format: this variable controls how to generate file name from meta data, nice!
• emms-tag-editor-rename: this function perform file renaming according to above format

emms-smart-browse to enter the smart browsing page.

From group buffer, type ^ to enter server buffer. Use <space> (NOT <enter>!) to browse the groups of it, and subscribe via u. To unsubscribe, type u again. Actually after unsubscribe, the group still shows up in the group buffer, with U mark. To really remove it, use C-k (gnus-group-kill-group) on it in the group buffer. Oh, just noticed this is just kill-line command, so you can yank it back via C-y (gnus-group-yank-group). Likewise, kill a region also works as expect.

Finding the groups

• gnus-group-browse-foreign-server (B): use nntp as back-end and news.gmane.org as address.
• gnus-group-list-active (A A): List all groups that are available from the server(s).
• gnus-group-unsubscribe-current-group (u): toggle subscription of the group
• gnus-group-list-groups (l): list only subscribed ones with unread articles
• gnus-group-list-all-groups (L): show all subscribed groups
• gnus-group-make-rss-group (G R): paste the rss feed url to add RSS feeds
• gnus-group-jump-to-group (j): jump to a group by entering name, this works for non-listing groups.
• gnus-group-make-rss-group (G R): prompt to enter the RSS url. It is the link of the rss page of a blog, e.g. https://danluu.com/atom.xml

Management

• gnus-group-catchup-current (c): mark all unread articles in the group under cursor as read
• gnus-group-catchup-current-all (C): mark all unread articles in the group under cursor as read
• gnus-group-mail (m): create a new message
• gnus-group-post-news (a): create a new post
• gnus-group-enter-server-mode (^): enter server buffer

Since we like organizing, there's a topic mode, enabled by t. After that, you will have a bunch of command prefixed with T. Topic mode group subscriptions into categories.

• gnus-topic-mode (t): toggle topic minor mode.
• gnus-topic-create-topic (T n): create a new topic
• gnus-topic-indent (<TAB>): indent current topic
• gnus-topic-unindent (M-<TAB>): unindent
• gnus-topic-delete (T <Del>): delete topic under cursor

You generally just kill (C-k) and yank (C-y) to organize the groups into specific topics. UPDATE: Don't use C-k C-y, it seems to cause bug, that cannot save the configuration. Use the following instead.

• gnus-topic-move-group (T m): move the group under cursor to a topic

When topic mode is enabled, <enter> and <space> on a topic line will fold or unfold it. So you don't really need the following commands.

• gnus-topic-hide-topic (T h):
• gnus-topic-show-topic (T s):

Groups can be combined into virtual groups. This is very helpful for reading emails. For gmail, the inbox will not show my interactions, that is in Sent Mail. So on Group buffer, create a virtual group by gnus-group-make-empty-virtual (G V) and edit it via gnus-group-edit-group-method (M-e) with regular expression like this:

(nnvirtual "nnimap\\+cymail:INBOX\\|nnimap\\+cymail:.*/Sent Mail")

This will list all the mails. <RET> to enter a specific mail. The following commands work in both buffers.

• gnus-summary-next-unread-article (n): next unread article
• gnus-summary-prev-unread-article (p): previous unread article
• gnus-summary-next-article (N): next article
• gnus-summary-prev-article (P): previous article
• gnus-summary-next-page (<SPC>): scroll down, move to next unread article when at bottom
• gnus-summary-prev-page (<DEL> or <BACKSPACE>): scroll up, but will not move article
• gnus-summary-expand-window (=): this expand the summary buffer, very handy (instead of switch to summary and C-x 1).

Replying

• gnus-summary-followup-with-original (F): follow-up to group and cite the article
• gnus-summary-followup (f): follow-up to group without citing the article
• gnus-summary-reply-with-original (R): reply by mail and cite the article
• gnus-summary-reply-with-original (r): reply by mail without cite the article
• message-forward-show-mml (C-c C-f): forward to another person
• gnus-summary-mail-other-window (m): new mail
• gnus-summary-post-news (a): new post

Management

• gnus-summary-catchup-and-exit (c): catchup ALL in the buffer
• gnus-summary-toggle-header (t): toggle all headers (a lot of MIME information)
• gnus-summary-insert-old-articles (/ o): show all read articles
• gnus-summary-rescore (V R): recompute the score. Score is computed by emacs rules. This can be explicitly set, or affected by some operations. For example, when you mark an article as read while didn't really read it, the related ones are marked like this.
• gnus-sticky-article (A S): normally the article and summary buffer is reused, that means you cannot put two mails side-by-side. This command make the current article buffer un-reusable for doing that.

Threading

• gnus-summary-toggle-threads (T T): toggle threading (flat style or thread style)
• gnus-summary-refer-thread (A T): display the full thread
• gnus-summary-refer-parent-article (^): fetch parent article
• gnus-summary-top-thread (T o): go to the top of this thread
• gnus-summary-kill-thread (T k): mark whole thread as read

Scores are computed for each article, for the sake of making important ones stand out.

• gnus-summary-lower-score (L): create low score
• gnus-summary-increase-score (I): create high score

Article will have marks to indicate the status of them. The followings are read marks:

• r: marked as read by d command
• R: actually been read
• O: stands for old, marked as read in previous session
• Y: having a too low score
• C: marked as catchup

Other marks:

• !: tick, i.e. important, and will always show
• ?: dormant for now. This will show up whenever there are follow-ups.
• A: this article has been replied or followed-up by me. gnus-replied-mark, this variable has a default value of 65, the ASCII for "A".
• F: this article has been forwarded
• *: this article is stored in cache
• S: this article is saved
• #: the process mark. This is similar to m in dired: you select some articles, and process them at the same time, using some commands.
• .: gnus-unseen-mark, this article hasn't been seen before by the user. What does this mean??

The following commands interact with marks

• gnus-summary-clear-mark-forward (M c): clear mark
• gnus-summary-mark-as-read-forward (d): mark as read.
• gnus-summary-tick-article-forward (!): mark as important.
• gnus-summary-mark-as-dormant (?): mark as dormant.
• gnus-summary-set-bookmark (M b): set a bookmark in the current article. This seems to be a position inside a long article. Gnus will jump to this bookmark the next time it encounters the article.
• gnus-summary-remove-bookmark (M B): remove the bookmark from current article.
• gnus-summary-mark-as-processable (#): mark the current article the process mark
• gnus-summary-unmark-as-processable (M-#): remove the process mark

This is pretty standard: C-c C-c for send, C-c C-k for kill. What is not standard though is C-c C-d for draft, C-c C-m f to attach file.

During editing a message, you can just save it normally, and it will be in the draft group. The next time you enter draft, type D e (gnus-draft-edit-message) in draft summary buffer, you will resume to editing. Rejected articles will also be in draft group.

There are some commands for jumping around the buffer, and edit the headers.

https://github.com/magnars/dash.el

This is a collection of list libraries.

• -map takes a function to map over the list, the anaphoric form with double dashes executed with it exposed as the list item.

   ;; normal version
   (-map (lambda (n) (* n n)) '(1 2 3 4))
   ;; also works for defun, of course
   (defun square (n) (* n n))
   (-map 'square '(1 2 3 4))
   ;; anaphoric version
   (--map (* it it) '(1 2 3 4))
  

• -update-at: (-update-at N FUNC LIST) Return a list with element at Nth position in LIST replaced with `(func (nth n list))`.
• -flatten: (-flatten L): Take a nested list L and return its contents as a single, flat list.

https://github.com/magnars/s.el

The string manipulation library

This package ports many common lisp facilities into elisp, most importantly, the loop facility. So this section, at least for now, focus on cl-loop.

Of course, cl-lib provides much more than just loops …

incf PLACE

is i++

The simplest debugger is called lisp debugger. You can turn on the debug-or-error flag, but I found inserting the (debug) command useful. Simply insert (debug) where you want program to suspend, and run it. You will enter the debugger at that point. In the debugger buffer, the following commands are available:

c

continue run program

d

step

e

evaluate an prompt expression

R

like e, but also save the result in *Debugger-record*

q

quit

v

toggle display of local variables ???

For this to work, first you need to instrument the code. You can instrument the defun by C-u C-M-x. Actually this is adding a prefix before eval-defun, which instrument, and then evaluate the defun.

After instrumentation, running the defun will cause the program to stop at the first stop point of the function. The stop points are

• before and after each subexpression that is a list
• after each variable reference

(ert-deftest addition-test()
  "Outline docstring."
  (should (= (+ 1 2) 4)))

The family of functions:

• should
• shoult-not
• should-error

expected failure:

(ert-deftest addition-test()
  "Outline docstring."
  :expected-result :failed
  (should (= (+ 1 2) 4)))

skip test

(ert-deftest addition-test()
  "Outline docstring."
  (slip-unless (featurep 'dbusbind'))
  (should (= (+ 1 2) 4)))

M-x ert will run it. The selector of test accept some more fancy staff like regular expression matching. But in the case of scratch testing, I need to evaluate the deftest and then call ert.

The nice thing is it supports interactive debugging. In the ert buffer, the following commands are available:

r

re-run the test

.

jump to the source code of this test

b

show back-trace

m

show the message this test printed

d

re-run the test with debugger enabled

instrumentation

go to source code, type C-u C-M-x, and re-run the test. You are able to step!

Also, select test by this:

(ert-run-test (ert-get-test 'my-defined-test))

• with-temp-buffer (with-temp-buffer &rest BODY) Create a temporary buffer, and evaluate BODY there like progn.
• (insert-file-contents FILENAME &optional VISIT BEG END REPLACE): Insert contents of file FILENAME after point.
• (secure-hash ALGORITHM OBJECT &optional START END BINARY): the object can be a buffer. This can be used to compare if a file has changed.
• (current-buffer): Return the current buffer as a Lisp object.
• (message FORMAT-STRING &rest ARGS): Display a message at the bottom of the screen.

There will be many buffers in an Emacs session, and the current-buffer returns the current one, which is the default target for most commands. When you want to make something interesting to some other buffer, you will need to set-buffer to set that buffer current. You will likely want to switch back to the original buffer after those operations, for that, don't use set-buffer to set back, because it is not error-safe. Instead, use save-current-buffer, or better with-current-buffer. with-temp-buffer don't need a provided buffer object, but creates a temporary one. The temporary buffer will be killed at the end of execution of body. All of these 3 form does not display the buffer, just make it current.

A buffer has a name, retrieved by buffer-name. The name can be set using rename-buffer. Buffers can be obtained by name via get-buffer. Buffers are also likely to be associated with a file, and the non-directory file name is buffer-file-name. You can also get the buffer using the file name via get-file-buffer. Since it just the filename, there must be multiple ones, and this function returns the first.

To create a buffer, use get-buffer-create, which returns the new buffer, or an existing buffer. It does not make that buffer current. Create a new unique buffer name by generate-new-buffer-name. It is not typically directly used though. The function generate-new-buffer uses that function to generate new name (by post-fixing <N>), if the provided name is in use.

Obtain all the live buffers using buffer-list. The order of list matters. The newly created buffer is added to the end of list, the current displayed buffer moves to the front. When a buffer is buried, it is moved to the end. other-buffer returns the first in the list that is not current one. last-buffer returns the last (end) in the list. bury-buffer and unbury-buffer moves a buffer to the end and switch buffer to the last buffer respectively. A buffer is killed by kill-buffer, in which case it is removed from the list.

A position is the index in a buffer. There of course will be a character before and one after the position. When we say "at position", we mean after position. Position in a buffer starts from 1, while position in a string starts from 0.

The point is the current cursor position. point returns the current point, point-min and point-max returns the beginning and end point.

There are many commands to move point. goto-char moves by position, and all other commands build upon it. I'm omitting the opposite version, e.g. forward v.s. backward, up v.s. down., beginning v.s. end

• moves by characters: forward-char
• moves by word: forward-word
• buffer: beginning-of-buffer moves to point-min
• line: beginning-of-line and end-of-line, forward-line and backward-line
• screen: you can also count the current vertical screen lines, and move the corresponding lines accordingly.
• balanced expression: forward-list, up-list, forward-sexp, end-of-defun
• skipping: skip-chars-forward skips over a list of chars represented by a pattern string. It is like regular expression, but is put implicitly inside brackets. Thus you can use for example "a-zA-Z".

It is useful to temporarily move to some position, do some tasks, and move back. It is called execursion, and is done via save-execursion.

Narrowing works with two positions. narrow-to-region does the narrowing, and widen undoes it. This creates the following effects:

1. determine the accessible portion of the buffer, but don't alter the position of the actual buffer.
2. The point cannot move outside the positions
3. no texts outside are displayed
4. most (?) functions refuse to operate on outside text

http://ergoemacs.org/emacs/elisp_define_face.html

You probably don't want to define a face from scratch. Try use the default ones:

• default
• bold
• italic
• bold-italic
• underline
• fixed-pitch
• variable-pitch
• shadow
• link
• link-visited
• highlight
• match
• isearch
• lazy-highlight
• error
• warning
• success

Or the ones defined in font-lock-mode:

• font-lock-builtin-face
• font-lock-comment-delimiter-face
• font-lock-comment-face
• font-lock-constant-face
• font-lock-doc-face
• font-lock-function-name-face
• font-lock-keyword-face
• font-lock-negation-char-face
• font-lock-preprocessor-face
• font-lock-regexp-grouping-backslash
• font-lock-regexp-grouping-construct
• font-lock-string-face
• font-lock-type-face
• font-lock-variable-name-face
• font-lock-warning-face

A marker has two component: the buffer it is in, and the position in the buffer. They can be retrieved by marker-position and marker-buffer.

The position is updated automatically when the text changes. The invariant is the surrounding two characters. The updating of marker position takes time, especially there are a lot of them. Thus, remove the marker if you know you won't use if any more.

You can make a marker by 4 functions, which differs only its initial point. make-marker, point-marker, point-min-marker, point-max-marker. You can also copy-markder from existing one. A marker can be moved by set-marker.

There's one special marker, designated the mark, whose position is returned by mark. To return the actual marker, use mark-marker, but this is dangerous, try to avoid it. The mark is mainly used to provide a default region for a command. The text between point and the mark is called the region. The beginning and end of it can be obtained by region-beginning and region-end. When using (interactive) to define a command, the "r" code will give the command two numeric values as the (point) and the mark, the smaller first. This region is used for most region based command by default.

Some command will set the mark, and when it does this, it will typically save the old mark on the mark ring. set-mark set the position of the mark, but it is not commonly used, because it discard the previous mark. Instead, push-mark and pop-mark handles the mark ring automatically.

Elisp can create async or sync processes. There are three primitives to create subprocess: make-process for async, call-process and call-process-region for sync. All others are built upon them.

To get a list of current live async processes, use list-processes. This seems to be for display purpose, and process-list seems to return process objects. You can also get process by its name via get-process. Process information can be retrieved by process-command, process-id, process-name, process-status, process-live-p, process-type, process-exit-status.

You also want to communicate with the subprocess: either send input, receive output, or send signals. To send string as input, use process-send-string, process-send-region, process-send-eof. To send signals, use interrupt-process, kill-process, quit-process, stop-process, continue-process, or the general one signal-process.

The output of a subprocess is inserted into a associated buffer, called the process buffer. This buffer serves two purposes: receive the output, and kill the process by kill the buffer. process-buffer returns the buffer with a particular process, and get-buffer-process returns the process object associated with the buffer. The position to insert is determined by the process mark, which is always set to the end of the buffer. You can set process buffer by set-process-buffer.

Network connection is also represented by a process object, but it is not a child process, has no process id, cannot be killed or sent signal. You can only send and receive data, or close the connection. make-network-process creates network connection. It seems to be a primitive, able to create TCP, UDP, or a server. Alternatively, open-network-stream creates TCP specifically.

• (defalias SYMBOL DEFINITION &optional DOCSTRING): Set SYMBOL's function definition to DEFINITION. E.g. (defalias 'helm-bibtex-get-value 'bibtex-completion-get-value), serves as a temporary patch for helm-bibtex update its API to bibtex-completion