Mine, an IDE for Coalton and Common Lisp(coalton-lang.github.io) |
Mine, an IDE for Coalton and Common Lisp(coalton-lang.github.io) |
I like the choice of Iosevka as a font, though.
Edit: One value I do see myself getting from Mine is as an example Coalton project. Last time I tried Coalton I couldn't figure out how to get ASDF to load standalone Coalton files. Now I have a working example to copy.
> However, the above is a tall order for someone just wanting to dip their toes in, to see if they have any interest in Coalton or Common Lisp. A couple hours on the weekend is easily sunk into getting configurations right, and the right subsystems installed, and the right paths setup, just so the first line of code can be executed.
> mine is not Emacs. It aims to eliminate all of that, and be a Coalton/Lisp-first development environment, whose only job is to be a Coalton/Lisp-first development environment. But more than that, it needs to be accessible. A non-programmer should find it easy to download, install, and run mine with nothing more than a download link.
Ah… yes, okay, I see what they did there… chuckle, sigh. Well, it's arguably in the same grand cultural tradition as EINE and ZWEI at least!
The consequence is that an integration with SLIME would have to be a very extensive contrib [1] that is shipped with the Coalton version the user is using, and updated whenever Coalton is updated. No doubt the contrib would have to be very elaborate—it would have to hook in to basically every aspect of SLIME and SWANK if it should be "Coalton-native", from the display of type errors to how auto-complete is handled. Unless the contrib author is very meticulous about backward compatibility, then version mismatches would make everyone involved unhappy. The contrib author would get annoyed at constant bug reports about things not working (even if there's a nice "your Coalton or contrib are out-of-date" error), and users would get annoyed they have to keep a Lisp library in sync with an Emacs add-on.
None of this gets to the matter that Emacs simply isn't a popular text editor, and it's not really the one people are rushing to learn, even if it has substantial merit. I don't know how trustworthy this source is [2], but it claims that Emacs represents a fraction of a percent of the developer community. Even if it's off by 10x, it's still 1-in-50 developers at best.
[1] There's a basic one that shows Coalton type hints, but not much more: https://github.com/slime/slime/blob/master/contrib/slime-coa...
For new users, this looks like a welcome alternative to messy things like Lem that never really worked very well for me.
General-purpose editor/IDE with high expansibility in Common Lisp
Emacs on native Windows has to go through the Win32 API for everything - file I/O, process spawning, subprocesses. Packages that shell out constantly (lsp-mode, magit, etc) will feel sluggish because spawning processes on Windows is genuinely slow compared to Unix. The more shell-heavy your config, the worse it gets. This isn't really Emacs' fault.
I really don't understand devs still insisting on running Emacs on Windows natively. Come on, guys, WSL2 been around like forever. You get real fork/exec speeds, proper shell integration, the full Unix toolchain, etc. Why choose inflicting pain instead of a trodden, well-known, existing path?
Seeing something like this is a step in the right direction.
In order to understand what it means to have true Lisp support in an editor/IDE, you have to understand what Lisp is about. Lisp is not just a syntax - it is a live, interactive, self-modifying computational environment. VSCode, like most editors, treats code as text files and execution as a subprocess you invoke. That model is fundamentally at odds with how Lisp development works.
Yes, there are some extensions like Calva and Joyride that attempt some serious work - but the host editor's mental model is always pushing back. So really it ain't about syntax highlighting, bracket matching, and a REPL pane you can type into.
That is something that "new devs" don't understand about Emacs. It's not about the features, nor about its looks - it's about what fundamentally it is - the Lisp REPL - a live, interactive, self-modifying computational environment. Something that VSCode could never truly become. I could never write some code in some scratch buffer, eval it and change some aspect of my editor - in Emacs, I can. And I wouldn't even have to save that code anywhere. In order for VSCode to become like that, you'd have to break its fundamental model, which causes it to become something else - not VSCode.
Therefore, if someone has no interest in Lisp just because VSCode doesn't support it nicely, well, honestly - it's their loss. You know, just because a megacorporation threw billions at developing it, it doesn't mean it's objectively better - there are still other, more pragmatic alternatives. F-35s that cost $1.7 trillion may look shiny and intimidating, but when it comes to the "real deal" - much cheaper, ugly, purpose-built, A-10 Warthog proves its worth, and does it so well that the Pentagon just can't seem to be able to retire it.
Two words: Programmable editor.
One of the best advantages of Lisp is the ability to metaprogram. After solving a problem, you find that your code can fit other cases and then you you write a program that will produce the relevant code for those cases. In most other PL you would have to write the slightly different code again or use a template language.
Once you get accustomed to that, you will start to decompose other parts of your workflow in smaller building blocks and realize that only a few parts differ, but they all fits the same workflow. And one of the main realization 99% of them are text, act on text, and produce text. So what you really need is a framework around text, not a bespoke assemblage of tools.
With Unix, you have the text processing tools and vi (some would say ed). All centered around the terminal, the shell and files. Emacs is another version with a lisp vm, a collection of functions and the buffer as the interface. A third version is acme with buffers and mouse clicks as commands. The idea here is to be able to build small tools that can take care of the misc. things we need to do while writing programs. From navigation to analyzing, from formatting to building, and the myriads things in between.
Modern UIs are good for beginner and light usage. Or if you're lucky, they have your specific workflow neatly packaged in some plugins. But when you get tired of having another helpful "update" messing your muscle memory, or want to establish an efficient workflow with some external program (A CL lisp runtime in your case), that's when the weakness appears.
I started using Emacs recently for Orgmode as an alternative to Obsidian, first I just thought I'd try using for about a month, and if I don't like it I'd quit. But I kept using it month after month, eventually switching it completely. It's been over a year since then.
Then I also figured I'd try some lisp since that's what it's used for, and installing SBCL and Sly was super easy. And then the actual experience of writing Lisp was easy too.
This is on Windows 10 too. You can install and update Emacs and SBCL for Common Lisp very easily with Scoop. It might not be the optimal way to do it, but it works perfectly fine. For comparison I tried installing Lem on Windows and I couldn't get it to work.
VS Code doesn't provide the liveness and extensibility Emacs and Lisp developers enjoy in their environments.
I'm talking about beginners, not seasoned Lisp hands, most of whom—until the great boomer dieoff occurs at least—are already comfortable in Emacs. If you're still just finding your feet in Lisp, you're not aware enough of its tremendous power to miss it from your IDE. You're just wondering why you have to Escape Meta Alt Control Shift to get anything done instead of, you know, just using the menu and mouse commands and keyboard shortcuts that literally everyone else uses.
I've been kicking the tires with mine a little bit yesterday and today, I think it's quite good for the beginner experience. But I'm constantly of two minds about reporting some feature requests. The project's primary goal seems to be existing as a stepping stone to even see what Lisp (and especially Coalton) is really all about before "graduating" to something like emacs, it feels like a secondary goal (though it is mentioned as a goal) to be usable by professionals as well, but there's inherent tension there. That's also been a weakness with the other editors: anyone already comfortable with Lisp development, professional or not, in emacs or not, isn't very likely to give the time of day to some new thing that's almost certainly not going to be as good as what they're used to. And so the new thing doesn't get the attention and feedback from experienced developers and the gap never closes.
2. "Easy enough for a non-programmer" may also say something about how easy it is for a programmer.
It's their IDE and they can design it how they want, but that's a weird goal for a CL IDE.
Or use something like:
sbcl --load <filename>
(defun myfun(x)
(let (x)
(setq x 5)
(when (eq x 6)
(print "6")
)
)
)
____
* Of course, technically, CLOS is something to behold. But you won't sell someone on Lisp because it can do "OOP".
Also automatic idiomatic formatting of lisp code is possible in any editor as long as they have the settings for it. Not sure how Emacs is the gatekeeper on that one.
If the beginners are curious about Lisp and insist on using VSCode, they can install Calva and try Clojure. It takes less than a minute and it has a really good "quick start" guide. There's no rule that says you have to get into Lisp specifically via SBCL. Once you grok structural editing and REPL-driven workflow, jumping between different Lisp dialects is not that hard.
And if a programmer refuses to learn a new language, technique or paradigm just because their favorite editor doesn't support it... well, that is sad, but also - not everyone has to be passionate about their work, huge sectors of the economy are driven by mediocre players and that is just fine. Passionate programmers sooner or later find their way to Lisp.
Why has it stuck with Emacs and its derivatives? I don't know. It seems interest in investing time to make a good Lisp environment for a non-Emacs editor fizzles out once it gets to the difficult part of productionizing it, which is why Emacs continues to be the #1 no-cost choice.