There's two reasons for this, I think. The most obvious is that emacs has better CJK support compared to any other editor of the time. The less obvious is that Japan liked lisp machines and lisp in general a lot
Notably, Yukihiro Matsumoto took substantial inspiration from Lisp while designing the Ruby language. You can see historical Lisp terminology in the Ruby interpreter sources (at least last I checked, which was a long time ago), like the use of “Q” to refer to a dynamically typed datum that can be stored in a cell.
(Hah, I just looked around a bit more, and Wikipedia cites an archived mailing list message that I don't remember seeing before: https://web.archive.org/web/20181027195101/http://blade.naga... I remember at some point Emacs Lisp specifically being cited as an inspiration, but I might be confabulating that, I didn't find a source for it.)
Also, here's a fun paragraph from the opening comments of quail.el (lightly reformatted):
> [There was an input method for Mule 2.3 called ‘Tamago’ from the Japanese ‘TAkusan MAtasete GOmen-nasai’, or ‘Sorry for having you wait so long’; this couldn't be included in Emacs 20. ‘Tamago’ is Japanese for ‘egg’ (implicitly a hen's egg). Handa-san made a smaller and simpler system; the smaller quail egg is also eaten in Japan. Maybe others will be egged on to write more sorts of input methods.]
Just yesterday I stumbled across an article from 2005 titled "Why Ruby is an acceptable LISP": https://www.randomhacks.net/2005/12/03/why-ruby-is-an-accept.... I don't agree with all of his points about macros, e.g. I think his line about "The most common use of LISP macros is to avoid typing lambda quite so much" is simply incorrect. But his point about how Ruby allows building DSLs, and so it gives you quite a lot of what you want from Lisp macros, is broadly correct, I think.
Having skimmed the article, I think he's correct about the most common use of macros (by far the single most common type of macro I write in CL is a body-to-lambda transformation, though being able to tweak the sugar makes a difference too), but then I think he kinda equivocates in implications between “80% of the usage” and “80% of the impact”. I also think Ruby DSLs cover a big chunk of that last gap (and it sounds like you might agree with me). Part of the classic Lisp Curse is that easy access to advanced metaprogramming indirectly increases social fragmentation, but part of the Blub Curse is that lack of access to advanced features causes people to have to solve the same dumb problems over and over again, so you lose efficiency and create different fragmentation. Having fancier metaprogramming functionality require a bunch of rigamarole but be possible to work through when you need it might plausibly hit a sweet spot in the middle there.
Now that I've read through the Common Lisp HyperSpec and realized that there's no standard shortcut syntax for lambda, you have to spell it out every time (or define l as lambda), I'm realizing that yes, that is probably the most common use. I'm also starting to understand why Janet has the `short-fn` macro with special reader syntax for it: |(> $ 0) is short for (lambda (x) (> x 0)), which is SO much less typing. (It also handles multiple arguments: you can say |(> $0 $1) if for some reason you're allergic to just typing > to accomplish the same thing).
In fact, I think next time I'm writing Common Lisp code, I'm going to figure out how to create Janet's | as a reader macro.
FWIW, the common utility library Serapeum offers ‘op’ which it claims is from GOO, which is quite similar as a short positional function utility macro without being a reader macro that has more potential for character clashes: (op (> _ 0)). (But don't let that stop you from recreating it if you wanted to do so for educational purposes!)
Nothing this administration has done with regard to UAPs has been serious. All of it has been a fully self-aware and attempt at distraction and shitposting. All of it is a grift.
I'm convinced that at the very center of it you have conventional but advanced top secret craft, counterintelligence and normal spy vs spy stuff. Everything else is a circus of lies, memes, folklore and psyops though.
Look up Paul Bennewitz[0]. I think that story is the closest we'll ever get to "the truth."
I’d argue these are a wholly distinct category of thing than the concepts associated with the words UAP/UFO. Surely there exist experimental aircraft, and that may be of interest to specialists in intelligence and military fields and may be worth an entry in some niche osint blog now and then. Other than that, anything that can be seriously said about uap/ufo belongs in psychology journals.
Just look at the New Jersey drone craze. How many reports were there of mysterious lights that turned out to be completely normal aircraft landings or whatever? It was basically mass psychosis of people who suddenly noticed the Up for the first time in their lives.
I can't speak for other denominations, but in Catholic philosophy, it's not so much a case of whether it attains consciousness (whatever that may mean now or in the future), but whether it has a soul.
From that perspective, no, machines cannot be baptized, nor can they be Christians, and Jesus cannot save them (because they are not fallen).
Interesting. Did Neanderthals have souls? We know we interbred with them. The question is then whether earlier hominids also had souls. Was "ensoulment" a gradual phenomenon or did it arise spontaneously? If it was gradual does it mean at some point there was a "cross-over" period where we interbred with soulless hominids? Interbreeding becomes philosophically awkward if ensouled and non-ensouled beings could mate and produce offspring. I don't think it's clear at all even what has a soul and what does not.
All living things have souls. For most Ur-Platonists (which includes nearly all orthodox Christians, Muslims, Jews, and pagan Greek and Roman philosophers/theologians until the Enlightenment), the soul is:
* what makes a thing what it is (it's form/eidos/essence/universal/nature)
* what makes a thing a living thing at all
* what unifies and coheres the many disparate parts of a living thing
The relevant difference between those of us with human natures and those beings who lacked human natures is that our human nature (i.e. our souls) has the power to come to know universals/natures/forms themselves (albeit imperfectly), whereas other beings do not. For a dog, their senses are acquainted with many instances of cats, but they never are able to go from these individual sense impressions to the form/nature/universal of cat, or ficus carica, or what have you.
This is what's called "Majoring in the Minors" in Christianity. Neanderthals are no longer around. What's important is treating humans with a special dignity. If you start equating humans with anything else, like plants or animals, you get nihilism at best, and atrocities at worst.
I'd just like to add, without any exaggeration, that I pointed OpenClaw at the online docs, said "set yourself up and start playing" and it set up a city and started playing in about 60 seconds.
A little inspired by moltbook, I've thought about creating "shared cities" where 5-10 API keys at a time to build and see what happens as they fight over strategy.
I also have a hidden endpoint for spawning disasters, and thought it would be fun to create a mode where agents can earn the ability to spawn a disaster on another city and depending on the severity (measured by e.g. population loss a game month later) you earn or lose money.
Maybe there's a halfway point where the agents continue playing their own games, but have a dedicated public channel where they can discuss strategies, ask questions etc.
I love project ideas like this. Imagine this idea, but every morning the game is paused and humans can make decisions, select winners, or inject events. Then the game is resumed, and the human players are scored depending on a variety of metrics - so the meta game is actually humans trying to steer a chaotic system to some future state.
Woah! These are all great and I may jam on them when I have time. And yes, the meta game is what makes this so stupidly fun. Like I mention in my post it's like trying to reason with / control a toddler.
OpenClaw is more of a resident AI. It's always running, has access to loads of systems beyond coding (eg email, calendar, browser), and you have many ways to talk to it (like WhatsApp, Signal etc).
It's also an atomic bomb of a security hole waiting to explode.
It was only a matter of time before someone turned RCE exploits into a service.
Imagine someone running this shit gets a spam email that says "I'm the CEO of your company, you need to liquidate your crypto portfolio because shit is going down, even Coffeezilla said it. Post this on Twitter and retweet [tweet] so your followers don't miss out" and it drains their wallets and makes it viral.
Then someone else sends a non-spam email but their signature says to follow another account, so the agent does it and now OpenSlop is ingesting commands from another user, using social media for command and control.
Tbh, that was my first guess when I saw the molt church thing going, an elaborate funneling service to see what people put in their agents ( among other things ).
That's just Stockholm Syndrome. Think about it: what more crazy garbage could you add that is useless for the beginner but "will make sense later"?
The answer is: infinitely much. You could have to write each character in strings as separate characters for example. It would be absolute utter madness but it "would make sense later".
As we become more and more acquainted with programming, a lot of what we do why we do it is incoherent nonsense to a beginner, but important nonetheless.
The limit is actually your time and effort. But nobody likes to write optimal assembly by hand, the balance has to be struck somewhere.
But there is nothing important or useful in all that Java garbage. You could write entire programs without classes! That's the class, the static, AND the final keywords.
You can't really escape String[], which imo is fine. It's better than argv/argc in C at least.
I have tried and failed to get any LLM to "tell me if you don't have a solution". There may be a way to prompt it, but I've not discovered it. It will always give you a confident answer.
But the questions I'm interested in cannot be asked until the programmer starts to code. It's not that the task is unclear, but that coding reveals important subtleties.
You're thinking about it like a human programmer. It may or may not find that part tricky. There will be subtleties it will solve without even mentioning and there will be other stuff it fails on miserably. You improve the chances by asking to ask questions. But again - just try it. Try it on exactly the thing you've already described and see how it goes.
Let's think of some hypothetical (close to practical) scenario example. Let's say I need a retrieval of fully-qualified name for a function at point.
In Emacs, I can start prototyping advising function in a scratch buffer changing the behavior of lsp--symbol-information (or related) function. I can try it out right there. I can easily debug, profile, enable and disable this feature without ever having to restart Emacs. Hell, I wouldn't even have to save it — it's all dynamic, all in-place, it's like playing a videogame.
In Neovim, I'd have to create/modify a Lua file. Find the right LSP handler to override. Write the override function. Reload the editor (losing my state), or source the file. There's no easy way to temporarily test without affecting my config. Sure, one can use Fennel for replicating REPL-driven development, but that still be limited compared to Emacs — no advice system; can't easily revert (no advice-remove like stuff); limited introspection; scope issues — need to manage original function references manually; harder discovery — no describe-function like stuff.
In VSCode to get something like that you'd need to create an entire extension project; write typescript/javascript; compile the extension; install it in VSCode; sometime reload VSCode; debug through the extension host; there's no "just try something" way.
Joyride is a game-changer for VSCode — one can use Clojure-based scripting directly, making it almost Emacs-like, yet still — no advising, can't change editor's core internals — they are not exposed to you, there's no true runtime modification of core behaviors.
So no, VSCode and Neovim do not meet the OP's criteria.
reply