pkal

I see that intelligence itself is a tool, but that doesn't mean I want an automated gun, automated hammer, automated nuclear warhead, etc.

I am familiar with the syntax, so I am biased ("*/3" and "12,14,20" makes sense if you are familiar with Unix tools), but it is still more intuitive to me than the systemd unit file syntax and usage. I know that I just have to edit /etc/cron or throw any executable file into /etc/cron.d/monthly and it will work on my system, but I cannot write a systemd timer file from scratch without looking it, and to do that I first have to find the directory where the other examples are located. /etc/systemd doesn't appear to be it.

This is generally my only real complaint about systemd. I don't care if it is too monolitic, written in C or whatever, I just want a straightforward syntax for straightforward operations. I'd like it if systemd could recognize if a .target file is a shell script and just do "the right thing". Perhaps it would make sense for a timer file to recognize cron syntax as well. Or at least allow for a kind of extensibility so that I can have it supported.

If systemd had a little more respect for existing conventions, I am pretty sure it wouldn't be so controversial. After all, system administrators like it because they use it all the time, but a regular, full-timer user like me, who only deals with it when something is broken or have to use it as a means-to-an-end to set something up, then all friction is annoying and bad UX. (And no, using Nix is not the solution)

or https://codeberg.org/anaseto/goal

No, because you can compute the optimal automaton (as in least number of states) that recognizes the same language: https://en.wikipedia.org/wiki/DFA_minimization

The article doesn't sell it that way. "You should play modern board games if ..." would be a different claim. The premise

They provide interesting puzzles to solve, and you work in a technical role - some part of your brain must find that appealing

is something I do not relate to at all. Almost every time I am in a situation where I play board games, my intuition is to think about how you solve the game so that one side always wins or break the rules so that everyone loses, but almost never am I actually interested in investing the energy to get invested in the game itself, let alone the rules.

In practice this should also work. Do keep in mind if you just add this to your init.el then this will not persist if you re-create the scratch buffer.

If we are already experimenting with different ideas, this should also work (and gives a hint of how you want to fix the issue upstream):

    (define-advice get-scratch-buffer-create (:filter-return (buf) trusted)
      (with-current-buffer buf
        (setq-local trusted-content :all))
      buf)

Do note that I only configure this for `lisp-interaction-mode', which in practice really only gets used for the *scratch* buffer. But there are a few other instances in core that also use it, and if that concerns you, you can extend the above snippet with a check like

    (when (equal (buffer-name) "*scratch*") ...)

Shouldn't something like this fix the problem, at least for scratch buffers:

(add-hook 'lisp-interaction-mode-hook (lambda () (setq-local trusted-content :all)))

No, I just guess that most people who dislike it (like me) dislike it on an "eyeroll" level, where you wouldn't use it yourself but don't have the energy to make a fuss about it.

But in 1976 Emacs was implemented in TECO. In 1984 it was implemented in Lisp, because Multics Emacs _or_ EINE/ZWEI (Lisp Machine editors) were using Lisp as an extension language, which apparently has shown itself to be useful.

A point of clarification: GNU ELPA (https://elpa.gnu.org/) is part of Emacs, and you have to sign the copyright assignment to submit packages an to contribute to packages. NonGNU ELPA (https://elpa.nongnu.org/) doesn't have this restriction.

From the historical sources I could find online, it appears that Rust's borrow system was independently invented, or at least they don't mention linear logic or anything substructural. This is kind of interesting to me, especially given the reactions in this thread, and ties into the general difficulty of PL research to find acceptance among practitioners, especially when presented by researchers (which I think is regretful, I like the ideas in the article!). Perhaps we really should stick to terminology like "function colors" to make effect systems more popular (or not, because the color framing makes it sound bad to have different colors in a program, IIRC).

I don't think it is not maintained, there is plenty of activity going on in the repo: https://repo.or.cz/tinycc.git, they just don't seem to be cutting releases?

To each his own; I really like his presentation style and the humor!

According to https://algol68-lang.org/, and as expressed in the recording, the contributors (specifically Marchesi) believe that ALGOL 68 continues to have advantages over other languages to this day ("more modern, powerful and safe" and "without successors"). One mentioned in the video is that the more complex, two-level grammars allow properties that would usually be described in the semantics of a language to be formally expressed in the syntax (the example he gives is the behaviour of numeral coercion). I guess this is not a surprise, as van Wijngaarden grammars are known to be Turing complete, but nevertheless it seems like something interesting thing to investiagate! There is a lot of lost wisdom in the past, that we dismiss because it doesn't fit into the language we use nowadays.

That isn't totally true, even on Linux we have had https://jmvdveer.home.xs4all.nl/en.algol-68-genie.html for years.

Also, most languages trace back to ALGOL 60 (the C family tree goes ALGOL 60 -> BCPL -> CPL -> B -> new B -> C -> ANSI C -> ..., though there was some influence such as the idea of "casting", but apparently C only has a castrated version of what ALGOL 68 had) and Pascal is if anything negativly influenced by ALGOL 68 due to Wirth's disagreements with van Wijngaarden: https://dcreager.net/people/wirth/1968-closing-word/.

I recently realized that "pure functional" has two meanings, one is no side-effects (functional programmers, especially of languages like Haskell use it this way) and the other is that it doesn't have imperative fragments (the jump ISWIM to SASL dropped the non-functional parts inherited from ALGOL 60). A question seems to be whether you want to view sequencing as syntax sugar for lambda expressions or not?

Then perhaps "Did you learn X stating your opinion on it as though it were comprehensive and authoritative"?

Some sites like Anna's Archive have .onion site for the Tor network, and others do not. Is there a considerable downside (DDOS?) to providing access to their site by those means?

I think so, or at least something like that. In https://www.arraycast.com/episodes/episode60-rob-pike he mentioned that he has now been working more on Ivy (https://github.com/robpike/ivy) in his spare time.

I am glad my comment resonated with you! There are probably people here with political motivations (on both sides), but it is encouraging to hear that there is a value in the direction of my exposition.

I am also not a fan, but since a recent discussion on HN I have been thinking about what I don't like about it.

The conclusion I have come to is more general: I just personally don't like nerd-culture. Having an anime girl (but the same would be the case for an star trek, my litte pony/furry, etc.-themed site) signifies a kind of personality that I don't feel comfortable about, mainly due to the oblivious social awkwardness, but also due to "personal" habits of some people you meet in nerdy spaces. I guess there is something about the fact of not distinguishing between a public presentation and personal interests that this is reminiscent of. For instance: A guy can enjoy model trains, sure, but he is your college at work and always just goes on about model trains (without considering if this interests you or not!), then the fact that this subsumes his personality becomes a bore or even just plain unpleasant. This is not to generalize that this is the case for everyone in these spaces, I am friends with nerdy-people on an individual basis, but I am painfully aware that I don't fit in perfectly like the last piece of a jigsaw puzzle -- and increasingly have less of a desire to do so.

So for me at least this is not offence, but in addition to the above also some kind of reminder that there is a fundamental rift in how decency and intersocial relations are imagined between the people who share my interests and me, which does bother me. Having that cat-girl appear every time I open some site reminds me of this fact.

Does any of this make sense? The way you and others phrase objections to the objections makes it seem like anyone who dislikes this is some obsessive or bigoted weirdo, which I hope I don't make the impression of. (Hit me up, even privately off-HN if anyone wants to chat about this, especially if you disagree with me, this is a topic that I find interesting and want to better understand!)

I would love to hear what you disagree with :)

OK, try the following in a Transient buffer:

- Search for something using C-s - Exit isearch by moving the point (e.g. C-n) - Is the transient buffer still usable for you? In my case it becomes just a text buffer and all the shortcuts just got mapped to self-insert-command.

And if you don't have anything configured, graphical Emacs will have a tool bar with a button to save and a menu bar that also gives the binding for the command.

GUI is different because there is no tool bar, but in Emacs 31 `xterm-mouse-mode' will be enabled by default so you can use the menu bar like a TUI.

For people who can look at a list of key bindings once and have them memorized, maybe. Turns out most people are not like that, and appreciate an interface that accounts for that.

To clarify, the "custom buffer" can list the bindings. Think of Ediff and the control buffer at the bottom of the frame.

I am not saying that transient offers nothing over regular prefix keys, there is a common design pattern that has some definitive and useful value. My objection is that the implementation is more complex than it should be and this complexity affects UX issues.

Not true. (Try it.) This was true for very early versions; it hasn't been true for years.

Then I was mistaken about the implementation, but on master C-s breaks transient buffers for me on master and I cannot use C-h k as usual to find out what a key-press execute. These are the annoyances I constantly run into that break what I tried to describe in my previous comment.

Except that in the case of transient you actually can enable such buffer switching, it's just strongly discouraged because you are going to shoot yourself in the foot if you do that

I did not know about this, so thank you for the link. I will probably have to take a closer look, but from a quick glance over the issue, I believe that the problem that you are describing indicates that the fear I mentioned above w.r.t. the complexity of transient might be true.

I usually do not respond to posts like this (anymore), but sometimes the urge is just too strong.

I understand your irritation and don't want to deny its validity. We do not have to discuss this publicly in a subthread about DOS IDEs, but I am ready to chat any time. I just want you to know that if I am not saying anything to personally insult you. Comments I make on cond-let and Magit sound the way they do because I am also genuinely irritated and concerned about developments in the Emacs package space. To be honest, it often doesn't occur to me that you would read my remarks, and I say this without any malicious or ulterior motives, in my eyes you are still a much more influential big-shot in the Emacs space, while I see myself as just a junior janitor, who's opinions nobody cares about. But these self-image and articulation problems are mine, as are their consequences, so I will do better to try to remember that the internet is a public space where anyone can see anything.

Transient is the worst part about Magit IMO (the best parts are how you can prepare a commit to just include the right changes, or the functionality bound inside the transient menus that make complex operations such as fixups or rebases trivial). Transient UIs are consistently uncomfortable to work with, and could usually be replaced by just using a regular special-mode keymap in a custom buffer. The fact that Transient hooks into the MVC and breaks elementary navigation such as using isearch or switching around buffers has irritated me ever since Magit adopted the new interface.

The real neat thing about Emacs' text interface is that it is just text that you can consistently manipulate and interact with. It is precisely the fact that I can isearch, use Occur write out a region to a file, diff two buffers, use find-file-at-point, etc. that makes it so interesting to me at least.

A far more interesting example than Magit is the compile buffer (from M-x compile): This is just a regular text buffer with a specific major mode that highlights compiler errors so that you can follow them to the referenced files (thereby relegating line-numbers to an implementation detail that you don't have to show the user at all times). But you can also save the buffer, with the output from whatever the command was onto disk. If you then decide to re-open the buffer again at whatever point, it still all looks just as highlighted as before (where the point is not that it just uses color for it's own sake, but to semantically highlight what different parts of the buffer signify) and you can even just press "g" -- the conventional "revert" key -- to run the compile job again, with the same command as you ran the last time. This works because all the state is syntactically present in the file (from the file local variable that indicates the major mode to the error messages that Emacs can recognize), and doesn't have to be stored outside of the file in in-memory data structures that are lost when you close Emacs/reboot your system. The same applies to grepping btw, as M-x grep uses a major mode that inherits the compile-mode.

I agree with you -- I never use vulgar words, so I cannot use this word myself. That being said, maybe you saw this article being posted a few days ago: https://frankchimero.com/blog/2025/selling-lemons/ writing about the concept of "Market for Lemons". The last paragraph compares the two ideas:

What makes the Market for Lemons concept so appealing (and what differentiates it in my mind from ens**tification) is that everyone can be acting reasonably, pursuing their own interests, and things still get worse for everyone. No one has to be evil or stupid: the platform does what’s profitable, sellers do what works, buyers try to make smart decisions, and yet the whole system degrades into something nobody actually wants.

(I don't know if Doctorow's concept really relies on malice.)

This is probably not useful for most people, but I wrote a little script for Emacs that lets me write TeX-style math in a comment and then render/update it below in MathML: http://sdf.org/~pkal/src+etc/mathml-from-tex.el. The translation itself is done by LaTeXML, which one must install on your system separately.

Can you also generate+use the XSLT stylesheet dynamically from a form input so that you can use a single meta-stylesheet for multiple sites?

Oh, and is you brother coming to the party?