As SRFI deadlines approach and the pre-SRFI queue grows, I am once again
asking for your moral support in considering a more lightweight process.

Scheme now has two standards processes:

- RnRS (very slow, very careful, got to get things right at once)

- SRFI (somewhat slow, careful, prefer to get things right at once)

We are missing a third process:

- very fast, not that careful, prefer to ship quickly and clean up later

I argue that a lot of the time we use SRFI and occasionally even RnRS to
design solutions to problems that we don't truly understand. It would be
better to solve these problems using a process that is tolerant
mistakes. This would better account for intrinsic human limits in
predicting the future and reasoning about unknown circumstances, and
alleviate the perfectionism and analysis paralysis that many of us
succumb to from time to time.

I previously suggested establishing Scheme Live (fledgling GH
organization at https://github.com/scheme-live/live) which got off to a
good start but only Amirouche and I have committed code so far.

What spurred me to write this email is that I just realized we could
basically dump the preliminary code from https://github.com/pre-srfi
into one monorepo and it would be a perfectly good start for a
lightweight design process. We could add in the R7RS-large SRFIs and the
code from https://github.com/scheme-live/live too, resolving any
duplicate functionality so there's one library for any given job.

We https://github.com/pre-srfi we basically have all the technical
trappings of a lightweight process already. We're just doing it Big
Design Up Front style out of habit.

In all discussions of this kind, it bears repeating that this is first
and foremost a social issue: a group of people have to decide to work
together and resolve problems by talking instead of forking code. The
good news is that that's the way we already resolve problems in SRFI.

Would the people around SRFI be interested in formalizing the
lightweight work we already more or less have?