Go seems like quite possibly the polar opposite of this, as far in the "keep it simple and understandable by literally everyone by cutting out many techniques for metaprograming and code reuse". Which perhaps is the point, but if so it seems like that point misses much of the draw of Emacs?
While this is definitely impressive technically, I think Guile Emacs is a much more plausible option.
Also, some of my projects that become bigger than 1000 LoC could benefit from static typing and (subjectively) better tooling.
By the way, I think extending Emacs in Racket would be great; just do not have an idea on how to implement that integration smoothly.
;;; -*- lexical-binding: t -*-
Racket seems like a near perfect match for the domain. Start with a hacky one-off script. Augment with unit tests. Code base grows and starts becoming more stable? Progressively migrate to Typed Racket.
Mapconcat is already used inside runtime implementation:
https://github.com/Quasilyte/goism/blob/master/src/emacs/rt/... (Print and Println functions).
Technically impressive, I'm sure, but will it be around for another 30 years?
If someone writes a module using this, will I be able to rely on that module keeping on working for the years to come?
There can be a backend that generates Emacs Lisp code. Not necessary optimized or idiomatic, but it could be a good starting point for rewriting.
But in general, I agree with you.
I'm far from a JS fanboy but I think your point lends credence to the idea of using JS more than it strengthens the use of Emacs Lisp.
Similarly, the package repository is not exactly inspiring. Similar patterns of many packages doing the same thing. Often not bringing new advantages to the table, so much as revising old weaknesses. Many rooted in choice of language.
Whether or not NPM is actually so impressive though, I won't debate. It's useful, but uhh... yeah. The baseline quality is not quite near something like, say, PyPI.
Still, I think you're looking at this from a different angle than I am. I haven't seen one person suggest that it would be a good idea to take the Lisp out of Emacs; simply that having the option to script it with other languages would be nice.
On .NET, UWP and Microsoft Office macros. It even is supported by .NET Native compiler, something that F# is still WIP.
And yes, at enterprise level, there are new lines of VB.NET and VBA being written every day.
But that's kind of beside the point, VB.net is nothing like the BASIC of the 80's or the 90's, it's got more in common with java.
The medicine you might take, has been probably measured DRC reaction curves in some VB.NET application.
It is the surviving BASIC, the evolution of QuickBasic and Visual Basic into the .NET environment.
Regarding the 80's BASIC, GW-BASIC was probably the last one of such type of unstructured line numbered BASIC.
That is the tool that many researchers with some programming skills reach for, maybe they will some day move to Python or R, but VB is what they use currently.
Seriosuly, is that hard to learn Emacs Lisp? Even if one is using Go or Rust (etc) at work, any programmer worth his salt should at least already be familiar with Lisp syntax.
It is one of the easiest languages to learn!!
Emacs has really good support for it which continues to improve over time.
But.. I love more than one language (and more than one Lisp for sure).
Will you try to persuade me that I am wrong in that regard?
If it's just a demo then it's neat. Interesting that it can be done.
On the other hand, if it's a real push to get people scripting Emacs with Go, then I don't see the point at all. It's solving a problem people don't really have.
Isn’t "I want to script Emacs but I don’t like LISP" a problem to solve?
I don't think it's that unusual. Emacs is quite popular. If even 25% of the user base coded in Lisp, it would be ... astonishing.
Source: am Emacs user, have a few (not a lot) functions that I cobbled together from things I did all the time.
Who decides they want a script-able editor, but then chooses one scripted in a language they don't like and don't want to learn?
Probably not (except those who made that project).
> Who decides they want a script-able editor, but then chooses one scripted in a language they don't like and don't want to learn?
Mostly because the scripting language is not the first thing you think about when using an editor (just guessing here; I don’t have data on that).
I started using Vim because its editing capabilities are quite powerful but its scripting language is really bad. Emacs’ LISP is great, but I can’t get used to the way Emacs commands work.
I found some optimizations that are not implemented inside Emacs lapcode optimizer.
If I will port them to byte-opt everyone win, right (if they pass Emacs team review, of course)?
Clearly, power is the only measure one should consider when picking a programming language. And Lisp surely has more power than Go. I'm going to guess 36.1% more power, to be exact.
>and what can be done about it
We could always start performing eugenics to get rid of them.
... Okay, I apologize for being an ass. But I hope my points aren't lost; the way you're phrasing things makes it feel like you're bitter that anyone would consider using something that's not Lisp.
>We could always start performing eugenics to get rid of them.
I meant more like what we could do to improve the more powerful languages to make them more appealing.
I'm less bitter than I am perplexed about the choice to use Go over Lisp.
But I find the rhetoric quite closed-minded, because I doubt any of the people replying here who've just found out about this and are calling it a bad idea have actually tried it yet. Clearly, there are advantages to Lisp that you would lose if you tried to do something in Go. But nobody is acknowledging the reverse, that there may also be advantages in Go to Lisp that are unforeseen, even for this specific task.
All in all this is a disappointing development. I don't think it would go over the same in other text editor communities, because people seem very defensive about the use of languages in place of Lisp where they might not be so defensive about the use of languages in place of say, VimScript.
No matter how bad people think Emacs Lisp is (an incorrect impression, Emacs Lisp has improved tremendously) it's still a powerful Lisp and only a Lisp would provide the powerful extensibility that Emacs has.
I think language bridges suck, but this isn't one. It transpiles Go to Lisp bytecode, making it much closer to a first class citizen.
But more importantly, the tagline of the project isn't "Let's write Emacs in Go," nor is it "Emacs Lisp is bad," it's "Not a fan of Emacs Lisp? Hack Emacs in Go!" -- that seems pretty straightforward to me. The aim of this seems to be potential Emacs users who do not code Lisp and don't like it. There are plenty of reasons to not like Lisp, not just Emacs Lisp, including the power that it possesses, just like there are plenty of reasons to not like Go. To suggest otherwise would be elitist.
The way I see it, the potential here is to open Emacs scripting up to a wider audience of people who are not necessarily all the same kind of programmers, who may prefer more typing to more magic.
Would you please list those reasons?
Since you asked though, I'll go into my personal list. You'll note that much of these can just as easily be advantages depending on the situation and I'm by no means saying that this list applies to all things and all people (in fact it objectively doesn't.)
- The syntax: duh. Its elegant in how it mixes code and data, and unifies so much functionality into one syntax. But it has a number of disadvantages. One, the number of parens is cumbersome. You can get used to it, but it's still cumbersome. Two, it isn't always intuitive; sometimes infix syntax just plain feels ergonomically better, all flaws aside. This can absolutely be said about math. Lisp takes order of operations out of the picture, but the same would be true if you threw a shit to of parens into any language, so I feel that doesn't count.
- It's absolutely magical. It's so powerful that I wouldn't trust most programmers to wield it. It's so powerful I wouldn't trust me to wield it. I like programs that are obvious. One of Go's strengths is that it is very stupid, for example, leading to stupid code that is stupid readable by anyone (even if they're.. you get the idea.)
- Lisp feels like the world of wheel reinvention. I don't know if that's due to the language or the community that surrounds it, but I'd guess it's at least a little bit of both.
- Lisp is a dynamic language. By nature this is going to mean you can do less things with code statically. I'm a big fan of static typing for the obvious advantages it brings to larger projects.
- Finally, comfort. Lisp is obviously a language that has stood the test of time, but even despite that Lisp programmers are far and few in the industry. Most people are going to be familiar with imperative programming languages based off of C like syntax, or maybe something closer to Python. Either way, if you pick a random programmer off the street, you wouldn't assume they knew Lisp. (Unless their beard was really long.)
I think some of your points are valid, although some of them (syntax and static typing vs dynamic typing) are mostly down to preferences or getting used to different ways of working.
I think, for example, that, given the choice between those two, i'd rather have macros (lisp macros) instead of static typing.
As for the beard comment, yes, the longer the beard, the easier is to get into Lisp.
I just wanted to note, however, that Lisp is an imperative programming language, just as C or Python is. (Of course, Lisp also allows functional programming and Common Lisp allows fantastically good object oriented programming). So yes, i agree, "most people are going to be familiar with imperative programming languages based off of C-like syntax". But on the other hand, Lisp syntax is much easier to learn than C-like syntax.
The implementation language does matter a lot in this case, because the part of Emacs that is written in Emacs Lisp (~90% of Emacs) can and should be leveraged (modified, extended or used to build upon) at runtime by users. This is what gives Emacs it's tremendous flexibility and power.
Using anything other than a Lisp with semantics close to Emacs Lisp for user code that leverages what Emacs offers built-in, will be an exercise in frustration since a lot of the power I described will be so cumbersome to access and make use of. It's been tried before, multiple times by people not very familiar with Emacs Lisp, and it has never worked out.
Experienced Emacs Lisp developers immediately understand the futility and pointlessness of such endeavors which is why you never see them attempt them.
Sarcasm aside, Lisp is as much as possible well-suited for the job of text and AST processing, Emacs is one of the Lisp's "killer apps" and the second best "case study" after classic old-school AI code (PAIP).
1. Use a plugin system (ecaml)
2. Transcompile to a target language (gosim and emscripten-like platforms)
3. Embed another VM inside Emacs and call its eval
There are many differences between these approaches and I am not sure one of them is objectively better as a general solution.
For the end users, all of these approaches can deliver good level of integration (they require different sets of tricks to achieve that).
I wonder about the implementation strategy -- why compile to Emacs LISP instead of doing a plugin (FFI) or RPC style setup?
Name mangling scheme preserves fully qualified package path.
All goism sources live inside GOPATH (1), so nothing stops us from implementing a jump to Go definition.
For given `goism-foo/bar.baz` Emacs symbol,
Go definition can be found in `GOPATH/src/foo/bar/` package.
Exact location can be found by using existing Go tools (simple grep-like solution can work, too).
(1) It can change in future; see https://news.ycombinator.com/item?id=13368846
and even more relevant: https://github.com/golang/go/issues/17271
Easier to debug, simpler to trust (for the end user) and not that hard to generate.
The problem is that it is harder to implement some features of Go in terms of Emacs Lisp without going down to the virtual machine level. Best examples are arbitrary return statements (can be emulated by throw/catch) and goto.
Possible implementation (about 20 lines of code): https://github.com/Quasilyte/goism/issues/57
Not sure if "defadvice" around "byte-compile-form" is acceptable for all users.
Some S-expressions with `cl-return' can be rewritten to avoid the need of it (by the optimizer); not sure it covers 100% of the cases though.