In this article, we’ll explore some of the fundamental concepts in Emacs Lisp that often confuse newcomers.

Variables: Global vs Local Scope

Elisp provides several ways to define variables, each with different scoping behaviors.

setq: Global Variables

The setq function is used to define and set global variables:

(setq my-variable "Hello, world!")

These variables are accessible from anywhere in your Emacs session once defined. They’re ideal for configuration settings or values that need to persist.

let and let*: Local Variables

For variables with limited scope, Elisp provides let and let*:

;; Using let for local binding
(let ((x 5)
      (y 10))
  (message "Sum: %d" (+ x y)))

;; x and y are not accessible here

The difference between let and let* is significant:

• let evaluates all variable expressions before binding
• let* evaluates in sequence, allowing later variables to reference earlier ones

;; This won't work with let
(let ((x 5)
      (y (+ x 2)))  ; Error: x is not yet bound when this is evaluated
  (message "y: %d" y))

;; This works with let*
(let* ((x 5)
       (y (+ x 2)))  ; Works because x is already bound
  (message "y: %d" y))  ; Output: "y: 7"

Understanding Quote (')

One of the most distinctive features of Lisp is the quote character ('). It prevents evaluation of an expression, instead treating it as data.

Quoting Variables

When you place a quote in front of a symbol:

'my-symbol

You’re telling Elisp, “Don’t evaluate this symbol, just give me the symbol itself.” This is similar to references in other programming languages.

Without the quote, Elisp would try to look up the value of the variable my-symbol.

List Syntax: '(...) vs (list ...) and (cons ...)

Lists are fundamental data structures in Lisp. There are several ways to create them:

;; These are equivalent:
'(a b c)
(list 'a 'b 'c)

;; These are also equivalent:
'(a . b)
(cons 'a 'b)

The quoted form '(...) is concise but has a limitation: everything inside is automatically quoted. This means you can’t mix evaluated and non-evaluated expressions.

When to use each:

• Use '(...) for literal lists that don’t need evaluation
• Use (list ...) when you need to mix literals and evaluated expressions:

(setq name "John")
(list 'person name 'age 30)  ; => (person "John" age 30)

Understanding Cons Cells: CAR and CDR

At the heart of Lisp’s data structures is the “cons cell” - a simple pair of values. Each cons cell has two parts, traditionally accessed with the functions car and cdr (pronounced “could-er”):

(setq my-pair (cons 'a 'b))

(car my-pair)  ; => a
(cdr my-pair)  ; => b

These peculiarly named functions are historical artifacts from the original Lisp implementation on IBM machines:

• car: Contents of the Address part of Register
• cdr: Contents of the Decrement part of Register

In modern terms, think of them as:

• car: head (first element)
• cdr: tail (rest of the list)

Lists in Lisp are actually chains of cons cells that always terminate with nil:

;; This list:
'(1 2 3)

;; Is actually structured as:
(cons 1 (cons 2 (cons 3 nil)))

Visualized as pairs:

(1 . (2 . (3 . nil)))

This implicit nil at the end is crucial - it’s what defines a “proper list” in Lisp. Without this nil termination, you would have a different data structure. The presence of this nil terminator is what allows functions like length to work properly and what lets Lisp know where a list ends.

You can extract elements from lists using these functions:

(setq numbers '(1 2 3 4))
(car numbers)       ; => 1
(cdr numbers)       ; => (2 3 4)
(car (cdr numbers)) ; => 2

Elisp provides convenient shorthand functions like cadr (car of cdr) for common combinations:

(cadr numbers)      ; => 2 (same as (car (cdr numbers)))
(caddr numbers)     ; => 3 (car of cdr of cdr)

The Dot Syntax in Pairs

In Emacs Lisp, you might encounter constructs with dot notation like:

(add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-mode))

This dot notation represents a “cons cell” or pair. In this example, we’re creating a pair where the car is "\\.md\\'" and the cdr is markdown-mode.

The following expressions are equivalent:

'("\\.md\\'" . markdown-mode)
(cons "\\.md\\'" 'markdown-mode)

The dot creates a direct pair between two values. This syntax is commonly used in alists (like auto-mode-alist), mode hooks, and other paired data structures in Emacs.

When you see a dot in the middle of a list, it means “the rest of this list is the cdr of this cons cell” rather than continuing the list structure with an implicit nil at the end.

To understand the difference clearly:

;; A list with two elements (has an implicit nil at the end)
'(1 2)  ; => equivalent to (cons 1 (cons 2 nil))

;; A single cons cell (a pair) - NOT a proper list
'(1 . 2)  ; => equivalent to (cons 1 2)

The difference is significant:

(length '(1 2))     ; => 2
(length '(1 . 2))   ; => Error: Wrong type argument: listp, (1 . 2)

This distinction is fundamental to understanding how Lisp data structures work.

Function Quoting: #' vs '

In Elisp, you’ll see both 'function-name and #'function-name when referring to functions. The difference is important:

• 'function-name simply quotes the symbol
• #'function-name is shorthand for (function function-name), which specifically tells Elisp that the symbol represents a function

When should you use #'? Best practice is to use it whenever you’re referring to a function as a function, especially with higher-order functions:

;; Good practice
(mapcar #'1+ '(1 2 3))  ; => (2 3 4)

;; Works but less explicit
(mapcar '1+ '(1 2 3))

Using #' helps the byte-compiler optimize your code and makes your intent clearer to other programmers.

Association Lists (alists)

Association lists (alists) are lists of key-value pairs used for simple lookups:

(setq my-alist '((name . "John")
                 (age . 30)
                 (city . "Boston")))

You can access values using functions like assoc:

(cdr (assoc 'age my-alist))  ; => 30

Alists are frequently used in Emacs for configuration options, especially when the list is relatively small and frequently modified. They’re simple but not as efficient for large datasets.

Property Lists (plists)

Property lists are another key-value structure in Elisp, but with a different syntax:

(setq my-plist '(:name "John" :age 30 :city "Boston"))

Notice how the keys are prefixed with colons. These are called keywords, similar to Ruby’s symbols. You can access values using plist-get:

(plist-get my-plist :age)  ; => 30

Other languages with similar concepts include:

• Ruby with its symbols (:symbol)
• Clojure with keywords (:keyword)
• Elixir with atoms (:atom)

Plists are often used for function arguments that have default values or are optional.

Summary

Understanding these fundamental Emacs Lisp concepts will help you:

1. Write more effective Elisp code
2. Understand existing Emacs configurations
3. Create your own Emacs extensions

Emacs Lisp’s power comes from its simplicity and consistency. Once you grasp these basic concepts, you’ll find that the language follows logical patterns that make learning advanced features much easier.

Happy hacking!

Emacs comes with an excellent built-in tutorial that can be accessed with C-h t (Control-h followed by t). I highly recommend all new users complete this tutorial to get comfortable with Emacs’ fundamentals. That said, the tutorial is comprehensive and takes time to complete.

This guide serves as a TL;DR and quick reference of the most essential hotkeys you should memorize. Consider it a short recap of what’s worth knowing by heart to be immediately productive in Emacs, whether you’re new to the editor or just need a refresher.

Understanding Emacs Notation

Before diving into the hotkeys themselves, let’s decode how to read Emacs key notation:

• C- represents the Control key. For example, C-a means “hold Control and press a”.
• M- represents the Meta key, which on modern keyboards is typically the Alt key. So M-f means “hold Alt and press f”.
• C-x followed by another key represents a two-key sequence. Press Control and x together, release, then press the next key.
• M-x similarly starts a command sequence where you type the command name after pressing Alt and x.

Multiple modifier keys can be combined. For example, C-M-f means holding both Control and Alt while pressing f.

With this foundation, let’s explore the essential hotkeys that will dramatically improve your Emacs efficiency.

Essential Emacs Hotkeys by Category

Text Navigation

Efficient text navigation is the foundation of productive editing. These shortcuts let you move through your document with precision:

The navigation keys follow a pattern: f for forward, b for backward, p for previous, and n for next. Once you internalize these patterns, they become second nature.

Text Editing

These shortcuts handle the core editing operations that you’ll use hundreds of times daily:

A unique aspect of Emacs is its “kill ring” - a clipboard system that remembers multiple deleted items. After using C-y to paste the most recent item, you can press M-y repeatedly to cycle through previously killed text.

Region and Selection

Working with selections in Emacs involves understanding the concept of the “mark” and “point”:

The mark is where a selection begins, and the point is your cursor position. Together they define the “region” - Emacs’ term for a selection.

File Operations

These commands handle file management tasks:

The C-x C-f command is particularly powerful as it allows you to create new files by entering paths that don’t exist yet.

Buffer Management

In Emacs, a buffer is essentially an open file or space for editing:

Efficient buffer navigation is crucial when working with multiple files.

Window Management

Emacs allows for sophisticated window layouts:

The ability to split the editor into multiple windows, each showing different buffers, is one of Emacs’ most powerful features.

Search and Replace

Finding and replacing text efficiently is essential for editing:

Emacs’ incremental search updates as you type, making it quick to locate specific text.

Help System

When you inevitably need guidance, Emacs has built-in help:

The self-documenting nature of Emacs means help is always just a few keystrokes away.

Macros

Macros are powerful tools for automating repetitive tasks:

To use macros: press F3, perform the sequence of actions you want to repeat, press F4 to finish recording, then press F4 again each time you want to replay those exact keystrokes. This is incredibly useful for mass operations on text.

Command Execution

Finally, the gateway to thousands of Emacs commands:

This shortcut unlocks Emacs’ full potential, giving you access to any command by name.

Building Your Muscle Memory

Learning these hotkeys will take time, but the productivity payoff is immense. Start by mastering the navigation and basic editing commands, then gradually incorporate the others. Consider printing this list and keeping it near your workspace until the keystrokes become automatic.

Remember that Emacs is highly customizable - once you’re comfortable with these basics, you can create your own keybindings for commands you use frequently.

Conclusion

The beauty of Emacs lies in how it becomes an extension of your thinking process once you’ve internalized these commands. Text manipulation becomes effortless, allowing you to focus on your actual work rather than the mechanics of editing.

While this guide covers the essential hotkeys, it barely scratches the surface of what Emacs can do. As you grow more comfortable with these basics, explore specialized modes for your particular work, whether that’s programming in specific languages, writing prose, managing projects, or organizing your life.

What began as a seemingly steep learning curve will transform into a powerful skillset that follows you throughout your computing life. Happy editing!

Additionally i was looking a little into the programming language rust.

The rust package manager cargo feels well designed. Also the language solves quite common issues in programming which makes classic inheritance unnecessary. The tutorial is easy to read and understand but in advanced topics you can see that things still change. The verbose annotation of object lifetime of references was reduced in recent releases and things that should not compile now finally do without issues. The basic data types quite bring everything you need out of the box, except some language features like drain_filter, quite similar to std::remove_if, are only available as unstable features. Therefore I would not recommend using the language in production, but i can already see its potential in the future. Memory related problems are reduced to ownership problems. It must be clear who is allowed to borrow a variable (keeping a reference) for later writing or read only operations. You can not have two writable references, nor have references that outlive the instance. This might cause a lot of confusion and iterations of code if you try to write code in your usual style. The ownership problem looks even worse when trying to communicate between threads. When a thread stops can be decided at runtime, either it is joined or it could be detached and even outlive the main thread. Therefore the classic thread’s lifetime is considered 'static. Solutions, for having threads with a defined lifetime existed: like std:🧵:scoped, but it had unforseen issues, related to accessing freed memory. To solve the issue, the library crossbeam provides a different approach to threads with a clearly defined lifetime. Still sharing objects as readable between threads is a challenge. One solution to the object being shared across threads could be by using std::sync::Arc<std::sync::Mutex<Foo>>. An Arc is for atomically accessing things from different threads, while the mutex is required to clearly define who is writing the memory. Otherwise for TcpStreams the handles can simply be cloned (see try_clone) without being in need of using a mutex object.

After reading this article you sure feel the complexity of that quite new programming language rust. But even if the language might not be ready for production, I recommend having at least a first look through the entire tutorial or even to learn it. The concepts might be different, but if you do you will be prepared for the future that is likely to come.

The original images which will be preprocessed and passed to a convolutional neural network are scanned A4 letters with a resolution of about 2550x3500 pixels at 300dpi.

At first some letters will be manually converted into text for labeling, which is required for the training process. A self written tool is used to assign a position to each character in the transcription. This process can be seen in the screenshot above. The tool was written with OpenCV and allows a preview of the next two words, highlights the current letter which is to be labeled and shows some bounding box with hints for the later cropping process. (If you want the source just write me some message but i also plan to release the project after some results)

After each letter has some assigned position, the image still needs to be preprocessed/enhanced as the color of the font is quite close to the background color. This step can be done automatically in the future. For each labeled character a 32x32px sub image will be cropped and additionally for each of those images small pixel translations, scaling and sinus wave transformations will be applied to generate a lot more training data for the learning process.

For the CNN i planned to use Tensorflow as it has been proven to be quite flexible for this task.

I will present the network configuration and further results in the next blog posts :)

Current letter counts after labeling two letters:

     16 ,
      2 !
     24 .
      2 0
      4 1
      3 2
      1 3
      2 4
      1 9
     71 a
      3 ä
     22 b
     54 c
     33 d
    162 e
     17 f
     26 g
     76 h
     81 i
      5 j
     13 k
     41 l
     22 m
    100 n
     26 o
      2 ö
      5 p
     65 r
     48 s
      4 ß
     57 t
     22 u
      4 ü
      1 Ü
      7 v
     31 w
     13 z

You can follow the project on the blog, github or via rss with the following urls:

• Blog: https://harpoon.0x17.de/blog/
• RSS: https://harpoon.0x17.de/blog/index.xml
• GitHub Harpoon: https://github.com/HarpoonOrg/Harpoon
• GitHub HarpoonClient: https://github.com/HarpoonOrg/HarpoonClient

Have fun reading! :)

Here are some screenshots of the current state:

Those screenshots need a little description, so here you go:

Harpoon consists of a server program and three different clients: Web/Desktop/Mobile.

In the first screenshot you can see the browser interface (topleft), whereas in the second screenshot you can see the desktop client.

The project is still work in progress as some essential parts are missing. Those are showing the backlog, user login and yet server configuration. In the next few updates those topics will be adressed and i will keep you up to date.

If you have questions you can find me on IRC. Just click the following link: freenode.net channel #harpoon.

Follow me on twitter, watch the project on github, read my RSS or join #harpoon on freenode.net to receieve status updates. :)