artsi0m

«2026 update: Let Over Lambda was published in 2008, to align with the 50th anniversary of Lisp's invention in 1958. A lot has changed since then, in both Lisp and programming practice in general. Although my thinking and opinions have evolved since, I still believe the book holds up well as a tutorial and explanation of why Lisp so special. Going forward, the entire book is free to read online (HTML, PDF). Happy lisping»

Let Over Lambda is one of the most advanced books on Common Lisp macros.

In this book authors shows the great possibilities that unhygienic macro system gives. He implements closures using Let Over Lambda pattern, shows usage of anaphoric and reader macros and also construct some kind of OOP system out of abilities that CL macro system provides.

Maybe, I would think about implementing it in this way.

Actually I don't really want to create a separate emacs package, but rather merge my code with main howm repo at some point, when it would be good enough.

Creating your own package would be acceptable alternative to this, though.

I also should add, that I can add enabling external grep part to my short howm config, but it seems to slow down howm, rather speed it up, when using it on windows.

I liked this one: https://baty.blog/2024/03/the-emacs-howm-package-for-notes

You can put more than one search link in currently edited note, than test all of them and at one point you will learn how to formulate search query so that you would recite yourself exactly as in that note that you want to see just now.

Also you would find more suitable titles while being in this process, but it wouldn't be for long.

I write down my uni's lectures in howm using org as markup, so maybe yes, probably.

howm has two types of links, both are search for all your data it howm actually, but the second type (<<< links) work as a tag, that would be highlighted everywhere.

I thing creating templates can be done with one or another emacs snippets packages. Or just by your own elisp.

(use-package howm)

Although I am the one who use it with org-mode too.

I've done it using prop-line feature of emacs and my own interactive, for today it is only interactive, function howm-insert-prop-line:

    (defun howm-insert-prop-line ()
  "Activate major mode and modify the file so that this mode is activated
  automatically the next time it is opened"
      (interactive)
      (howm-mode)
      (let*
   ((modes (mapcar #'cdr auto-mode-alist))
    (mode-name (completing-read "Choose major mode: " modes))
    (mode (intern-soft mode-name)))
 (unless (or (null mode)
     (eq mode major-mode))
   (funcall mode)
   (howm-mode)
   (add-file-local-variable-prop-line
    'mode (intern (string-trim-right mode-name "-mode\\'"))))))

https://github.com/artsi0m/howm-use-any-markup

My problem is that I can't combine well nested interactive+let or let+interactive, so it is only as interactive function for now.

I set up wireguard and unbound on VPS in Amsterdam and share with 10-15 people by posting wireguard config in private telegram channel.

Ironically enough, but I block porn access using StevenBlack hosts converted into Unbound config by awk script, so porhhub dot com will return REFUSE dns response from unbound.

I know, that is not impressive idea of how to utilize computing power of the VPS, but I also used it for running tor snowflake (disabled because of eating too much ram), running tor obfs4_proxy (would also eat much ram, but that can be adjusted, I don't remember clearly why I disabled it at one point) and I used it as a server for Postgres that I tried to use for uni's coursework on databases.

Maybe I am too lazy to setup tools like zapret for bypassing deep packet inspection locally on my laptop or on router. But still there should be a ton of things that can be done on the same vps.

[1]: https://github.com/freznicek/awesome-awk [2]: https://github.com/Ypnose/ahrf

sed-chess: https://news.ycombinator.com/item?id=37896854

awk-raycaster: https://github.com/TheMozg/awk-raycaster

It allows you to mark headlines in a file as "flashcards", turning pieces of knowledge you want to learn into a question-answer test.

These cards are reviewed at regular interval. After each review, a Repetition Spacing Algorithm is used to calculate the next interval based on how well you remembered the contents of the card.

[1]: https://proofwiki.org/wiki/Definition:Modulo_Operation/Modul...

I heard, that there is something simillar in FreeBSD with zstd compression.

For me cons is that you can't run some programms that depends on Linux kernel insides, like rr debugger, which depends on some specific of linux ptrace(2): https://github.com/rr-debugger/rr?tab=readme-ov-file#system-...

Different notations like revers polish notation also easier to parse. You can evaluate RPN only using stack.

Also, recently I learned about thread-last macro in emacs lisp. Using it you can evaluate forms from left to right, and using it you can write less parenthesis.

It seems clear for me, because I remember learning De Morgan's Laws in electronics class and from one specific level of Turing Complete game.