I am curious how many of you are using native compilation.

Native compilation has been out for some years, and the performance boost from it for old machines is night and day, e.g. my old macbook.

However, with the beefy hardware of the new machines, e.g. M1 mac, the effect of native compilation becomes indistinguishable. On my Linux desktop, which was built in 2019, I have been using native compilation since the beginning, but I just freshly compiled from source without native compilation and found no obvious performance difference at all.

And on my new macbook with M1Pro, the performance is similar, and no obvious power consumption difference.

Without performance differences, the only thing native compilation brings is the large usage in disk space, although in today's standard, the disk space used by native compilation is far from being significant.

I am curious how many people are using native compilation right now. What machine you are on and why?

Version 0.7 of detached.el (formerly known as dtache)

Hello everyone :)

I wanted to notify the community that there is a new release of my package dtache, which now also has been renamed to detached.el, or detached. For those previously not familiar with the package, the short description is "An Emacs package to launch, and manage, detached processes". It can be used to dispatch shell commands to an external program dtach, which allows processes to outlive Emacs.

The new release is version 0.7, and here is a list of improvements and change that has been made:

• The development of the package has been moved to sourcehut at https://git.sr.ht/~niklaseklund/detached.el

• The configuration of the package has been drastically improved, now users simply need to call (dtache-init) to integrate with all supported packages. Of course the integration is lazy-loaded

• The completion of sessions are now dynamic. Both the width of the command as well as the annotations adapts dynamically

• There is an integration with dired's dired-do-shell-command

There has also been improvements to the user experience of the package, credits should go to user https://gitlab.com/rosetail

• The package now features an option to show a session's output when attaching to it. This feature can be enabled through detached-show-output-on-attach. As of now this seems like a better alternative then detached tail command which users previously had to resort to gain similar functionality. The upside is that the attach functions in detached is more performant.

• The packages detached-env script now features a mode, which can either be plain-text or terminal-data. The former is basically what detached have offered till now, the latter allows a session to store raw terminal data so that session output could contain colored data for example. If a specific command is misbehaving with the terminal-data option it can be added to detached-env-plain-text-commands to force it to use plain-text.

The package, under its new name, is available at ELPA and MELPA. A patch with the update has been provided to Guix, but has not yet merged.

My own Transient example

After asking some questions and reading docs and getting some help, I have my own example of how to build a Transient. I honestly like this a lot better for this kind of work than Hydra; Hydra is fantastic, but this saves me a lot of duplicate work that I was doing with defining keymaps to assemble the right combination of arguments to pass to build functions. My usage of lisp is what I'd consider fairly simple. I'm just trying to build a command line to feed to compile.

;; -*- lexical-binding: t; -*-
;; Functions for building unreal on PROJ using dir-locals
(defconst +proj-target-list+ '("Development" "Debug" "Release"))
(defconst +proj-executable-list+ '("UnrealHeadertool" "ProjEditor" "ProjGame"))
(defconst +proj-platform-list+ '("Win64"))
(defconst +uproject-path+ "Proj/Proj.uproject")
(defconst +batch-builder+ "Engine/Build/BatchFiles/Build.bat")
(defconst +genproj-bat+ "GenerateProjectFiles.bat")

(defun nop ()
  (interactive)
  )

;; For future queue work, args can be stuffed into a list and executed later.
(transient-define-suffix proj-transient-build-unreal (args)
  "Build Unreal"
  :description "Build using current overrides"
  (interactive (list (transient-args transient-current-command)))
  (when-let ((build-path (getvar base-path)))
	(let* ((exe (transient-arg-value "--exe=" args))
		   (target (transient-arg-value "--target=" args))
		   (platform (transient-arg-value "--platform=" args))
		   (debug (s-present? (transient-arg-value "--debug" args)))
		   (command (concat build-path +batch-builder+ " " exe " " platform " " target)))
	  (setq args (cl-remove "--exe=" args :test #'s-contains?))
	  (setq args (cl-remove "--target=" args :test #'s-contains?))
	  (setq args (cl-remove "--platform=" args :test #'s-contains?))

	  (when (s-contains? "Editor" exe)
		(setq command (concat command " \"" build-path +uproject-path+ "\"")))
	  (setq command (concat command " " (mapconcat #'identity args " ")))
	  (if debug
		  (message command)
		(compile command)))))

(transient-define-suffix proj-transient-genproj (args)
  "Generate projects"
  :description "Generate the project files"
  (interactive (list (transient-args transient-current-command)))
  (setq args (cl-remove "--exe=" args :test #'s-contains?))
  (setq args (cl-remove "--target=" args :test #'s-contains?))
  (setq args (cl-remove "--platform=" args :test #'s-contains?))
  (when-let ((build-path (getvar base-path)))
	(if (s-present? (transient-arg-value "--debug" args))
		(message (concat build-path +genproj-bat+ " " (mapconcat #'identity args " ")))
	  (compile (concat build-path +genproj-bat+ " " (mapconcat #'identity args " "))))))

;; Define a transient to set all the arguments.
(transient-define-prefix proj-transient-build ()
  "A transient to construct build strings and execute them."
  ["Build Configuration"
   ["Current Project Environment"
	("P" proj-set-project-override)
	("//" nop :description (lambda () (format "Base Dir: \"%s\"" (getvar base-path))) :transient t)
	("--" nop :description (lambda () (format "UProject Path: \"%s\"" +uproject-path+)) :transient t)
	("@@" nop :description (lambda () (format "Batch Builder: \"%s\"" +batch-builder+)) :transient t)
	("++" nop :description (lambda () (format "Genproj bat: \"%s\"" +genproj-bat+)) :transient t)
	("%%" nop :description (lambda () (format "Search Instance: \"%s\"" (getvar helm-locate-instance))) :transient t)]

   ["Build args"
	("-p" "Show Progress" "-progress")
	("-N" "No Hot Reload" "-NoHotreloadfromide")
	("-D" "Preview Build" "--debug")]
   ["Targets"
	("e" "Set Executable" "--exe=" :always-read t :choices ,+proj-executable-list+)
	("t" "Set Target" "--target=" :always-read t :choices ,+proj-target-list+) 
	("p" "Set Platform" "--platform=" :always-read t :choices ,+proj-platform-list+)]]
  ["Execute Commands"
   ("g" "Generate Projects" proj-transient-genproj)
   ("B" "Build Project" proj-transient-build-unreal)])

Some notes:

• getvar is a macro I've written that returns the value of a variable that may or may not be set in a dir-locals.el file, and may furthermore be overridden. I need it because I often have to work in multiple different projects, but I'm still only compiling ONE SPECIFIC project, no matter what base directory I happen to be in.

• nop is there so I can have entries that are purely informative. If you type out the keys corresponding to the option, it just exits and does nothing. It's a hack, since Transient doesn't like entries that are only descriptions. Still, it works just fine.

• Unless you really need to for some other reason, try to work within these transient arguments. That is, unless you're trying to set a lisp variable for some other specific purpose, don't do what I did and write infixes that set lisp variables that you later access to do the compilation. It works just fine, but it's honestly more cumbersome and takes up more space. If your use case is like mine here--actually building a command to execute--the full-on Transient way ends up being cleaner.

https://github.com/ErnestKz/KeyWork

This post ended up being half-announcement and half-story. :p

I am quite obsessed with key-press efficiency and having as friction-less of a human-computer interface as possible (flow states become magical).

This package is aimed at being able to specify arbitrary keymap modes along with arbitrary key sequence setups from scratch as concisely as possible.

My reasons for a modal, key sequence, oriented bindings DSL:

• Reduce wrist and hand strain from the vigorous key-chording I used to do.

• Have major/minor mode specific bindings closer to the home row, for speed and ease.

• Be able to rapidly iterate over my keyboard config to see what feels good.

• Reduce the friction of me trying to specialise the bindings of a new major/mode.

I initially was using xah-fly-keys, which was nice as it felt quite efficient, though I began theory-crafting even more ways of making efficient interfaces and got very creative, and wanted a way to express it, xah-fly-keys was a not very suitable to build off of, as it had baked in the "command-mode" modal mechanism. Though my visions were of arbitrary amount of modes, and modes that merge together based on the environment.

I started writing this the summer of 2021, and was finding it difficult and complex to parse the symbols of the language, but then I encountered monadic parsers, which made it much easier. Towards the end of the summer I got it to a personally usable state, and was using throughout the subsequent college term to great effect.

The actual implementation of mode switching is only 60 lines in total (including whitespace and comments), it's done by having a single minor mode map "KeyWork", and just replacing the minor mode map that's held within the KeyWork-map symbol with the one you want activated. The rest of the code is parsing and expanding the macros.

The main modes that I ended up creating and using in KeyWork the most were:

• A command mode (code, (my F8 keys is bound to CapsLock)), where all the keys close to the home row are responsible for moving around text, cutting, yanking, marking, inserting comments, undoing, etc. And the space key is a leader key for various key sequences. This command mode is heavy influenced by the command mode of xah-fly-keys.

• A scroll mode (code), which is activated from the command mode with "d", and I mostly used for smoothly scrolling the buffer either rapidly, or slowly, with (j,k), and (u,i).

• An insert mode (code), for inserting text.

• An org programming mode (code), which is activated from the command mode with "s". I used this mode when programming python within emacs-jupyter . I setup the mode to be able to navigate between org source blocks, expand/collapse them, execute them, move them up or down, create new source blocks, hide/show results, and some more, and almost all of these commands using the high value home-row and surrounding keys without needing to press leader keys or chords.

During the year I was switching between the web-based colab (for group projects and gpu usage) and my specialised org setup, I noticed when I eventually would come back to org, the process of experimenting bits of code in isolated source blocks (quite a core part of workflow) was much smoother and I would do it more often (due to the reduced friction of not needing to stretch my hands to move mouse or press key chords) and faster (efficient keys placement, creating blocks, cutting, pasting, executing, deleting blocks with minimum keystrokes)

So finally, now, that I've finished college, I found myself today making this package presentable. In the readme I've added an excerpt of my config with comments indicating the key syntax of the DSL.

I'm not sure how this will be received, but figured I'll share the story, and have an emacs package to go with it. I hope you enjoyed, and find the package interesting. :)

Until now I have written most of my Org and Markdown files with auto-fill-mode, never exceeding more than 80 characters per column. However, I've increasingly noticed many counterexamples, where each paragraph was a single long line of text. Some platforms like GitHub seem to encourage this practice, as newlines in comments are treated as newlines in the rendered page, contrary to vanilla Markdown.

There seem to be some advantages to this approach. For example, writing prose with mixed-pitch-mode makes a lot more sense if lines are arbitrarily long, and I find it a lot more pleasant. But if I'm sharing a document with someone else, I wonder if generally they'd be annoyed at receiving a document without wrapping that requires them to enable visual-fill-column-mode and visual-line-mode, disable hl-line-mode, etc. I know I was at first before I discovered how to make the experience feel like I was using auto-fill-mode instead.

I'm interested to hear r/emacs 's thoughts on this!

Write research paper notes/summaries in emacs

I am a beginner in Emacs and I was wondering if there is a way to write research paper summaries with the PDF of the paper open on the side and text (preferably markdown) summary on the other side with references to lines/locations in paper. I currently use Mendeley for general text highlighting and in-line notes but I am looking for adding summaries and reference lines in the Mendeley annotated PDF in Emacs.

When I narrow a file down to a region containing a single function, the line numbers restart at one, and I would like to be able to make references based on the actual line number in the file.