It is very often the case that one works on a certain document (it might be a scientific paper, it might be a book, it might be a newspaper article, it might be a master’s thesis – whatever) and from time to time one wants to revert some changes („this wasn’t that brilliant idea I thought it was”), or highlight the changes made since the last reading by the advisor, or be able to check which parts of the file were last edited on what date, or any similar thing. In general, knowing what part of the file changed from what and when is occasionally quite useful.
Of course, you can save subsequent versions of your paper under filenames like
paper-v23.tex and so on (actually, a better idea is to use
paper-v01.tex – the padding zeros make lexicographic sorting yield better results). Or better,
paper-2014-10-18.tex, using the ISO 8601 standard. But this method is error-prone and cumbersome. And usually, if there is something which is error-prone because it needs a lot of bookkeeping but no creative thinking, it is better to leave that task to a machine.
What is needed in such situations is called a version control system, or VCS. There are plenty of such systems out there. Personally, I used to use Mercurial, but after a few years it became clear that Git is a better choice, and so I made a switch. (Mercurial is easier to use for beginners. Git is more powerful. Don’t care about other ones unless you really have to. For instance, I heard rumors of Subversion (SVN) being a nasty beast, though, so you might want to avoid that one – in general, a so-called distributed VCS seems a more versatile tool anyway.)
What are the advantages of using such systems?
What are the disadvantages? Well, I can think of one: there is some overhead connected with „committing” each change (that is, telling the VCS „hey, this is the next version, please remember it!”). Of course, you can commit only after some major rewrites, but it is usually better to do it more often.
To sum it up: if you work alone, on small projects (say, less than 2 pages of text each), and do backups regularly, you might not need a VCS (but it might come handy anyway). In all other cases, you probably do need it.
Typing (E)lisp code in Emacs is great – the editor takes care of proper indentation etc. Sometimes, however, when debugging, you need to print a long and/or deeply nested list. This is the kind of situation when the pretty printer in
pp.el comes handy.
There are quite a few functions defined there.
C-h f pp- TAB is a good idea to learn about them. I’m going to write about two of them here.
pp-eval-expression takes one parameter: a (quoted) expression, for instance
(pp-eval-expression '(list "hello" "world"))
(If you tried
(pp-eval-expression '("hello" "world")), you would obviously get an error, since Emacs would try to evaluate that list, and there is no function whose name would be the string (not symbol!)
(pp-eval-expression ''("hello" "world")) works as expected.)
This function puts its output into a special (emacs-lisp-mode) buffer called
*Pp Eval Output*, and is useful to get the result of calling some function pretty-printed. In order to display some fixed expression, one can either use the abovementioned double-quote trick, or employ another function from
pp-display-expression. It takes an expression and the name of the output buffer, so e.g.
(pp-display-expression '("hello" "world") "tmp") pretty-prints this list in a
"tmp" buffer (it gets created when nonexistent).
One caveat: this works all well for “hello world” examples, but for really complicated lists, it might be a good idea to set
(setq eval-expression-print-level nil) (setq eval-expression-print-length nil)
The default values (4 and 12 respectively) put rather a tight limit on the displayed lists, and instead of nicely formatted content of some complicated data structure, you get annoying ellipsis. With
nils as their values, there is no limit, so you get everything.
An annoying thing is that if you press e.g. a letter key in a
read-only buffer, you just get a message like
Buffer is read-only: #<buffer whatever-buffer>
If there is no use for most
self-inserting keys anyway, why not
use them for scrolling etc.?
(setq view-read-only t)
changes that. Now all read-only buffers are automatically put in
view-mode, irrespective of whether you don’t have permissions to
edit them or if you just press
C-x C-q. How handy.
(Więcej means More in Polish; click it to see older entries.)