GNU Software

For sanity checking, it's helpful to have access to older versions of Emacs. We can download and verify a version like this:

#aria2c https://ftp.gnu.org/gnu/gnu-keyring.gpg -d /tmp/
#gpg --import /tmp/gnu-keyring.gpg
VERSION=24.2
aria2c https://ftp.gnu.org/gnu/emacs/emacs-${VERSION}.tar.xz.sig -d /tmp/
gpg --verify /tmp/emacs-${VERSION}.tar.xz.sig
aria2c https://ftp.gnu.org/gnu/emacs/emacs-${VERSION}.tar.xz -d /tmp/
tar -xf emacs-${VERSION}.tar.xz

First, clone the repo:

git clone https://git.savannah.gnu.org/git/emacs.git /tmp/emacs

Once the source is in hand, I strongly recommend making a separate build directory and calling the configure script from there.

mkdir /tmp/emacs-build && cd /tmp/emacs-build
../emacs/configure --with-mailutils --with-imagemagick --with-x-toolkit=athena --without-pop --without-sound --with-json --enable-link-time-optimization --with-native-compilation --with-modules
NATIVE_FULL_AOT=1 make -j8
# test the build with './src/emacs' (location of output binary)
# install emacs binaries on current system
make install

The configure script takes a bunch of different flags that customize the build, and generate a build-specific Makefile.

The next line compiles the source. Install with make install and you're done! A custom Emacs binary with all the fixings has just been installed for your current user. :)

Here are some of the other configuration flags worth investigating:

• –without-all
• –with-x-toolkit=no
• –without-x
• –without-dbus –without-gconf –without-gsettings

• Emacs General Variables
  • probably want to set load-path

• textmodes/remember.el

Hyperbole, as a data presentation tool, always struck me as being very powerful, but it seemed to require a lot of "front-end" work before that data was really available. The problem with BBDB, or keeping up a Bibl-mode file, is that you have to use different functions to record the data, and it always takes time to stop what you're doing, format the data in the manner expected by that particular data interface, and then resume your work.

With "remember", you just hit `M-x remember' (you'd probably want to bind this to an easily accessible keystroke, like C-x M-r), slam in your text however you like, and then hit C-c C-c. It will file the data away for later retrieval, and possibly indexing.

Indexing is to data what "studying" is in the real world. What you do when you study (or lucubrate, for some of us) is to realize certain relationships implicit in the data, so that you can make use of those relationships. Expressing that a certain quote you remembered was a religious quote, and that you want the ability to pull up all quotes of a religious nature, is what studying does. This is a more labor intensive task than the original remembering of the data, and it's typical in real life to set aside a special period of time for doing this work.

"Remember" works in the same way. When you enter data, either by typing it into a buffer, or using the contents of the selected region, it will store that data – unindexed, uninterpreted – in a data pool. It will also try to remember as much context information as possible (any text properties that were set, where you copied it from, when, how, etc). Later, you can walk through your accumulated set of data (both organized, and unorganized) and easily begin moving things around, and making annotations that will express the full meaning of that data, as far as you know it.

Obviously this latter stage is more user-interface intensive, and it would be nice if "remember" could do it as elegantly as possible, rather than requiring a billion keystrokes to reorganize your hierarchy. Well, as the future arrives, hopefully experience and user feedback will help to make this as intuitive a tool as possible.

the Emacs Web Wowser, a browser written in elisp based on shr.el.

eww() {
 emacsclient -a '' -t -e '(eww-browse-url "'"$1"'")'
}

Emacs Unified Directory Client

Eglot is the Emacs client for the “Language Server Protocol” (LSP). The name "Eglot" is an acronym that stands for "Emacs polyGLOT". (1) Eglot provides infrastructure and a set of commands for enriching the source code editing capabilities of Emacs via LSP. LSP is a standardized communications protocol between source code editors (such as Emacs) and language servers–programs external to Emacs which analyze the source code on behalf of Emacs. The protocol allows Emacs to receive various source code services from the server, such as description and location of function calls, types of variables, class definitions, syntactic errors, etc. This way, Emacs doesn't need to implement the language-specific parsing and analysis capabilities in its own code, but is still capable of providing sophisticated editing features that rely on such capabilities, such as automatic code completion, go-to definition of function/class, documentation of symbol at-point, refactoring, on-the-fly diagnostics, and more.

Eglot itself is completely language-agnostic, but it can support any programming language for which there is a language server and an Emacs major mode.

• eglot-server-programs
  • alist of (major-mode . server)
• eglot#Advanced server configuration

• Featues

  • At-point documentation: when point is near a symbol or an identifier, information about the identifier's significance in the program (its function or method signature, its type, its custom documentation string, etc.) is made available via the ElDoc package (*note (emacs)Programming Language Doc::).

  • On-the-fly diagnostic annotations, via the Flymake package (*note (Flymake)Top::). Eglot's Flymake backend replaces other Flymake backends while it is managing a buffer, and enhances diagnostics with interactive server-suggested fixes (so-called “code actions”, *note Eglot Commands::).

  • Finding definitions and uses of identifiers, via Xref (*note (emacs)Xref::). Eglot provides a backend for the Xref capabilities which uses the language server's understanding of the program source. In particular, it eliminates the need to generate tags tables (*note (emacs)Tags tables::) for languages which are only supported by the ‘etags’ backend.

  • Buffer navigation by name of function, class, method, etc., via Imenu (*note (emacs)Imenu::). Eglot provides its own variant of ‘imenu-create-index-function’, which generates the index for the buffer based on the language server's program source analysis.

  • Enhanced completion of symbol at point by the ‘completion-at-point’ command (*note (emacs)Symbol Completion::). This uses the language server's parser data for the completion candidates.

  • Server-suggested code refactorings. The ElDoc package is also leveraged to retrieve so-called “code actions” nearby point. When such suggestions are available they are annotated with a special indication and can be easily invoked by the user with the ‘eglot-code-action’ command (*note Eglot Commands::).

  • On-the-fly succinct informative annotations, so-called “inlay hints”. Eglot adds special intangible text nearby certain identifiers, be it the type of a variable, or the name of a formal parameter in a function call. *Note Eglot Commands::, and the ‘eglot-inlay-hints-mode’ minor mode.

  • Enhanced source code fontification via LSP “semantic tokens”. Eglot can leverage the language server's understanding of the role and meaning of identifiers in the code to provide more accurate syntax highlighting. *Note Eglot Commands::, and the ‘eglot-semantic-tokens-mode’ minor mode.

  • Display of function call and type hierarchies via the ‘eglot-show-call-hierarchy’ and ‘eglot-show-type-hierarchy’ commands (*note Eglot Commands::).

  • Code reformatting via the ‘eglot-format’ and related commands (*note Eglot Commands::). Automatic reformatting of source code is also supported and is activated automatically as you type.

  • Eglot enhances symbol completion front-ends by providing completion candidates based on the language server's understanding of the source code (*note (emacs)Symbol Completion::). The Company package, installable from GNU ELPA, is a popular package known to work well with Eglot.

  • If YASnippet, a popular third-party package for automatic insertion of code templates (snippets), is installed, and the language server supports snippet completion candidates, Eglot arranges for the completion package to instantiate these snippets using YASnippet. (YASnippet can be installed from GNU ELPA.)

  • When the server provides at-point documentation formatted as Markdown in addition to plain text, Eglot arranges for the ElDoc package to enrich this text with fontifications, hyperlinks and other nice formatting before displaying it to the user. This makes the documentation shown by ElDoc look nicer on display.

  • In addition to enabling and enhancing other features and packages, Eglot also provides a number of user commands based on the capabilities of language servers. Examples include renaming symbols with ‘eglot-rename’ and asking to automatically correct problems with ‘eglot-code-actions’. *Note Eglot Commands::.

• eglot is optimistic by default - to opt out of features use eglot-ignored-server-capabilities and eglot-managed-mode-hook
• autostart: (add-hook 'foo-mode-hook 'eglot-ensure)
  • on first connection: eglot-connect-hook
• some multiserver scenarios not supported by Eglot's architecture, better off building a LSP server multiplexer (hint hint)
  • joaotavora/rassumfrassum
• extension documentation recommends just read the source
  • uses generics
  • example included: eglot#Extending Eglot : inactiveRegions clangd 17 feature
  • see also eglot#JSONRPC objects in Elisp
• performance opts: eglot-events-buffer-config

24
3
'/

8

fsolve(x*2+x=4,x)

x = 1.33333333333

fsolve([x + y = a, x - y = b],[x,y])

[x = a + (b - a) / 2, y = (a - b) / 2]

• see also Wordsmithing in Emacs - Mastering Emacs

Simple Emacs Spreadsheet

GNU Radio Companion

• GUI tool for creating signal flowgraphs