emacs (Editing MACroS)

# interactive and non-interactive

ESC x is for using an emacs command by only its name, because a command is an interactive function: it prompts for its needed values. (Command: ESC x execute-extended-command.)

ESC : is for any function, even commands, therefore encapsulate the function name and the listed values it needs within a pair of parentheses. For example, when inserting text. (Command: ESC x eval-expression.)

When a parenthesized expression is available within the text, place the point somewhere after its final parenthesis and use Controlx Controle to evaluate it. (Command: ESC x eval-last-sexp.)

# general OS commands

ESC ! is for an operating system command without having to use ESC x shell. The shell commands for the default shell are also available. Use the Controlu prefix to insert the results of the OS command, t.i. Controlu ESC !, f.e. when inserting text. (Command: ESC x shell-command.)

ESC & is for an operating system command as a background process so as to continue using emacs for something else while that gets done in the background. The shell commands for the default shell are also available. (Command: ESC x async-shell-command.)

For example, turn off Airport on macOS (from macOS commands).

ESC ! networksetup -setairportpower en0 off

For general file manipulation with operating system commands, consider using dired with its similar keybindings of either ! or &.

# customization

ESC x customize reveals the customization table of contents. ESC x customize-variable asks for the name of a variable (with tab completion, of course). ESC x customize-face asks for the name of a face to customize. ESC x customize-group asks for the name of a group of settings.

ESC x customize-unsaved for showing all settings changed for this session only rather than saved for future sessions.


Discover the face at point with ESC x describe-face.

Customize a face with the command ESC x customize-face, and the face at point will be the suggested face. For the default face, choose the default face. For the face used to indicate when text has been selected, choose the region face.

The first face listed as inherited has priority over later faces in that list. An unmarked feature allows inheritance. Specifically setting a marked feature as "off" will prevent the feature from affecting that text from a lesser priority face with that marked feature specifically set as "on".

A box with a negative width thickens the top and bottom borders towards its inside, while the left and right sides thicken outward as usual. That maintains line height.

The overline margin variable is two pixels by default, which is one pixel for the overline thickness and a 1 pixel gap above the text. Zero for the overline-margin maintains line height. The overline itself is the same as the top edge of the top border of a box.


The cursor foreground color is taken from the region's backgroud color, and the cursor's background color is taken from the region's foreground color. The cursor face allows customizing only the background color, and it is usually ignored when it's set the same as the region's foreground color.

The cursor-type is customized with ESC x customize-variable, which is in the display group. A horizontal bar specified with a height of zero is approximately equivalent to 4 pixels in height and automatically resizes itself when the text is resized with ControlxControl+ or ControlxControl-.

# search, then highlight or replace

Search interactively with Controls or in reverse with Controlr, or use regular-expression patterns with ESC Controls or ESC Controlr.

The "isearch" minor mode is active in the mode line when searching. There are many options listed within the help for that mode, available while searching with the shortcut for mode help Controlh m. While searching, list all keybindings with Controlh b.

Controlw adds the next word or character from the buffer. ESC Controly adds the next character from the buffer. ESC Controld removes the last character of search term. ESC s e for editing the search term directly.

ESC s c toggles case-sensitivity. ESC s ' toggles character folding, f.e. a, á, à, etc. ESC s SPACE toggles strict whitespace matching. ESC s r toggles regular-expression mode.

ESC s o evokes the occur command (same shortcut) with the search term. Type a number (f.e. Control1) before that for including that many lines from before and after a match with each match, or a negative number for only the lines before a match. Or, type Controlu before that and it will prompt for a replacement based on the regular expression search, which will be used only for displaying the "Occur" results and without modifying the original buffer. In other words, specify parenthesized matches from the regular expression or add additional text, then that will be the format of each match listed.

ESC s h r for highlighting the matches and exiting. ESC % for specifiying a replacement and begin getting asked for each match. Or ESC Control% for regular-expressions.

ESC s ESC < goes to the first match. ESC s ESC > goes to the last match.

ESC p switches to the previous search term. ESC n switches to the next search term.

For the current match, customize the isearch face. For other matches, customize the lazy-highlight face.

# highlighting

ESC s h p for highlighting a phrase. ESC s h r for highlighting with a regular-expression pattern. ESC s h u for unhighlighting a previous highlight. Prefix with Controlu to unhighlight all previous highlights.

Customize the highlighting faces in the hi-lock-faces group (with the command ESC x customize-group).

# replacement of matches

ESC % begins query for replacement without prior search. Or ESC Control% to use regular-expression patterns.

After specifying the replacement, it states in the minibuffer to type ? for help. There are three basic options while replacing matches: whether to replace; pausing, continuing, exiting; and remaining or moving to the previous or next match.

RET or q to exit. Period . to replace the current match and exit. ! replaces all remaining matches in the current buffer. For multi-buffer/file replacements, Y replaces all remaining matches in all remaining buffers/files.

SPACE or y replaces the current match and moves to the next. Comma , replaces match and stays there. DELETE or n skips to the next match. For multi-buffer/file replacements, N skips to the next buffer/file without replacing remaining matches in the current buffer.

Controlr is for pausing (recursive edit), and ESC Controlc continues. Controlw deletes match and pauses for recursive edit.

^ moves to previous match. u moves to previous match and reverts its replacement. U undoes all replacements.

E for editing the replacement string. Controll refreshes the screen and offers same replacement again.

Controlg exits the query-replace, as expected. According to the documentation, supposedly Controlx ESC ESC restarts an exited query-replace, because that is the key binding for repeat-complex-command. Recall a command that used the minibuffer is considered a complex command; therefore it provides a lisp form for the last complex command. However, it has yet to work with query-replace.

# elaborate description of emacs

Use emacs (from its website) for editing text, and when it is helpful occasionally record sequences of typing and commands as macros to repeat with a single press of a button. No computer programming necessary. Hence, "editing macros" means macros for use with editing text, and in emacs everything is text.

Everything can be done with the buttonboard in emacs. No need for repititiously lifting, clunking, and sliding a buttonbox with gymnastic precision. The buttonboard can remain sitting still, and most of its buttons are labeled. With repeatability there is no worry about repetitive stress, no need for ergonomics.

Remember: a computer is different than a typewriter. There is no need to keep hands positioned over the "home" buttons of asdf and jkl; at all times. Just relax, occasionally press a few buttons in whatever comfortable manner, and let the computer do the work.

# what?  how?  the command prompt

A single blank line known as the "minibuffer" is at the very bottom where short messages are revealed after evoking a command, or a prompt is shown waiting for an answer. This is how to know what has just happened, or what is needed in order for something to happen.

A command can be executed by typing the two characters ESC x, t.i. the ESC (escape) button and then the x button, and then typing the command's full name and the RET (return) button. The use of the ESC button causes these typed characters to be shown in the minibuffer while typing them, not in the document being edited. After typing RET the command will be executed.

Sometimes there will be a message about the results of the command evoked, depending on the command. For example, typing ESC x forward-paragraph RET will move the text cursor to the beginning of the next paragraph, and there will be no message about the result.

Tab completion is usually available whenever there is a prompt in the minibuffer, such as text followed by a colon ": ", when typing a command name or other values in the minibuffer. At such a prompt either type the TAB button, or type the beginning of something and then type the TAB button. Either the only possible value is filled in, or all possibilities are shown in a temporary view. Not much need to remember how to spell anything or whether it exists.

Type Controlg to give up and go back to editing text instead of finishing typing a command in the minibuffer.

# shortcuts

Sometimes a command name is bound to a shorter sequence of buttons (a "binding" or "shortcut"), which is a nickname of sorts. A shortcut is often one modifier button combined with one other character, or the ESC character followed by another character.

Modifier buttons tend to be at the bottom corners of the buttonboard, on either side of the space bar-button. The SHIFT button is a modifier button, and so is the CONTROL button, the ALT button, the OPTION button, the COMMAND button, and even the FN button. They all work in same way, so knowing how to use the SHIFT button means knowing how to use any modifier button, but of course each does a different modification. For example, Shifta inserts a capital "a", t.i. "A".

On the other hand, the ESC (escape) button, the TAB button, the SPACE (space) button, and the RET (return) button are regular buttons and therefore produce characters (though typically without symbols) just like the letter buttons, number buttons, and punctuation buttons.

A shortcut can also have multiple modifier buttons used with a character. Typically, shortcuts are kept simple and the complex ones are for rarely used commands. Of course, they can be personally customized if desired, and more than one shortcut for the same command is allowed.

The helpful shortcut Controlh w will reveal which shortcuts a command has by prompting for the command name in the minibuffer. For example, type Controlh w, then at the prompt type the command name forward-paragraph (or use tab completion) and then the RET (return) button. The minibuffer will reveal its shortcut, which is by default the two characters ESC }.

Similarly, Controlh f will also prompt for a command name to find, but it reveals the documentation for the command name which will also include the shortcuts for it. The documentation will be shown in a view rather than shown in the minibuffer.

Contrarily, the shortcut Controlh c will reveal the command name for a shortcut, if there is one. For example, type Controlh c and then at the prompt type the two-character shortcut ESC {. The command name for that shortcut will be immediately revealed as backward-paragraph in the minibuffer. Or, query about either Shifta or just a, and then the minibuffer will reveal the command self-insert-command.

Similarly, Controlh k will also prompt for a shortcut, but it reveals the command name and its documentation, and in a view rather than in the minibuffer.

Sometimes a modifer button and character is a prefix for a longer shortcut name, for example Controlx (a very common prefix for executing shortcuts). In that case, the minibuffer will show an abbreviated form of the characters typed (f.e. C-x- for Controlx) after a short pause, meaning it's waiting for more. There's no need to wait for the prompt when the complete shortcut is already known, and when typed fast enough it won't show in the minibuffer at all. Either finish typing the shortcut sequence to evoke the command, or type Controlh for help and then a listing of known shortcuts beginning with that prefix will be revealed in another view. On the other hand, using Controlg with a prefix will typically cancel it because the resulting shortcut is typically not defined.

# repeat commands without repeating commands

Commands can be repeated a specific number of times by using the CONTROL button with a number (or with just the first digit of the number) before evoking a command. For example, to move the text cursor forward three paragraphs type Control3 ESC x forward-paragraph RET.

Or, use repeatibility with its shortcut by typing Control1 Control2 ESC } to move the text cursor 12 paragraphs forward, or perhaps more conveniently with only Control1 2 ESC }.

Sometimes it makes sense to use a negative value with a command. Type a hyphen first to indicate a negative value, such as Control- 27 for -27. Also, using only Control- is a convenient equivalent to Control- 1.

Of course, this can be used with typing. For example, type Control8 0 - to produce 80 hyphens. Or, use it with the DEL (delete) button to remove a specific number of characters, forwards when with a positive value and backwards with a negative value. Or, use it to select text, such as a specific number of words or paragraphs, either forwards or backwards.

# type anything, start highlighting, select everything

The prefix Controlx 8 is for inserting any Unicode character. Just type Controlx 8 Controlh for a helpful list of all possibilities revealed in a new buffer (and likely in a new view).

The prefix ESC s h is for specially highlighting patterns of text, f.e. the same word or phrase throughout a document. As usual, following the prefix with Controlh will reveal the various possibilities. For example, ESC s h p will prompt for a phrase to highlight, and then color that text throughout the document. (Using ESC s h r asks for a "regular expression", which is a pattern for text.) The default is yellow the first time, and then a different color for each successive call for new phrases, but any color can be chosen.

Search with Controls or in reverse with Controlr. All matches will be highlighted, and can be traversed forwards or backwards by repeating those shortcuts. While searching, use the higlighting command ESC s h r to choose a color for the matches, which then ends the search. Or while searching, use the shortcut ESC % to specify a replacement and begin getting asked for each match.

Use CONTROL and the SPACE bar-button, t.i. ControlSPACE, to set the mark for selecting text. Then maneuver the text cursor as normal and the text will be selected. For example, use ESC } to move to the beginning of the next paragraph thereby selecting everything in between. Or, use ControlSPACE ControlSPACE (t.i. twice) to deactivate the mark, which cancels selecting text.

Similarly, using the SHIFT modifier button with the movement shortcuts will also select a region. For example, the tutorial reveals ESC e moves to the end of the sentence (or the next one if at the end already), so ESC Shifte would select to the end of the sentence. The content of the whole buffer can be selected with the simpler Controlx h, no matter where the cursor is currently located.

While selecting text, use search to extend the selected region. The selection will extend to the next or previous match, and each thereafter for each repeat of the search shortcut. End the search and then do whatever with the region, such as search/replace within it and only it.

Once a region is selected, then use Controlx n n to narrow the contents to only that selected region. In other words, everything else in the buffer is hidden. Select another region and narrow it again, if desired. Show everything once again by widening with Controlx n w. (Obviously, Controlx n is a shortcut prefix, so Controlx n Controlh will show help in another view with other shortcuts beginning with it.)

# documents

Editing a document is always on a copy of it from its file, and in emacs this is explicitly acknowledged by referring to the copy as a "buffer", a temporary place for editing.

Already existing documents can be viewed with the "directory edit" mode using the command ESC x dired RET (shortcut: Controlx d). The prompt in the minibuffer shows the name of the default directory (folder) that will be listed in the current view, otherwise type the name of the desired directory before typing RET.

When viewing a listing of files in dired mode, help for the mode can be shown with Controlh m (as that shortcut does for any mode). Note that many of dired's shortcuts are simply a single button or use the SHIFT modifier button, such as for copying (Shiftc), renaming (Shiftr), or toggle sorting the listing by name or date (s). Just move the text cursor to the name of the file and type RET to reveal its contents for editing.

Compress or uncompress a file in a dired listing with Shiftz (which also adds or removes ".gz" from end of name). If gnupg is installed with emacs (perhaps for use with email authentication), then a file in dired can be encrypted with : e (which also adds or removes ".gpg" from end of name).

No need to uncompress a file before editing it. In emacs, the uncompressed contents are shown for editing, and then automatically recompressed when saved again. Same thing for encrypted files (".gpg") (automatically asking for passphrase), or even encrypted compressed files (".gz.gpg", or the potentially smaller ".gpg.gz").
(But tricky: Will work when a document is saved with both extensions, in either order. However, compressing an encrypted file within dired results in viewing only encrypted data. To fix: Open file; use Controlx h to select contents of whole buffer; use ESC x epa-decrypt-region, and agree to replace text; then save document.)

A new document (file) can be initiated with Controlx Controlf and then typing a name for it in the prompt in the minibuffer. However, it will be only a buffer (a temporary place for editing), and the file will not actually exist until the buffer is saved.

Save the changes of a document done within a buffer to its associated file with Controlx Controls. Saving a buffer overwrites the document's file (if already existing), though a backup of the original is automatically made the first time (with same name plus "~"). Write a document to a new file name with Controlx Controlw. Add ".gz" to the name of the file to have it compressed when saved, or ".gpg" to have it encrypted when saved (assuming that has already been set up), or add both.

# buffers, views, and frames

A simple listing of all buffers is available with the command ESC x list-buffers (shortcut: Controlx Controlb). Or, use ESC x ibuffer for ibuffer mode with more features for sorting, filtering, marking, and general organizing of a long list of buffers. (Again, Controlh m shows help for the mode in a view.)

More than one view of the same document is possible, such as when desiring to view different parts of the document simultaneously instead of scrolling back and forth. Simply show the buffer listing in a view and choose the buffer with the same document already shown in another view. Or, use ESC x switch-to-buffer (shorcut: Controlx b) to switch to it by typing its name at the prompt in the minibuffer at the bottom (and with tab completion). In other words, it's possible to have more buffers than views, or more views than buffers.

It's worth keeping in mind emacs has tiled-view management rather than the typical overlapping-view management. (A view is sometimes referred to as a "window" in operating systems (OSes) like macOS or MS Windows, or other OSes might have a "window manager".) A tiled layout means all views are always visible from edge to edge, never obscuring each other, and no wasted space.

There's no need for micromanaging widths and heights of views (though it is possible). Simply use the whole screen for emacs and then split its height in half (new view below) with Controlx 2, or split its width in half (new view on right side) with Controlx 3, as many times as desired. Equally distribute the size of all the tiled views with Controlx +. The computer does the computing.

Close (kill) the buffer/document in the current view with Controlx k RET and then the next most recent buffer is shown in the same view, keeping the layout the same. Collapse a view to nothing (without closing the document) to give its space to a nearby view with Controlx 0 (zero), and the document remains available in the list of buffers. Or do both: collapse the view and close the document shown within it at the same time with Controlx 4 0 (zero), for less clutter.

For example, imagine the whole screen is one view showing the contents of a document. After splitting the width of that view in half with Controlx 3, the right half shows the same content as the left half, and the left half retains the focus. Scroll a few pages down in the left half and the right half will stay still, it retains the original position. Split the width of the left view in half and there will be a new right half. Both are one-quarter of the screen width because they began as the left half of the screen. So, three views of the same document: two views are one-quarter of the screen width, one view is one half of the screen width. Now equally distribute the three views with Controlx + and the width of each will become one-third of the screen width: left, middle, right. The left still has the focus, so now close that one with Controlx 0: its area is merged with the middle, and now has the focus. That means there are now two views: the left view is two-thirds of the screen width, and the right side is one-third of the screen width.

Of course, a document can be edited at any time in any of its views, they are all functional. That can make it easier to copy/cut from one section of a document and then past in another of its sections, while being able to see both places at once.

Switch the focus to the other view with Controlx o, either from top to bottom or from left to right. Or, switch to the other view in the other direction with Control- Controlx o. Or, switch the focus to any view with command repeatability, f.e. switch to the fifth next view with Control5 Controlx o.

Therefore there is nothing to move because views are always aligned edge to edge, and no listing of views because they are all visible. Instead, peruse a listing of buffers/documents, or a dired listing ("directory edit" mode). Just choose what buffer/document is shown in a view, split a view in half for viewing the same buffer/document or for showing another one, and collapse any view no longer needed in order to give space to everything else.

With that said, it is worth knowing that all views are together within a frame, and it is also possible to have more frames. For example, using emacs with the whole screen means all the views are in a frame that is the size of the whole screen. Creating another frame the size of the whole screen would obscure the other frame. However, in this way it would be possible to have multiple layouts of views because each frame would have its own set of views showing whichever buffers/documents have been chosen for them.

Multiple frames within emacs is akin to the "virtual desktops" implemented with over-lapping views of most every window manager of most any operating system (OS). With emacs, this is without the novel addition of an unchangeable default directory listing (a.k.a. the desktop) that becomes inaccessible beneath overlapping views. Instead, in emacs any directory is listed with dired (directory edit) in any view of any width/height, fullscreen or otherwise. No artificial limits, no obscuring, no imposing novelty.

# getting to know emacs

Mac OS X is notorious for having an ancient version of emacs, and macOS is no different. Best to find and install the latest emacs on macOS instead. (Or, some other operating system, such as GuixSD. (Or preferably an operatable system, but then that would be like emacs anyway.))

Starting emacs will show a message saying to start the tutorial with C-h t, which means to use the CONTROL button to type Controlh and then type t. (Recall from the shortcuts description that the CONTROL button is used like the SHIFT button.)

After completion of the tutorial, it is worthwhile reading manual sections 30, 17, 13, and 44 sooner rather than later, t.i. rather than starting with section 1. As revealed with help on help (with Controlh Controlh), the emacs manual can be referenced at any time desired with Controlh r by means of Info mode.

The latest emacs manual is also available at its website.

When reading anything in Info mode the node name for a page can be seen at its top. A name in parentheses indicates the manual name, and after the parentheses is a section name. The node name for a page can be instantly copied with c regardless of where the cursor is located, and then the name is also temporarily shown in the minibuffer. The manual name in parentheses is needed only when changing manuals.

Use g to go to a node by name, then the minibuffer at the bottom will prompt with "Go to node: ". The buttonboard shortcut ESC ( (for ESC x insert-parentheses) inserts a pair of parentheses and places the text cursor in between them. Tab completion for typing manual page names is possible, as expected.

For example, Controlh i evokes Info mode with a listing of all available manuals. Type g and then the minibuffer at the bottom will show the prompt "Go to node: ", then type (ses) to switch to the "Simple Emacs Spreadsheet" manual. Or, type (emacs)Rmail Basics to switch to a page within the rmail section in the emacs manual. Or, type (emacs)Rmail TAB to use tab completion to reveal in another view a listing of emacs manual page names beginning with "Rmail".

# SPOILER to the emacs manual

Note that section 17 is about the "editing macros", which is the namesake of emacs. It is the basic premise of ancient science fiction about computers: at the touch of a button a computer does whatever is desired, no computer programming necessary.

In short, F3 starts memorizing every button pressed until F4 is typed to end recording the macro. Then each time F4 is typed, whatever sequence was memorized is performed again. Note that commands are typed, shortcuts are typed, text is typed, and so on. Therefore, any series of actions ever done in emacs can be memorized by the computer as a list of instructions, and then it can be repeated at the press of a button.

Select a document in dired, open it, search for a specific location in the text, insert a copy of some text, save and close the document: repeat. Anything that becomes repetitive can be recorded and repeated. There can even be moments when a macro queries whether to continue, which also allows for doing something different at any time within the middle of a macro, as many times as helpful. To emphasize again: no programming necessary at all.

Of course, a macro can be repeated a specific number of times, too. For example, type Control4 2 for 42, and then type F4: the prior memorized sequence is performed that number of times.

With emacs, the computer does the work. Just show it how. No computer engineer needed, no code needed.

# email is text

Reading email in emacs is quick and simple with rmail, t.i. ESC x rmail. The key factor is installing mailutils for accessing IMAP email accounts. Consider using this alternate rmail.el library for checking email from multiple email accounts.

Sending email works simply. Configuring requires setting at least two variables: send-mail-function, message-send-mail-function. Consider using this alternate smtpmail.el library for sending email from multiple email accounts, and also obviating a slew of other variables.

# three-trailer semi-trucks (rant)

The diesel engine of a semi-truck is said to be "powerful", and no doubt that is what helps with towing three trailers. However, emacs has a self-documenting foundation from which has emerged its own blueprints rather than becoming obscurely powerful, and is immediately extensible rather than rich with unmodifiable features.

Nonetheless, there are three anti-extensible trailer loads that have been incorporated into emacs, and are aggresively promoted to software developers of new additions for emacs, though they are still optional.

Contextual menus accessible only with a buttonbox, inaccessible by buttonboard.

The huge amounts of extra LISP for contextual menus must be carefully avoided (or completely removed) whenever personalizing the mode line, the option menu bar, or other places buttonbox-only menus have been inserted. Menus in general also promote the use of a buttonbox, which allows arbitrary selection and is inherently anti-macro.

Personally created menus are an expresion of extensibility, but pre-decided menus are simply a list of decisions made by someone else. Imitating other programs that have menus just for the sake of it ignores the spirit of personally customizing emacs, as that is the action of extending (for marketing) rather than the state of being extensible (by the person editing).

Instead, share an approach for people to use when a menu is desired. Perhaps provide a small menu as an example, but make sure it is visible rather than hidden, and make sure it is accessible with the buttonboard (of labeled buttons) rather than an unlabeled optional buttonbox.

Customize, a system of preferences decided by computer programmers.

The sort-of-optional Customize system does successfully list and categorize a lot (almost "most") of the personalizable options. However, that also means it fails to list only the options that has been changed by the person, and absolutely fails to have those options categorizable by the person editing, both of which automatically and naturally emerge when a person edits the init file instead of using Customize.

The init document is for personal preferences decided upon by the person ediiting with emacs, and within that file the value of a personalized variable can be shared with other declared variables. However, the Customize system can only save the value of a variable, and notably is incapable of using a personalized variable amongst any "custom" variables. For example, a personalized variable with the value of a color will be obliterated by Customize when used as the values of any Customize variables within the init file.

The interface for the Customize system also enforces datatypes for the "good intention" of preventing a person from being wrong, and therefore impedes referencing personalized variables. Unfortunately, the Customize system saves its use of incompatible variables within the same init file, and it discourages editing those values within the file because the Customize system would be unable to scream at the person for doing it wrong.

In other words, the Customize system makes emacs less customizable and less friendly, and gives the impression people should avoid using the init file for personalizing emacs. Extensibility is impeded when basic abilities like making personalized variables are ignored or broken, or personalizing beyond what was imagined by computer programmers is discouraged.

Better to share approaches, intent, and revise the documentation rather than promote ignorance and reduce options with the Customize system. (Well, unless emacs has truly become so fragile that a person editing with it should avoid personally extending emacs; in that case, best to rewrite emacs from scratch.)

Package management, for installing and removing additional commands or modes obtained from other people.

The recently introduced (with good intentions!) package management system encourages blindly accepting code without understanding what it does by installing it for immediate use rather than for immediate review. In essence, that is the same approach promoted by the developers of web browsers and their ask-no-questions execution of any JavaScript, which has led to them also accusing the person using their programs as trying to hide.

In other words, the package management system promotes the decades-old faulty computer-medium approach of blind trust and mass ignorance for the sake of immediate gratification (with carte blanche use of the computer resources of that person) rather than supporting personal responsibility and self-development.

No computer program should be so complicated that it requires a program to install it, but these packages are apparently that complicated even though they are just additional features for emacs rather than full programs. There is no freedom with such an ignorance-first approach, instead it must be think-first.

Rather than package management, there should be a distribution of shared approaches. In essence, little or no code, but instead documented intent with perhaps some working examples. Such documentation and promotion of free thought is the spirit of emacs, rather than the pre-packaged obscurity shared as programs too bloated to modify or understand (even by the authors). There is neither extensibility nor software freedom possible (in the real world!) when overwhelmed into a state of ignorance, let alone is it readily spoken about (other than "don't think, just do it") by the everyday person in casual conversation.