Add a proposed mechanism for tracking known "quality" implementations.

There is obvious overlap here with our existing list of implementations
-- note though that we have loose (or no) criteria for listing
implementations on the page.

Here instead we wish to specifically raise languages for which we know
no good implementation to exist, despite the language being popular or
widespread, if any.

What's here does *not* yet render this data anywhere, nor does it
implement the dynamic API calling mentioned in the body (for retrieving
statistics from any listed repository).

What it does do is identify a simple initial list of languages (from
TIOBE and GitHub's own lists), and propose a format for tracking data
points about implementations meeting the proposed criteria.

The initial goal is to get feedback on this template, and to solicit
help in filling it in for these languages.

Refs: json-schema-org/community#418

data/validator-libraries-by-language.yml

@@ -0,0 +1,90 @@
+# This file, unlike the adjacent validator list data files, collects metrics to try and assist in identifying "higher quality" implementations.
+#
+# Absence from this list is not meant to be a slight against anyone or anyone's work certainly.
+#
+# The goals are to constructively help users choose libraries for their desired environment, and to identify gaps in the ecosystem that might need help.
+# In that spirit, the collection of languages below is simply an initial list, based largely on:
+#
+#   * the GitHub popularity list (https://octoverse.github.com/2022/top-programming-languages)
+#   * the TIOBE index (https://www.tiobe.com/tiobe-index/)
+#
+# where it combines languages at the top of the popularity list with those on the rising / fastest growing list.
+#
+# Only partial information is filled in here.
+#
+# You can help!
+# For each language, we wish to track whether one or more known implementations exist which:
+#
+#   * Fail less than 2% (around 30) tests from the official JSON Schema test suite
+#     (This 2% number was chosen simply because it represents the dividing point between one cluster of implementations supported by Bowtie.
+#      Above this number is a collection of implementations failing larger orders of magnitude of tests).
+#   * Supports one of the most recent 2 releases of JSON Schema
+#   * Has had a release of itself in the last 3 years (which is around the timeline on which JSON Schema itself has seen its last release)
+#   * Has had some human-authored commit in the last year
+#   * Does not have explicit indication, by its maintainer or documentation, that it is not production ready
+#
+# and then highlight any languages for which this is not the case.
+#
+# For languages that *do* have one or more such implementations, we then wish to include:
+#
+#   * the name and link to the implementation
+#   * the date of its last commit
+#   * the date of its last release
+#   * the number of open security vulnerabilities it has, if known
+#   * the number of open issues it has on its issue tracker
+#   * the number of open pull requests it has
+#   * whether it implements some or all of the interfaces specified on our Common Interfaces page (https://json-schema.org/implementers/interfaces),
+#     and if so, which
+#
+# A number of the above data points are likely to change often.
+# We therefore assume only some of the above should be tracked in this file.
+# The remainder will likely be fetched dynamically from the GitHub API (or equivalent, for any implementations hosted elsewhere).
+#
+# An example entry for this file is then:
+#
+# - language: Blub
+#   implementations:
+#     - name: jsonschema-ftw
+#       url: https://example.com/someone/jsonschema-ftw
+#       known_to_have:
+#         many_failing_tests: false
+#         recent_draft_support: true
+#         recent_release: true
+#         recent_commit: true
+#         non_production_status: false
+#       metrics:
+#         # last_commit_date: fetched from GitHub
+#         # last_release_date: fetched from GitHub
+#         # open_security_vulnerabilities: fetched from GitHub
+#         # open_issues: fetched from GitHub
+#         # open_prs: fetched from GitHub
+#       known_interfaces:
+#         instance-validation: https://docs.jsonschema-ftw.com/validation/validate_function
+#         version-detection: https://docs.jsonschema-ftw.com/validation/version_of_schema
+#                  
+# Note that *not* all of the above must precisely match the above!
+# Specifically, an implementation with *no* recent commits is not disqualified from being considered "high quality".
+# One with a high number of failing tests however, is indeed likely not to meet the definition.
+# The above is simply meant to track these data points without necessarily imposing all of them as gospel -- users of these libraries should make their own judgements there.
+#
+#
+# Please pick a language you're familiar with and feel free to fill in such an entry!
+# When updating this page, it also is helpful to double check that what you find about an implementation is also up to date in the adjacent implementation data files (which track slightly different data points).
+#
+# Feedback on this format itself is also welcome in an issue!
+
+- language: C
+- language: C#
+- language: C++
+- language: Command Line / Shell
+- language: Go
+- language: Java
+- language: JavaScript
+- language: Kotlin
+- language: Lua
+- language: PHP
+- language: Python
+- language: Ruby
+- language: Rust
+- language: Swift
+- language: TypeScript