Good point. I have an idea what about we rank the features Scheme should have
like split them into percentages so they sum up into 100 that show the
progress bar like indicator how much it's complete.

For instance call/cc and TCO will be 10 each so LIPS would be 80% and Gambit
it it will have 100%. Or maybe better list all the features the Scheme should
have and calculate percentage based on max value. Those features can all be
same rank or they can have different ranks in will depend how much the
features is needed. If Gambit is so feature reach and have all needed parts
it will have 100% ranking and implementations can be sorted by ranks. So the
lowest rank will be at the bottom.

Example:

* TCO: 100
* call/CC: 100
* debugger: 100
* meaningful stack traces: 100
* Numerical Tower: 200
* syntax-rules: 400
* define-library and modules: 100
* at least one fully compatible standard R3RS or higher (not need to support
  other ranked features): 1000?

Each RnRS spec can have different ranking and R7RS can have higher ranking
then R5RS but that's just an option. If implementation is very good R5RS
Scheme I think it should have ranking as R7RS that are similarly good.

The numbers can be assigned using try and error, we need to test each
implementation and see how they rank and if the rank is similar to what you
would guess without the rank.

If think that it would be good idea to include all implementation even poorly
compatible with the standard, they can be less prominent and have lower
ranking, the progress bard can look like Coverage report (but not as
restrictive as Coveralls) I think that 80+ can be green 70+ can be
yellow and less then 70 can be red or maybe less then 50.

Example:
https://s3.amazonaws.com/assets.coveralls.io/badges/coveralls_75.svg

What are your thoughts about this?

Jakub

On Sun, 14 Feb 2021 09:52:37 +0200
Lassi Kortela <xxxxxx@lassi.io> wrote:

> Sorry about the delay in replying.
>
> Scheme.org is intended to reflect the collective will of the Scheme
> community (to the extent that such a will exists). Since schemers
> disagree on so many things, we probably have to err on the side of
> having less strict criteria to avoid stalemates and low engagement over
> the long term.
>
> Scheme implementation conformance is one recurring point of
> disagreement. As you point out, there are almost no strictly conforming
> implementations of any language, and most useful Scheme implementations
> have gaps in conformance (including Gambit).
>
> However, I agree that more conformant or otherwise more fully featured
> implementations should be displayed more prominently. It's an open
> question how to best do this. I suggest that we invent a set of
> objective criteria. I wish the community would get together to define
> those criteria, but I've mentioned the topic several times over the
> years and so far there has been little enthusiasm. Perhaps schemers wish
> to avoid upsetting implementers. Nevertheless, it seems clear that we
> have to invent the criteria at some point to settle questions like the
> one in this thread on neutral grounds.
>
> I already promised Jakub earlier that a lips.scheme.org is fine to have,
> and in general, I believe it's better to err on the side of having more
> projects on Scheme.org than less. However, Gambit has been one of the
> most advanced Scheme implementations for 30 years, and Marc should also
> have reassurance that Gambit is featured more prominently than new
> implementations that just got started.
>
> For defining the criteria, we could start with conformance, or start
> with how many features an implementation has.
>
> Empirically, there would seem to be a fairly natural split between
> implementations that have a native-code compiler (or compile via C to
> native code), and implementations that don't. Since writing a
> native-code compiler is a big and advanced project, and takes a long
> time, those implementations tend to be more full-featured in other ways
> too. So listing the native-code implementations and interpreter-only
> implementations in separate groups (e.g. on the Scheme.org front page)
> would go a long way.
>
> If we use conformance as the criterion, Chibi-Scheme makes for a good
> conversation starter. It's possibly the most conformant R7RS Scheme
> there is, but has a simple bytecode interpreter which is not
> particularly fast even for an interpreter. It has many tools (including
> FFI) and libraries, but is missing a debugger. So Chibi would be
> classified as very conformant, but not necessarily full-featured.
>
> Thoughts?

--
Jakub T. Jankiewicz, Web Developer
https://jcubic.pl/me