DDX for PostgreSQL — Merit Ranking
WHAT THIS RANKING IS
The people list is ordered by a merit score: a blend of signals observable in the public archives, meant as a rough activity-and-quality signal, not a judgement of worth. It is one estimation among many. Contribution is not truly measurable; a 12-line bug fix can matter more than a 6,000-line rewrite. People appear here because their work shows up in public archives; people who are absent are not less valuable.
Every input below is already public (mailing lists, the postgres git history,
commitfest, the buildfarm). We compute no private data and store nothing about readers.
THE FORMULA
Each component is normalized to the range [0, 1], then combined. For a non-committer:
merit = 0.30 · contribution
+ 0.25 · authored_landed
+ 0.20 · credibility
+ 0.25 · patch_readiness
− 0.10 · revert_rate (clamped to [0, 1])
For a committer, the patch-readiness weight is cut to 0.05
(see Patch readiness for why), and the freed 0.20 is
redistributed across the other three factors in proportion:
merit = 0.38 · contribution
+ 0.3167 · authored_landed
+ 0.2533 · credibility
+ 0.05 · patch_readiness
− 0.10 · revert_rate (clamped to [0, 1])
Engaged people (committers, or anyone with a landed authored commit, who also
appear in the lists' To/Cc traffic) have that base scaled to 0.80 and get the freed
0.20 from how the community engages with them (see Engagement):
merit = 0.80 · base
+ 0.10 · engagement_power
+ 0.10 · breadth (engaged people only)
Three bonus terms are then added for everyone, and the sum is clamped to [0, 1]:
+ security_bonus (0 … 0.15)
+ volunteer_bonus (0 … 0.09)
+ extension_bonus (0 … 0.10)
The people list is sorted by this score, highest first.
THE COMPONENTS
Contribution (0.30)
Breadth and frequency of participation: log(1 + total_contributions) / log(1 + max),
where total_contributions is the person's commits plus mailing-list messages in the
core/all-time bucket, and max is the most prolific contributor's figure. The logarithm
compresses a four-order-of-magnitude range so the gap between rank 1 and rank 100 is a fraction,
not 10,000×.
Authored-landed (0.25)
Distinct postgres commits that credit the person as Author: or
Co-authored-by: in the commit trailers, log-scaled against the top author. This rewards
a non-committer whose patch reached commit, regardless of who pushed it — so you
are not penalized for lacking commit access.
Credibility (0.20)
Endorsement by committers. We build a directed interaction graph (who replies to whom on the lists, who credits whom in commit trailers) and sum the edge weight flowing into a person from the project's committers. Being reviewed, tested, or replied-to by the people who gate commits counts; attention from an unknown does not. This is the structural reading of "committer sentiment": the judgement of those whose approval is required to commit.
Patch readiness (0.25 non-committer / 0.05 committer)
How committable a submitted patch was — how little a committer had to change it.
For each commit that links a Discussion: thread, we take the last patch posted
to that thread and compare it to what landed:
- Code edit distance. We break both the submitted patch and the commit into
(file, hunk) units, compare the hunks the commit touched, and compute a normalized edit distance
over the code lines only — comments are stripped (per language: C/SQL block and line
comments, Perl/shell
#, SGML<!-- -->, Python#). Insignificant whitespace is ignored, except in whitespace-significant languages like Python, where indentation is kept. We deliberately do not normalize awaypgindentreformatting: if the author did not run it, the committer's reflow is real work the patch required, and counts. - Commit-message similarity. Token-set cosine between the submitted proposed
message and the committed message, after stripping metadata trailers (
Author:,Reviewed-by:,Discussion:, etc.) from both. - Comment deltas. Comment lines the committer added or removed are recorded and count against readiness — a committer rewriting the comments is work the author should have done.
readiness = 0.6 · code_similarity + 0.4 · message_similarity
− comment_churn_penalty (clamped to [0, 1])
Why committers are discounted. For a committer, "submitted vs committed" is just their own self-revision — they commit their own work and will not change it much, so a high score is automatic and a low one only means they reshaped their own patch at push time, which is not a quality deficit. So readiness carries almost no weight for committers; it is a real signal only for non-committers whose patch a committer had to judge and land.
Readiness requires at least 3 measured patches; below that, the sample is too thin
and the score falls back to a neutral 0.5 (neither reward nor penalty). Measurement is
incremental — a nightly job works through the backlog — so a person's readiness may read neutral until
enough of their patches have been measured.
Revert rate (−0.10)
The fraction of a person's landed authored commits that were later reverted (traced through the
This reverts commit <sha> trailer). Code that had to be backed out is a negative
quality signal, so it subtracts from merit.
PeopleRank (used by engagement power)
PageRank over the interaction graph described under Credibility: 40 iterations, so a person's score is high when people who are themselves central reply to them and credit them. It is not a term of its own in the formula; it weights who is engaging with whom.
Engagement: power and breadth (0.10 each, engaged people only)
Who writes to you, and how many people you talk with both ways. From every message's From and To/Cc headers we take each distinct (sender, addressee) pair of known people.
- Engagement power sums the PeopleRank of everyone who has addressed you, normalized to the highest figure. Being written to by central people counts more than by peripheral ones.
- Breadth counts the people with whom the exchange is reciprocal (you have written
to them and they to you), as
log(1 + n) / log(1 + max).
Only engaged people get these terms, so someone who only posts to the lists is not ranked on attention alone.
Security-work bonus (0 … 0.15)
Security fixes are coordinated privately: most of the work (analysis, patch review,
back-and-forth) happens on the closed security list before the fix lands with a
Security: CVE-… trailer, so the public archive under-counts it. The bonus uses public
data only:
security_bonus = max( 0.02 if on the public Security Team roster,
0.15 · log(1 + cves) / log(1 + max_cves) )
cves is the number of distinct CVEs a person authored or co-authored a fix for; for
members of the public Security Team roster,
CVE fixes they committed count too, since the team lands them. One fix is about 0.02; the
top fixer gets the full 0.15. Roster members with no CVE commits get the
0.02 floor for triage and disclosure work that never reaches git. The bonus is shown on each
person's profile and in the API.
Extension bonus (0 … 0.10)
Building and maintaining PostgreSQL extensions is community work that the core archive does not
see. For each extension a person leads or contributes to, we take the extension's usage weight (a
proxy from Debian popularity-contest installs and GitHub stars, since PGXN publishes no usage ranking)
times 1.0 for a lead or 0.35 for a contributor:
extension_bonus = 0.10 · min(1, Σ over extensions of usage_weight · role)
The extensions and their people are listed at /api/v2/extensions.
Volunteer bonus (0 … 0.09)
Running a Recognized PostgreSQL User Group (organizer, committee,
or board) is real community service that leaves little public-archive footprint, so it is credited
directly: 0.03 per group a person volunteers for, capped at 0.09. These
memberships are recorded from the group's public roster or the person's own statement — never inferred
from activity.
WHAT WE DO NOT MEASURE
Two signals that would be reasonable to want are not computed, and we will not fabricate them:
- Textual sentiment / tone. There is no sentiment model over the mail corpus. The structural proxies above (committer endorsement, revert rate) stand in for "how the work was received"; we do not invent a tone score.
- Byte-level patch drift. We measure how many revision rounds and how much code distance a patch needed, not a perfect diff of the exact submitted bytes against the committed bytes — submitted patch bodies are not all stored in a form that allows it. The code-edit-distance above is the honest approximation.
IDENTITY AND BOTS
A person's many email addresses are coalesced into one identity (manual curation plus email/name matching), so contributions under a personal gmail and a work address count together. Automated/role accounts (CI bots, shared ops addresses) are excluded from the ranking.
If your identity is split, merged wrong, or your employer is off, see the community page for how corrections are made.
HOW OFTEN IT UPDATES
The contribution, authored-landed, credibility, and revert components refresh with the nightly data pipeline. Patch readiness is backfilled incrementally by a nightly job, so coverage (and thus the readiness component for people with few measured patches) grows over time.
See status for data freshness, and data for the raw datasets.