Hi,
I’ve been talking a lot recently, and not that recently, with many of
you about the status of Guile and about the fact that we, Guix users and
developers, rely on it for most of our computing.
Most of us would probably agree on that we should give Guile a little
bit more of love.
There is a problem, though, that I’ll try to describe from my experience.
I’ve been trying to improve Guile for long but all the very small
patches I’ve been sending during the last years haven’t been
reviewed[^1]. While larger patch sets have only been reviewed and
accepted, basically, because the maintainers know me and I have been
pinging them repeatedly (thank you <3).
One of the changes, that rewrites the string-peg module and adds some
features to it, was applied by Ludovic, who we all know is already very
busy with his awesome work at Guix, the Shepherd, and many other things
he does.
The other, a RISC-V backend for the Guile JIT, was merged by Andy, but
not in Guile directly, but in Lightening, the JIT compilation library
Guile uses, that is managed as a separate project in Andy’s personal
Gitlab account. This took three years to be finished, because I couldn’t
make it work even if it was passing all the tests, and I tried again
years later when my skills improved, but I got no answer, comment or
review in between. Thankfully, I was told about some undocumented
environment variable during the second attempt that helped me finish the
work. Of course, we all also know about how Andy has been working on
Whippet, the new Garbage Collector for Guile, Hoot, and many other
things we are very grateful for.
From my experience, it feels like while the maintainers are great
programmers and are able to deliver great software for us, are too busy,
to the point that it feels like a exception to see someone’s patch
accepted by them. In Andy’s case this problem might be even worse,
because he’s the only maintainer of Lightening, and probably he’s the
person in the planet that knows more about how Guile and programming
languages, in general, work.
There are committers in Guile, too, and they are also doing a great
work, but my feeling is there are not enough of them, at least to
accommodate the potential increase of contributions that I’d like the
project to have, because they are already struggling.
I’m not criticizing, quite the contrary: I think they need help, so they
can do what they do with more freedom and joy.
There’s also a second problem, but I think that’s the easiest one to
solve. I’ve been working with compilers and programming languages for
the last couple of years and most of my programmer friends talk to me as
if I was crazy. I see why that is, because I can recognize the feeling.
Not that long ago, I was also scared of languages.
We tend to look to the long term probably way more than other projects
do, that’s why we pay attention to bootstrappability, reproducible
builds and so on, and I think we have the energy and the people to
tackle an extra front: the language.
Hacking on a programming language is as easy as any other program, but
also as difficult. Programming languages, specially scheme
implementations, have quite a bit of background and scientific research
on their past. Understanding the subject takes time and study and, in my
opinion, the best way to learn is from others. Sadly, Guile is not as
active as a community as Guix is, where people share their knowledge and
encourage newcomers to make packages, improve their configuration and so on.
I believe we should get more involved in Guile, not only because Guix
relies on it but also because we should know more about how it works.
This knowledge should be more accessible and commonplace, not just
something that only a few programmers know.
We could and should teach each other.
But we shouldn’t put more responsibility on those that already are doing
more than their best: the Guile developers. I think this should be
bootstrapped one way or another, so we can help them relief some of the
weight they are struggling to lift.
I’m sending this email because I’d like to encourage people to try to
learn about programming languages, Guile in particular, and slowly try
to get in the Guile community, become committers and eventually
maintainers. But also because I don’t know how we should approach this
in the short term and I’d like to have some ideas from you.
As you can see, I’ve been trying to do this myself for long, but this
will take time, specially from now on because I have other
responsibilities. That’s why I think together we can do it faster and
better, learning one from another. But I don’t know how we should
approach this as a collective.
Ideas?
Best,
Ekaitz
PS: From my side, feel free to ask anything about programming languages
in general and Guile in particular. I will try to do my best to answer
with what I know, which I cannot promise is much.
[^1]: There have been a few in the last 3 years:
- This patch that adds the repl command that deletes all breakpoints:
https://lists.gnu.org/archive/html/bug-guile/2022-07/msg00005.html
- This one fixes an example in the docs:
https://lists.gnu.org/archive/html/bug-guile/2023-08/msg00002.html
- This other fixes a typo:
https://lists.gnu.org/archive/html/bug-guile/2023-10/msg00000.html
- Here I document a feature of the SXML module that is not documented:
https://lists.gnu.org/archive/html/bug-guile/2023-10/msg00001.html
- And here I document a global variable you need when debugging the JIT:
https://lists.gnu.org/archive/html/bug-guile/2024-1/msg00001.html
