Hacker News Reader

Comment by NeutralForest | Hacker News Reader

Little tooling: you need to use Emacs and there's no LSP, no great debugging capabilities, no great testing libs, etc Bad docs for beginners: the docs are very complete in terms of coverage and yet have no tutorials or explanations in how to use Guile properly.

Very little visibility as well, Scheme is already a niche. By catering to only the most FOSS oriented/adamant part of the public, your pool of devs is very tiny.

Most guile libs can also only be installed through Guix or failing that, tar files.

The ergonomics of the language are bad and there no concerted community story and publicity around it either imo.

It's sad because it's a cool language and the efforts Wingo and people like the Spritely institute have put into it, are amazing.

View on HN

You can also use it pretty comfortably in vim (with a couple of plugins) https://gist.github.com/mhitza/a00d7900571e9f13bac2bbf4a203d... . I've used this setup to write both Guile and Chicken Scheme programs.

The LSP is the biggest missing piece for these niche languages.

In my perspective the reason why it still hasn't taken over is because it's not a focused and supported effort. In my understanding Guile should have been "the GNU scripting language" but the integration is nowhere near what a universal language would be (GNU Make integration is disappointing and totally not what I was expecting).

Then the fact that the project seems to be hopping between different directions (last time I checked they wanted to be a runtime for more than one language).

And they also lived their own Python2 -> Python 3 "migration pain". (In my above gist, I specifically had to compile Guile from source because at that time some application with a hard dependency on Guile2 wasn't getting updated in Fedora, which was holding back the Guile v3 rollout).

Yep, language success is also very much a social endeavor and there wasn't and isn't, a strong push and consistent messaging about Guile.

Here is an experimental for Guile Scheme. While it is currently for VSCodium and Emacs looks interesting.

https://codeberg.org/rgherdt/scheme-lsp-server

This LSP performs reasonably well and having used it I'm not sure it's fair to call it "experimental". There's certainly some room for improvement in the code (e.g. diagnostics don't seem to run consistently with every change was the big one for me).

The greatest barrier I had with it was the installation.

I know about it but that's only part of the problem, afaik you can't use breakpoint in Guile and dependency management is still non existent.

That is why I created https://codeberg.org/ZelphirKaltstahl/guile-examples. I like GNU Guile and many things exist, even in the batteries that are included, but are not easy to find or one needs to figure out how to effectively use them. Also got an awesome list somewhere, but I need to migrate that to codeberg later.

Compared to some other languages, the ecosystem is small though. While in Python often you have 3 or 4 libraries solving the same or similar problem, in GNU Guile you often only have 1 or need to write your own. Knowledgeable people are able to quickly throw something together, or call out to C libraries using FFI, but I have not done FFI yet. Some day I really should look into that ... And into Hoot by Spritely Institute [1]

If one wants to check out more algorithmic stuff, I also have some stuff on that: AoC 2024[2] (and previous years too), and guile-algorithms[3] (not that much yet, but useful things, and trying to keep it fully functional). Some time ago I also wrote a toy implementation of a decision tree in Guile[4]. It is even parallelized and achieves linear speedup in my tests. I call it a toy, because you will have to do all the data preparation yourself, because it only deals with numbers, and there are probably smarter ways of storing the data for each node, maybe even avoiding duplication. There is also no library like numpy or dataframes like in Python, so I am using possibly not so optimal data structures. But it is probably worth checking out and adapting, if anyone wants to make a proper decision tree library. It is a start.

[1]: https://spritely.institute/ [2]: https://codeberg.org/ZelphirKaltstahl/advent-of-code-2024 [3]: https://codeberg.org/ZelphirKaltstahl/guile-algorithms [4]: https://codeberg.org/ZelphirKaltstahl/guile-ml

Migrated the list from notabug: https://codeberg.org/ZelphirKaltstahl/guile-awesome

Guile is supported by conjure in neovim. It's a nice alternative to emacs, has some nice repl integration, and recently includes some autocompletions without an LSP.

https://github.com/Olical/conjure

Reply on news.ycombinator.com