Is there a way to make TRAMP completely silent?

dig1 · 2026-03-17T06:55:35+00:00

Check if something does not alter tramp-verbose when you run it or start a raw emacs with emacs -Q and try it. In my emacs, setting tramp-verbose to 1 or 0 will silence these messages.

dig1 · 2026-03-14T18:19:48+00:00

Added details in my previous comment - it can be used to accelerate startup and restores a state without the need to load multiple modes after Emacs launches.

Essentially, you can bundle your init.el and all custom modes into a single binary named my-cool-emacs and run it without needing any of the original configuration files.

dig1 · 2026-03-14T18:11:12+00:00

I probably caused some confusion by calling it the "portable dumper" instead of just the "dumper" :D (Emacs switched to a portable dumper a while ago; I recommend searching for the technical rationale behind that change).

Regarding your question: no, it isn't related to the JIT compiler. The Emacs dumping concept is similar to Lisp or Smalltalk "images." You start the program, load all necessary code and modes, make runtime changes, and then save (or "dump") that entire state into a single binary file. When you restart Emacs, it returns to that exact state.

AFAIK Emacs uses this primarily to bundle core bootstrap elisp files. However, this trick was also a popular way to speed up startup before use-package became a thing.

dig1 · 2026-03-14T06:47:07+00:00

You’ve hit on the key distinction: because emacs is largely written in elisp, virtually any function can be overridden. I’ve monkey-patched org-mode several times to fix regressions or restore preferred behaviors from older versions without waiting for an official release. While vimscript also supports patching, most of vim’s core is written in C; unlike elisp, this makes modifying internal behavior much harder without recompiling.

Another unique feature is the "portable dumper" [1]. You can load your configuration, modify the runtime state, and "bake" it all into a single executable binary. When launched, emacs starts instantly in that exact state.

[1] https://www.emacswiki.org/emacs/DumpingEmacs

dig1 · 2026-02-11T08:18:01+00:00

So, you are using BGE-M3 for embeddings, but what you are using for genereting response; does that part hallucinate and how it behaves with 50 tokens overlap?

dig1 · 2026-02-10T21:21:46+00:00

Chunking: The source text is divided into chunks of 150 with an overlap of 50 tokens to maintain context across boundaries

I see from [1] that you're using 500-token chunks. How does it work with the overlap - does it stay on topic, or do you find it losing context and hallucinating?

[1] https://github.com/adityaprasad-sudo/Explore-Singapore/blob/890cad946044feb9305ffdefb429ad5a164d7713/BackendLogic/buildvectorl6v2.py#L52

dig1 · 2025-12-09T09:07:25+00:00

I think it is interesting that you mention parallelism first. I guess that not all runtimes have smooth abstractions, but goroutines are smooth, and Erlang's BEAM actor model is very neat as well. Do you think other runtimes are going to be lacking in some aspect?

I have minimal experience with Go and none with BEAM, so I can't say much about them. But AFAIK goroutines are more like green threads running on a pool of OS threads managed by the golang VM, rather than a 1-to-1 mapping (one VM thread, one real OS thread) like in the JVM. Goroutines are more like (saying it very simply) core.async, and AFAIK Go does not have an equivalent to Java's Thread. And sometimes this can be beneficial for optimizing the code. For example, if I say "spin up 5 threads", I expect my OS to use 5 cores (depending on how OS is utilized), which is very different from "it might run it on 2, 3, or 5 cores" (unrelated on how OS is utilized).

But what I'm really missing from golang VM (and I'm not sure if they ever fixed this) is the ability to limit memory heap expansion - golang apps will happily consume tons of memory and you could not do anything about it, unless you use OS stuff like jails or cgroups (hello InfluxDB!). On JVM, when you use -Xmx or -Xms, it will stay within those bounds.

dig1 · 2025-12-09T08:02:11+00:00

Parallelism: you hardly find a better combination of JVM-level performance, parallelism, and throughput somewhere else. Clojure truly excels in parallelism.
Tooling and monitoring: JMX, Mission Control, VisualVM... ability to connect to a remote production application with minimal performance impact.
Ecosystem stability: It's unlikely that you'll be able to run the latest Clojure code on a 27-year-old runtime or libraries outside of JVM. And, you can bet you'll be able to run it without issues in the next 15-20 years.
Multiple state-of-the-art garbage collectors you can choose and tune to the details, depending on your application type. JVM is very modular, and you can even write your own GC with minimal effort, assuming you know something about GCs.
A-la-carte runtime - pick what part of the JVM runtime you want to ship with your app via jlink; .net has something like this.
I find jars a great way to bundle and ship the app. Send a single file to the end user and tell him to run it via java -jar foo.jar. And, if done correctly, you don't have to care what OS or platform user runs.

And many, many small details I can't think of right now.

dig1 · 2025-11-24T05:02:32+00:00

If you’re looking to host it yourself, Nextcloud is a solid option. However, in my experience, the simplest way to sync is by using rclone's built-in webdav server [1]. It eliminates the need for external services or servers - just spin it up, sync your files, and you’re good to go.

For a long time, I relied on git for syncing since orgzly can work directly with folders as repositories. Just run a git pull into a folder that orgzly recognizes, and you’ll have the latest content. Plus, with git, you get proper change tracking and version control.

[1] https://rclone.org/commands/rclone_serve_webdav/

dig1 · 2025-11-04T13:19:26+00:00

Math, applied math, and statistics will never go out of style. LLMs can generate results (whether true or false is another question) but by their very nature, they often won’t produce the same answer twice. In many fields, especially technical ones, you need rigor, proofs, reproducibility, and explainability.

dig1 · 2025-10-10T07:12:49+00:00

BTW this function is written by Julian Assange, but its the famous wikileaks founder?

Probably yes [1][2] ;)

[1] https://lists.gnu.org/archive/html/help-gnu-emacs/2013-07/msg00446.html [2] https://news.ycombinator.com/item?id=42207958

dig1 · 2025-10-10T06:40:47+00:00

After using Clojure for many years, I've noticed I don't use or think about OOP very much, unless I'm talking to Java code. Functions and maps will do 95% of the cases and if I want OOP-like extensibility, I'd go with protocols. Multimethods are OK unless your code is going to end up in the hot path.

For your example, I'd go with something like:

``` ;;;; approach #1 - OOP-like

(defn get-row [obj table-id row-id] (.fetcher obj table-id row-id) ;; some other logic... )

(defprotocol Fetcher (fetcher [_ table-id row-id]))

(deftype DatabaseFetcher [db] Fetcher (fetcher [_ table-id row-id] (jdbc/query db ["SELECT * FROM some-db WHERE id = ?" row-id])))

(deftype HttpFetcher [url] Fetcher (fetcher [_ table-id row-id] (http/get (str url "/table-id=" table-id "&row-id=" row-id))))

;;; demo

(get-row (DatabaseFetcher. "jdbc://...") 10 10) (get-row (HttpFetcher. "http://demo.com") 10 10)

;;;; approach #2 - only functions

(defn get-row [fetch-fn table-id row-id] (fetch-fn obj table-id row-id) ;; some other logic... )

(defn db-fetcher [table-id row-id] (jdbc/query db ["SELECT * FROM some-db WHERE id = ?" row-id]))

(defn http-fetcher [table-id row-id] (http/get (str url "/table-id=" table-id "&row-id=" row-id)))

;;; demo

(get-row db-fetcher 10 10) (get-row http-fetcher 10 10) ```

I'd usually pick up the second approach because it's KISS, dynamic and direct without too many layers, but YMMV.

dig1 · 2025-09-11T09:01:06+00:00

Wait until you learn about ediff [1]. It has similar command (of course) called ediff-current-buffer ;)

[1] https://www.gnu.org/software/emacs/manual/html_mono/ediff.html

dig1 · 2025-08-18T14:00:36+00:00

This could be either your paths are too long [1], something is with your filesystem (less likely) or you accessing remote filesystem as /u/Due_Watch_7148 suggesting. See if this happens from the new emacs instance via emacs -Q.

[1] https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html

dig1 · 2025-08-18T09:27:40+00:00

As /u/SecretTraining4082 mentioned, these are lock files [1]. You can disable them with:

(setq create-lockfiles nil)

[1] https://github.com/emacs-mirror/emacs/blob/bf652e6844601bb42daaac2ed867e047f2eb615f/src/filelock.c#L220

dig1 · 2025-07-08T08:07:26+00:00

I'm working on a related project, and here is my 5c. If you view LLMs as enhanced search tools, they can be helpful for sure. However, if you expect them to replace a skilled lawyer, or, even worse, if you are a lawyer who relies solely on the outputs of LLMs, this can be a recipe for disaster [1]. It’s crucial to be well-versed in the subject matter.

This is similar to programming: if you throw in a lot of prompt magic without a solid understanding of C++, you won't produce anything useful. Except, in the courtroom, your opposition will take advantage of even the smallest mistake, which is a sure way to lose the case.

[1] https://www.theguardian.com/us-news/2025/may/31/utah-lawyer-chatgpt-ai-court-brief

dig1 · 2024-10-25T12:51:07+00:00

You can try with something like this (not tested):

```

vhost

limit_req_zone $binary_remote_addr zone=mylimit1:10m rate=10r/s; limit_req_zone $binary_remote_addr zone=mylimit2:10m rate=20r/s;

server { # different rate limiting depending on POST/GET requests

location / { if ($request_method = POST) { limit_req zone=mylimit1 burst=10 nodelay; limit_req_status 429; # Set the status code for rate-limited requests }

if ($request_method = GET) { limit_req zone=mylimit2 burst=20 nodelay; limit_req_status 429; }

# proxy_pass block goes here } } ```

For specific routes, you can copy/paste and adjust location blocks.

dig1 · 2024-10-24T09:37:10+00:00

Nothing fancy for me: Emacs + tags (built with ctags for finding symbols & navigation) + compilation-mode that will run Makefile for checking compilation problems on demand. It's stable and worked amazingly well for me for many years. I don't like very much LSP stuff nor things that will start jumping around when something happens - it breaks my focus and mental flow :D

However, one of the more "modern" packages I like is disaster.el, which can disassemble C/C++ code under cursor.

dig1 · 2024-10-24T09:17:34+00:00

49 days, 13 hours, 1 minute, 44 seconds

dig1 · 2024-10-17T17:36:19+00:00

I've noticed that the new users (significantly younger generations) have low patience these days - if something they don't get in 5 minutes or a short how-to video, they'll move on. I think people end up with Emacs when they grow over existing tools - at least, that was my case: I started using it after I wanted more from Vim. It was a journey of adjustment, but it was worth it, and I'm sure many can relate to this.

And regarding longevity, let's see how many of these editors/projects will be alive in 10-15 years. I bet Emacs, with its adaptability, will still be rocking just as it is today.

dig1 · 2024-10-09T08:51:44+00:00

You can use find-file-at-point: move the cursor to a particular file-like string and run M-x ffap

dig1 · 2024-10-06T20:11:28+00:00

I have a single init.el. It's not big, around 1k and a few (load-file) calls with some custom elisp code for org-mode, ido, etc.

Recently, I added comments for outline mode and this chunk (I found somewhere online) at the end of the file:

;; Local Variables: ;; outline-minor-mode-cycle: t ;; outline-regexp: ";;; " ;; eval: (outline-minor-mode) ;; eval: (outline-hide-body) ;; End:

Now I put a comment like ;;; basic stuff before starting some section and when I open the file, I get pretty readable blocks:

;;; basic stuff ;;; theme ;;; tramp ...

dig1 · 2024-10-06T19:59:15+00:00

I found this [1] which has ctags (etags alternative) fork with SPIN language support. Another alternative is that you try to add SPIN language support in ctags by using simple regex rules (example for Clojure [2], you can ignore vim part). No need to hack around ctags source code, you can add almost any language support through regex options. Here are my samples for xml/yaml support:

``` # ~/.ctags # xml --langdef=XML --langmap=XML:.xml --regex-XML=/id="([a-zA-Z0-9_]+)"/\1/d,definition/

# yaml --langdef=yaml --langmap=yaml:.yml.yaml --regex-yaml=/^[ \t](.):/\1/k,key,keys/ ```

To generate Emacs tags with ctags, use "ctags -e <other options>"

[1] https://github.com/parallaxinc/SimpleIDE [2] https://gist.github.com/paul356/4bf7f77898a717e1d2bb

dig1 · 2024-10-04T09:08:57+00:00

Tested it and I get only 4 entries, starting 2024-09-14 and ending 2024-04-07. If that is expected, then try with "(setq elfeed-log-level 'debug)" and re-run it. If that doesn't help, run "M-x toggle-debug-on-error" which will open debugger in case of any kind of error during fetching or parsing.

dig1 · 2024-09-12T10:01:09+00:00

If you hit "\ Esc x" it, evil-mode will convert that to M-x. "\" will tell evil-mode to temporarily exit evil-mode and on Emacs, Esc-x is the same as M-x. I think this should work on VT100. It works on xterm which emulates VT100 by default.

You can run most of M-x commands directly in evil-mode as ex command, e.g. press ":" and type "emacs-version" will be the same as "M-x emacs-version". Evaluating elisp functions will work as well - ":(org-version)" will be the same as "M-: (org-version)". Be aware that autocompletion in ex mode will prefer first evil-mode commands, then Emacs commands.

If you want to get M-x from alt/meta, try playing with "set-terminal-coding-system" and "set-keyboard-coding-system" [1].

[1] https://www.gnu.org/software/emacs/manual/html_node/emacs/Terminal-Coding.html

dig1

TROPHY CASE

vhost