Getting started in a principled way

The good starting point is to uderstand what a text is and get familar with the two classic text editors – vi and emacs.

A text has “many structures”, layers and nesting – it consists of sequences of sequences – sequences of paragraphs, sequeunces of sentenses, sequences of words and special charactes, including punctuation, and sequences of ordinary characters (which denotes letters and numbers).

The key insight is that one navigates a text following its nested structure, not (and never!) just by pressing the arrow keys on a keyboard, which is silly, tedious, slow and lame. Programing languages (the source code) have even richer and deeper nested structures.

It has thus a regular structure, which means a hierarchy of nested linear sequences (all sequences are ordered – they have some particular implicit ordering of elements), thus the Regular Expressions has been generalized out of it.

From the regular and nested nature of a text other methodology has been emerged - markup languages, both for structuring the text (XML) and for creating structured documents (Org, markup, etc).

The vi editor (and its modern implemetations, such as Neovim) are especially designed to take advantage of the deeply nested structure of “markups” and “sources”, with the basic regular expressions in mind, so it feels familiar, intuitive and even “natural” just after few days of use.

Emacs, on the other hand, has the most powerful programming technique – the ability to create new and use existing Domain-Specific Languages (for an appropriate level of abstraction), embedded in the Emacs-Lisp, which is the language in which all the high-level functionality of Emacs has been programmed. (Please, completely ignore the previous sentence for now).

And then here comes:

• LaTeX: A Document Preparation System, 2rd edition.

as an ultimate declarative document structuring. Well, not so fast.

Lets take a few little baby steps first. Lets get ourselves familiar with Emacs and vi. They are free, well-known, multi-platform and open-source.

The main principle to always keep in mind (and to observe everywhere) is that a nested, hierarchical strucure is the most fundamental characteristic of almost everything in the world, from Molecular Biology of cells, up to all the spoken human languages, which just “mimic” this universal fact.

So, there are 3 modern classics books from the 90s:

• Learning The vi Editor, 6th edition.
• Learning GNU Emacs, 3rd edition.
• Mastering Regular Expressions, 3rd edition.

which teach the right understanding and the proper concepts.

There are nice summaries of cheat-sheets:

• https://www.gnu.org/software/emacs/refcards/pdf/refcard.pdf
• https://vim.rtorr.com/
• https://devhints.io/vim

For using these as toolkits or toolboxes there are differnt books:

• Modern Vim: Craft Your Development Environment with Vim, etc.
• Mastering Emacs, 4th edition.

Notice that Neovim and Emacs are both programs (layered and “modularized”) and programming environments, so getting familiar with and used to them is a good practice, similar to these of “marial artists”.

Everything is available on the internet as a “pirated content”. Learning how to find and download everything (including understanding the risks) is the crucial skill for larning anything.

There is also some high quality free content from inspired people and a literally sea of low-effort bullshit, which degens mostly copying (parroting) from each other.

The blog posts and youtube videos are plentiful and sometimes even fun. Develop a habit of extracting the principles and generalized knowledge from everything you watch or read.

This is the first steps to real hacking (which is understanding of how everything “works” and why, including the social dynamics and all the social “constructs”).

Just watching what other people managed to do with their copies of Emacs or Neovim is both inspiring, encouraging and satisfying, meaning that you can do it too.

The most important rule: never just copy-paste configurations (or code) without understanding. Always try to come up with a minimal config or a set of functions based on other people’s stuff. Always re-write yourself.

And suddenly you are so submerged in all this stuff of learning, understanding, configuration and customization, that you don’t have time for anything else, at least no time for bullshit.

Last, but not least, you should use the latest stable versions (releases) of your editors, preferably after a major bugfix release, such as, lets sat. 0.9.2 or 29.2. At least it shoud math the version which the examples or configs use.

This will save you from of frustration and stress caused by unexpected errors and compatibility mismatrches. Very few people use the development versions, but major crowds migrate to releases.

It pays off to wait till the most entusiastic and eager power users will switch to a new major release, encounter the bugs, scream and write angry blog posts and even bugreports, so the major bugs will be fixed in a next minor version.

All this is just common, recurrent social dynamics anong developers and users. Learn and develop a habit to observe and understand “hows” and “whys” in what is going on is societies and social niches.

Do not use ready-made configurations, like Doom Emacs or some “branded” Neovim configs from GitHub before you understand the principles and most of the details of how they work, including your personal experience of configuring.

Some day you might find something like

• An Introduction To Programming In Emacs Lisp, 3rd edition.
• Writing GNU Emacs Extensions, 1st edition.

and your whole life will be changed forever. Ok, just kidding.

emacs -q

(self-insert-command 1 'a)

nvim --clean

  <number><command><'text object' | motion>