> > It is also a technical issue, the Scheme world is so diverse in terms
> > of implementations and goals that it is difficult to contribute to
> > Scheme without a dedicated Scheme implementation for the purpose of
> > the SRFI process and RnRS.
>
> It is, but a big collection of working code would also motivate porting
> work.

If I understand correctly, SRFI / RnRS libraries would be collectively
owned by participants including maintainers of Scheme implementations
that want to take part in the process? The alternative at the moment
is to copy and tweak sample implementations or create an
implementation from scratch.

> Unit testing and CI could be solved in one place, especially if we
> use a monorepo.

I agree.

> Then adding tests for any new code can immediately use
> the work that has gone into those tools, and for portability there are
> lots of existing cond-expand's to use as examples for how to do it.

As far as I know cond-expand is not trivial to implement. And even if
it was, it will not completely eliminate the problem that some Scheme
may want to use a completely different implementation that will force
us to have cond-expand based on implementations.

>
> A sample implementation of Scheme and SRFI would be awesome but I assume
> it's too difficult to pull off, unless an existing implementation is
> gradually turned into the sample implementation by adding features.
>

As far as I know there is no Scheme implementation that can run on a
trivial subset of Scheme (that is maximally portable across Scheme
implementations and Operating Systems), and that is easy to debug
(breakpoints, step debugger, variable inspection, one step macro
expansion). Including a garbage collector is too much work (I am
clueless about the subject). Regarding things like threads, network or
SRFI-170, it could be emulated (a portable C FFI can be a very useful
addition :).

> >> Would the people around SRFI be interested in formalizing the
> >> lightweight work we already more or less have?
>
> > I do not understand the question. What needs formalization?
>
> Really just blessing a monorepo with "official" status. The community is
> already doing work like this, but it's split into many libraries around
> the net, with different people working on each library. If we had one
> library that is known as a canonical one, with many people working on it
> (roughly, the people now writing SRFIs, plus anyone else who wants to
> join) people would slowly learn to trust it.

I agree. I still wonder whether being portable like the projects below
is not more work than the alternative I describe above. One drawback
of relying a lot on external implementations, is that if the
maintainer goes, scheme-live will end-up with debt code or we will
need to decide to drop support for that implementation, which is a
difficult choice.

Also I support your approach to request some formal acknowledgement
for this monorepo: the projects you mentioned below have tried to
reach an informal consensus, but did not succeed, it can be improved
and that is not wasted effort. scheme-live can probably re-use some of
those libraries.

> The library collections like Schemepunk, Yuni, Spells, Spheres, etc. are
> especially interesting as prior art. These are like Scheme Live, but
> tend to have one maintainer who stops working on it after a few years.
> Ideally we could roll all of them into one collection with enough people
> to ensure continued maintenance.

Those are great projects. Also it shows there is a strong interest
about the subject.