Daphne Preston-Kendal <xxxxxx@nonceword.org> writes:

> I am happy to respond to constructive, actionable criticism of our processes,
> but ‘I don’t like it’ is neither constructive nor actionable.

1. It's uniquely annoying to write portable Scheme, because each
   implementation has inconsistent library support.

2. In order to find documentation for writing portable Scheme, you need
   to consult at least 3 different websites simultaneously (the
   standard, SRFIs, implementation).

3. No reference implementations, so lots of duplication of work. The
   SRFI examples often are not portable (especially the older ones), and
   need to be put together piecemeal, because there is no standard for
   package management.

4. The largest program written in Scheme, the Guix package manager, does
   not have a way to install or (re)use R7RS libraries, ironically.

5. There's no Scheme Foundation, and no way to connect with other
   Schemers in a given geographic area, etc. Most of the different
   Scheme sub-communities are really just a few people, a webpage, and
   maybe a mailing list.

6. The steering committee's activities seem completely opaque. What do
   they discuss? What decisions do they make? How will it affect the
   direction of the language? How is their membership decided? How
   active are they?

7. As Marc mentioned, the difficulty in following what is going on
   where. The reason I didn't reply to your initial message for a few
   days is because I wasn't subscribed to srfi-discuss, and had no idea
   you responded.

8. It's unclear who has the ability/authority to make any sort of
   change. Could you address any of the above, if you wanted to?
   Hypothetically, if most people agree that N=3 is not sufficient,
   would you have to get approval from the steering committee to change
   it? What would happen if they disapproved?

> I am really not sure what we can do to make the process more ‘transparent’. But
> it’s especially hard to know when people apparently have ideas such as that ICFP
> is somehow part of the process.

That is part of the transparency problem. I heard about ICFP from the
WG2 mailing list. Hosting meetings at ICFP is inaccessible and
problematic: the price and logistics of attending such a conference
keeps most Scheme users out. Unsure if that is the intention.

And the WG2 mailing list appears to only be available on Google Groups,
disjointed from any of the other Scheme sites.

> *All* current Scheme implementations are fundamentally volunteer efforts. (Chez
> was the exception, but is no longer a commercial product, and it’s not clear to
> me that Cisco is really paying anyone to work on it.) Some volunteers in some
> communities (mostly Racket and Gambit) are also working on those implementations
> as part of academic projects which result in some papers being published on how
> such-an-implementation was used to try out such-an-idea. Thus it has ever been:
> Scheme is still an academic language for the most part, although it has picked
> up a strong hobbyist contingent in the last 20 years.

I disagree. The Scheme track at ICFP only has a handful of talks now,
and most are about teaching.

Maybe it would be better to focus on the "hobbyist" contingent? I think
that would be a more realistic mental model of the average Scheme user.
And be more feasible with the relatively small number of people working
on the language and its spec.

Also, calling that area "hobbyist" is a bit misleading. For example, an
entire Linux distro (Guix) is written in Scheme, and has an active
community that is completely separate from the community here,
unfortunately.

> The fact that implementers are still largely volunteering their efforts means we
> have to be careful about scope. The N=3 rule is *one* of the tools we have to
> reduce scope to keep implementability within reach. But, yes, the Large language
> will be a large language, suitable for the needs of mainstream software
> development. You don’t crank out an implementation of Python, Go, or Haskell
> overnight, either. Loko shows that new implementations of a language on the
> scale of R6 are possible (admittedly, Gwen Weinholt is also a deity-level
> programmer), and the core of the Foundations is a cleaned-up R6. If you want
> something you can really implement in a few days to a few weeks, the small
> language is there for a reason.

It doesn't have to be this way. If a Large reference library were
provided, then Small implemetations would get Large for free. However, I
think Scheme currently lacks the coordination to create and maintain
such a library. I would be happy to be proved wrong on that though!