Planet Emacslife

In a nice followup to yesterday’s post on Hippie Expand, deltille asks for clarification on the Emacs’ completion methods. His post was in response to Mickey’s article about hippie expand. Detille is a new Emacs user and is confused about when to use the various expansion Emacs mechanisms—there’s a lot of them—for completion.

Mickey jumps in with an excellent overview of the various methods and why you might want to use one or the other. To my mind, there’s a pretty bright line. If you want syntax-aware editing mediated by an LSP process then you should use completion-at-point or whatever your LSP package uses. If, like me, you’re mainly concerned with just minimizing typing, hippie-expand is the best bet. You can configure it to sequentially try any of the other methods. I use it many times a day and love it.

That leaves templates. If you want to expand a keyword into some text, perhaps with substitutions, then Yasnippet is a very nice solution. Mickey has some other recommendations but unless you have some special needs, Yasnippet is a good answer.

If, like many people, you’re confused by the plethora of completion/expander methods, take a look at this reddit post and Mickey’s answer.

I’m using the Emacs git frontend (‘porcelain’) Magit for all my projects nowadays. I fire up GitUp (which is great) only to traverse the commit history visually.

Here’s one of the reasons:

With auto-completion framework company, I get completion suggestions when I type my commit message. These are based on the actual code diff of the commit.

That means when I introduce veryLongAndCumbersomeToTypeAttributeName, I can begin craft my commit message by typing this:

Introduce new attribute ver|

And company will suggest an auto-completion candidate veryLongAndCumbersomeToTypeAttributeName for the “ver” I’ve just typed.

That makes talking about the classes and attributes and functions that were modified or introduced in a commit so much simpler. No more copy and paste, no more typing mistakes.

Completion candidates starting with 'ver' for this blog post. (The blue-ish background at the bottom isn't a selection but an insertion; I have color-blind modus-themes settings enabled to not have to work with red/green there.)

“Acktshually, that’s not a Magit feature!”, someone might point out without being asked, thankyouverymuch, but that’s only part of the truth: Yes it’s 100% dependent on company being enabled to suggest completion candidates like this for me, but company wouldn’t suggest anything if Magit didn’t display the commit message next to the code diff!

Receive Christian’s new posts via email

Using the org-map-entries API to loop through selected or all headings in an Org file.

Below question on Mastodon by the user @postroutine inspired me to write this post:

I got a lot of Org-Mode headings and I want to modify their properties (add, remove, edit). Is there a function to do the same modifications on each heading?

I think that the best solution to that question is using the org-map-entries function.

But somehow when replying to that question then, that wasn’t what first came to my mind! .. when ironically that function is the main function that enables my preferred subtree-based flow in ox-hugo 😆. So I am writing this post to better ingrain the following concept in myself ..

Next,

1. I will give a give introduction to the org-map-entries API.
2. Then provide a super-short solution to the above question.

org-map-entries API #

I will give only a broad level overview on how to use this function. I would encourage the reader to refer to the resources at the end of this post to learn more about it.

So let’s start by looking at this function’s signature:

(org-map-entries FUNC &optional MATCH SCOPE &rest SKIP)

The org-map-entries function iterates through all the headings meeting the MATCH criteria in the determined SCOPE, and then calls the specified function FUNC at each of those headings.

• The FUNC function accepts no arguments and is called at the beginning of each Org heading.
• The optional second argument MATCH is either nil, t or a search string.
  • If MATCH is nil or t, all headings will be visited by the iteration and FUNC will be called on all of them.
  • But if MATCH is a string, the headings will first be filtered based on that string and then the FUNC will be called on only those.
• For explanations on the optional SCOPE and SKIP arguments, see Org Info: Using the Mapping API or C-h f org-map-entries from within Emacs.

Here’s a typical org-map-entries call that loops through all the headings in the visible buffer: (org-map-entries #'some-function) where all the optional argument values are nil. Next, we’ll see some examples of string-type MATCH arguments used for filtering the headings.

MATCH strings #

Below table shows few examples of match string patterns.

Comparison Types #

• If the comparison value is a plain number, a numerical comparison is done, and the allowed operators are ‘<’, ‘=​’, ‘>’, ‘<=​’, ‘>=​’, and ‘<>’.
• If the comparison value is enclosed in double quotes, a string comparison is done, and the same operators are allowed.
• If the comparison value is enclosed in curly braces, a regexp match is performed. For this comparison, only ‘=​’ (regexp matches) and ‘<>’ (regexp does not match) operators are allowed.
• Comparison with dates and Group Tags is also possible. See Org Info: Matching tags and properties for more details.

Other notes #

• The property names are case-insensitive. So these all work the same: "COLOR<>\"blue\"", "color<>\"blue\"", "Color<>\"blue\"".
• The “tag” and “property” matches can be mixed up using the boolean ‘&’, ‘|’, ‘+’ and ‘-​’ operators. So searching ‘+LEVEL=3+boss-TODO​="DONE"’ lists all level three headlines that have the tag ‘boss’ and are not marked with the TODO keyword ‘DONE’.
• ‘&’ binds more strongly than ‘|’.
• Grouping of match expressions using parentheses is not supported.

Example: Modifying a property in all headings #

Below is an example solution to the Mastoson question that I referenced in the beginning of this post.

(defun test/set-property-at-heading ()
  "Function to be called at the beginning of an Org heading."
  (let ((el (org-element-at-point)))
    (org-set-property "foo" (org-element-property :title el))))
(org-map-entries #'test/set-property-at-heading)

• It defines a function that parses the Org element at point using org-element-at-point, gets the title property of the element This function is designed to be called by org-map-entries and so the point at the time of calling this function will always be on a heading. , and sets that to the headline element’s foo property.
• The org-map-entries call now simply calls this function on each heading in the visible scope of the Org buffer.

org-map-entries References #

• C-h f org-map-entries
• Org Info: Using the Mapping API
• Org Info: Matching tags and properties

Over at Mastering Emacs, Mickey has a nice post on one of Emacs’ hidden gems: hippie expand. The odd thing is that although it is the most capable expander built into Emacs, it does not have a default binding. As Mickey points out, its much less versatile cousin, dynamic abbrev does have a binding but hippie expand does everything it does so there’s no reason to bother with it.

Mickey suggests remapping the binding for dynamic abbrev to hippie expand since it’s unlikely Emacs will ever change the current default. Of course, that’s part of the power of Emacs: you don’t have to put up with the way things are; you can change them to suit yourself.

I’ve been using hippie expand for years and have it bound to Meta+Tab, which seems natural to me for a completion mechanism. Dynamic abbrev is bound to Meta+/, which isn’t as natural but may be easier to type. After reading Mickey’s post I’m going to remap Meta+/ to hippie expand and see if I like it. Of course, Meta+Tab is burned into my muscle memory so I’ll probably forget to use it.

In any event, be sure to take a couple of minutes to read Mickey’s post. As usual it’s well written, informative, and well worth your time.

Generally, the MacPorts version of Emacs works great on my Mac Mini. But every so often, I'd hit a Too many open files error.

The *Messages* buffer was little help as it just repeated what I already knew:

insert-directory: Opening process input file: Too many open files, /dev/null [2 times]

I'd attempt to close buffers or shut down projectile projects, but there was nothing I could reliably do to recover from this error. Ultimately, I had to do the unthinkable and restart emacs.

I tried the obvious fix: telling my Mac to allow processes to open more files. I followed this recipe:

$ sudo cat /Library/LaunchDaemons/limit.maxfiles.plist
<?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
  <plist version="1.0">
    <dict>
      <key>Label</key>
      <string>limit.maxfiles</string>
      <key>ProgramArguments</key>
      <array>
        <string>launchctl</string>
        <string>limit</string>
        <string>maxfiles</string>
        <string>64000</string>
        <string>20480</string>
      </array>
      <key>RunAtLoad</key>
      <true/>
      <key>ServiceIPC</key>
      <false/>
    </dict>
  </plist>

$ sysctl kern.maxfiles
kern.maxfiles: 20480
$ sysctl kern.maxfilesperproc
kern.maxfilesperproc: 64000

It didn't help. Perhaps I was setting the limit incorrectly for my particular version of the OS. Or maybe I was setting the value too high, and the system was reverting it to something smaller. Or maybe all was good at the OS level, and it was a bash ulimit problem.

I considered all of these scenarios, but no matter how I set the file limit or what I set the file limit too, emacs kept hitting a 1024 open files limit. I could easily confirm this with lsof:

$ ps auxww|grep Emacs
ben              15944   0.0  0.7 412688032 111280   ??  S    Mon06AM  71:07.20 /Applications/MacPorts/Emacs.app/Contents/MacOS/Emacs
$ lsof -p 15944 | wc -l
    1618

After much frustration and searching, I finally stumbled on this reddit thread where a fellow emacs user complained about the 1024 max file limit:

Been trying to figure out a way to get out of this trap… I got a new Mac as a work laptop and I can’t seem to update the file descriptors. I updated it for the system but whenever eMacs is opened, ulimit is still at 1024.

Thankfully, there was a helpful reply:

I hit this all the time, as I work on a large monorepo with lsp-mode (and sometimes treemacs, which also watches stuff).

Whenever it happens I run M-x file-notify-rm-all-watches and things go back to normal for a while.

Last time I looked into this, you could not work around it by adjusting ulimits or literally anything. It's a core limitation of a low-level API used internally and is not configurable. I will try to find the previous discussion.

Aha! This made sense, as I've added lsp-mode to my workflow recently.

I was delighted to find I wasn't the only one having this problem, and more importantly, there was an easy work around.

Alas, when I tried to execute M-x file-notify-rm-all-watches I found that my version of emacs didn't have this function.

A quick Google search turned up this source file for filenotify.el. It does have file-notify-rm-all-watches defined as follows:

(defun file-notify-rm-all-watches ()
  "Remove all existing file notification watches from Emacs."
  (interactive)
  (maphash
   (lambda (key _value)
     (file-notify-rm-watch key))
   file-notify-descriptors))

I copied the code, untouched, into my emacs configuration. Next time I got the dreaded Too many open files error, I ran M-x file-notify-rm-all-watches and just like that, emacs was happy again. And so was I.

This is an anecdotal post on how I found myself installing GNU Guix on Sunday, even though my OS competence is such that installing Debian was a little challenge. The moral of this story is: moving towards software freedom even for the non-expert gives so many customizable options that I hope more people will talk about and experience this freedom.

Let’s talk about dynamic text expansion, but not the kind you may already know about. Dynamic text expansion is something Emacs does well, and you may have heard about two of Emacs’s builtin ones: Skeletons and Tempo. A common third-party tool is Yasnippet. The third (but very useful) abbrev is much simpler than either of those, preferring to silently replace one word with another, making it a useful tool for auto-correction and fixing typos. I use abbrev heavily; and so should you.

But, that’s not what I’m going to talk about. I’m here to talk about Dynamic Abbrev – zero relation to my good friend abbrev – and its talented cousin, Hippie Expand.

Dynamic abbrev is bound to M-/ and C-M-/. When you call M-/, it will expand your word at point to one of a number of different expansions sourced from either your current buffer, or all buffers. Its job is to help with repetitious data entry, or to jog your mind if you forgot the exact name of something. Unfortunately, it’s rather bad at its job: it can ably complete words found in your buffers, but not much more than that.

You see, for nearly 30 years, Emacs has had a well-kept secret. It’s called Hippie Expand. It’s everything Dynamic Abbrev should’ve been, if only the latter had tried harder in school. It’s surely also a better default than the current one, but I won’t hold out hopes of the default changing. It’s been this way for decades; it’s unlikely to change now.

So let’s right this injustice:

(global-set-key [remap dabbrev-expand] 'hippie-expand)

And now you can press M-/ and invoke hippie-expand instead. Feel free to pick a key binding of your choosing if you don’t like the default.

So what’s different about it? Well, you can have a look at C-h v hippie-expand-try-functions-list to see a list of completers it’ll use. M-x apropos-function RET ^try- RET will show you a reasonable guess of all available completers.

As you cycle through matches with M-/, hippie expand tells you where it’s drawing its matches from in the echo area.

But how about a few examples?

File Names and File Paths

The first is its uncanny ability to complete filenames and file paths. Simply start typing a path in your buffer – any buffer will do – and type M-/. Hippie will attempt to either partially complete a filename or path, or walk through all possible matches with successive calls to M-/.

This alone makes it great. If you ever find yourself wanting to insert a filename or path you can use hippie to help you.

Expanding a whole line

This may not seem useful, but if you ever find yourself having to repeat a line from earlier, you can ask hippie to auto complete it. Just start typing the beginning of the line, and let hippie take care of the rest.

Completing “lists”

This one’s a bit nebulous and hard to explain, but hippie’s capable of ‘detecting’ lists and list-like entries. Consider:

int foo(int a, int b) {
}

int bar(-!-

With point at -!-, hippie’ll expand to (int a, int b) when you type M-/. That makes it really useful for, say, repeating function arguments or other bracketed structures. Try successive expands to cycle through the options.

Switches and Keywords in M-x shell or M-x eshell

Not really a completer per se, but more of a benefit of its word completers (drawn from Dynamic Abbrev). But I find it useful to expand --some-long-argument simply by typing in parts of it. Great if you can’t quite remember the name of a switch in a mile-long shell buffer of output. Because hippie will only expand things it’s actually seen, it’s also a pretty iron clad way of testing if you fumbled the name completely and it doesn’t know what you’re on about.

Elisp Symbols

Unsurprisingly, it can also do this. Start typing a symbol and it’ll auto complete it. It, again, works everywhere. Like in the minibuffer or in a complex form you’re writing in M-:.

It’s so ingrained in my workflow that I completely forget I’m using it.

From your Kill Ring

So you can recall stuff from your kill ring if you have previously killed something into it.

Now a lot of people will go, but yeah, OK, I’m using Company mode and/or LSP — and yeah, the former can draw from the same sources of information (and indeed does to an extent.) But LSP won’t save your bacon when you’re trying to complete something in a README file. Hippie will, though.

So the next time you’re trying to write out a filepath in a string or shell script, give Hippie Expand a try. You’ll quickly end up using it for lots of things once you’ve picked up on the cues you need to give it to tease out the completion you want.

TMR is an Emacs package that provides facilities for setting timers using a convenient notation. Below are the release notes.

Sources:

• Package name (GNU ELPA): tmr
• Official manual: https://protesilaos.com/emacs/tmr
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/tmr
  • Mirrors:
    • GitHub: https://github.com/protesilaos/tmr
    • GitLab: https://gitlab.com/protesilaos/tmr
• Mailing list: https://lists.sr.ht/~protesilaos/tmr

Version 0.3.0 on 2022-05-17

The gist of TMR’s May Release is that TMR is Maintained Rigorously—but enough with The Mostly Recursive acronyms!

• This is the first version for which we produce a change log. The short story of previous releases: I (Protesilaos) was using and developing TMR (pronounced as “timer” or “T-M-R”) as part of my personal setup for more than a year until I eventually contributed it to GNU ELPA.

• What was once tmr.el is now split up into purpose-specific files: tmr.el (core functionality), tmr-tabulated.el (grid view), tmr-sound.el (audible notifications), and tmr-notification.el (desktop notifications).

• The tmr-with-description command creates a new timer while always asking for a description. Whereas the standard tmr command prompts for a description only when invoked with a prefix argument.

• The tmr-clone command copies the duration and optional description of an existing timer object into a new one. The operation is performed without further questions, except if a prefix argument is supplied: in that case the command will prompt for a duration and, if the original timer had a description, for one as well. The default values of these prompts are those of the original timer.

• The tmr-remove-finished deletes all elapsed timers. This means that they are removed from the list of available timers and, thus, cannot be cloned.

• The tmr-timer-created-functions, tmr-timer-completed-functions, and tmr-timer-cancelled-functions are hooks which can be used to control what happens once a timer is (i) created, (ii) elapses, or (iii) is cancelled.

• Elapsed and running timers are displayed in a grid view with the command tmr-tabulated-view. The buffer looks like this:

  Start      End        Finished?  Description
  09:22:43   09:32:43   ✔         Prepare tea
  09:17:14   09:37:14              Boil water
  09:07:03   09:57:03              Bake bread
  

• In that grid view, it is possible to create a new timer, or operate on the one at point to cancel, clone, redescribe, and reschedule it.

• Thanks to Christian Tietze for implementing changes to how desktop notifications are handled. The overall effect should still be the same for existing users, though the implementation has been redesigned.

• Thanks to Damien Cassou who is now is my co-author due to multiple contributions for tmr.el, the addition of the grid view, and the splitting of TMR into numerous files. Please consult the Git commit log for the details. (I still am the maintainer.)

• Christian and Damien have assigned copyright to the Free Software Foundation. It is required for all non-trivial changes to packages distributed via GNU ELPA.

The manual documents the technicalities and provides a sample configuration. Either evaluate the form (info "(tmr) Top") if you have the package installed or visit https://protesilaos.com/emacs/tmr.

I’ve written about this before but it’s so useful and magic-like that it bears repeating. The TL;DR is that when you’re in eshell, you can simply cd to a directory on a remote machine. Once there you can pretty much treat the remote machine as if its file system is mounted on your local workstation.

Alain Lafon has a short post that describes using cd to seamlessly log into another machine. You use the same syntax you would with Tramp to specify the path to the remote machine. Once there, you can copy files to and from the remote machine, load a file with the usual Ctrl+x Ctrl+f, or any of the other normal operations. As Lafon says, “It’s magic!”

• Upcoming events:
  • M-x Research (contact them for password): Functional programming: an (Emacs) Lisp view (4/n) https://m-x-research.github.io/ Tue May 17 0800 Vancouver / 1000 Chicago / 1100 Toronto / 1500 GMT / 1700 Berlin / 2030 Kolkata / 2300 Singapore
  • Emacs Berlin (virtual, in English) https://emacs-berlin.org/ Wed May 25 0930 Vancouver / 1130 Chicago / 1230 Toronto / 1630 GMT / 1830 Berlin / 2200 Kolkata – Thu May 26 0030 Singapore
  • Emacs APAC (virtual, in English) https://emacs-apac.gitlab.io/ Sat May 28 0130 Vancouver / 0330 Chicago / 0430 Toronto / 0830 GMT / 1030 Berlin / 1400 Kolkata / 1630 Singapore (Announcement)
• Emacs configuration:
  • Advanced Techniques for Reducing Emacs Startup Time (HN)
  • What have you recently removed from your Emacs configuration?
• Evil mode:
  • evil-matchit 3.0.0 is published
  • Best packages to use with evil mode .
• Emacs Lisp:
  • eask - Command-line tool for building and testing Emacs Lisp packages (Reddit)
• Appearance:
  • Protesilaos Stavrou: The colours of the Emacs modus-themes are in the public domain
  • Protesilaos Stavrou: Re: What is your font setup for Emacs?
• Navigation:
  • emacs, most efficient ways to open file (32:45)
• Org Mode:
  • Intro a org mode - Emacs (22:49)
  • Perfect workflow with Emacs, Org and Cron (13:53, Reddit)
  • scripter.co | Emacs: Using Org Logbook Notes to record blog post updates
  • scripter.co | Emacs: Building Org Development version (2022)
  • org-mode links in 2022: implementation, packages, articles and videos | THIS IS EMACS (Reddit)
  • Taking org-roam on the go with logseq
  • Org development:
    • news and manual: Mention ox-latex's engraved code
    • ox-latex: Replace `org-latex-listings'
• Coding:
  • Vanilla Emacs to Java IDE in 5 minutes (11:26, Reddit)
• Math:
  • math-preview updated to MathJax3
• Mail and news:
  • Extending elfeed with PDF viewer and subtitles fetcher (Reddit)
• Multimedia:
  • Chen Bin (redguardtoo): Configure EMMS (Emacs Multi-Media System) for Multimedia Keyboard
• Community:
  • Weekly Tips, Tricks, &c. Thread
  • I’ve used Emacs nearly every day since 1980/teco. I’m now on 28.1. What are the best things I’m missing?
  • What different before you were using emacs?
  • Lars Ingebrigtsen: 50%
  • Meetup #05 - Investment and leverage, A story about Emacs (28:09)
• Other:
  • Emacs: Transform text while replacing (04:56)
  • Keyboard macros, one of the most powerful features in Emacs (03:32, Irreal)
  • A CEO's Guide to Emacs (2015, HN)
  • Protesilaos Stavrou: About the 'elpa-devel' package archive (Emacs)
  • I did some hack to integrate emacs in wsl2 with the windows host (Reddit)
  • Emacs 28.1 available in kelleyk/emacs PPA
• Emacs development:
  • Add new user option compilation-hidden-output
  • Document recent tooltip changes on NS
  • Improve cycle-spacing and bind it to M-SPC by default
  • Add OVERRIDES argument to prin1/prin1-to-string
  • Add support for the Syloti Nagri script
  • describe-keymap: Suggest symbol at point
  • Add new minor mode `header-line-indent-mode'
  • Make imenu-flush-cache into a function
  • Allow changing the face used for text and frame colors in tooltips
  • Add new user option 'sh-indent-statement-after-and'
  • Add new command 'imenu-flush-cache'
  • New command 'package-update-all'
  • Add new user option switch-to-prev-buffer-skip-regexp
  • Fix non-variable widgets in the 'H' command in Cus-mode
  • char-uppercase-p: New predicate
  • Add new user option 'cperl-file-style'
  • Add new command 'vc-dir-mark-by-regexp'
  • Bind gud-go and allow the prefix to enter arguments
  • Warn about quoted symbols in defcustom choice/other forms
  • EUDC: Add completion-at-point support
  • Add support for the Siddham script
  • Add new command to toggle hiding all widgets in a Customize buffer
  • Make ispell-region/buffer push the mark of the final word
  • Allow packages to alter menu entries in the Buffers menu
  • Make `apropos-variable' include values in output
  • Add more compilation-auto-jump-to-first-error options
  • Factor out scratch initialization
  • Add NEWS entries for recent autosaved buffer modification status
  • Add support for the Sharada script
• New packages:
  • arxiv-citation: Utility functions for dealing with arXiv papers (MELPA)
  • org-edit-indirect: Edit anything, not just source blocks (MELPA)
  • plz: HTTP library (GNU ELPA)
  • sql-trino: Adds Trino support to SQLi mode (MELPA)
  • zetteldesk: A revision and outlining tool for org-roam (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, emacs-devel, and lemmy/c/emacs.

Emacs server need be started first.

I use emacsclient to execute emms commands in the emacs server.

Key bindings setup in ~/.i3/config for i3 window manager,

# music player client (mpc, emms ...)
bindsym XF86Search exec --no-startup-id ~/bin/music-player-client show
bindsym XF86Tools exec --no-startup-id ~/bin/music-player-client random
bindsym XF86AudioStop exec --no-startup-id ~/bin/music-player-client toggle
bindsym XF86AudioPause exec --no-startup-id ~/bin/music-player-client toggle
bindsym XF86AudioNext exec --no-startup-id ~/bin/music-player-client next
bindsym XF86AudioPrev exec --no-startup-id ~/bin/music-player-client prev

Content of ~/bin/music-player-client,

#!/bin/bash

# use mpc&mpd or emacsclient&emms to play music

if [ -z "$1" ]; then
    echo "Usage: music-player-client pre|next|toggle|random|show"
    exit 1
fi

# Please uninstall mpc&mpd if using emms
if command -v mpc &> /dev/null; then
    case $1 in
        prev )
            mpc prev
            ;;
        next )
            mpc next
            ;;
        toggle )
            mpc toggle
            ;;
    esac
elif command -v emacsclient &> /dev/null; then
    case $1 in
        prev )
            emacsclient --eval '(emms-previous)'
            ;;
        next )
            emacsclient --eval '(emms-next)'
            ;;
        toggle )
            emacsclient --eval '(emms-pause)'
            ;;
        random )
            emacsclient --eval '(progn (emms-shuffle) (emms-next))'
            ;;
        show )
            # program like dunst can show the notification
            notify-send "$(emacsclient --eval '(file-name-base (emms-show))')"
            ;;
    esac
fi

I usually run M-x emms-play-directory-tree to play music. My emms setup,

(with-eval-after-load 'emms
  ;; minimum setup is more robust
  (emms-minimalistic)
  (setq emms-player-list '(emms-player-mplayer
                           emms-player-vlc)))

Screen shot of running ~/bin/music-player-client show,

Quick introduction to Org mode’s :LOGBOOK: feature and how I use it to record time-stamped notes for blog post updates.

Most of my blog posts are mainly to serve as documentation for my future self This post will serve to remind me how to get the :LOGBOOK: notes working once again in case I end up with some issue there. . So when I get a chance, I try to fix outdated stuff in my old blog posts. And along with the act of updating things, adding brief notes describing those updates comes naturally to me.

Prior forms of adding post updates #

As I author my posts in Org mode, I can easy enter a date stamp using the org-time-stamp command (bound by default to C-c . RET) and follow that by the update note.

While that worked, that approach bothered me because those notes didn’t have consistent format across multiple posts. For example, I might type the update as “*Update (<time stamp>)*: <note>” in one post, while I might type the same in a description list form in another: “- <time stamp>) :: <note>”.

To solve the consistency problem, I came up with this Org macro:

#+macro: update - $1 :: $2

This worked mostly … except when the update text needed to be a bit longer, like a paragraph. It didn’t look elegant in that case. Also, if the text had a comma character in there, it needed to be escaped with a backslash (\).

Introducing :LOGBOOK: #

So when I learned A little bit of history .. I learned about the :LOGBOOK: drawer when Adam Porter mentioned it in ox-hugo Issue # 203 back in September 2018. I wanted to use that feature, but I didn’t have time and/or know-how on how exactly I would parse those Org Drawers in ox-hugo until very recently (May 2022)! about the Org :LOGBOOK: drawer, it solved all those problems: (i) consistency in adding notes (ii) easy to add update notes – in fact much easier (iii) easy to type long form notes (iv) no comma escaping needed.

Org Drawers look like this:

Content before the drawer
:DRAWERNAME:
Content inside the drawer
:END:
Content after the drawer

and they can be inserted anywhere in your Org content using the org-insert-drawer command (bound by default to C-c C-x d).

:LOGBOOK: is a special kind of drawer that’s auto-inserted by Org mode when certain actions are detected, like changing the TODO state of a subtree, or adding a note . That latter action is what this blog post is about.

Adding notes to :LOGBOOK: #

You need to enable this feature using one of these methods:

1. Set the org-log-into-drawer variable to a non-nil value (typically t) in your Emacs config, or as a file-local variable, or in your project’s .dir-locals.el (⭐ my preference).
2. Set #+startup: logdrawer to enable this for the whole Org file.
3. To enable this feature for only selected subtrees, set the :LOG_INTO_DRAWER: t property in the subtree (or one of its parent subtrees).

Once this is set, call the org-add-note command (bound by default to C-c C-z). That will open a window with ∗Org Note∗ buffer where-in you will type your post update and then C-c C-c to save it to the subtree’s :LOGBOOK: drawer. If that drawer didn’t exist already, it will be created directly under the subtree’s heading.

The note will get recorded in this format by default under the current subtree:

* Subtree title
:LOGBOOK:
- Note taken on <current date and time> \\
  <note text>
:END:

As you see, you only type the note text, and the time-stamp is inserted automatically.

:LOGBOOK: Notes Example #

Here are the update notes from one of my posts:

:LOGBOOK:
- Note taken on <2018-08-26 Sun> \\
  Mention =org-babel-demarcate-block=, tweak the =org-meta-return= advice.
- Note taken on <2018-08-23 Thu> \\
  Use ~M-return~ instead of ~C-return~ for splitting blocks and
  support upper-case blocks (though I [[https://scripter.co/org-keywords-lower-case/][don't prefer those]]!).
:END:

You can see how they rendered at the top of the Splitting an Org block into two post.

If you are an ox-hugo user following the subtree-based export flow, and would like to export :LOGBOOK: notes in a similar fashion, check out the ox-hugo Manual: Drawers page for details.

References #

• Org Info: Drawers
• Org Info: Tracking TODO state changes

One of the reasons I am not a heavy smartphone user is privacy concerns. However, the truth is that I have a smartphone and I use it, so clearly being aware of a problem and not act on it is not going to fix it any time soon.

This is why I have finally decided to move on a different operative system for my Fairphone 2. After researching the right OS for my needs, I landed on DivestOS. I won’t go into the technical details underneath the software because the website is fairly rich in this regard. Let’s see the practicals, instead.

First of all, I backed up the important data on my phone. This means PGP keys, OTP settings, and everything else that Google was not already saving for me. I then downloaded the required fp2 images from Device Downloads. After that, I moved to the Bootloader/Installation page and went through the Prerequisites section by making sure USB debugging was enabled on my phone and by running the following command on my laptop:

sudo apt install android-tools-adb android-tools-fastboot

Since DivestOS is a fork of LineageOS, I preferred to follow the Install LineageOS on FP2 steps instead of the ones over at the Fastboot section of the Bootloader/Installation page. Why? Because I am a newbie at smartphone flashing and I wanted clear instructions on how to proceed.

The installation went smoothly. I then set up the few apps I need, making sure everything from my VPN to basic email was working as expected. The only problem I soon discovered is PosteID, which is the app I use to handle SPID, the digital identity system the Italian government offers to access online administration services. Luckily, there is a workaround to avoid the PosteID app which relies on good old SMS for part of the authentication process. It’s limited to 8 messages every 3 months, but that is enough for me.

When I started this de-googling project I knew I was sacrificing comfort in favour of more control over my digital life. How much the whole operation is worth only time will tell.

Just a quickie today. Bhaskar Chowdhury has a short video (6 minutes, 54 seconds) that describes 4 vital Emacs shortcuts. Three of them are probably already in your repertoire:

• switch-to-buffer (Ctrl+x b)
• async-shell-command (Meta+&)
• shell-command (Meta+!)

Most of you probably use those all the time. The last is something I didn’t know about. If you’re an Ivy user, there’s the counsel-switch-buffer command. Its like switch-to-buffer except that as you scroll down the list of buffers, the buffer at point is displayed in the current window so you can see its content. That can be handy, especially if you have many buffers open at a time.

The counsel-switch-buffer command is not bound by default so if you kike it you will either have to find a binding for it or simply steal the Ctrl+x b binding for it. You probably don’t want to use Ctrl+b as Chowdhury does since it’s an important cursor movement chord.

Exploiting Ruby’s Object Model to Ease Collaboration

One of the common patterns I use in my day-to-day Ruby 📖 coding is to define a module or level call method. I like to establish these call methods as crisp interfaces between different concerns.

Dependency Injection with Objects That Respond to Call

In the following example I’ve constructed a “Package” class that has a deliver! method. Let’s take a look:

module Handler
  def self.call(package:)
    # Complicated logic
  end
end

module Notifier
  def self.call(package:)
    # Complicated logic
  end
end

class Package
  def initialize(origin:, destination:, notifier: Notifier, handler: Handler)
    @origin = origin
    @destination = destination
    @handler = handler
    @notifier = notifier
  end
  attr_reader :origin, :destination, :handler, :notifier

  def deliver!(with_notification: true)
    notifier.call(package: self) if with_notification
    handler.call(package: self)
  end
end

If I want to test the deliver! method I have a few scenarios to consider:

• I’m not sending a notification
• I’m sending a notification and it raises an exception
• I’m sending a notification and it succeeds

And let’s assume that both Notifier.call and Handler.call are very expensive to run in test. Without stubbing or mocking, I could write the following test:

def test_assert_not_sending_notification
  # By having the notifier `raise`, we'll know if it was called.
  notifier = ->(package:) { raise }
  handler = ->(package:) { :handled }
  package = Package.new(
    origin: :here,
    destination: :there,
    notifier: notifier,
    handler: handle
  )

  assert(package.deliver!(with_notification: false) == :handled)
end

Dependency Injection Using a Collaborating Object’s Method as a Lambda

There are some interesting pathways we can now go down. First, what if we really don’t like the .call method naming convention?

module PlanetExpress
  def self.deliver(package:)
    # Navigates multiple hurdles to renew delivery licenses
  end
end

We could create an alias of PlanetExpress.deliver but we could also do a little bit of Ruby magic:

Package.new(
  origin: :here,
  destination: :there,
  handler: PlanetExpress.method(:deliver)
)

The Object.method method returns a Method object, which responds to call. This allows us to avoid modifying the PlanetExpress module, while still enjoying the flexibility of a call based interface.

This is perhaps even more relevant when I think about interfacing with ActiveRecord. Are there cases where I want to have found a record and process it? Maybe the creation of that record is expensive. Let’s short-circuit that.

class User < ActiveRecord::Base
end

# An async worker that must receive an ID, not the full object.
class CongratulatorWorker
  def initialize(user_id:, user_finder: User.method(:find))
    @user = user_finder.call(user_id)
  end

  def send_congratulations!
    # All kinds of weird things with lots of conditionals
  end
end

With the above, I can now setup the following in test:

def test_send_congratulations!
  user = User.new(email: "hello@domain.com")
  finder = ->(user_id) { user }
  worker = CongratulatorWorker.new(user_id: "1", user_finder: finder)

  worker.send_congratulations!
end

In the above scenario, I’d be scratching my head if I saw a User.call method declared in the User class. But in the CongratulatorWorker I would have a bit more of a chance of reasoning what was going on.

Using a Method Object as a Block

This example steers in a different direction, but highlights the utility of the convention of having a call method.

module ShoutOut
  def self.say_it(name)
    puts "#{name} is here"
  end
end

["huey", "duey", "louie"].each(&ShoutOut.method(:say_it))

I was hoping that I could define call on ShoutOut and use that as the block (e.g. .each(&ShoutOut)). But that did not work.

Conclusion

This degree of dynamism is one aspect I love about Ruby. And it’s not unique to Ruby; I do this in Emacs-Lisp.

Early in learning Ruby, I stumbled upon a few statements that inform Ruby:

• Everything’s an Object
• A Class is an Object and an Object is a Class

And even the methods on an Object are themselves Objects. What’s nice about that is these objects have shape and form; you can see that in “detaching” the method and passing it around.

I keep getting the titular question fairly often—two just yesterday! I am thus publish the present entry to be able to link to it instead of rewriting the whole thing every time (or storing it in a text register, but you get the idea).

The short version is:

• Fonts are part of my Iosevka Comfy project.
• My relevant Emacs packages are fontaine, cursory, logos, modus-themes.
• Other neat packages I use include olivetti, org-modern.
• Plus tweaks to Org, directory-local variables, variable-pitch-mode.

My font is Iosevka Comfy

• Git repo on SourceHut: https://git.sr.ht/~protesilaos/iosevka-comfy
  • Mirrors:
    • GitHub: https://github.com/protesilaos/iosevka-comfy
    • GitLab: https://gitlab.com/protesilaos/iosevka-comfy
• Mailing list: https://lists.sr.ht/~protesilaos/general-issues

This is a highly customised build of Iosevka that I have designed meticulously to work optimally for my requirements. Excerpts from its README:

Iosevka Comfy is more vertically compact than the standard upstream configuration. Glyphs are rounder and have tailed ends or serifs only when those are required to both impose a predictable rhythm and keep characters distinct from each other.

[…]

Roman and italic variants are made to look more consistent while retaining their stylistic features. Unlike the default Iosevka style, the upright glyphs do not have a mixture of straight/blocky and curved or serified characters (special exceptions notwithstanding). While the italics do not have calligraphic tendencies that greatly contrast with their counterparts. The differences within each character set and between the variants themselves are nuanced. The intent is to make everything feel part of the same aesthetic. Distinctions are drawn on the premise of contributing to the demands of the design without ever calling attention to themselves (as opposed to sporadic calligraphic glyphs amid an otherwise austere presentation).

[… lots of technicalities elided]

Iosevka Comfy comes in five variants, all of which share the same stylistic overrides, as documented above.

• iosevka-comfy is monospaced and supports ligatures. Apart from ligatures, it allows certain glyphs, such as arrows, to occupy more than one block.

• iosevka-comfy-fixed is strictly monospaced and does not support ligatures. All glyphs are exactly the same width. Use this if you prefer it or if your application (e.g. terminal emulator) does not recognise iosevka-comfy as a monospaced font.

• iosevka-comfy-duo is quasi-proportional and supports ligatures. The naturally wide glyphs, such as m, are allowed to occupy two blocks instead of one.

• iosevka-comfy-wide is the same as iosevka-comfy except it is noticeably wider. It also looks taller than iosevka-comfy even though both variants fit the same number of lines on a screen.

• iosevka-comfy-wide-fixed same as iosevka-comfy-wide though it is strictly monospaced and does not support ligatures.

I manage font configurations with my ‘fontaine’ package

• Package name (GNU ELPA): fontaine
• Official manual: https://protesilaos.com/emacs/fontaine
• Change log: https://protesilaos.com/emacs/fontaine-changelog
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/fontaine
  • Mirrors:
    • GitHub: https://github.com/protesilaos/fontaine
    • GitLab: https://gitlab.com/protesilaos/fontaine
• Mailing list: https://lists.sr.ht/~protesilaos/fontaine

I have already written about fontaine on this blog. It lets the user declare font presets and switch between them on demand: helpful when you want to switch between different contexts. The official manual elaborates on the particulars. Excerpt from my dotemacs with just the presets:

(setq fontaine-presets
      '((tiny
         :default-family "Iosevka Comfy Wide Fixed"
         :default-height 70)
        (small
         :default-family "Iosevka Comfy Fixed"
         :default-height 90)
        (regular
         :default-height 100)
        (medium
         :default-height 110)
        (large
         :default-weight semilight
         :default-height 140
         :bold-weight extrabold)
        (presentation
         :default-weight semilight
         :default-height 170
         :bold-weight extrabold)
        (t
         ;; I keep all properties for didactic purposes, but most can be
         ;; omitted.  See the fontaine manual for the technicalities:
         ;; <https://protesilaos.com/emacs/fontaine>.
         :default-family "Iosevka Comfy"
         :default-weight regular
         :default-height 100
         :fixed-pitch-family nil ; falls back to :default-family
         :fixed-pitch-weight nil ; falls back to :default-weight
         :fixed-pitch-height 1.0
         :variable-pitch-family "Iosevka Comfy Duo"
         :variable-pitch-weight nil
         :variable-pitch-height 1.0
         :bold-family nil ; use whatever the underlying face has
         :bold-weight bold
         :italic-family nil
         :italic-slant italic
         :line-spacing nil)))

Cursors are handled by my ‘cursory’ package

• Package name (GNU ELPA): cursory
• Official manual: https://protesilaos.com/emacs/cursory
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/cursory
  • Mirrors:
    • GitHub: https://github.com/protesilaos/cursory
    • GitLab: https://gitlab.com/protesilaos/cursory
• Mailing list: https://lists.sr.ht/~protesilaos/cursory

Same principle as fontaine, but for cursor styles. Excerpt from my dotemacs, while I let you check the manual for the details:

(setq cursory-presets
      '((bar
         :cursor-type (bar . 2)
         :cursor-in-non-selected-windows hollow
         :blink-cursor-blinks 10
         :blink-cursor-interval 0.5
         :blink-cursor-delay 0.2)
        (box
         :cursor-type box
         :cursor-in-non-selected-windows hollow
         :blink-cursor-blinks 10
         :blink-cursor-interval 0.5
         :blink-cursor-delay 0.2)
        (underscore
         :cursor-type (hbar . 3)
         :cursor-in-non-selected-windows hollow
         :blink-cursor-blinks 50
         :blink-cursor-interval 0.2
         :blink-cursor-delay 0.2)))

I do presentations with my ‘logos’ package

• Package name (GNU ELPA): logos
• Official manual: https://protesilaos.com/emacs/logos
• Change log: https://protesilaos.com/emacs/logos-changelog
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/logos
  • Mirrors:
    • GitHub: https://github.com/protesilaos/logos
    • GitLab: https://gitlab.com/protesilaos/logos
• Mailing list: https://lists.sr.ht/~protesilaos/logos

Logos lets me move between “pages” and [optionally] treat each of them as a pseudo-slide (by leveraging Emacs’ narrowing capabilities). For me this is the best way to do presentations, as I simply switch to a different fontaine preset, tweak the cursors, and then use the same Org file I was already editing. No unwieldy PDFs, no elaborate export mechanism to some external app, no fancy transitions or effects. Just regular Emacs.

Logos optionally leverages Paul W. Rankin’s excellent olivetti package to centre the buffer’s contents in its window. It helps make a page look like a slide.

What constitutes a “page” is discussed in the manual. A snippet from my dotemacs:

(setq logos-outlines-are-pages t)
(setq logos-outline-regexp-alist
      `((emacs-lisp-mode . ,(format "\\(^;;;+ \\|%s\\)" logos--page-delimiter))
        (org-mode . ,(format "\\(^\\*+ +\\|^-\\{5\\}$\\|%s\\)" logos--page-delimiter))
        (markdown-mode . ,(format "\\(^\\#+ +\\|^[*-]\\{5\\}$\\|^\\* \\* \\*$\\|%s\\)" logos--page-delimiter))
        (conf-toml-mode . "^\\[")
        (t . ,(or outline-regexp logos--page-delimiter))))

(setq-default logos-hide-mode-line t)
(setq-default logos-hide-buffer-boundaries t)
(setq-default logos-hide-fringe t)
(setq-default logos-variable-pitch t) ; see my `fontaine' configurations
(setq-default logos-buffer-read-only nil)
(setq-default logos-scroll-lock nil)
(setq-default logos-olivetti t)

Relevant options of my modus-themes

• Package name (GNU ELPA): modus-themes (also built into Emacs >= 28)
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/modus-themes
  • Mirrors:
    • GitHub: https://github.com/protesilaos/modus-themes
    • GitLab: https://gitlab.com/protesilaos/modus-themes
• Mailing list: https://lists.sr.ht/~protesilaos/modus-themes
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors

The user option modus-themes-mixed-fonts can be set to non-nil to let you use M-x variable-pitch-mode while retaining fixed spacing for certain elements like tables and inline code. In practical terms, I can use Iosevka Comfy Duo (the quasi-proportional variant) together with Iosevka Comfy when I am in an Org file (e.g. for a presentation).

Alternatively, the modus-themes-headings can make all headings use the variable-pitch face. This is what I use for regular editing, but presentations get the “mixed fonts” treatment via variable-pitch-mode and logos.

Directory-local settings for Org

In the directory where I store my presentations, I keep a .dir-locals.el file with these contents:

;;; Directory Local Variables
;;; For more information see (info "(emacs) Directory Variables")

((org-mode . ((org-hide-emphasis-markers . t)
              (org-hide-macro-markers . t)
              (org-hide-leading-stars . t))))

It basically keeps Org clean.

Note that I do not hide those elements by default (check my dotemacs), because I prefer to avoid “gotcha!” moments where some markup character is not visible and messes up with my writing. Also, I don’t want to implement a setup that smartly hides/reveals markup: I find it useful to always see markup while editing, though not while presenting.

Org is further enhanced with Daniel Mendler’s org-modern package: it improves the looks of various Org elements. For the purposes of my presentations, it makes the asterisks of headings use different glyphs, prettifies list characters, renders horizontal rules (-----) as horizontal lines, while it shows quote/src blocks without all the verbose markup (e.g. quote instead of #+begin_quote).

A guide on how to build Org mode from its main branch and load in Emacs without any path shadowing.

I am assuming that you already know what Org mode is and that’s why you are here 😃.

You would want to build Org from its development branch (main branch) to get the latest and greatest goodies plus bug fixes! Go through the ORG-NEWS file to read about what’s new in the main branch.

If you like what you see there, here are the steps for installing the development version of Org.

1 Clone the Org repo #

git clone https://git.savannah.gnu.org/git/emacs/org-mode.git

2 Build Setup #

1. Copy <REPO_ROOT>/mk/default.mk to <REPO_ROOT>/local.mk
2. Tweak local.mk (optional)

Customizing local.mk (Optional) #

Here are few variables that you might like to change in the local.mk:

prefix

Org installation directory

prefix = /dir/where/you/want/to/install/org # Default: /usr/share

The .el files will go to $(prefix)/emacs/site-lisp/org by default. If you’d like to change that, change the lispdir variable too.

infodir

Org Info installation directory. I like to keep the Info file for development version of Org in a separate directory.

infodir = $(prefix)/org/info # Default: $(prefix)/info

ORG_MAKE_DOC

Types of Org documentation you’d like to build by default. Setting below generates only the Org Info manual.

ORG_MAKE_DOC = info # Default: html pdf

3 Build #

make autoloads
make
make doc
make install

Type make help for help on the Org Makefile. Type make helpall to get a detailed help, or see the Org build system help.

4 Set the correct paths in your Emacs config #

1. Update load-path to remove the Org version that ships with Emacs. Do the same if you have Org installed via GNU ELPA If you need the latest stable version of Org mode, install it from GNU ELPA. too.
2. Also remove the associated old Org mode Info manuals from Info-directory-list.
3. Update the load-path and Info-directory-list variables to point to the Org mode source code and Info manual built using the main branch.

Below code does all that but make sure this code is executed after you do (package-initialize), but before you require the org package . You can use use-package and make sure that this order of code evaluation is always correct — Just put the code from Code Snippet 2 where <HERE> is shown in the below snippet:

(use-package org
  :preface
  <HERE>)

(defvar modi/org-version-select 'dev
  "Variable to choose the version of Org to be loaded.
Valid values are `dev', `elpa' and `emacs'.

When set to `dev', the development version of Org built locally
is loaded.
When set to `elpa', Org is installed and loaded from GNU ELPA.
When set to `emacs', the Org version shipped with Emacs is used.")

(defvar modi/default-lisp-directory "/your/emacs/share/dir/version/lisp/"
  "Directory containing lisp files for the Emacs installation.

This value must match the path to the lisp/ directory of your
Emacs installation.

If Emacs is installed using --prefix=\"${PREFIX_DIR}\" this value
would typically be
\"${PREFIX_DIR}/share/emacs/<VERSION>/lisp/\".")

(defvar org-dev-lisp-directory "/value/of/lispdir/in/local.mk"
  "Directory containing lisp files for dev version of Org.

This value must match the `lispdir' variable in the Org local.mk.
By default the value is \"$prefix/emacs/site-lisp/org\", where
`prefix' must match that in local.mk too.")

(defvar org-dev-info-directory "/value/of/infodir/in/local.mk"
  "Directory containing Info manual file for dev version of Org.

This value must match the `infodir' variable in the Org local.mk.")

(when (and org-dev-lisp-directory
           org-dev-info-directory)
  (with-eval-after-load 'package
    ;; If `modi/org-version-select' is *not* `emacs', remove the Emacs
    ;; version of Org from the `load-path'.
    (unless (eq modi/org-version-select 'emacs)
      ;; Remove Org that ships with Emacs from the `load-path'.
      (let ((default-org-path (expand-file-name "org" modi/default-lisp-directory)))
        (setq load-path (delete default-org-path load-path))))

    ;; If `modi/org-version-select' is *not* `elpa', remove the Elpa
    ;; version of Org from the `load-path'.
    (unless (eq modi/org-version-select 'elpa)
      (dolist (org-elpa-install-path (directory-files-recursively
                                      package-user-dir
                                      "\\`org-[0-9.]+\\'"
                                      :include-directories))
        (setq load-path (delete org-elpa-install-path load-path))
        ;; Also ensure that the associated path is removed from Info
        ;; search list.
        (setq Info-directory-list (delete org-elpa-install-path Info-directory-list))))

    (let ((dev-org-path (directory-file-name org-dev-lisp-directory))
          (dev-org-info (directory-file-name org-dev-info-directory)))
      (if (eq modi/org-version-select 'dev)
          (progn
            (add-to-list 'load-path dev-org-path)
            ;; It's possible that `org-dev-info-directory' is set to
            ;; an unconventional value, in which case, it will not be
            ;; automatically added to `Info-directory-alist'. So add
            ;; it to `Info-directory-alist' manually.
            (add-to-list 'Info-directory-list dev-org-info))

        ;; If `modi/org-version-select' is *not* `dev', remove the
        ;; development version of Org from the `load-path', and its
        ;; Info from the Info search list.
        (setq load-path (delete dev-org-path load-path))
        (with-eval-after-load 'info
          (setq Info-directory-list (delete dev-org-info Info-directory-list)))))))

Note

Remember that you need to correctly set the values of these 3 variables in the above snippet:

• modi/default-lisp-directory
• org-dev-lisp-directory
• org-dev-info-directory

5 Testing that the right Org version got loaded #

1. Restart Emacs (Don’t be lazy — do it!)

2. M-x org-version – That should show something like this in the echo area:

   Org mode version 9.5.3 (release_9.5.3-482-gd5a52b @ /home/kmodi/usr_local/apps/7/emacs/emacs-28/share/emacs/site-lisp/org/)
   

   This message format is broken down as:

   Org mode version <ORG-VERSION> (release_<ORG-VERSION>-NNN-g<GIT-HASH> @ <PREFIX>/emacs/site-lisp/org/)
   

If the GIT-HASH and PREFIX above are what you expect, congratulations! You did it! 🎉

Else, let me know in comments if I can help you.

Future Org development version updates #

1. Below will do git pull and build Org.

   make update
   

2. Restart Emacs.

References #

• setup-org.el in my Emacs config
• setup-packages.el in my Emacs config

I am assuming that you already know what Org or org-mode is and that’s why you are here.

You would want to build Org from its development branch (master branch) to get the latest and greatest goodies plus bug fixes! Go through the ORG-NEWS file to read about the new features.

If you like what you see there, here are the steps for installing the development version of Org.

Clone the Org repo #

git clone https://code.orgmode.org/bzg/org-mode.git

Build Setup #

1. Copy <REPO_ROOT>/mk/default.mk to <REPO_ROOT>/local.mk
2. Tweak local.mk

Customizing local.mk #

Here are few variables that you might like to change in the local.mk:

prefix

Org installation directory

prefix = /dir/where/you/want/to/install/org # Default: /usr/share

The .el files will go to $(prefix)/emacs/site-lisp/org by default. If you’d like to change that, change the lispdir variable.

infodir

Org Info installation directory. I like to keep the Info file for development version of Org in a separate directory.

infodir = $(prefix)/org/info # Default: $(prefix)/info

ORG_MAKE_DOC

Types of Org documentation you’d like to build by default. Below enables generation of the Info and PDF Org manuals and the Org reference cards (in PDF too).

# Define below you only need info documentation, the default includes html and pdf
ORG_MAKE_DOC = info pdf card # html

ORG_ADD_CONTRIB

Packages from the contrib/ directory that you’d like to build along with Org. Below are the ones on my must-have list.

# Define if you want to include some (or all) files from contrib/lisp
# just the filename please (no path prefix, no .el suffix), maybe with globbing
#   org-eldoc - Headline breadcrumb trail in minibuffer
#   ox-extra - Allow ignoring just the heading, but still export the body of those headings
#   org-mime - Convert org buffer to htmlized format for email
ORG_ADD_CONTRIB = org-eldoc ox-extra org-mime

Build #

make autoloads
make
make install

Type make help for help on the Org Makefile. Type make helpall to get a detailed help, or see the Org build system help.

Set the correct paths in your emacs config #

1. Remove the default Org version that ships with Emacs from the load-path. Do the same if you have Org installed via Melpa/Org Elpa too (the latest stable versions).
2. Remove the older Org Info directory references too from Info-directory-list.
3. Update the load-path and Info-directory-list variables with values based on the lispdir and infodir variables above.

Below snippet of code does all that – Make sure this code is executed after you do (package-initialize), but before you require the org package.

(defvar modi/org-version-select 'dev
  "Variable to choose the version of Org to be loaded.
Valid values are `dev', `elpa' and `emacs'.

When set to `dev', the development version of Org built locally
is loaded.
When set to `elpa', Org is installed and loaded from Org Elpa.
When set to `emacs', the Org version shipped with Emacs is used.

The value is defaulted to `elpa' as few things in this config
need Org version to be at least 9.x.")

(defvar modi/default-lisp-directory "/your/emacs/share/dir/version/lisp/"
  "Directory containing lisp files for the Emacs installation.

This value must match the path to the lisp/ directory of your
Emacs installation.  If Emacs is installed using
--prefix=\"${PREFIX_DIR}\" this value would typically be
\"${PREFIX_DIR}/share/emacs/<VERSION>/lisp/\".")

(defvar org-dev-lisp-directory "/value/of/lispdir/in/local.mk"
  "Directory containing lisp files for dev version of Org.

This value must match the `lispdir' variable in the Org local.mk.
By default the value is \"$prefix/emacs/site-lisp/org\", where
`prefix' must match that in local.mk too.")

(defvar org-dev-info-directory "/value/of/infodir/in/local.mk"
  "Directory containing Info manual file for dev version of Org.

This value must match the `infodir' variable in the Org local.mk.")

(when (and org-dev-lisp-directory
           org-dev-info-directory)
  (with-eval-after-load 'package
    ;; If `modi/org-version-select' is *not* `emacs', remove the Emacs
    ;; version of Org from the `load-path'.
    (unless (eq modi/org-version-select 'emacs)
      ;; Remove Org that ships with Emacs from the `load-path'.
      (let ((default-org-path (expand-file-name "org" modi/default-lisp-directory)))
        (setq load-path (delete default-org-path load-path))))

    (>=e "25.0" ;`directory-files-recursively' is not available in older emacsen
        ;; If `modi/org-version-select' is *not* `elpa', remove the Elpa
        ;; version of Org from the `load-path'.
        (unless (eq modi/org-version-select 'elpa)
          (dolist (org-elpa-install-path (directory-files-recursively
                                          package-user-dir
                                          "\\`org\\(-plus-contrib\\)*-[0-9.]+\\'"
                                          :include-directories))
            (setq load-path (delete org-elpa-install-path load-path))
            ;; Also ensure that the associated path is removed from Info
            ;; search list.
            (setq Info-directory-list (delete org-elpa-install-path Info-directory-list)))))

    (let ((dev-org-path (directory-file-name org-dev-lisp-directory))
          (dev-org-info (directory-file-name org-dev-info-directory)))
      (if (eq modi/org-version-select 'dev)
          (progn
            (add-to-list 'load-path dev-org-path)
            ;; It's possible that `org-dev-info-directory' is set to an
            ;; unconventional value, in which case, it will not be
            ;; automatically added to `Info-directory-alist'. So to ensure
            ;; that the correct Org Info is used, add it to
            ;; `Info-directory-alist' manually.
            (add-to-list 'Info-directory-list dev-org-info))
        ;; If `modi/org-version-select' is *not* `dev', remove the
        ;; development version of Org from the `load-path'.
        (setq load-path (delete dev-org-path load-path))
        (with-eval-after-load 'info
          ;; Also ensure that the associated path is removed from Info search
          ;; list.
          (setq Info-directory-list (delete dev-org-info Info-directory-list)))))))

To simplify the “before you require the org package” part, if using the use-package, above code would go in HERE:

(use-package org
  :preface
  <HERE>)

Note: Remember that you need to correctly set the values of these 3 variables in the above snippet:

• modi/default-lisp-directory
• org-dev-lisp-directory
• org-dev-info-directory

Related Emacs package manager customization (Bonus Points) #

You may refer to my setup-packages.el to see how I fine-tune the Emacs package manager setup to work well with the development version of Org.

• Prevent adding Org Elpa to package-archives.
• Prevent auto-installation of the older versions of Org triggered by package-dependency checks.
• Even if you install Org from (M)Elpa, do not prompt to upgrade it (as you would be rocking the shiniest and newest version of Org from its master branch from now on! 😄).

Search for modi/org-version-select in there.

Testing that the right Org got loaded #

1. Restart Emacs (Don’t be lazy – do it!)

2. M-x org-version – That should show something like this in the echo area:

   Org mode version 9.0.9 (release_9.0.9-648-gc56021 @ /home/kmodi/usr_local/apps/6/emacs/master/share/emacs/site-lisp/org/)
   

   This message format is broken down as:

   Org mode version <ORG-VERSION> (release_<ORG-VERSION>-NNN-g<GIT-HASH> @ <PREFIX>/emacs/site-lisp/org/)
   

If the GIT-HASH and PREFIX match to your expectations, congratulations!

Else, let me know in comments if I can help you.

Future Org development version updates #

1. Below will do git pull and build Org.

   make update
   

2. Restart Emacs.

I promised that this week’s Red Meat Friday would serve as a sort of balance to last week’s RMF post making fun of IDE users. It was supposed to be about an Emacs reddit post that asked Is emacs only for those with “low” cognitive abilities? That was an obvious troll and most of the respondents recognized that and joined in the fun. Those who took the post seriously—or didn’t care that it was a troll—engaged its points and provided reasonable rebuttals.

Sadly, you can’t read the post (although the comments are still available) because some reddit nanny decided that the post was insufficiently civil or something. When did we become such babies? The post didn’t call out any individual and wasn’t vicious. It just poked fun at Emacs users exactly as Vi users and other editor partisans have been doing for ages.

I don’t know about the rest of you but I don’t want or need any humorless apparatchiks censoring what I can read. I’m sorry to see this nonsense invading the tech sector. Judging by what’s happened in other domains, it won’t end well.

Overview of GNU ELPA

The official package archive of Emacs is GNU ELPA. It is maintained as part of Emacs: those with write access to emacs.git can commit changes to elpa.git.

The “ELPA” acronym stands for “Emacs Lisp Package Archive”. GNU ELPA is enabled by default in recent stable versions of Emacs per the value of the variable package-archives. This means that the user can install lots of useful, free/libre packages without setting up another package archive.

One might read in various fora references to “ELPA” without a qualifier. These typically mean “GNU ELPA”.

The “devel” version of GNU ELPA

GNU ELPA provides the latest tagged release of a package. There is, however, the option to fetch packages that are built periodically from source using the most recent commit in the main branch. This is the “development” version of GNU ELPA, hereinafter referred to as elpa-devel, which can be added to the list of archives thus:

(add-to-list 'package-archives '("elpa-devel" . "https://elpa.gnu.org/devel/"))

Or declare the entire list outright:

(setq package-archives
      '(("elpa" . "https://elpa.gnu.org/packages/")
        ("elpa-devel" . "https://elpa.gnu.org/devel/")
        ("nongnu" . "https://elpa.nongnu.org/nongnu/")
        ("melpa" . "https://melpa.org/packages/")))

[ Remember to use M-x package-refresh-contents to update the list of packages. ]

elpa-devel is useful for those who (i) want to live on the bleeding edge, (ii) understand that packages may break from time-to-time, and (iii) may want to help the developer test their program.

Setting up elpa-devel does not mean opting in to it indiscriminately. The user can pick which version of a package they prefer, such as by specifying the one to download in the buffer of M-x list-packages. More on this in the next section.

M-x describe-package (C-h P by default) shows which versions are available. If the package is already installed, the Help buffer will mention which version is in use. Example:

     Status: Installed in ‘vertico-0.23.0.20220511.61449/’. [Delete]
    Version: 0.23.0.20220511.61449
     Commit: d5d6e312af7c2525c8e6be3397373929a28dd421
    Summary: VERTical Interactive COmpletion
   Requires: emacs-27.1
    Website: https://github.com/minad/vertico
 Maintainer: Daniel Mendler <mail@daniel-mendler.de>
     Author: Daniel Mendler <mail@daniel-mendler.de>
Other versions: 0.23.0.20220511.61449 (elpa-devel), 0.23 (elpa).

Notice the difference in notation. elpa will get the value of the Version header specified in the package’s metadata: 0.23 in this case. Whereas elpa-devel follows a more descriptive pattern of VERSION.DATE.IDENTIFIER, as in 0.23.0.20220511.61449.

Prioritise archives and pin packages to archives

By default, package archives are not prioritised. The Emacs package manager (package.el) will fetch the highest version it finds. Users can control this behaviour by configuring the user option package-archive-priorities.

;; Assuming a `package-archives' like this:
(setq package-archives
      '(("elpa" . "https://elpa.gnu.org/packages/")
        ("elpa-devel" . "https://elpa.gnu.org/devel/")
        ("nongnu" . "https://elpa.nongnu.org/nongnu/")
        ("melpa" . "https://melpa.org/packages/")))

;; Highest number gets priority (what is not mentioned gets priority 0)
(setq package-archive-priorities
      '(("elpa" . 2)
        ("nongnu" . 1)))

[ Remember M-x package-refresh-contents to propagate changes. ]

In this example, the Emacs package manager will prefer the elpa version of a package, even if it is found in other archives.

Notwithstanding such prioritisation, the Emacs package manager has the power to choose versions of individual packages by associating them with a particular archive. The user option is package-pinned-packages. It is only needed for packages that should deviate from the norm of package-archive-priorities.

;; Do it like this:
(setq package-pinned-packages
      '((fontaine . "elpa-devel")
        (logos . "elpa-devel")
        (vertico . "elpa-devel")))

;; Or perhaps:
(defvar my-elpa-devel-packages
  '(fontaine logos vertico)
  "List of packages I want to pin to elpa-devel.")

(dolist (package my-elpa-devel-packages)
  (add-to-list 'package-pinned-packages (cons package "elpa-devel")))

Help test packages

GNU ELPA is “stable” though “stability” here refers to the cadence of updates, not the inherent features of the respective package’s code base. A stable package can still have bugs!

From my perspective as a maintainer of several Emacs packages, the elpa-devel option is very helpful to identify misfeatures or errors and iterate on them in a timely fashion. Feedback is valuable.

I often receive emails pertaining to my packages which start with a statement along the lines of “sorry to bother you about PACKAGE”. Don’t worry about it: the duty of a maintainer is to consider information of this sort and act on it accordingly.

On this note, I encourage you to report actual or even perceived problems to package maintainers, while consulting the official documentation (asking folks on some forum is okay, but don’t expect the maintainer to keep track of such exchanges). Emacs is one of those programs that encourages you to introspect it and, in the process of learning, blur the line between user and developer.

Do your part to improve packages, however minor you may think your contribution is.

Torstein Johansen, who’s been using Emacs for 20 years, has a shocking confession: Although he learned about them, he’s never used keyboard macros. Part of the reason for that, he says, is that he uses multiple cursors instead. My first impression was, “But multiple cursors was just introduced 3 or four years ago.” Actually, Sveen’s famous Emacs Rocks! video on multiple cursors was 10 years ago so it’s more than possible that lots of people have always used it in preference to keyboard macros.

Regardless, Johansen set out to remedy the situation by getting serious about macros and recording a short video on how to use them. The video uses macros to solve a simple reformatting problem and then solves the same problem with multiple cursors for comparison. The amount of work is pretty much the same—especially if use the repeat macro to end of buffer command instead of repeating it for each line—but multiple cursors does take a few less keystrokes.

The video illustrates a problem with multiple cursors that I mentioned in my Are Multiple Cursors Suboptimal? post: there are several commands devoted to placing the initial cursors that you have to know whereas you can do real work with keyboard macros by just knowing how to start and end the macro recording. I like the F3 and F4 keystrokes for that especially since F4 will replay the macro after it’s been recorded.

All in all, the video is a nice introduction to using keyboard macros and it’s short (3 min, 31 secs) so there will be no problem finding time for it. The video does not cover everything you can do with macros but just knowing the simple commands Johansen illustrates will cover 90% of everything you want to do.

A special quick edition of my “%” Emacs development blog series: We now have some magic numbers!!!1!

Today, we dipped below 2219, which is a magical number, because:

The most open bugs we had was 4437, and (/ 4437.0 2) => 2218.5.

50% down from the top! Let the celebrations start! Carnivals in the streets! Crowds going mad!

We’ve basically shaved a decade’s worth of bugs off, and we’re down to 2012 levels. Or 2011, if you wanna disregard that bump…

Oh, and another magical number:

2222 — should have waited until May 22nd, I guess. More twos is more magical, right? Right.

This concludes this session on Numerology in Computing.

Good news for all Emacsers who have a copy of Mickey Petersen’s excellent Mastering Emacs: Mickey has updated the book to cover Emacs 28. You can read the “2022 Edition Update” section of the book at the previous link but the TL;DR is that the big change is, of course, native compilation and that Emacs 28 otherwise consists of incremental changes to many aspects of Emacs. You can read the section or Mickey’s longer treatise on what’s new in Emacs 28 for details.

If you currently own the book, you’ve probably already received an email from Mickey alerting you to the update. You can get the update for free by using the secure link for updating that you originally used to get the book and subsequent updates.

If you don’t yet own a copy, now’s a good time to get one. You can buy it for only $28.79 at the Mastering Emacs site. It’s a great book and one every Emacs user should have.

On the mailing list of the modus-themes, user “takeda” inquired whether they could use colours from my themes to style their website. There was uncertainty about the matter, as the themes are distributed under the terms of the GNU General Public License version 3 (or later) and takeda has a website whose source code is closed: it would constitute a violation of the GPL to re-use copylefted code in a non-copyleft code base, or so the thinking was.

After consulting with the folks on the emacs-devel mailing list, I am putting the colour palette of the modus-themes—just the ~400 colours, not the entire source code—in the public domain (technically, the Creative Commons Zero license (CC0)). Thanks to everyone involved!

The reason I asked about this on emacs-devel is because the modus-themes (modus-operandi and modus-vivendi) are built into Emacs (since August 2020) and I did not want to jeopardise Emacs or anyhow put the maintainers in a difficult spot.

To copy the colours freely, visit: https://protesilaos.com/emacs/modus-themes-colors. You do not have to provide attribution for the colour palette, but doing so, such as by linking to that page, can help others discover the original material.

That granted, I must stress that the Modus themes are not colour schemes and cannot be thus reduced. They are fully fledged applications: colours in certain combinations which are applied to particular contexts using specific methods. In simple terms, I pick colours that work well for the purposes of the design and concomitant accessibility standards, but I do not, say, choose a shade of yellow that has the prettiest contrast next to a shade of blue—what a colour scheme does. If I were to design a colour scheme, I would make different decisions.

Further reading

• From the themes’ manual: Are these color schemes?
• Blog post: Colour theory and techniques used in the Modus themes

• Upcoming events:
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri May 13 0900 Vancouver / 1100 Chicago / 1200 Toronto / 1600 GMT / 1800 Berlin / 2130 Kolkata – Sat May 14 0000 Singapore
  • M-x Research (contact them for password): TBA https://m-x-research.github.io/ Tue May 17 0800 Vancouver / 1000 Chicago / 1100 Toronto / 1500 GMT / 1700 Berlin / 2030 Kolkata / 2300 Singapore
• Beginner:
  • Wrote some basic emacs notes for myself as I kept forgetting these and looking these up would take a lot of time in the dense manuals.
  • Emacs Important Shortcuts 2022_05_06_06:03:45 (06:55) C-x b, M-:, M-& (Irreal)
• Emacs configuration:
  • Nicolas P. Rougier's dotemacs (screenshot, Reddit)
• Emacs Lisp:
  • xah talk show 2022-05-07 look into emacs lisp string functions (01:14:10)
• Appearance:
  • Protesilaos Stavrou: Emacs: fontaine version 0.2.0
• Dired:
  • Emacs for Professionals: "Batch file renaming" (Reddit)
• Org Mode:
  • Marcin Borkowski: My productivity system - implementation
  • Org mode - Insert timestamp in proposals (06:38)
  • org-imenu-filter to filter imenu-list with "regular" tags/properties expressions. (Reddit)
  • [ANN] org-ql 0.5 released; (Reddit)
  • #4 Org mode profiling meetup on Sat, May 7 - meeting notes (Reddit)
  • org-store-link… powerful and flexible | THIS IS EMACS (Reddit)
  • org-mode links everywhere, not only in org-mode buffers | THIS IS EMACS (Reddit, Irreal)
  • Import, export, and integration:
    • PSA: ox-hugo will remove the option to export front-matter in YAML format in near future
    • Magnus: Comments and org-static-blog
  • Org Roam:
    • Making Connections in Your Notes (13:49, Irreal) - org-roam
    • How to rank your backlinks notes with Org Roam (Reddit)
  • Org development: ob-plantuml: Allow setting PlantUML args for jar file
• Coding:
  • Emacs for Professionals: "Browsing source code" (Reddit)
  • Org-capturing live Jira Issues (Reddit)
  • Flymake module for awesome-tray package (Reddit)
  • scripter.co | Emacs: Creating a patch file using Magit
  • Team Linguini: Emacs IDE (05:01)
• Fun:
  • Read the diminish.el source; got some unexpected literary edification. (Reddit)
• Community:
  • Weekly Tips, Tricks, &c. Thread
  • Making fan Doom Emacs logo for dashboard. Plan to make both Nord and Doom One versions. Any suggestions? and day 2
  • Protesilaos Stavrou: I am translating the Emacs TUTORIAL into Greek
  • Lars Ingebrigtsen: 16x10%
  • Let's Give Emacs Another Look | Before TheLinuxCast 😎😅 (02:30:09)
• Other:
  • Mickey Petersen: The Emacs 28 Edition of Mastering Emacs is out now (Irreal)
  • New package: Clippo - Clipboard Manager via Emacs (currently, tailored only for yabai but support for other WM's shouldn't be too hard!)
  • Emacs for Professionals: "Emacs as a Shell" (not about shell-mode) about how Emacs is a shell in and of itself (Reddit)
  • flite mode demo: Text to Speech (TTS) using Festival Lite in Emacs (01:57)
  • New package image-roll! Improved document display engine providing continuous scrolling.
  • Update: MSI Installer for GNU Emacs 28.1 for Windows (Reddit)
• Emacs development:
  • emacs-devel progress on feature/tree-sitter
  • Add support for the Sharada script
  • Add new user option table-latex-environment
  • Allow precision-scrolling nonselected windows when the minibuffer is resized
  • Add Greek translation of the tutorial
  • Add support for the Tirhuta script
  • Allow term-mode to send function keys to the underlying shell
  • Make 'delete-process' into a command
  • (dabbrev-completion): Fix bug#45768
  • Add support for the Kaithi script
  • Document the `x' DWIM action in the manual
  • Make `x' in package-menu-mode more DWIM
  • Allow dabbrev to ignore binary buffers
  • Allow inhibiting linkification in Help buffers
  • Avoid having font locking triggering unnecessary auto-saving
  • Char-fold quotation characters in info and Help
  • Add new helper macros for minor modes to restore variables
  • Turn on XInput 2 support by default
  • Add NEWS entry about incompatible sorting command behaviors
  • Add new macro with-buffer-unmodified-if-unchanged
  • Improve the behavior of concatenating parts of Eshell arguments
  • Return a list of numbers if all lines of an Eshell subcommand are numeric
  • Eshell variable expansion should always return strings inside quotes
  • Add new command 'package-update'
• New packages:
  • cpupower: cpupower command interface (GNU ELPA)
  • cue-mode: Major mode for CUE language files (MELPA)
  • evm-mode: Major mode for editing Ethereum EVM bytecode (MELPA)
  • le-thesaurus: Query thesaurus.com for synonyms of a given word (MELPA)
  • project-rootfile: Extension of project.el to detect project with root file (MELPA)
  • scholar-import: Import Bibtex & PDF from Google Scholar (MELPA)
  • sisyphus: Create releases of Emacs packages (MELPA)
  • timu-rouge-theme: Color theme inspired by the Rouge Theme for VSCode (MELPA)
  • tomelr: Convert S-expressions to TOML (GNU ELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, emacs-devel, and lemmy/c/emacs.

I'm using org-static-blog to generate the contents of this site. So far I'm very happy with it, but I've gotten a few emails from readers who've wanted to comment on something I've written and they always point out that it's not easy to do. It's actually not a coincidence that it's a bit difficult!

Yesterday I came up with a way that might make is slightly easier without involving JavaScript from a 3rd party. By making use of the built-in support for adding HTML code for comments. One slight limitation is that it's a single variable holding the code, and I'd really like to allow for both

• using a link to a discussion site, e.g. reddit, as well as
• my email address

As the comment support in org-static-blog comes in the form of a single variable this seems a bit difficult to accomplish. However, it isn't difficult at all to do in elisp due to the power of advice-add.

By using the following advice on org-static-blog-publish-file

(advice-add 'org-static-blog-publish-file :around
            (lambda (orig-fn filename &rest args)
              (let*  ((comments-url (with-temp-buffer
                                      (insert-file-contents filename)
                                      (or (cadar (org-collect-keywords '("commentsurl")))
                                          my-blog-default-comments-url)))
                      (org-static-blog-post-comments (concat "Comment <a href=" comments-url ">here</a>.")))
                (apply orig-fn filename args))))

and defining my-blog-default-comments-url to a mailto:... URL I get a link to use for commenting by either

1. set commentsurl to point to discussion about the post on reddit, or
2. not set commentsurl at all and get the mailto:... URL.

If you look at my previous post you see the result of the former, and if you look below you see the result of the latter.

After several weeks of tweaking and editing, the Mastering Emacs book is now current with Emacs 28. Although Emacs 28 is mostly an incremental upgrade, introducing a large swathe of changes and improvements touching on many parts of Emacs, I think the hallmark feature (as I allude to below in the excerpt from the 2022 update from the book) is native compilation. I first wrote about it some years ago now, and I think native compilation is one of very few features in Emacs that pushed people to build Emacs from source just to try it out.

I’ve been using it daily for years and it’s rock solid. It’s a major engineering triumph. My personal thanks to Andrea Corallo for his incredible and steadfast work on this: it took him years!

2022 Edition Update

Emacs 28 is the newest version available and a significant upgrade over Emacs 27, as it introduces the long-awaited native compilation feature. With the size – and ambition – of third-party packages growing every year, so must Emacs’s performance.

Native compilation greatly improves Emacs’s performance across the board by compiling elisp into native code suitable for your platform and system architecture. It was a herculean effort by mostly one person, Andrea Corallo, that took several years of hard work before it made it into Emacs 28.

Aside from that major feature, the vast majority of changes in Emacs 28 are incremental, and I’ve updated the book accordingly, when I feel the new commands or customizations are worth knowing about.

However, there are a couple of larger features that I want to highlight here:

Project Management Improvements

Some of them made it into Emacs 27, but it’s been greatly enhanced in Emacs 28. A dedicated project management keymap makes it more accessible and easy to use, and it enhances a lot of features already present in Emacs.

Friendlier Help and Description Commands

Emacs is self-documenting, but it did have a few blind spots that I think this release helps address. The Help system is updated slightly with additional key bindings and better descriptions.

The describe system is the primary way of looking up symbols in Emacs, and Emacs 28 adds a couple of new commands that helps with that.

Better Discoverability

Finding useful commands related to a minor or major mode is not always that easy. A mode may introduce many commands, of which only a handful are likely of interest to the average user. Emacs now lets you ask it to execute a command pertinent to the modes active in your current buffer. It greatly improves discoverability.

As for the book itself, I’ve also gone through and removed most version markers – some dating back to Emacs 24 – as they’re not going to make a material difference to readers today. As part of that process, I’ve reworded and clarified things that I felt weren’t as obvious or clear as I wanted them to be.

Emacs in the Future

What’s in store for Emacs in the coming years, then? One tantalizing possibility is recognizing that regular expressions – the preferred tool of most editors to syntax highlight and extract semantic information – peaked decades ago, and if we want more intelligent tooling, we need to smarten up how we parse source code. That’s not a new or novel idea, but one that is hard to achieve at scale — a fact that held back intelligent code completion until Language Servers democratized it with a standardized protocol anyone could tap into and build on.

Emacs does have a few major modes that use language parsers for syntax and semantic enrichment, like js2-mode and nxml-mode. CEDET, a sprawling polyglot IDE with its own language parsers and semantic tooling, was merged into Emacs’s core about a decade ago, but it never caught on.

I believe tree sitter, a general-purpose incremental language parsing library that has seen significant adoption in other editors already, is the right tool for the job. It will not replace regular expressions completely, and nor should it: regular expressions have their place. But, tree sitter works with dozens of languages already and, rather propitiously, uses an s-expression-based query language. That makes it a perfect fit for Emacs and elisp. It’s also fast, and it can handle broken source code, so it’ll still work properly when you’re writing code. If you’re keen on experimenting, you can use tree sitter in Emacs right now for a much-improved syntax highlighting experience.

Tony Aldon has been busy posting informative articles to the Emacs reddit. One of his latest discusses org-open-at-point-global, a way of following a link formatted in Org syntax even if it’s not within an Org buffer. That’s something I didn’t know about but can be pretty handy. Rather than killing the link and pasting it into Emacs, your browser, or some other application, you simply put the point on the link and call org-open-at-point-global.

The example Aldon uses has two links before the definition of a user-defined function in an init.el file. One, [[help:pcase]], was a link to the HELP entry for pcase. The other, [[info:elisp#Current Buffer]], was a link to the Elisp info node for “Current Buffer”. Both links are in a comment in an Elisp buffer so they are in no way active as Org links. Nonetheless, org-open-at-point-global will follow the link by popping up a buffer to the appropriate place.

Almost all my non-code text buffers are Org buffers so Aldon’s example is perfect for me. If I want to put a link to something in a source code buffer, I can use the usual Org syntax in a comment and follow it easily if I need to.

It turns out that there’s an edge case concerning link definitions that Aldon discusses but other than that, org-open-at-point-global will faithfully follow any link. The link definition issue was raised on the Org-mode list so perhaps the edge case will be fixed.

To be sure, org-open-at-point-global is a small thing that’s not going to revolutionize anyone’s workflow but it’s still useful and I’m glad to have discovered it from Aldon’s post.

Whaa… it’s been less than a month since the last of these posts (wherein I give a report from my gamified Emacs bug tracker spelunking).

I’ve been using various ways to select bug reports to handle since I started on this back in… 2019? Yes. I started, of course, with reports about things that I had experience with (Gnus, eww, etc), but I soon ran out of things to do that way.

So instead I started looking through all bug reports that hadn’t had any responses, and then all bug reports I had been the last person to respond (they have a tendency to end with “So I think we should do <foo>, anybody have any comments?” and then nobody does. So then I would do <foo>.

But then I ran out of those, too, so I started just sorting all the bug reports by the length of the discussion. It looks like this:

And this 10% stretch!

I made it all of the way to the bottom, Maggie!

The longest bug thread had 135 messages.

It turns out that, contrary to what I had imagined, many of those well-discussed bug reports had actionable conclusions: That is, after discussing something back and forth for a couple of years, the conclusion was that indeed we should do <foo>, but then nobody did.

So I did that now, which explains why this is the speediest ten-percenter in quite a while:

Started April 13th, done May 8th.

Of course, reading those threads too some time, but figuring out what to do usually takes more time.

Anyway, that means that there aren’t really anything big new feature to report this time over (except that Tree Sitter has landed on a feature branch), just a buttload of bug fixes and small new features. Here’s some of them:

Easier Scripting

Emacs now has an -x switch designed to make scripting easier. With the above, you can do:

Emacs almost had this capability before, but it was a bit messy and not very convenient.

Restarting Emacs

When trying stuff out in Emacs, you want to be able to restart Emacs conveniently so that you can see that things work as you want them to. A new M-x restart-emacs command now makes things easier.

*Help* improvements

My mission to make the help buffers prettier and easier to read continues, and menus which used to be explained this way…

… are now displayed this way:

You can now also edit variable values, and you can keep the *Help* window selected (without popping to other windows when clicking on buttons in that window).

C-h m has also been reformatted. It used to look like this:

It’s now:

I.e., that endless list of global minor modes has been moved to after the major mode.

Double-buffering on Windows

Emacs on Windows now has double-buffering (courtesy of Po Lu), so there should be less flickering when displaying animated images, and less flickering overall.

OK, I’m not going to go through the entire NEWS file; it’s just smaller items like this:

Lots and lots of teensy stuff. (As well as a buttload of bug fixes; about 30 commits per day.)

Well, onward and upward… literally. Because I’m now making my way back up again in the list, going through the reports I either skipped going downwards, or just missed (due to a buglet in debbugs-gnu: it didn’t sort merged bugs stably, so they appeared arbitrarily at the point of one of the bug reports in the list, so I missed them, at random, when making my way down the list).

We started this stretch at 2400 open bugs, and we’re now down to 2264. Which means that the next 10% is just 226. Mua ha ha.

Fontaine lets the user specify presets of font configurations and switch between them on demand. This makes it easy to optimise for different contexts, such as a “reading” preset with large, spacious fonts, and an “editing” preset with smaller, more compact fonts.

Sources:

• Package name (GNU ELPA): fontaine
• Official manual: https://protesilaos.com/emacs/fontaine
• Change log: https://protesilaos.com/emacs/fontaine-changelog
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/fontaine
  • Mirrors:
    • GitHub: https://github.com/protesilaos/fontaine
    • GitLab: https://gitlab.com/protesilaos/fontaine
• Mailing list: https://lists.sr.ht/~protesilaos/fontaine

Below are the release notes. Also make sure to check my [growing] list of Emacs packages: https://protesilaos.com/emacs.

Version 0.2.0 on 2022-05-09

• Fontaine can apply its changes on a per-frame basis. One frame may, for example, use a preset of font configurations for the purposes of a “presentation” while the other has a “small” setup. Concretely, invoke the commands fontaine-set-preset and fontaine-set-face-font with a universal prefix argument (C-u). Without a prefix argument, these commands apply to all frames (as it was before).

• The fontaine-presets accepts a special t preset which provides “shared fallback values” for all presets. The manual has a section titled “Shared and implicit fallback values for presets” which covers all permutations of fontaine-presets at length. The gist is that the user can write more concise presets. Thanks to Ted Reed for proposing the idea and testing my prototype in the mailing list: https://lists.sr.ht/~protesilaos/fontaine/%3C87y1zcmo67.fsf@zenithia.net%3E.

• Simplified the sample configuration on how to restore the latest saved value or fall back to a preferred preset. Thanks to Christopher League for proposing an elegant expression over at the mailing list: https://lists.sr.ht/~protesilaos/fontaine/%3C87sfpop0dm.fsf@contrapunctus.net%3E#%3C87pmksoyv6.fsf@contrapunctus.net%3E

• The fontaine-latest-state-file is now handled by the package no-littering. Thanks to Christopher League for adding it there: https://github.com/emacscollective/no-littering/commit/76b7335202a5b6ddc6b6798a2e2fd5b09df57dc2

• The new user option fontaine-font-families specifies the preferred font families that are provided as completion candidates of the command fontaine-set-face-font. If left to its default nil value, Fontaine tries to find relevant fonts from the underlying system, though this is not always accurate depending on the build of Emacs and where it runs in.

• The doc string of fontaine-presets mentions some important caveats or information about font settings in emacs. Thanks to Eli Zaretskii for the feedback on the emacs-devel mailing list: https://lists.gnu.org/archive/html/emacs-devel/2022-04/msg01281.html.

As most of you know, I’m a big fan of the Zettelkasten idea and of its org-roam implementation in Emacs. There are several videos on org-roam, including the System Crafter series, that will help you get started. Matt Williams also has a video that provides motivation for why you might want to explore org-roam and a few words on how to get started.

What makes Williams’ video unique is that he’s not really an Emacs user. He’s bounced around between editors and is apparently currently using VS Code. Nonetheless, he likes org-roam and uses Emacs specifically to get access to it.

As an Emacs n00b, Williams had to figure out how to install Emacs and get everything configured. That turned out to be not too hard. He installed Doom Emacs and its dependencies using Homebrew. I’m not sure that’s really easier than just installing or compiling vanilla Emacs and adding a couple of lines to your init.el to add the org-roam package. Regardless, neither method too hard even for a beginner.

The video is 13 minutes, 49 seconds so it should be easy to schedule some time to watch it. The majority of the video is devoted to why you should embrace org-roam so there’s not a lot of technical complexity and it’s easy to watch.

Quick tip on how to create git patch files in Emacs using Magit.

Recently I came across few instances where people were asking questions related to creating patches for contributions to Emacs and Org mode repos here and then here. I was in the same shoes back then when I was about to make my first contribution to Emacs. And so I thought of sharing this tip on how to use Magit to create patch files.

If you have been using both Emacs and git, you might have already heard about the awesome Magit package. If you haven’t 😲, check out this screenshot-annotated review of what Magit is. With that out of the way, and assuming that you already have it installed (use-package magit :ensure t) , here’s how to create a patch file using Magit ..

Single-file patch #

1. Commit your changes to the git repo first.
2. Bring up the Magit Log view. From the Magit status buffer, you would type l l to show the log of the current branch.
3. Move the point to the commit that you want to send as a patch file, and hit W c c RET.
   • The last RET selects the commit the point is on, in the ∗magit-log∗ buffer.
   • If the first line of the commit log of the selected commit is “Update docstrings for shortdoc.el”, you’ll see a patch file named 0001-Update-docstrings-for-shortdoc.el.patch created in your git repo root.
   • You can now email this patch file as an attachment to bug-gnu-emacs@gnu.org (if contributing to Emacs) or to emacs-orgmode@gnu.org (if contributing to Org mode).

Multi-file patch #

If you need to create a multi-file patch i.e. patch files for a series of commits, select those commits in the ∗magit-log∗ buffer The commit selection process is the same as how you would select text in any Emacs buffer. For example, if I want to create a series of 5 patches, I would go to the latest commit in the series, hit C-SPC and then C-n 4 times to select 5 rows of commits. , and then use the same W c c binding.

More Resources #

Here are the official contribution guides for Emacs and Org mode:

• How to contribute to Emacs – Emacs CONTRIBUTE document
• How to contribute to Org – Worg

Here are some more resources that got shared in the Emacsverse recently (within the past year as of writing this):

1. <2022-04-23 Sat> Contributing patches to Org – Ihor Radchenko
2. <2022-04-09 Sat> Primer on formatting Git patches with Emacs (Magit) – Protesilaos Stavrou
3. <2021-08-17 Tue> Contributing to Emacs – Colin Woodbury

A need of getting the current UNIX time is something that comes up every now and then. Just this week I needed it in order to add a k8s liveness probe¹.

While it's often rather straight forward to get the Unix time as an integer in other languages², in Haskell there's a bit of type tetris involved.

1. getPOSIXTime gives me a POSIXTime, which is an alias for NominalDiffTime.
2. NominalDiffTime implements RealFrac and can thus be converted to anything implementing Integral (I wanted it as Int64).
3. NominalDiffTime also implements Num, so if the timestamp needs better precision than seconds it's easy to do (I needed milliseconds).

The combination of the above is something like

truncate <$> getPOSIXTime

In my case the full function of writing the timestamp to a file looks like this

writeTimestampFile :: MonadIO m => Path Abs File -> m ()
writeTimestampFile afn = liftIO $ do
    truncate @_ @Int64 . (* 1000) <$> getPOSIXTime >>= writeFile (fromAbsFile afn) . show

I’ve written about this many times before but it’s so useful it bears repeating. It’s about a technique I use all the time and one that I’m sure the rest of you will find worthwhile too. This post is inspired by one from Alain Lafon, a master Emacs user, about whom I’ve written several times.

The idea is simple. If you’re an Emacs user and want to rename a file, the easiest way to do that is to use dired from within Emacs. But what if you want to rename several, similarly named files? The answer is the same except that you have to turn on wdired mode (Ctrl+x Ctrl+q by default). Once you’ve entered wdired mode, the changes you make to the dired listing are reflected back to the actual files. So all you have to do is turn on wdired mode and use your favorite search replace method to change the target file names. Then you simply type Ctrl+c Ctrl+c to exit wdired mode and rename the files.

Lafon’s post has an animated GIF that demonstrates the process but the easiest way to see how it works is to try it out yourself. It really is a trick worth knowing.

UPDATE 2022-05-20 09:35 +0300. Changed the Greek word for “buffer” from “αποσβεστήρας” to “ενταμιευτής”. Thanks to Basil L. Contovounesios and Romanos Skiadas for the feedback in Emacs bug#55332. For future updates to the TUTORIAL.el_GR file, check the emacs.git source.

UPDATE 2022-05-08 19:07 +0300. My contribution is now part of Emacs. See the Annex below for a verbatim copy of TUTORIAL.el_GR.

I am in the process of translating the Emacs TUTORIAL into Greek. This is the document every newcomer is supposed to study and which can be accessed at any moment with C-h t (M-x help-with-tutorial). I am about 75% done as of this writing and will prepare a patch either tomorrow or on Monday (it is a long document and needs attention to detail).

Below I provide a table with select technical terms and their translations. I understand that certain words, such as “buffer”, have a peculiar meaning in computer science that slightly differs from, say, phrases like “the buffer zone” or “a buffer state”. I have tried to capture the meaning of such concepts, based on my ~3-year experience with Emacs though I must stress that I am not a computer scientist and have no background in any of the related disciplines.

Furthermore, there is at least one case with the word “kill” (“kill ring”, etc.) where I have intentionally not translated it literally. I am instead using the Greek equivalent of “extinguish” as it is conceptually more accurate than what would otherwise denote “murder”, “homicide”, and related. The word I use can be understood as “remove”, which is closer to what killing in Emacs—as opposed to deleting—is about (well, “kill” is an awkward term even in English, but I won’t argue against the mnemonics and convenience of C-k, C-M-k, …).

As such, I would appreciate if anyone with the requisite knowledge and command of Greek could double-check this table and tell me what they think about my choice of words (contact me).

[ I am not covering every possible inclination of those words. You get the idea! ]

Trivia

The Greek locale is referred to as el (or el_GR). Translations of the TUTORIAL must be named TUTORIAL.locale but writing TUTORIAL.el has the adverse effect of treating it as an Elisp file. I can do M-x fundamental-mode or use a local variable, but it is a nuisance. As such, I am naming it TUTORIAL.el_GR even though I think the _GR part is superfluous: there is only one written version of modern Greek (which encompsasses all intelligible variations of the language from the ancient times to modernity).

The language spoken in Cyprus has marginal differences in idioms or accent, but is the same language nonetheless—especially as taught in school or used in an official capacity. In terms of dialect, some Cypriot Greek words, concepts, expressions come directly from Ancient Greek, whereas in Greece they may have changed through the Middle Ages and/or, in contemporary times, by successive governments. Still, Greece has many regional dialects of its own (I grew up speaking one of them) which have no effect on the integrity of the locale.

I believe that for Cypriot Greek to qualify as a meaningful locale, it would need to have its own glyphs to better capture its pronunciation (and I am all for that). Especially for consonants whose equivalents are found in the extended Latin sets or in Cyrillic but not in the Greek alphabet. If anyone knows how we can extend Unicode code points or, anyhow, make things happen on this technical front, please let me know: I am interested to preserve and enrich the language and volunteer to do whatever it takes within my means (for Emacs and beyond).

Annex

This is TUTORIAL.el_GR as of the latest update on 2022-05-20 09:38 +0300.

Εκμάθηση του Emacs.  Δες το τέλος για όρους αντιγραφής.

Στο Emacs οι εντολές γενικά περιλαμβάνουν το πλήκτρο CONTROL (συχνά
αναγράφεται ως Ctrl) ή το πλήκτρο META (συνήθως επισημαίνεται ως ALT).
Αντί να γράφουμε το πλήρες όνομα κάθε φορά, θα χρησιμοποιούμε τις εξής
συντομογραφίες:

 C-<χαρ>  σημαίνει κράτα πατημένο το πλήκτρο CONTROL καθώς
	  πληκτρολογείς τον χαρακτήρα <χάρ>.  Συνεπώς, C-f είναι:
	  κράτα πατημένο το CONTROL και πληκτρολόγησε το f.
 M-<χαρ>  σημαίνει κράτα πατημένο το πλήκτρο META ή ALT καθώς
	  πληκτρολογείς τον χαρακτήρα <χάρ>.  Σε περίπτωση που δεν
	  υπάρχει πλήκτρο META ή ALT, πληκτρολόγησε και απελευθέρωσε
	  το πλήκτρο ESC και κατόπιν πληκτρολόγησε τον <χάρ>.
	  Γράφουμε <ESC> για το πλήκτρο ESC.

Σημαντική σημείωση: για να τερματίσεις το Emacs, πληκτρολόγησε C-x
C-c.  (Δύο χαρακτήρες.)  Για να ακυρώσεις μια μερικώς πληκτρολογημένη
εντολή, πληκτρολόγησε C-g.
Για να σταματήσεις την εκμάθηση, πληκτρολόγησε C-x k, κατόπιν <Return>
στην προτροπή.
Οι χαρακτήρες ">>" στο αριστερό περιθώριο δείχνουν οδηγίες για να
δοκιμάσεις μια εντολή.  Για παράδειγμα:
<<Blank lines inserted around following line by help-with-tutorial>>
[Κενό για διδακτικούς σκοπούς.  Το κείμενο συνεχίζεται παρακάτω.]

>> Τώρα πληκτρολόγησε C-v (δες επόμενη οθόνη) ώστε να κυλήσεις πιο
   κάτω στην παρούσα εκμάθηση.  (Κάνε το, κρατώντας πατημένο το
   πλήκτρο CONTROL και πληκτρολογώντας v.)  Από εδώ και στο εξής,
   παρακαλώ κάνε αυτό όποτε φτάνεις στο τέλος της οθόνης.

Σημείωσε πως υπάρχει επικάλυψη δύο γραμμών όταν κυλάς μια πλήρη οθόνη:
αυτή σου προσφέρει κάποια συνέχεια ώστε να συνεχίσεις να διαβάζεις το
κείμενο.

Αυτό είναι αντίγραφο του κειμένου εκμάθησης του Emacs, ελαφρά
τροποποιημένο για εσένα.  Παρακάτω θα σου αναθέσουμε να δοκιμάσεις
μερικές εντολές που τροποποιούν το εν λόγω κείμενο.  Μην ανησυχείς αν
τροποποιήσεις αυτό το κείμενο πριν σου το ζητήσουμε· η πράξη αυτή
αναφέρεται ως «επεξεργασία» και το Emacs χρησιμοποιείται για αυτόν τον
σκοπό.

Το πρώτο πράγμα που πρέπει να γνωρίζεις είναι πως να κινείσαι από το
ένα σημείο σε άλλο σημείο του κειμένου.  Ήδη ξέρεις πως να πηγαίνεις
μια οθόνη προς τα κάτω με το C-v.  Για να κινηθείς αντίστροφα,
πληκτρολόγησε M-v (κράτα πατημένο το META και πληκτρολόγησε το v, ή
πληκτρολόγησε <ESC>v εάν δεν έχει πλήκτρο META ή ALT).

>> Δοκίμασε να πληκτρολογήσεις M-v και μετά C-v μερικές φορές.

Είναι αποδεκτό να κυλήσεις το κείμενο με άλλους τρόπους, αν τους
ξέρεις.

* ΣΥΝΟΨΗ
--------

Οι εξής εντολές είναι χρήσιμες για να βλέπεις πλήρης οθόνες:

	C-v	Κινήσου μπροστά/κάτω μια πλήρη οθόνη
	M-v	Κινήσου πίσω/πάνω μια πλήρη οθόνη

	C-l	Καθάρισε την οθόνη επανεμφανίζοντας το κείμενο της και
		μεταφέροντας τον δείκτη (κέρσορα) στο κέντρο της.
		(Αυτό είναι CONTROL-L, όχι CONTROL-1.)

>> Εντόπισε τον δείκτη και σημείωσε το κείμενο πέριξ του.  Μετά
   πληκτρολόγησε C-l.  Ξαναβρές τον δείκτη και παρατήρησε το κείμενο
   δίπλα του, αλλά τώρα πρόσεξε πως βρίσκεται στο κέντρο της οθόνης.
   Εάν πατήσεις C-l πάλι, το κείμενο αυτό θα μετατοπιστεί στο πάνω
   μέρος της οθόνης.  Πάτα το C-l ξανά και θα πάει στο κάτω μέρος.

Μπορείς επίσης να χρησιμοποιήσεις τα πλήκτρα PageUp και PageDn για να
κινηθείς ανά πλήρη οθόνη, εάν ο ακροδέκτης (τερματικό) σου τα έχει,
ωστόσο είναι πιο αποτελεσματικό να χρησιμοποιείς τα C-v και M-v.


* ΒΑΣΙΚΟΣ ΕΛΕΓΧΟΣ ΤΟΥ ΔΕΙΚΤΗ
----------------------------

Η κίνηση ανά πλήρη οθόνη είναι χρήσιμη, αλλά πως θα πας σε
συγκεκριμένο σημείο εντός του κειμένου της οθόνης;

Υπάρχουν πολλοί τρόποι να το επιτύχεις αυτό.  Μπορείς να
χρησιμοποιήσεις τα πλήκτρα με τα βέλη, αλλά είναι πιο αποτελεσματικό
να κρατήσεις τα χέρια σου στην κανονική θέση και να χρησιμοποιήσεις
τις εντολές C-p, C-b, C-f, και C-n.  Οι χαρακτήρες αυτοί είναι το
αντίστοιχο των τεσσάρων πλήκτρων με τα βέλη, κατά αυτόν τον τρόπο:

			  Προηγούμενη γραμμή, C-p
				  :
				  :
   Πίσω, C-b .... Παρούσα θέση του δείκτη .... Εμπρός, C-f
				  :
				  :
			    Επόμενη γραμμή, C-n

>> Μετακίνησε τον δείκτη στη μέση του διαγράμματος αυτού
   χρησιμοποιώντας C-n ή C-p.  Μετά πληκτρολόγησε C-l για να δεις το
   όλο διάγραμμα στο κέντρο της οθόνης.

Θα σου είναι ευκολότερο να θυμάσαι αυτά τα γράμματα από τις λέξεις τις
οποίες αναφέρουν στην Αγγλική: P για προηγούμενο (previous), N για
επόμενο (next), B για πίσω (backward), και F για εμπρός (forward).  Θα
χρησιμοποιείς διαρκώς αυτές τις βασικές εντολές για την τοποθέτηση του
δείκτη.

>> Κάνε μερικά C-n μέχρι να φέρεις τον δείκτη σε αυτή την γραμμή.

>> Κινήσου εντός της γραμμής με μερικά C-f και μετά πάνω με κάποια
   C-p.  Δες τι κάνει το C-p όταν βρίσκεται στην μέση της γραμμής.

Κάθε γραμμή κειμένου τελειώνει με τον χαρακτήρα νέας γραμμής, που
επιτελεί τον σκοπό του διαχωρισμού της μίας γραμμής από την άλλη.
(Συνήθως η τελευταία γραμμή σε ένα αρχείο τελειώνει με τον χαρακτήρα
νέας γραμμής, ωστόσο το Emacs δεν απαιτεί κάτι τέτοιο.)

>> Δοκίμασε το C-b στην αρχή της γραμμής.  Θα μετακινήσει τον δείκτη
   στο τέλος της προηγούμενης γραμμής.  Διότι κινείται προς τα πίσω
   προσπερνώντας τον χαρακτήρα νέας γραμμής.

Το C-f έχει την ίδια συμπεριφορά με το C-b.

>> Κάνε μερικά ακόμα C-b, ώστε να εντοπίσεις τον δείκτη.  Κατόπιν
   κάνε C-f για να γυρίσεις στο τέλος της γραμμής.  Μετά ένα ακόμα C-f
   για να κινηθείς στην αρχή της επόμενης γραμμής.

Όταν κινείσαι πέρα από το πάνω ή κάτω μέρος της οθόνης, το κείμενο
πέραν της άκρης μετατοπίζεται εντός της οθόνης.  Αυτό ονομάζεται
«κύλιση».  Επιτρέπει στο Emacs να φέρει τον δείκτη στο ορισμένο
σημείο του κειμένου χωρίς να κινηθεί εκτός της οθόνης.

>> Δοκίμασε να κινήσεις τον δείκτη πέρα από το κάτω μέρος της οθόνης
   με το C-n και δες τι συμβαίνει.

Εάν η κίνηση ανά χαρακτήρα είναι πολύ αργή, μπορείς να κινηθείς ανά
λέξη.  Το M-f (META-f) πάει μπροστά μια λέξη και M-b πίσω μια λέξη.

>> Πληκτρολόγησε μερικά M-f και M-b.

Όταν βρίσκεσαι στο μέσο μιας λέξης, το M-f πηγαίνει στο τέλος της.
Όταν βρίσκεσαι σε κενό μεταξύ λέξεων, το M-f κινείται στο τέλος της
ακόλουθης λέξης.  Το M-b λειτουργεί αναλόγως προς την αντίθετη
κατεύθυνση.

>> Πληκτρολόγησε M-f και M-b μερικές φορές, με C-f και C-b μεταξύ τους
   ώστε να παρατηρήσεις την δράση των M-f και M-b σε διάφορα σημεία
   εντός και μεταξύ λέξεων.

Παρατήρησε την παράλληλο μεταξύ C-f και C-b από την μία, και M-f και
M-b από την άλλη.  Πολύ συχνά οι Meta χαρακτήρες χρησιμοποιούνται για
πράξεις που σχετίζονται με μονάδες που ορίζει η εκάστοτε γλώσσα
(λέξεις, προτάσεις, παραγράφους), ενώ οι Control χαρακτήρες επιδρούν
σε βασικά στοιχεία που είναι ανεξάρτητα του τι επεξεργάζεσαι
(χαρακτήρες, γραμμές, κτλ.).

Αυτή η παράλληλος ισχύει μεταξύ γραμμών και προτάσεων.  C-a και C-e
πηγαίνουν στην αρχή και το τέλος της γραμμής, ενώ M-a και M-e
πηγαίνουν στην αρχή και το τέλος της πρότασης.

>> Δοκίμασε δύο C-a και ύστερα δύο C-e.
   Δοκίμασε δύο M-a και ύστερα δύο M-e.

Παρατήρησε πως αλλεπάλληλα C-a δεν κάνουν τίποτα, ενώ επανειλημμένα
M-a συνεχίζουν να κινούνται ανά μία πρόταση.  Παρότι δεν είναι
ανάλογα, το καθένα φαντάζει φυσικό.

Η θέση του δείκτη εντός του κειμένου ονομάζεται «σημείο» (point).  Με
άλλα λόγια, ο δείκτης δείχνει που βρίσκεται το σημείο εντός του
κειμένου στην οθόνη.

Ιδού μία σύνοψη των απλών κινήσεων του δείκτη, συμπεριλαμβανομένων
των εντολών για κίνηση ανά λέξη και πρόταση:

	C-f	Κινήσου εμπρός ένα χαρακτήρα
	C-b	Κινήσου πίσω ένα χαρακτήρα

	M-f	Κινήσου εμπρός μία λέξη
	M-b	Κινήσου πίσω μία λέξη

	C-n	Κινήσου στην επόμενη γραμμή
	C-p	Κινήσου στην προηγούμενη γραμμή

	C-a	Κινήσου στην αρχή της γραμμής
	C-e	Κινήσου στο τέλος της γραμμής

	M-a	Κινήσου πίσω στην αρχή της πρότασης
	M-e	Κινήσου εμπρός στο τέλος της πρότασης

>> Δοκίμασε όλες αυτές τις εντολές μερικές φορές για εξάσκηση.  Αυτές
   είναι οι πιο συνηθισμένες εντολές.

Δύο άλλες σημαντικές κινήσεις του δείκτη είναι το M-< (META
Μικρότερο), που κινείται στην αρχή ολόκληρου του κειμένου, και M->
(META Μεγαλύτερο) που κινείται στο τέλος ολόκληρου του κειμένου.

Στους πλείστους ακροδέκτες (τερματικά), το '<' είναι στο ίδιο πλήκτρο
με το κόμμα, οπότε πρέπει να κρατάς πατημένο το shift για να το
πληκτρολογήσεις.  Σε αυτούς τους ακροδέκτες πρέπει να χρησιμοποιήσεις
το shift και για το M-<, αλλιώς θα πατάς M-κόμμα.

>> Δοκίμασε το M-< τώρα για να κινηθείς στην αρχή αυτής της εκμάθησης.
   Κατόπιν χρησιμοποίησε το C-v επανειλημμένα για να επιστρέψεις εδώ.

>> Τώρα δοκίμασε το M-> για να κινηθείς στο τέλος αυτής της εκμάθησης.
   Κατόπιν χρησιμοποίησε το M-v επανειλημμένα για να επιστρέψεις εδώ.

Μπορείς επίσης να χρησιμοποιήσεις τα πλήκτρα με τα βέλη, εάν ο
ακροδέκτης σου τα υποστηρίζει.  Προτείνουμε να μάθεις τα C-b, C-f, C-n
και C-p για τρεις λόγους.  Πρώτον, δουλεύουν σε όλων των ειδών τους
ακροδέκτες.  Δεύτερον, όταν αποκτήσεις εμπειρία στην χρήση του Emacs,
θα διαπιστώσεις πως αυτοί οι χαρακτήρες του Control είναι πιο γρήγοροι
στην χρήση παρά τα βέλη (διότι δεν απομακρύνεις τα χέρια σου από την
θέση πληκτρολόγησης δια αφής).  Τρίτον, εφόσον διαμορφώσεις την
συνήθεια να χρησιμοποιείς τις εντολές με τους Control χαρακτήρες,
μπορείς πιο εύκολα να μάθεις πιο προηγμένες εντολές κίνησης.

Οι πλείστες εντολές του Emacs δέχονται αριθμητική παράμετρο: για τις
περισσότερες εντολές αυτή λειτουργεί ως μετρητής επανάληψης.  Ο τρόπος
που δίνεις σε μια εντολή αριθμητική παράμετρο γίνεται πληκτρολογώντας
το C-u και μετά τα ψηφία προτού πληκτρολογήσεις την εντολή.  Εάν έχεις
το πλήκτρο META (ή ALT), υπάρχει άλλος εναλλακτικός τρόπος εισαγωγής
αριθμητικής παραμέτρου: πληκτρολόγησε τα ψηφία κρατώντας πατημένο το
πλήκτρο META.  Συνιστούμε να μάθεις την μέθοδο του C-u γιατί ισχύει σε
όλους τους ακροδέκτες.  Η αριθμητική παράμετρος ονομάζεται επίσης
«προθεματική παράμετρος», καθώς πληκτρολογείς την παράμετρο πριν την
εντολή στην οποία δίνεται.

Για παράδειγμα, C-u 8 C-f κινείται εμπρός οκτώ χαρακτήρες.

>> Δοκίμασε να χρησιμοποιήσεις το C-n ή C-p με αριθμητική παράμετρο
   για να κινήσεις τον δείκτη σε μια γραμμή κοντά σε αυτή με μόνο μία
   εντολή.

Οι πλείστες εντολές χρησιμοποιούν την αριθμητική παράμετρο ως μετρητή
επανάληψης, αλλά μερικές εντολές την χρησιμοποιούν με διαφορετικό
τρόπο.  Αρκετές εντολές (αλλά καμία από αυτές που έμαθες έως τώρα) την
χρησιμοποιούν ως ένδειξη--η παρουσία προθεματικής παραμέτρου,
ανεξαρτήτως της αξίας της, κάνει την εντολή να εκτελέσει κάτι
διαφορετικό.

Τα C-v και M-v συνιστούν άλλο ένα είδος εξαίρεσης.  Όταν τους δοθεί
παράμετρος, κυλούν το κείμενο πάνω ή κάτω κατά τόσες γραμμές, αντί για
πλήρη οθόνη.  Για παράδειγμα, C-u 8 C-v κυλάει πάνω κατά 8 γραμμές.

>> Δοκίμασε να πληκτρολογήσεις C-u 8 C-v τώρα.

Αυτό πρέπει να κύλησε το κείμενο πάνω κατά 8 γραμμές.  Αν θέλεις να το
φέρεις κάτω πάλι δοκίμασε την ίδια αριθμητική παράμετρο με το M-v.

Εάν χρησιμοποιείς γραφική προβολή, όπως το X ή MS-Windows, θα πρέπει
να υπάρχει μια ψηλή, ορθογώνια επιφάνεια σε πλευρά του παραθύρου του
Emacs που είναι γνωστή και ως η μπάρα κύλισης (scroll bar).  Μπορείς
να κυλήσεις το κείμενο πατώντας με το ποντίκι πάνω στην μπάρα κύλισης.

Αν το ποντίκι σου έχει ροδέλα, μπορείς να την χρησιμοποιήσεις για
κύλιση.


* ΑΝ ΤΟ EMACS ΠΑΨΕΙ ΝΑ ΑΝΤΑΠΟΚΡΙΝΕΤΑΙ
-------------------------------------

Αν το Emacs πάψει να ανταποκρίνεται στις εντολές σου, μπορείς να το
σταματήσεις με ασφάλεια πληκτρολογώντας C-g.  Μπορείς να
χρησιμοποιήσεις το C-g για να σταματήσεις μια εντολή που παίρνει πολύ
χρόνο να εκτελεστεί.

Μπορείς επίσης να χρησιμοποιήσεις το C-g για να καταργήσεις μια
αριθμητική παράμετρο ή την αρχή μιας εντολής που δεν θέλεις να
ολοκληρώσεις.

>> Πληκτρολόγησε C-u 100 για να φτιάξεις μια αριθμητική παράμετρο του
   100, μετά πληκτρολόγησε C-g.  Τώρα πληκτρολόγησε C-f.  Θα πρέπει να
   κινηθεί μόνο ένα χαρακτήρα, διότι ακύρωσες την παράμετρο με το C-g.

Σε περίπτωση που έχεις πληκτρολογήσει το <ESC> κατά λάθος, μπορείς να
το ξεφορτωθείς με το C-g.


* ΑΠΕΝΕΡΓΟΠΟΙΗΜΕΝΕΣ ΕΝΤΟΛΕΣ
---------------------------

Κάποιες εντολές του Emacs είναι «απενεργοποιημένες» ώστε νέοι χρήστες
να μην τις χρησιμοποιήσουν κατά λάθος.

Αν πληκτρολογήσεις μία από αυτές τις απενεργοποιημένες εντολές, το
Emacs παρουσιάζει μήνυμα που αναφέρει ποια είναι η εντολή και σου ζητά
αν θέλεις να την εκτελέσεις.

Εάν πράγματι θες να δοκιμάσεις την εντολή, πληκτρολόγησε <SPC> (το
κενό) ως απάντηση στην ερώτηση.  Κανονικά, αν δεν θέλεις να εκτελέσεις
την απενεργοποιημένη εντολή απαντάς με το «n».

>> Πληκτρολόγησε C-x C-l (που είναι απενεργοποιημένη εντολή) και μετά
   πληκτρολόγησε n ως απάντηση.


* ΠΑΡΑΘΥΡΑ
----------

Το Emacs μπορεί να έχει πολλά «παράθυρα», με το καθένα να δείχνει το
δικό του κείμενο.  Θα εξηγήσουμε παρακάτω πως να χρησιμοποιείς πολλά
παράθυρα.  Για την ώρα θέλουμε να εξηγήσουμε πως θα ξεφορτωθείς
πλεονάζοντα παράθυρα για να επιστρέψεις στην βασική επεξεργασία εντός
ενός παραθύρου.  Είναι απλό:

	C-x 1	Ένα παράθυρο (δηλαδή εξαφάνισε όλα τα άλλα παράθυρα)

Αυτό πρόκειται για το CONTROL-x που ακολουθείται από το ψηφίο 1.  Το
C-x 1 μεγιστοποιεί το παράθυρο που περιέχει τον δείκτη.  Διαγράφει τα
άλλα παράθυρα.

>> Φέρε τον δείκτη σε αυτή την γραμμή και πληκτρολόγησε C-u 0 C-l.
>> Πληκτρολόγησε C-h k C-f.
   Δες πως το παράθυρο συρρικνώνεται, καθώς ένα νέο εμφανίζεται για να
   παρουσιάσει την καταγραφή της εντολής C-f.

>> Πληκτρολόγησε C-x 1 και δες πως το παράθυρο της καταγραφής
   εξαφανίζεται.

Υπάρχει σειρά εντολών που ξεκινούν με το CONTROL-x· πολλές εξ αυτών
έχουν να κάνουν με παράθυρα (windows), αρχεία (files), ενταμιευτές
(buffers), και τα σχετικά.  Αυτές οι εντολές είναι δύο, τρία ή τέσσερα
γράμματα μάκρος.


* ΕΙΣΑΓΟΝΤΑΣ ΚΑΙ ΔΙΑΓΡΑΦΟΝΤΑΣ
-----------------------------

Αν θέλεις να εισάγεις κείμενο, απλά πληκτρολόγησε το.  Κοινοί
χαρακτήρες, όπως το Α, 7, *, κτλ. εισάγονται καθώς τους πληκτρολογείς.
Για να εισάγεις τον χαρακτήρα νέας γραμμής, πληκτρολόγησε <Return>
(αυτό είναι το πλήκτρο που μερικές φορές αναγράφεται ως «Enter»).

Για να διαγράψεις τον χαρακτήρα ακριβώς πριν από το τωρινό σημείο του
δείκτη, πληκτρολόγησε <DEL>.  Αυτό είναι το πλήκτρο που συνήθως
αναγράφεται στο πληκτρολόγιο ως «Backspace»--το ίδιο θα
χρησιμοποιούσες κανονικά κι εκτός Emacs για να διαγράψεις τον
τελευταίο χαρακτήρα που εισήγαγες.

Συνήθως υπάρχει άλλο ένα πλήκτρο που αναγράφεται ως <Delete>, αλλά
αυτό είναι διαφορετικό από αυτό που προαναφέραμε και που εννοούμε με
το <DEL> του Emacs.

>> Κάνε αυτό τώρα--πληκτρολόγησε μερικούς χαρακτήρες, μετά διάγραψε
   τους πατώντας το <DEL> μερικές φορές.  Μην ανησυχείς για την
   τροποποίηση αυτού του αρχείου: δεν τροποποιείς το κύριο κείμενο
   εκμάθησης.  Αυτό είναι το προσωπικό σου αντίγραφο.

Όταν η γραμμή του κειμένου γίνεται πολύ μεγάλη για μια γραμμή της
οθόνης, η γραμμή του κειμένου «συνεχίζεται» σε δεύτερη γραμμή οθόνης.
Εάν χρησιμοποιείς γραφική προβολή, καμπυλωτά βελάκια θα εμφανιστούν
στα στενά πλαίσια που βρίσκονται στα άκρα της επιφάνειας του κειμένου
(οι «παρυφές» αριστερά και δεξιά), για να επισημάνουν που συνεχίζεται
η γραμμή.  Εάν χρησιμοποιείται προβολή κειμένου, η συνεχιζόμενη γραμμή
παρουσιάζεται με την αντίστροφη κάθετο ('\') στην δεξιότερη στήλη της
οθόνης.

>> Εισήγαγε κείμενο μέχρις ότου φτάσεις στο δεξί περιθώριο και
   συνέχισε να προσθέτεις.  Θα δεις να εμφανίζεται η γραμμή συνέχειας.

>> Πάτα <DEL> επανειλημμένα για να διαγράψεις το κείμενο μέχρι που η
   γραμμή να χωράει ξανά στην οθόνη.  Η γραμμή συνέχειας θα χαθεί.

Μπορείς να διαγράψεις τον χαρακτήρα νέας γραμμής όπως κάθε άλλο
χαρακτήρα.  Διαγράφοντας τον χαρακτήρα νέας γραμμής μεταξύ δύο γραμμών
έχει σαν αποτέλεσμα την συνένωση τους σε μία γραμμή.  Εάν σαν
αποτέλεσμα η γραμμή είναι πολύ μεγάλη, θα παρουσιαστεί με την γραμμή
συνέχειας.

>> Μετακίνησε τον δείκτη στην αρχή της γραμμής και πληκτρολόγησε
   <DEL>.  Αυτό θα συνενώσει την γραμμή με την από πάνω της.

>> Πληκτρολόγησε <Return> για να επανεισάγεις τον χαρακτήρα νέας
   γραμμής που μόλις διέγραψες.

Το πλήκτρο <Return> είναι ειδικό, καθώς πληκτρολογώντας το μπορεί να
κάνει περισσότερα πράγματα πέραν της εισαγωγής του χαρακτήρα νέας
γραμμής.  Ανάλογα με το περιβάλλων κείμενο, μπορεί να προσθέσει κενό
μετά τον χαρακτήρα νέας γραμμής, ώστε όταν αρχίσεις να γράφεις στην
νέα γραμμή, το κείμενο να στοιχίζεται με την προηγούμενη γραμμή.
Ονομάζουμε αυτή την συμπεριφορά (όπου το πάτημα ενός πλήκτρου κάνει
κάτι παραπάνω από την εισαγωγή του σχετικού χαρακτήρα) «ηλεκτρική».

>> Ιδού ένα παράδειγμα της ηλεκτρικότητας του <Return>.
   Πληκτρολόγησε <Return> στο τέλος αυτής της γραμμής.

Κανονικά θα δεις πως μετά την εισαγωγή του χαρακτήρα νέας γραμμής, το
Emacs εισάγει κενά ώστε ο δείκτης να βρίσκεται ακριβώς κάτω από το
«Π» του «Πληκτρολόγησε».

Θυμήσου πως οι πλείστες εντολές του Emacs δέχονται μετρητή επανάληψης·
αυτό περιλαμβάνει την εισαγωγή κειμένου.  Επαναλαμβάνοντας ένα
χαρακτήρα κειμένου τον εισάγει πολλές φορές.

>> Δοκίμασε το τώρα -- πληκτρολόγησε C-u 8 * για να εισάγεις ********.

Έχεις ήδη μάθει τους πιο βασικούς τρόπους για την πληκτρολόγηση
κειμένου στο Emacs και την διόρθωση των λαθών.  Μπορείς επίσης να
διαγράψεις λέξεις και γραμμές.  Ιδού η σύνοψη των πράξεων διαγραφής:

	<DEL>        Διάγραψε τον χαρακτήρα ακριβώς πριν τον δείκτη
	C-d   	     Διάγραψε τον χαρακτήρα ακριβώς μετά τον δείκτη

	M-<DEL>      Εξαφάνισε την λέξη ακριβώς πριν τον δείκτη
	M-d	     Εξαφάνισε την λέξη μετά τον δείκτη

	C-k	     Εξαφάνισε από το σημείο του δείκτη ως το τέλος της γραμμής
	M-k	     Εξαφάνισε ως το τέλος της παρούσας πρότασης

Πρόσεξε πως το <DEL> και C-d σε σύγκριση με M-<DEL> και M-d
προεκτείνουν την παράλληλο που άρχισε με το C-f και M-f (κατ'ακρίβεια,
το <DEL> δεν είναι χαρακτήρας control, αλλά ας μην ανησυχούμε για
αυτό).  Τα C-k και M-k είναι κατά τρόπο όπως το C-e και M-e καθώς οι
γραμμές ταιριάζουν με τις προτάσεις.

Μπορείς επίσης να εξαφανίσεις ένα μέρος κειμένου με ενιαίο τρόπο.
Κινήσου σε μία άκρη του και πληκτρολόγησε C-<SPC>.  (<SPC> είναι το
πλήκτρο του κενού.)  Κατόπιν, μετακίνησε τον δείκτη στην άλλη άκρη του
κειμένου που θέλεις να εξαφανίσεις.  Καθώς το κάνεις αυτό, το Emacs
επισημαίνει το κείμενο μεταξύ των δύο άκρων του δείκτη και του σημείου
όπου πληκτρολόγησες C-<SPC>.  Τέλος, πληκτρολόγησε C-w.  Αυτό
εξαφανίζει το κείμενο μεταξύ των δύο σημείων.

>> Μετακίνησε τον δείκτη στο γράμμα Μ στην αρχή της προηγούμενης
   παραγράφου.
>> Πληκτρολόγησε C-<SPC>.  Το Emacs θα σου γράψει μήνυμα στο κάτω
   μέρος της οθόνης πως τέθηκε σημάδι («Mark set»).
>> Μετακίνησε τον δείκτη στο κ της λέξης «άκρη» στην δεύτερη γραμμή
   της παραγράφου.
>> Πληκτρολόγησε C-w.  Αυτό θα εξαφανίσει το κείμενο που άρχιζε με Μ
   και τελειώνει ακριβώς πριν το κ.

Η διαφορά μεταξύ της «εξαφάνισης» και της «διαγραφής» είναι πως το
«εξαφανισμένο» κείμενο μπορεί να επανεισαχθεί (σε οποιαδήποτε θέση),
ενώ τα «διαγραμμένα» πράγματα δεν μπορούν να επανεισαχθούν κατά αυτόν
τον τρόπο (μπορείς, ωστόσο, να αναιρέσεις την διαγραφή--δες παρακάτω).
Επανεισαγωγή εξαφανισμένου κειμένου ονομάζεται «τράβηγμα» («yanking»).
(Φαντάσου πως τραβάς κάτι πίσω το οποίο είχε αφαιρεθεί.)  Γενικά, οι
εντολές που αφαιρούν πολύ κείμενο το εξαφανίζουν, ενώ οι εντολές που
αφαιρούν απλά ένα χαρακτήρα, ή μόνο κενές γραμμές ή κενά, κάνουν
διαγραφή (οπότε δεν μπορείς να τα τραβήξεις πίσω).  <DEL> και C-d
κάνουν διαγραφή στην απλή περίπτωση, χωρίς παράμετρο.  Αν τους δοθεί
παράμετρος, τότε κάνουν εξαφάνιση.

>> Μετακίνησε τον δείκτη στην αρχή μιας γραμμής που δεν είναι κενή.
   Κατόπιν πληκτρολόγησε C-k για να εξαφανίσεις το κείμενο ως το τέλος
   της γραμμής.
>> Πληκτρολόγησε C-k δεύτερη φορά.  Θα δεις πως εξαφανίζει τον
   χαρακτήρα νέας γραμμής που ακολουθεί εκείνη την γραμμή.

Σημείωσε πως ένα C-k εξαφανίζει το περιεχόμενο της γραμμής, ενώ
δεύτερο C-k εξαφανίζει την ίδια την γραμμή και κάνει όλες τις
ακόλουθες γραμμές να μετατοπιστούν προς τα πάνω.  Το C-k ερμηνεύει την
αριθμητική παράμετρο με ειδικό τρόπο: εξαφανίζει τις γραμμές ΚΑΙ το
περιεχόμενο τους.  Αυτό δεν πρόκειται για απλή επανάληψη.  C-u 2 C-k
εξαφανίζει δύο γραμμές και τους αντίστοιχους χαρακτήρες νέας γραμμής·
ενώ πληκτρολογώντας το C-k δύο φορές δεν θα το έκανε αυτό.

Μπορείς να τραβήξεις εξαφανισμένο κείμενο στο ίδιο σημείο από όπου
εξαφανίστηκε, ή σε κάποιο άλλο σημείο που επεξεργάζεσαι, ή ακόμα σε
άλλο αρχείο.  Μπορείς να τραβήξεις το ίδιο κείμενο πολλές φορές· αυτό
δημιουργεί πολλαπλά αντίγραφα του.  Άλλοι κειμενογράφοι ονομάζουν την
εξαφάνιση και το τράβηγμα «αποκοπή» και «επικόλληση» (δες το γλωσσάριο
στο εγχειρίδιο του Emacs).

Η εντολή για τράβηγμα είναι C-y.  Εισάγει το τελευταίο εξαφανισμένο
κείμενο στην τρέχουσα θέση του δείκτη.

>> Δοκίμασε το· πληκτρολόγησε C-y για τα τραβήξεις το κείμενο πίσω.

Εάν κάνεις πολλά C-k στην σειρά, όλο το εξαφανισμένο κείμενο
αποθηκεύεται μαζί, ώστε ένα C-y τραβάει όλες τις γραμμές συλλήβδην.

>> Κάνε το τώρα· πληκτρολόγησε C-k αρκετές φορές.

Τώρα ανάκτησε το εξαφανισμένο κείμενο:

>> Πληκτρολόγησε C-y.  Κατόπιν μετακίνησε τον δείκτη κάτω μερικές
   γραμμές και πληκτρολόγησε C-y ξανά.  Τώρα βλέπεις πως να
   αντιγράψεις ορισμένο κείμενο.

Τι κάνει εάν έχεις κείμενο που θέλεις να τραβήξεις πίσω και μετά να
εξαφανίσεις κάτι άλλο; Το C-y θα τραβήξει την πιο πρόσφατη εξαφάνιση.
Αλλά η προηγούμενη της δεν έχει χαθεί.  Μπορείς να επιστρέψεις σε αυτή
χρησιμοποιώντας την εντολή M-y.  Αφού έχεις κάνει C-y για να πάρεις
την πιο πρόσφατη εξαφάνιση, πληκτρολογώντας το M-y αντικαθιστά το
τραβηγμένο κείμενο με το λιγότερο πρόσφατο εξαφανισμένο κείμενο.
Πληκτρολογώντας M-y ξανά και ξανά επαναφέρει ολοένα και παλαιότερες
εξαφανίσεις.  Όταν βρεις το κείμενο που ψάχνεις, δεν χρειάζεται να
κάνεις κάτι άλλο για να το κρατήσεις.  Απλά συνέχισε την επεξεργασία,
αφήνοντας το τραβηγμένο κείμενο εκεί που είναι.

Εάν χρησιμοποιήσεις το M-y αρκετές φορές, θα επιστρέψεις στο αρχικό
σημείο (την πιο πρόσφατη εξαφάνιση).

>> Εξαφάνισε μια γραμμή, κινήσου κάπου αλλού, εξαφάνισε άλλη γραμμή.
   Μετά πάτα C-y για να επαναφέρεις την δεύτερη εξαφανισμένη γραμμή.
   Μετά κάνε M-y κι αυτή θα αντικατασταθεί με την πρώτη εξαφανισμένη
   γραμμή.  Κάνε κι άλλα M-y να δεις τι θα σου βγάλει.  Συνέχισε ώσπου
   να σου δώσει πάλι την δεύτερη εξαφανισμένη γραμμή.  Αν θέλεις
   μπορείς να περάσεις στο M-y θετικές ή αρνητικές παραμέτρους.


* ΑΝΑΙΡΕΣΗ
----------

Εάν κάνεις αλλαγή στο κείμενο κι ύστερα κρίνεις πως ήταν λάθος,
μπορείς να την αναιρέσεις με την εντολή αναίρεσης C-/.

Κανονικά, το C-/ αναιρεί τις αλλαγές που επέφερε μία εντολή.  Αν
επαναλάβεις το C-/ πολλές φορές στη σειρά, κάθε επανάληψη αναιρεί
ακόμα μία εντολή.

Ωστόσο υπάρχουν δύο εξαιρέσεις: εντολές που δεν τροποποιούν κείμενο
δεν μετρούν (όπως εντολές που κινούν τον δείκτη ή κυλούν το κείμενο)
και χαρακτήρες που αυτό-εισάγονται συνήθως κρίνονται ως ομάδες έως 20
μέλη.  (Αυτό είναι για να περιορίσει τον αριθμό των C-/ που
απαιτούνται για την αναίρεση εισαγωγής κειμένου.)

>> Εξαφάνισε αυτή την γραμμή με C-k και πληκτρολόγησε C-/ ώστε να
   επανεμφανιστεί.

Το C-_ είναι εναλλακτική εντολή αναίρεσης που λειτουργεί το ίδιο με το
C-/.  Σε ορισμένους ακροδέκτες κειμένου, ενδέχεται να μην χρειάζεται
το shift για να εισάγεις το C-_.  Σε ορισμένους ακροδέκτες κειμένου,
το C-/ στέλνει το σήμα του C-_ στο Emacs.  Εναλλακτικά, το C-x u
λειτουργεί ακριβώς όπως το C-/, αλλά είναι λίγο πιο δύσκολο να το
πληκτρολογήσεις.

Η αριθμητική παράμετρος στα C-/, C-_, C-x u δρα ως μετρητής
επανάληψης.

Μπορείς να αναιρέσεις την διαγραφή κειμένου κατά τον ίδιο τρόπο που
αναιρείς την εξαφάνιση κειμένου.  Ο διαχωρισμός μεταξύ εξαφάνισης και
διαγραφής έχει σημασία μόνο όταν θες να τραβήξεις κάτι πίσω με το C-y:
δεν έχει καμιά διαφορά για τους σκοπούς της αναίρεσης.


* ΑΡΧΕΙΑ
--------

Για να καταστήσεις μόνιμο το κείμενο που επεξεργάζεσαι, πρέπει να το
βάλεις σε αρχείο.  Αλλιώς θα χαθεί όταν κλείσεις το Emacs.  Για να
βάλεις κείμενο σε αρχείο, πρέπει να το «βρεις» πριν εισάγεις το
κείμενο.  (Η πράξη αυτή ονομάζεται επίσης ως «επίσκεψη» στην τοποθεσία
του αρχείου.)

Εξεύρεση του αρχείο σημαίνει πως βλέπεις το περιεχόμενο του εντός του
Emacs.  Κατά πολλούς τρόπους, είναι σαν να επεξεργάζεσαι το αρχείο
απευθείας.  Ωστόσο, οι αλλαγές που κάνεις καθίστανται μόνιμες μόνο
αφού «αποθηκεύσεις» το αρχείο.  Αυτό γίνεται ώστε να μην μένουν
μισοτελειωμένα αρχεία στο σύστημα ενάντια στην θέληση σου.  Ακόμα κι
αν αποθηκεύσεις τις αλλαγές, το Emacs διατηρεί αντίγραφο του γνησίου
αρχείου υπό ελαφρώς τροποποιημένο όνομα, ώστε να μπορείς να το
επαναφέρεις σε περίπτωση που συνέβη κάποιο λάθος.

Αν κοιτάξεις προς το κάτω μέρος της οθόνης θα δεις μια γραμμή που
αρχίζει με παύλες και αναφέρει « -:--- TUTORIAL.el_GR» ή κάπως έτσι.
Αυτό το μέρος της οθόνης συνήθως δείχνει το όνομα του αρχείου που
επισκέπτεσαι.  Τώρα επισκέπτεσαι το προσωπικό σου αντίγραφο του
κειμένου εκμάθησης του Emacs, που ονομάζεται «TUTORIAL.el_GR».  Όταν
βρίσκεις ένα αρχείο με το Emacs, το όνομα του θα εμφανιστεί σε εκείνο
ακριβώς το σημείο.

Μια ειδική πτυχή της εντολής για εξεύρεση αρχείου είναι πως πρέπει να
προσδιορίσεις ποιο αρχείο θέλεις.  Λέμε πως η εντολή «διαβάζει την
παράμετρο» (στην προκειμένη περίπτωση αυτή είναι το όνομα του
αρχείου).  Αφού πληκτρολογήσεις την εντολή

	C-x C-f   Βρες ένα αρχείο

το Emacs θα σου ζητήσει να πληκτρολογήσεις το όνομα του.  Το όνομα
του αρχείου που εισάγεις εμφανίζεται στο κάτω μέρος της οθόνης.  Η
τελευταία γραμμή ονομάζεται μικροενταμιευτής (minibuffer) όταν
χρησιμοποιείται για τέτοιους σκοπούς εισαγωγής εντολής.  Μπορείς να
χρησιμοποιήσεις τις κοινές εντολές του Emacs για επεξεργασία κειμένου
καθώς γράφεις το όνομα του αρχείου.

Ενόσω δακτυλογραφείς το όνομα του αρχείο (ή κάθε άλλο κείμενο στον
μικροενταμιευτή), μπορείς να ακυρώσεις την εντολή με το C-g.

>> Πληκτρολόγησε C-x C-f και μετά C-g.  Αυτό ακυρώνει τον
   μικροενταμιευτή και την εντολή C-x C-f που τον χρησιμοποιούσε.
   Συνεπώς δεν θα βρεις κανένα αρχείο.

Όταν ολοκληρώσεις την εισαγωγή του ονόματος ενός αρχείου, πάτα
<Return> για να την επικυρώσεις.  Ο μικροενταμιευτής εξαφανίζεται
καθώς το C-x C-f αναλαμβάνει δράση για να βρει το αρχείο που του
όρισες.

Το περιεχόμενο του αρχείου τώρα εμφανίζεται στην οθόνη και μπορείς να
το επεξεργαστείς.  Όταν θέλεις να μονιμοποιήσεις τις αλλαγές που
έκανες, χρησιμοποίησε την εντολή

	C-x C-s   Αποθήκευσε το αρχείο

Αυτή αντιγράφει το κείμενο που βρίσκεται στο Emacs στο εν λόγω αρχείο.
Την πρώτη φορά που το κάνεις αυτό, το Emacs μετονομάζει το γνήσιο ώστε
να μην χαθεί.  Το νέο όνομα περιέχει το σύμβολο «~» ως κατάληξη του
αρχικού ονόματος.  Όταν ολοκληρωθεί η αποθήκευση, το Emacs παρουσιάζει
το όνομα του αρχείου όπου γράφτηκαν οι αλλαγές.

>> Πληκτρολόγησε C-x C-s TUTORIAL.el_GR <Return>.
   Αυτό θα αποθηκεύσει αυτό το κείμενο σε αρχείο με το όνομα
   TUTORIAL.el_GR και θα αναφέρει πως έγραψε σε αυτό στο κάτω μέρος
   της οθόνης.

Μπορείς να βρεις υφιστάμενο αρχείο είτε για να το δεις ή να το
επεξεργαστείς.  Μπορείς επίσης να βρεις αρχείο το οποίο δεν
προϋπάρχει.  Έτσι το Emacs θα δημιουργήσει το αρχείο: θα βρεις το νέο
αρχείο, το οποίο είναι κενό, και κατόπιν θα εισάγεις κείμενο σε αυτό.
Όταν επιχειρήσεις να το αποθηκεύσεις, το Emacs θα δημιουργήσει το
αρχείο αυτό με το περιεχόμενο που του έδωσες.  Από εκεί και πέρα
θεώρησε πως επεξεργάζεσαι ένα υφιστάμενο αρχείο.


* ΕΝΤΑΜΙΕΥΤΕΣ
-------------

Εάν βρεις δεύτερο αρχείο με το C-x C-f, το πρώτο παραμένει εντός του
Emacs.  Μπορείς να επανέλθεις σε αυτό αν το ξαναβρείς με το C-x C-f.
Έτσι δύναται να έχεις πολλά αρχεία ανοιχτά εντός του Emacs.

Το Emacs αποθηκεύει το περιεχόμενο του κάθε αρχείου σε αντικείμενο το
οποίο ονομάζεται «ενταμιευτής» (buffer).  Η εξεύρεση αρχείου
δημιουργεί νέο ενταμιευτή εντός του Emacs.  Για να δεις την λίστα με
όλους τους υφιστάμενους ενταμιευτές, πληκτρολόγησε

	C-x C-b   Παράθεσε ενταμιευτές

>> Δοκίμασε το C-x C-b τώρα.

Παρατήρησε πως κάθε ενταμιευτής έχει όνομα ενώ δύναται να έχει επίσης
κι όνομα αρχείου του οποίο το περιεχόμενο κρατεί.  ΟΤΙΔΗΠΟΤΕ βλέπεις
σε παράθυρο Emacs πάντα είναι μέρος ενός ενταμιευτή.

>> Πληκτρολόγησε C-x 1 για να εξαφανίσεις το παράθυρο που παραθέτει
   τους ενταμιευτές.

Όταν έχεις πολλούς ενταμιευτές, μόνο ένας είναι ο «τρέχον» σε κάθε
στιγμή.  Πρόκειται για τον ενταμιευτή που επεξεργάζεσαι.  Εάν θες να
επεξεργαστείς κάποιον άλλο ενταμιευτή, πρέπει να «μεταβείς» σε αυτόν.
Αν θα μεταβείς σε ενταμιευτής που επισκέπτεται αρχείο, μπορείς να το
κάνεις με το C-x C-f προσδιορίζοντας το όνομα του αρχείου.  Αλλά
υπάρχει ευκολότερος τρόπος: χρησιμοποίησε την εντολή C-x b.  Σε αυτή
την εντολή, πρέπει να εισάγεις το όνομα του ενταμιευτή.

>> Δημιούργησε αρχείο ονόματι «foo»: γράψε C-x C-f foo <Return>.
   Μετά πληκτρολόγησε C-x b TUTORIAL.el_GR <Return> για να επιστρέψεις
   σε αυτό το κείμενο εκμάθησης του Emacs.

Συνήθως, το όνομα του ενταμιευτή αντιστοιχεί σε αυτό του αρχείου
(χωρίς το μέρος του αρχείου που αναφέρει τον κατάλογο/φάκελο στον
οποίο βρίσκεται).  Ωστόσο αυτό δεν ισχύει πάντοτε.  Η παράθεση
ενταμιευτών που φτιάχνει το C-x C-b δείχνει τόσο το όνομα του
ενταμιευτή όσο κι αυτό του αρχείου.

Κάποιοι ενταμιευτές δεν ανταποκρίνονται σε αρχεία.  Ο ενταμιευτής
ονόματι «*Buffer List*», που περιέχει τα στοιχεία του C-x C-b, δεν
έχει κάποιο υποκείμενο αρχείο.  Ο ενταμιευτής αυτού του
TUTORIAL.el_GR αρχικά δεν είχε κάποιο αρχείο, αλλά τώρα έχει, καθώς
στην προηγούμενη ενότητα χρησιμοποίησες το C-x C-s για να τον
αποθηκεύσεις σε αρχείο.

Ο ενταμιευτής με το όνομα «*Messages*» επίσης δεν έχει αρχείο.  Αυτός
περιέχει όλα τα μηνύματα που εμφανίζονται στο κάτω μέρος της οθόνης
κατά την λειτουργία του Emacs.

>> Πληκτρολόγησε C-x b *Messages* <Return> για να δεις τον ενταμιευτή
   με τα μηνύματα.  Μετά πληκτρολόγησε C-x b TUTORIAL.el_GR <Return>
   για να επανέλθεις εδώ.

Εάν κάνεις αλλαγές στο κείμενο ενός αρχείου, μετά βρεις κάποιο άλλο
αρχείο, η πράξη αυτή δεν αποθηκεύει τις αλλαγές που έκανες στο πρώτο
αρχείο.  Οι αλλαγές παραμένουν εντός του Emacs, στον ενταμιευτή που
ανταποκρίνεται σε εκείνο το αρχείο.  Η δημιουργία ή επεξεργασία του
δεύτερου αρχείου δεν επηρεάζει το πρώτο.  Αυτό είναι πολύ χρήσιμο,
ωστόσο σημαίνει πως χρειάζεσαι έναν βολικό τρόπο να αποθηκεύεις
αλλαγές σε πολλούς ενταμιευτές.  Το να πρέπει να επιστρέψεις στο
πρώτο αρχείο απλά και μόνο για να το αποθηκεύσεις είναι ενοχλητικό.
Οπότε έχουμε

	C-x s     Αποθήκευσε ορισμένους ενταμιευτές στα αρχεία τους

Το C-x s ρωτά για κάθε ενταμιευτή που επισκέπτεται αρχείο και που
κρατά αλλαγές οι οποίες δεν έχουν αποθηκευτεί.  Σε ρωτά για κάθε
ενταμιευτή κατά πόσον να αποθηκευτούν οι αλλαγές του στο αρχείο.

>> Εισήγαγε μια γραμμή κειμένου και πληκτρολόγησε C-x s.
   Θα σε ρωτήσει κατά πόσον θες να αποθηκεύσεις τον ενταμιευτή με
   όνομα TUTORIAL.el_GR.  Απάντα καταφατικά με το «y» (yes).


* ΕΠΕΚΤΕΙΝΟΝΤΑΣ ΤΟ ΣΥΝΟΛΟ ΕΝΤΟΛΩΝ
---------------------------------

Υπάρχουν πάρα πολλές εντολές του Emacs που δεν μπορούν να χωρέσουν σε
όλους τους control και meta χαρακτήρες.  Το Emacs ξεπερνά αυτό το
εμπόδιο με την εντολή επέκτασης (eXtend).  Αυτή έχει δύο μορφές:

	C-x	Χαρακτήρος επέκταση.  Ακολουθείται από τον χαρακτήρα.
	M-x	Ονόματος επέκταση.  Ακολουθείται από όνομα.

Αυτές είναι εντολές που είναι χρήσιμες εν γένει αλλά χρησιμοποιούνται
σχετικά λιγότερο από αυτές που έμαθες έως τώρα.  Έχεις ήδη δει εντολές
επέκτασης, όπως το C-x C-f και το C-x C-s.  Άλλο παράδειγμα είναι η
εντολή που κλείνει το Emacs--αυτή είναι C-x C-c.  (Μην ανησυχείς για
απώλεια αλλαγών που έκανες· το C-x C-c ρωτά να αποθηκεύσει αλλαγές σε
κάθε αρχείο πριν τερματίσει το Emacs.)

Εάν χρησιμοποιείς γραφική προβολή, δεν χρειάζεσαι κάποια ειδική εντολή
για να μεταβείς από το Emacs σε κάποια άλλη εφαρμογή.  Μπορείς να το
κάνεις με το ποντίκι ή τις εντολές του διαχειριστή παραθύρων.  Αν όμως
χρησιμοποιείς ακροδέκτη κειμένου ο οποίος προβάλει μόνο μία εφαρμογή,
τότε πρέπει να «αναστείλεις» το Emacs για να επιλέξεις οποιαδήποτε
άλλη εφαρμογή.

C-z είναι η εντολή της *προσωρινής* εξόδου από το Emacs--μπορείς να
επιστρέψεις στην ίδια συνεδρία υστερότερα.  Όταν το Emacs λειτουργεί
εντός ακροδέκτη κειμένου, το C-z «αναστέλλει» το Emacs· δηλαδή
επιστρέφει στο περίβλημα (shell) χωρίς να καταστρέψει την εργασία του
Emacs.  Στα πλείστα περιβλήματα, μπορείς να επαναφέρεις το Emacs με
την εντολή «fg» ή την «%emacs».

Χρησιμοποιείς το C-x C-c όταν θες να αποσυνδεθείς πλήρως.  Είναι η
σωστή πράξη για έξοδο από το Emacs, παράδειγμα για περιπτώσεις ταχείας
επεξεργασίας κειμένου όπως στην διαχείριση ηλεκτρονικού ταχυδρομείου.

Υπάρχουν πολλές εντολές του τύπου C-x.  Παραθέτουμε αυτές που έμαθες:

	C-x C-f		Εξεύρεση αρχείου
	C-x C-s		Αποθήκευση ενταμιευτή σε αρχείο
	C-x s		Αποθήκευση μερικών ενταμιευτών στα αρχεία τους
	C-x C-b		Παράθεση ενταμιευτών
	C-x b		Μετάβαση σε ενταμιευτή
	C-x C-c		Έξοδος από το Emacs
	C-x 1		Διαγραφή όλων πλην ενός παραθύρου
	C-x u		Αναίρεση

Επώνυμες εκτεταμένες εντολές είναι αυτές που χρησιμοποιούνται με
λιγότερη συχνότητα, ή εντολές που χρησιμοποιούνται μόνο σε
συγκεκριμένες λειτουργίες.  Ως παράδειγμα έχουμε την εντολή
replace-string, η οποία αντικαθιστά μια σειρά (αλληλουχία) χαρακτήρων
με μια άλλη εντός του ενταμιευτή.  Όταν πληκτρολογείς M-x, το Emacs
σε προτρέπει στο κάτω μέρος της οθόνης για το όνομα της εντολής·
«replace-string» σε αυτή την περίπτωση.  Απλά να πληκτρολογήσεις το
«repl s<TAB>» και το Emacs θα ολοκληρώσει το όνομα.  (<TAB> αναφέρεται
στο πλήκτρο Tab, που συνήθως βρίσκεται πάνω από το Caps Lock ή το
Shift στην αριστερή πλευρά του πληκτρολογίου.)  Κατάθεσε το όνομα της
εντολής με το <Return>.

Η εντολή replace-string απαιτεί δύο παραμέτρους--την σειρά χαρακτήρων
προς αντικατάσταση και αυτή που θα την αντικαταστήσει.  Κάθε
παράμετρος τελειώνει με το <Return>.

>> Μετακίνησε τον δείκτη στην κενή γραμμή δύο γραμμές κάτω από αυτήν.
   Πληκτρολόγησε M-x repl s<Return>αλλάξει<Return>μετατραπεί<Return>

   Πρόσεξε πως αυτή η γραμμή έχει αλλάξει: αντικατέστησες την λέξη
   «αλλάξει» με την «μετατραπεί» όπου αυτή υπήρχε μετά την αρχική θέση
   του δείκτη.


* ΑΥΤΟΜΑΤΗ ΑΠΟΘΗΚΕΥΣΗ
---------------------

Όταν έχεις κάνει αλλαγές σε ένα αρχείο, αλλά δεν τις έχεις αποθηκεύσει
ακόμα, ενδέχεται να χαθούν αν ο υπολογιστής κλείσει.  Για να σε
προστατέψει από αυτό το ενδεχόμενο, το Emacs κατά διαστήματα γράφει σε
ένα αρχείο «αυτόματης αποθήκευσης» κάθε αρχείο που επεξεργάζεσαι.  Το
όνομα αυτού του αρχείου έχει ένα # στην αρχή κι ένα στο τέλος· για
παράδειγμα, αν το αρχείο σου ονομάζεται «hello.c», η αυτόματη
αποθήκευση γίνεται στο «#hello.c#».  Όταν αποθηκεύσεις το αρχείο με
τον φυσιολογικό τρόπο, το Emacs διαγράφει το αρχείο αυτόματης
αποθήκευσης.

Εάν ο υπολογιστής κλείσει αναπάντεχα μπορείς να ανακτήσεις αυτό που
επεξεργαζόσουν με το να βρεις το αρχείο (το κανονικό αρχείο, όχι αυτό
της αυτόματης αντιγραφής του) και να πληκτρολογήσεις M-x
recover-this-file <Return>.  Όταν σου ζητηθεί επιβεβαίωση,
πληκτρολόγησε yes<Return> για την ανάκτηση των δεδομένων.


* ΤΟΠΟΣ ΑΝΤΗΧΗΣΗΣ
-----------------

Αν το Emacs διακρίνει πως πληκτρολογείς τους χαρακτήρες μιας
μακροσκελούς εντολής με σχετικά αργό ρυθμό, θα σου τους δείξει στο
κάτω μέρος της οθόνης σε αυτό που ονομάζεται «τόπος αντήχησης».  Ο
τόπος αντήχησης περιλαμβάνει την τελευταία γραμμή της οθόνης.


* ΓΡΑΜΜΗ ΚΑΤΑΣΤΑΣΗΣ
-------------------

Η γραμμή ακριβώς πάνω από τον τόπο αντήχησης ονομάζεται «γραμμή
κατάστασης».  Αυτή αναφέρει πληροφορίες όπως:

 -:**-  TUTORIAL.el_GR       63% L800    (Fundamental)

Αυτή η γραμμή έχει χρήσιμες πληροφορίες για την κατάσταση του Emacs
και του κειμένου που επεξεργάζεσαι.

Ήδη γνωρίζεις τι σημαίνει το πεδίο ονόματος του αρχείου--αναφέρει το
αρχείο που έχεις επισκεφθεί.  Το ΝΝ% δείχνει την τρέχουσα θέση σου
στον ενταμιευτή του κειμένου: σημαίνει πως ΝΝ επί τις εκατό του
ενταμιευτή βρίσκεται πέρα από το πάνω μέρος της οθόνης.  Εάν το πάνω
μέρος περιέχει όλο το προηγούμενο κείμενο, τότε θα γράφει «Top» αντί
για «0%».  Αν είναι στο κάτω μέρος του ενταμιευτή, τότε θα αναγράφει
«Bot».  Αν ο ενταμιευτής είναι μικρός ώστε όλο το περιεχόμενο του να
χωράει στην οθόνη, τότε η γραμμή κατάστασης θα γράφει «All».

Το L και τα ψηφία δείχνουν την θέση με άλλο τρόπο: τον αριθμό της
γραμμής όπου βρίσκεται το σημείο.

Οι αστερίσκοι κοντά στην αρχή δείχνουν πως έχουν υπάρξει τροποποιήσεις
στο κείμενο.  Μόλις επισκεφθείς ή αποθηκεύσεις ένα αρχείο, εκείνο το
τμήμα δεν δείχνει αστερίσκους παρά μόνο παύλες.

Το τμήμα της γραμμής κατάστασης εντός παρενθέσεων αναφέρει τις
λειτουργίες επεξεργασίας που ισχύουν.  Η βασική λειτουργία ονομάζεται
Fundamental κι είναι αυτή που χρησιμοποιείς τώρα.  Πρόκειται για
παράδειγμα «αξιωματικής λειτουργίας» (major mode).

Το Emacs έχει πολλές αξιωματικές λειτουργίες.  Κάποιες αφορούν την
επεξεργασία κειμένου σε διάφορες γλώσσες προγραμματισμού ή για διάφορα
ήδη κειμένου, όπως Lisp mode, Text mode, κτλ.  Μόνο μια αξιωματική
λειτουργία γίνεται να είναι σε ισχύ, και το όνομα της βρίσκεται στην
γραμμή κατάστασης όπου τώρα υπάρχει το «Fundamental».

Κάθε αξιωματική λειτουργία κάνει κάποιες εντολές να συμπεριφέρονται με
διαφορετικό τρόπο.  Για παράδειγμα, υπάρχουν εντολές για την
δημιουργία σχολίων σε ένα πρόγραμμα, και καθώς κάθε γλώσσα έχει τις
δικές τις ιδέες για το τι συνιστά σχόλιο, η εκάστοτε αξιωματική
λειτουργία εισάγει σχόλια ιδιοτρόπως.

Κάθε αξιωματική λειτουργία φέρει το όνομα μιας εκτεταμένης εντολής,
που είναι ένας τρόπος να αλλάξεις σε αυτή.  Για παράδειγμα, M-x
fundamental-mode είναι η εντολή που θέτει σε ισχύ το Fundamental mode.

Αν θα επεξεργάζεσαι κείμενο σε ανθρώπινη γλώσσα, όπως αυτό το αρχείο,
μάλλον θες να χρησιμοποιήσεις το Text mode.

>> Πληκτρολόγησε M-x text-mode <Return>.

Μην ανησυχείς, καθώς καμία από τις εντολές που έχεις μάθει δεν αλλάζει
με ουσιαστικό τρόπο.  Ωστόσο θα διαπιστώσεις πως M-f και M-b τώρα
θεωρούν τα εισαγωγικά ως μέρος της λέξης.  Πριν, στο Fundamental mode,
M-f και M-b διάβαζαν τα εισαγωγικά ως διαχωριστικά λέξεων.

Αξιωματικές λειτουργίες κάνουν τέτοιες εκλεπτυσμένες αλλαγές: οι
πλείστες εντολές «διεκπεραιώνουν το ίδιο έργο» σε κάθε αξιωματική
λειτουργία, αλλά ίσως το επιτυγχάνουν με ελαφρώς διαφορετικό τρόπο.

Για να μάθεις περισσότερα σχετικά με την τρέχουσα αξιωματική
λειτουργία, πληκτρολόγησε C-h m.

>> Μετακίνησε τον δείκτη στην γραμμή μετά από αυτήν.
>> Πληκτρολόγησε C-l C-l ώστε να έρθει αυτή η γραμμή στο πάνω μέρος
   της οθόνης.
>> Πληκτρολόγησε C-h m για να διαβάσεις πως διαφέρει το Text mode από
   το Fundamental mode.
>> Πληκτρολόγησε C-x 1 για να αφαιρέσεις την καταγραφή από την οθόνη.

Οι αξιωματικές λειτουργίες ονομάζονται έτσι διότι υπάρχουν και οι
ελάσσονες λειτουργίες (minor modes).  Ελάσσονες λειτουργίες δεν
υποκαθιστούν τις αξιωματικές λειτουργίες, παρά μόνο επί μέρους πτυχές
τους.  Κάθε ελάσσων λειτουργία μπορεί να ενεργοποιηθεί ή
απενεργοποιηθεί αυτοτελώς, ανεξάρτητα από άλλες ελάσσονες λειτουργίες
ή οποιονδήποτε συνδυασμό τους.

Μια ελάσσων λειτουργία που είναι πολύ χρήσιμη, ειδικά για την
επεξεργασία κειμένου ανθρώπινης γλώσσας, είναι η Auto Fill mode.  Όταν
αυτή η λειτουργία ενεργοποιηθεί, το Emacs αυτόματα διαχωρίζει τις
γραμμές μεταξύ των λέξεων όταν αυτές γίνονται πολύ πλατιές.

Το Auto Fill mode ενεργοποιείται με M-x auto-fill-mode <Return>.  Όταν
η λειτουργία είναι σε ισχύ, μπορεί να απενεργοποιηθεί πάλι με M-x
auto-fill-mode <Return>.  Αν είναι απενεργοποιημένη, τότε η εντολή
αυτή την ενεργοποιεί, και το αντίστροφο.  Λέμε πως η εντολή
«εναλλάσσει την λειτουργία».

>> Πληκτρολόγησε M-x auto-fill-mode <Return> τώρα.  Κατόπιν
   πληκτρολόγησε μια γραμμή με «ασδφ » πολλές φορές ως που να δεις ότι
   διαιρείται σε δύο γραμμές.  Πρέπει να έχει κενά μεταξύ των
   χαρακτήρων, διότι μόνο με βάση αυτά λειτουργεί το Auto Fill (δεν
   κόβει λέξεις).

Το μήκος συνήθως ορίζεται στους 70 χαρακτήρες, αλλά μπορείς να το
αλλάξεις με την εντολή C-x f.  Όρισε τον αριθμό που επιθυμείς ως
αριθμητική παράμετρο.

>> Πληκτρολόγησε C-x f με παράμετρο το 20.  (C-u 2 0 C-x f).  Κατόπιν
   πληκτρολόγησε τυχαίο κείμενο με κενά και πρόσεξε πως το Emacs
   συμπληρώνει τις γραμμές έως τους 20 χαρακτήρες.  Μετά θέσε πάλι το
   μήκος τους 70 χαρακτήρες χρησιμοποιώντας C-x f με αριθμητική
   παράμετρο.

Αν κάνεις αλλαγές στην μέση της παραγράφου, το Auto Fill mode δεν
επανασυμπληρώνει για χάρη σου.
Για να επανασυμπληρώσεις μια παράγραφο χειροκίνητα, πληκτρολόγησε M-q
(META-q) με τον δείκτη εντός της παραγράφου εκείνης.

>> Μετακίνησε τον δείκτη στην προηγούμενη παράγραφο και πληκτρολόγησε
   M-q.


* ΑΝΑΖΗΤΗΣΗ
-----------

Το Emacs μπορεί να αναζητήσει σειρές (σειρά (string) είναι αλληλουχία
χαρακτήρων) είτε προς τα εμπρός είτε ανάποδα.  Αναζήτηση σειράς
συνιστά κίνηση του δείκτη· μετακινεί τον δείκτη όπου εμφανίζεται η
σειρά.

Η εντολή αναζήτησης του Emacs είναι «τμηματική».  Αυτό σημαίνει πως η
αναζήτηση γίνεται ενόσω δακτυλογραφείς τους χαρακτήρες της σειράς που
αναζητείς.

Η εντολή προς εκκίνηση αναζήτησης είναι C-s για κίνηση προς τα εμπρός
και C-r και κίνηση όπισθεν.  ΑΛΛΑ ΠΕΡΙΜΕΝΕ!  Μην τις δοκιμάσεις ακόμα.

Όταν πληκτρολογείς C-s θα δεις πως η σειρά «I-search» εμφανίζεται ως
προτροπή στον τόπο αντήχησης.  Αυτό σου λέει πως το Emacs βρίσκεται σε
αυτό που ονομάζεται «τμηματική αναζήτηση» και περιμένει να
πληκτρολογήσεις αυτό το οποίο ψάχνεις.  <Return> ολοκληρώνει την
αναζήτηση.

>> Τώρα πληκτρολόγησε C-s για να αρχίσεις την αναζήτηση.  ΑΡΓΑ, ένα
   γράμμα τη φορά, γράψε «δείκτη», κάνοντας παύση αφού εισάγεις τον
   κάθε χαρακτήρα για να δεις τι συμβαίνει με τον δείκτη.
   Τώρα έχεις αναζητήσει για «δείκτη» μία φορά.
>> Πάτα πάλι C-s για να ψάξεις την επόμενη εμφάνιση του «δείκτη».
>> Τώρα πληκτρολόγησε <DEL> τέσσερις φορές και δες πως κινείται ο
   δείκτης.
>> Πληκτρολόγησε <Return> για να τερματίσεις την αναζήτηση.

Είδες τι έγινε; Το Emacs, σε τμηματική αναζήτηση, προσπαθεί να
εντοπίσει την επόμενη εμφάνιση της σειράς χαρακτήρων που έγραψες.  Για
να μεταφερθείς στην επόμενη εμφάνιση, πάτα C-s ξανά.  Εάν δεν υπάρχει
άλλη, το Emacs θα σηματοδοτήσει «αποτυχία» (failing).  Το C-g μπορεί
να τερματίσει την αναζήτηση.

Κατά την διάρκεια μιας τμηματικής αναζήτησης εάν πατήσεις <DEL>, η
αναζήτηση «υποχωρεί» σε πρότερο σημείο.  Αν πατήσεις <DEL> αμέσως
αφότου έχεις πληκτρολογήσει C-s για μετακίνηση στην επόμενη εμφάνιση
μιας σειράς χαρακτήρων, θα μεταβείς πίσω στην προηγούμενη εμφάνιση.
Εάν δεν υπάρχει προηγούμενη εμφάνιση, το <DEL> διαγράφει τον τελευταίο
χαρακτήρα στην σειρά.  Για παράδειγμα, φαντάσου πως έγραψες «δ» για να
βρεις την πρώτη εμφάνιση του.  Τώρα αν προσθέσεις το «ε» θα πας στην
πρώτη εμφάνιση του «δε».  Τώρα πάτα <DEL>.  Διαγράφει το «ε» από την
σειρά και μετακινεί τον δείκτη πίσω στην πρώτη εμφάνιση του «δ».

Αν είσαι στο μέσον μιας αναζήτησης και πληκτρολογήσεις ένα χαρακτήρα
control ή meta (με κάποιες εξαιρέσεις--όπως C-s και C-r που έχουν
ειδική σημασία στην αναζήτηση), η αναζήτηση θα τερματιστεί.

Το C-s ξεκινά αναζήτηση που ψάχνει για κάθε εμφάνιση της αναζητούμενης
σειράς ΑΠΟ την τρέχουσα θέση του δείκτη.  Εάν θες να βρεις
προηγούμενες εμφανίσεις, χρησιμοποίησε το C-r.  Όσα είπαμε για το C-s
ισχύουν για το C-r, με μόνη διαφορά την κατεύθυνση της αναζήτησης.


* ΠΟΛΛΑΠΛΑ ΠΑΡΑΘΥΡΑ
-------------------

Ένα από τα καλά του Emacs είναι πως μπορείς να παρουσιάσεις πέραν του
ενός παραθύρου στην οθόνη.  (Σημείωσε πως το Emacs χρησιμοποιεί τον
όρο «πλαίσιο» (frame)--επεξηγείται στην επόμενη ενότητα--για αυτό που
ορισμένες εφαρμογές αποκαλούν «παράθυρο» (window).  Το εγχειρίδιο του
Emacs περιέχει γλωσσάριο με όλους τους όρους.)

>> Φέρε τον δείκτη σε αυτή την γραμμή και πληκτρολόγησε C-l C-l.

>> Τώρα πάτα C-x 2, που μοιράζει την οθόνη σε δύο παράθυρα.
   Και τα δύο παράθυρα παρουσιάζουν αυτή την εκμάθηση.  Ο δείκτης
   επεξεργασίας παραμένει στο πάνω παράθυρο.

>> Πληκτρολόγησε C-M-v για να κυλήσεις το κάτω παράθυρο.  (Εάν δεν
   έχεις META ή ALT πλήκτρο, τότε πληκτρολόγησε <ESC> C-v.)

>> Πληκτρολόγησε C-x o («o» είναι για το «άλλο» στην αγγλική (other))
   ώστε να επιλέξεις το έτερο παράθυρο.

>> Χρησιμοποίησε C-v και M-v στο κάτω παράθυρο για να το κυλήσεις.
   Συνέχισε να διαβάζεις αυτές τις οδηγίες στο πάνω παράθυρο.

>> Πάτα C-x o και πάλι ώστε να φέρεις τον δείκτη πίσω στο πάνω
   παράθυρο.  Ο δείκτης στο πάνω παράθυρο είναι εκεί που ήταν και
   πριν.

Μπορείς να συνεχίσεις να χρησιμοποιείς C-x o για εναλλαγή μεταξύ των
παραθύρων.  Το «επιλεγμένο παράθυρο», όπου γίνεται η επεξεργασία,
είναι αυτό που έχει ένα φανερό δείκτη που αναβοσβήνει καθώς γράφεις.
Τα άλλα παράθυρα έχουν τις δικές τους θέσεις για τον δείκτη· αν
χρησιμοποιείς γραφική προβολή του Emacs, αυτοί οι δείκτες
παρουσιάζονται ως άδεια κουτιά που δεν αναβοσβήνουν.

Η εντολή C-M-v είναι πολύ χρήσιμη όταν επεξεργάζεται κείμενο σε ένα
παράθυρο και χρησιμοποιείς το έτερο παράθυρο για αναφορά.  Χωρίς να
φύγεις από το επιλεγμένο παράθυρο, μπορείς να κυλήσεις το παράθυρο με
C-M-v.

Το C-M-v αποτελεί παράδειγμα CONTROL-META χαρακτήρα.  Αν έχεις META (ή
ALT) πλήκτρο, πληκτρολογείς C-M-v κρατώντας πατημένα τόσο το CONTROL
όσο και το META και πληκτρολογώντας v.  Δεν έχει σημασία αν το CONTROL
ή το META «έρχεται πρώτο», καθώς αμφότερα μεταβάλουν τον χαρακτήρα που
εισάγεις.

Αν δεν έχεις το πλήκτρο META (ή ALT), και χρησιμοποιείς το <ESC>, τότε
η σειρά έχει σημασία: πρώτα πατάς κι αφήνεις το <ESC> κι ακολουθείς με
CONTROL-v, διότι CONTROL-<ESC>-v δεν θα δουλέψει.  Αυτό γιατί το <ESC>
είναι χαρακτήρας από μόνο του, κι όχι πλήκτρο μετατροπής χαρακτήρων.

>> Πληκτρολόγησε C-x 1 στο πάνω παράθυρο για να κλείσεις το κάτω
   παράθυρο.

(Άν πατούσες C-x 1 στο κάτω παράθυρο, θα έκλεινες το πάνω.  Φαντάσου
πως αυτή η εντολή λέει «κράτα ένα παράθυρο--αυτό που έχω επιλεγμένο.»)

Δεν είναι απαραίτητο να παρουσιάζεις τον ίδιο ενταμιευτή σε πολλά
παράθυρα.  Αν χρησιμοποιήσεις το C-x C-f για να βρεις ένα αρχείο στο
ένα παράθυρο, το έτερο παράθυρο δεν αλλάζει.  Μπορείς να βρεις ένα
αρχείο σε κάθε παράθυρο ανεξάρτητα από τα άλλα.

Ιδού άλλος ένα τρόπος για να χρησιμοποιείς δύο παράθυρα που δείχνουν
διαφορετικά πράγματα:

>> Πληκτρολόγησε C-x 4 C-f και δώσε όνομα αρχείου στην σχετική
   προτροπή που εμφανίζεται στο κάτω μέρος της οθόνης.  Επικύρωσε την
   επιλογή σου με το <Return>.  Δες πως το επιλεγμένο αρχείο
   εμφανίζεται στο κάτω παράθυρο.  Ο δείκτης πάει κι αυτός εκεί.

>> Πληκτρολόγησε C-x o για να επιστρέψεις στο πάνω παράθυρο και μετά
   C-x 1 για να κλείσεις το κάτω παράθυρο.


* ΠΟΛΛΑΠΛΑ ΠΛΑΙΣΙΑ
------------------

Το Emacs μπορεί επίσης να δημιουργήσει πολλά «πλαίσια».  Πλαίσιο
ονομάζουμε αυτό που περιέχει ένα ή περισσότερα παράθυρα, μαζί με τα
μενού, μπάρες κύλισης, τόπο αντήχησης, κτλ.  Σε γραφικές προβολές,
αυτό που το Emacs αποκαλεί «πλαίσιο» είναι το ίδιο που άλλες εφαρμογές
ονομάζουν «παράθυρο».  Πολλά γραφικά πλαίσια μπορούν να εμφανίζονται
στην οθόνη ταυτόχρονα.  Σε ακροδέκτη κειμένου, μόνο ένα πλαίσιο μπορεί
να παρουσιάζεται κάθε φορά.

>> Πληκτρολόγησε C-x 5 2.
   Δες ένα νέο πλαίσιο που εμφανίστηκε στην οθόνη.

Μπορείς να κάνεις όσα έκανες στο αρχικό πλαίσιο και στο νέο πλαίσιο.
Δεν υπάρχει τίποτα το ειδικό για το ένα ή το άλλο.

>> Πληκτρολόγησε C-x 5 0.
   Αυτό αφαιρεί το επιλεγμένο πλαίσιο.

Μπορείς πάντοτε να αφαιρέσεις ένα πλαίσιο με τον κοινό τρόπο που
προσφέρει το σύστημα γραφικών (συνήθως πατάς με το ποντίκι πάνω σε ένα
εικονίδιο «X» σε ένα από τα πάνω άκρα του πλαισίου).  Αν αφαιρέσεις το
τελευταίο πλαίσιο της λειτουργίας του Emacs κατά αυτόν τον τρόπο, τότε
κλείνει το Emacs.


* ΕΠΙΠΕΔΑ ΑΝΑΔΡΟΜΙΚΗΣ ΕΠΕΞΕΡΓΑΣΙΑΣ
----------------------------------

Κάποιες φορές θα βρεθείς σε αυτό που ονομάζουμε «επίπεδο αναδρομικής
επεξεργασίας».  Αυτό επισημαίνεται από αγκύλες στην γραμμή κατάστασης
που περιβάλλουν τις παρενθέσεις γύρω από την αξιωματική λειτουργία.
Για παράδειγμα, ίσως δεις [(Fundamental)] αντί για (Fundamental).

Για να βγεις από επίπεδο αναδρομικής επεξεργασίας, πληκτρολόγησε <ESC>
<ESC> <ESC>.  Αυτή είναι η γενική εντολή εξόδου.  Μπορείς να την
χρησιμοποιήσεις για να κλείσεις όλα τα έτερα παράθυρα και για να βγεις
από τον μικροενταμιευτή.

>> Πληκτρολόγησε M-x για να μπεις στον μικροενταμιευτή· κατόπιν πάτα
   <ESC> <ESC> <ESC> για να εξέλθεις.

Δεν μπορείς να χρησιμοποιήσεις C-g για να βγεις από επίπεδο
αναδρομικής επεξεργασίας.  Αυτό είναι έτσι γιατί το C-g ακυρώνει
εντολές ή τις παραμέτρους αυτών ΕΝΤΟΣ του τρέχοντος επιπέδου
αναδρομικής επεξεργασίας.


* ΠΕΡΙΣΣΟΤΕΡΗ ΒΟΗΘΕΙΑ
---------------------

Σε αυτό τον οδηγό προσπαθήσαμε να προσφέρουμε βασικές γνώσεις για να
αρχίσεις να χρησιμοποιείς το Emacs.  Υπάρχουν τόσα πολλά στο Emacs που
θα ήταν αδύνατο να τα εξηγήσουμε όλα εδώ.  Ωστόσο, μάλλον θα θέλεις να
μάθεις περισσότερα για τις διάφορες δυνατότητες που παρέχει το Emacs.
Προς αυτόν τον σκοπό, το Emacs προσφέρει εντολές για την εξεύρεση κι
ανάγνωση οδηγιών.  Αυτές οι εντολές «βοήθειας» (help) όλες αρχίζουν με
τον χαρακτήρα CONTROL-h, που αποκαλείται «ο χαρακτήρας βοηθείας».

Για να χρησιμοποιήσεις τις υπηρεσίες βοηθείας, πληκτρολόγησε C-h, και
μετά ένα χαρακτήρα που ανταποκρίνεται στο είδος της βοήθειας που
επιζητείς.  Αν είσαι σε ΠΡΑΓΜΑΤΙΚΑ δύσκολη θέση, πάτα C-h ? και το
Emacs θα σου πει τι είδη βοηθείας υπάρχουν.  Αν έχεις ήδη πατήσει C-h
και αποφάσισες πως δεν θέλεις καμία βοήθεια, απλά ακύρωσε το με C-g.

(Αν το C-h δεν προβάλει μήνυμα για βοήθεια στο κάτω μέρος της οθόνης,
δοκίμασε το πλήκτρο F1, αλλιώς M-x help <Return>.)

Η πιο βασική βοήθεια προσφέρεται από το C-h c.  Πληκτρολόγησε C-h,
ύστερα το c, και μετά τον χαρακτήρα ή αλληλουχία χαρακτήρων
οποιασδήποτε εντολής: το Emacs θα εμφανίσει μια σύντομη περιγραφή της
εντολής.

>> Πληκτρολόγησε C-h c C-p

Το μήνυμα θα είναι κάπως έτσι:

	C-p εκτελεί την εντολή previous-line

Αυτό σου λέει το «όνομα της συνάρτησης».  Καθώς οι συναρτήσεις έχουν
ονόματα που φανερώνουν την λειτουργία τους, μπορούν να ερμηνευθούν κι
ως πολύ σύντομες περιγραφές--επαρκείς για να σου υπενθυμίσουν κάτι που
ήδη έχεις μάθει.

Εντολές με πολλούς χαρακτήρες, όπως C-x C-s ή <ESC>v (αντί του M-v για
όσους δεν έχουν πλήκτρο META ή ALT) μπορούν κι αυτές να δοθούν μετά το
C-h c.

Για περισσότερες πληροφορίες αναφορικά με μια εντολή, χρησιμοποίησε το
C-h k αντί του C-h c.

>> Πληκτρολόγησε C-h k C-p.

Αυτό δείχνει την πλήρη καταγραφή της συνάρτησης, καθώς και το όνομα
της, σε νέο παράθυρο του Emacs.  Όταν το διαβάσεις, πάτα C-x 1 για να
κλείσεις εκείνο το παράθυρο.  Δεν χρειάζεται να το κάνεις αυτό αμέσως.
Ίσως θες πρώτα να επεξεργαστείς κάτι καθώς αναφέρεσαι στο κείμενο
βοηθείας και μετά να πληκτρολογήσεις C-x 1.

Ιδού άλλες χρήσιμες επιλογές με το C-h:

   C-h x	Περιέγραψε μια εντολή.  Ζητά το όνομα της εντολής.

>> Προσπάθησε C-h x previous-line <Return>.
   Δείχνει όλες τις πληροφορίες που έχει το Emacs σχετικά με την
   συνάρτηση που δίνει την εντολή C-p.

Παρόμοια εντολή είναι αυτή του C-h v που δείχνει την καταγραφή μιας
μεταβλητής, συμπεριλαμβανομένων αυτών που μπορείς να τροποποιήσεις για
να αλλάξεις την συμπεριφορά του Emacs.  Πρέπει να γράψεις το όνομα της
μεταβλητής στην σχετική προτροπή.

   C-h a        Συναφή εντολών (command apropos).  Γράψε μια
                λέξη-κλειδί και το Emacs θα παραθέσει όλες τις εντολές
                των οποίων το όνομα περιέχει αυτήν την λέξη.  Όλες
                αυτές οι εντολές μπορούν να κληθούν με το META-x.  Για
                ορισμένες εντολές, τα συναφή εντολών περιέχουν και την
                σχετική αλληλουχία χαρακτήρων που εκτελεί την εντολή.

>> Πληκτρολόγησε C-h a file <Return>.

Αυτό παραθέτει σε έτερο παράθυρο όλες τις εντολές M-x που περιέχουν
τον όρο «file» στο όνομα τους.  Θα δεις εντολές χαρακτήρος μεταξύ των
επονομαζομένων (όπως C-x C-f πέριξ του find-file).

>> Πληκτρολόγησε C-M-v για να κυλήσεις το παράθυρο βοηθείας.  Κάνε το
   μερικές φορές.

>> Πληκτρολόγησε C-x 1 για να κλείσεις το παράθυρο βοηθείας.

   C-h i        Διάβασε τα εγχειρίδια (Info manuals).  Αυτή η εντολή
                σε βάζει σε ειδικό ενταμιευτή που ονομάζεται «*info*»
                όπου μπορείς να διαβάσεις εγχειρίδια για τις
                συσκευασίες που είναι εγκατεστημένες στο σύστημα σου.
                Πληκτρολόγησε m emacs <Return> για να διαβάσεις το
                εγχειρίδιο του Emacs.  Αν δεν έχεις χρησιμοποιήσει το
                Info ποτέ, πληκτρολόγησε h και το Emacs θα σου δείξει
                τις σχετικές λειτουργίες.  Αφού ολοκληρώσεις αυτή την
                εκμάθηση, να αναφέρεσε στο εγχειρίδιο του Emacs ως την
                κύρια πηγή όλων των καταγραφών.


* ΑΛΛΕΣ ΛΕΙΤΟΥΡΓΙΕΣ
-------------------

Μπορείς να μάθεις περισσότερα για το Emacs διαβάζοντας το εγχειρίδιο
του, είτε ως έντυπο βιβλίο, είτε εντός του Emacs (χρησιμοποίησε τον
κατάλογο βοηθείας ή πληκτρολόγησε C-h r).  Δύο λειτουργίες που ίσως να
σου φανούν χρήσιμες είναι η «ολοκλήρωση», που εξοικονομεί στην
δακτυλογράφηση, και το Dired, που απλοποιεί την διαχείριση αρχείων.

Η ολοκλήρωση είναι τρόπος αποφυγής αχρείαστης πληκτρολόγησης.  Για
παράδειγμα, αν θες να μεταβείς στον ενταμιευτή *Messages*,
πληκτρολογείς C-x b *M<Tab> και το Emacs θα συμπληρώσει το υπόλοιπο
του ονόματος ως εκεί που μπορεί να κρίνει αντιστοιχία με αυτό που
έχεις ήδη γράψει.  Η ολοκλήρωση δουλεύει επίσης για ονόματα εντολών κι
αρχείων.  Στο εγχειρίδιο καταγράφεται στην ενότητα «Completion».

Το Dired σου επιτρέπει να παραθέτεις κατάλογο αρχείων (και προαιρετικά
υποκαταλόγους), να επιλέγεις, επισκέπτεσαι, μετονομάζεις, διαγράφεις,
ή γενικά να επιδράς πάνω σε αρχεία.  Το Dired καταγράφεται στο
εγχειρίδιο στην ενότητα «Dired».

Το εγχειρίδιο καταγράφει πολλές άλλες λειτουργίες του Emacs.


* ΕΓΚΑΤΑΣΤΑΣΗ ΣΥΣΚΕΥΑΣΙΩΝ
-------------------------

Υπάρχει πλούσιος όγκος συσκευασιών (packages) του Emacs που έχουν
παρασκευαστεί από την κοινότητα των χρηστών του, που επεκτείνουν τις
δυνατότητες του Emacs.  Αυτές οι συσκευασίες περιλαμβάνουν υποστήριξη
για νέες γλώσσες, πρόσθετα θέματα χρωμάτων, προεκτάσεις για εξωτερικές
εφαρμογές, και άλλα πολλά.

Για παράθεση των διαθέσιμων συσκευασιών, πληκτρολόγησε M-x
list-packages.  Στη σχετική λίστα, μπορείς να εγκαταστήσεις ή
απεγκαταστήσεις συσκευασίες, καθώς και να διαβάσεις τις περιγραφές
τους.  Για περισσότερες πληροφορίες περί διαχείρισης συσκευασιών, δες
το εγχειρίδιο του Emacs.


* ΚΑΤΑΛΗΚΤΙΚΑ
-------------

Για έξοδο από το Emacs, χρησιμοποίησε C-x C-c.

Αυτή η εκμάθηση γράφτηκε για να είναι κατανοητή σε όλους τους νέους
χρήστες.  Αν λοιπόν κάτι παραμένει ασαφές, μην κάτσεις εκεί να
κατηγορείς τον εαυτό σου - πες μας για το πρόβλημα σου!


* ΑΝΤΙΓΡΑΦΗ
-----------

Αυτό το κείμενο εκμάθησης είναι συνέχεια μιας μακράς γραμμής κειμένων
εκμάθησης του Emacs, αρχής γενομένης αυτού του Stuart Cracraft για το
αρχικό Emacs.

Αυτή η έκδοση της εκμάθησης είναι μέρος του GNU Emacs.  Έχει
πνευματικά δικαιώματα και δίνεται με την άδεια διανομής αντιγράφων υπό
κάποιους όρους.

  Πνευματικά Δικαιώματα (C) 1985, 1996, 1998, 2001-2022 Free Software
  Foundation, Inc.

  Αυτό το αρχείο είναι μέρος του GNU Emacs.

  Το GNU Emacs είναι ελεύθερο λογισμικό: μπορείτε να το αναδιανέμετε
  ή/και να το τροποποιήσετε σύμφωνα με τους όρους της GNU Γενική
  Δημόσια Άδεια (GNU General Public License) όπως δημοσιεύθηκε από το
  Ίδρυμα Ελεύθερου Λογισμικού (Free Software Foundation), είτε την
  έκδοση 3 της άδειας, είτε (κατά την επιλογή σας) οποιαδήποτε
  μεταγενέστερη έκδοση.

  Το GNU Emacs διανέμεται με την ελπίδα πως θα είναι χρήσιμο, αλλά
  ΧΩΡΙΣ ΚΑΜΙΑ ΕΓΓΥΗΣΗ· χωρίς καν την συνεπαγόμενη εγγύηση της
  ΕΜΠΟΡΕΥΣΙΜΟΤΗΤΑΣ ή ΚΑΤΑΛΛΗΛΟΤΗΤΑΣ ΓΙΑ ΣΥΓΚΕΚΡΙΜΕΝΟ ΣΚΟΠΟ. Δείτε την
  GNU Γενική Δημόσια Άδεια (GNU General Public License) για
  περισσότερες λεπτομέρειες.

  Οφείλατε να λάβετε αντίγραφο της GNU Γενικής Δημόσιας Άδειας (GNU
  General Public License) μαζί με το GNU Emacs.  Εάν όχι, δείτε
  <https://www.gnu.org/licenses/>.

Παρακαλώ όπως διαβάσετε το αρχείο COPYING και δώσετε αντίγραφα του GNU
Emacs στους φίλους σας.  Βοηθήστε στην καταπολέμηση του περιορισμού
(«ιδιοκτησία») του λογισμικού δια της χρήσης, γραφής, και κοινοποίησης
ελεύθερου λογισμικού!

Last week’s Red Meat Friday was essentially anodyne so here’s something to get (certain) people’s juices flowing:

real software is written in #vim, #nano, or #emacs. if you still use an ide (especially for interpreter languages), go back to high school.

— walid (@walidabualafia) April 28, 2022

Don’t worry IDE users, next week we’ll have another point of view that will annoy all the folks who are laughing now.