How many Python core devs use typing?

The optional type annotations in Python is a big and relatively new thing. For the majority of its life, Python didn’t have any good solution for static type checking, and people coming to the language fell in love with it for different reasons.

Today’s case study: how many old-school Python developers use type annotations? Specifically, we’ll be looking at the core developers because these are mostly people the most dedicated to the language.

TL;DR: Out of all Python core devs ever, about 53% have recent open-source projects, and 39% of them use type annotations. Out of people joining the team in the past 3 years, 76% use type annotations.

The list of core developers

First, we need a list of Python core team members. Not only present but past as well. We don’t want to fall for survivorship bias and miss the people who left because they don’t like the new language direction.

The sources I’ve found:

• devguide.python.org is the best source. It includes names, dates, and GitHub usernames. 188 people.
• github.com has a list of CPython contributors, about 2500 people at the moment who ever changed even a single line of Python code.
• github.com also has a list of the Python org members.
• discuss.python.org list 105 CPython core developers.

Methodology

I open the GitHub page of the person (or find another website they use for hosting open-source projects), find the latest non-fork project, and check if it has type annotations. I look only at projects updated in the past few years. I prefer checking public libraries created for others to use but if there are none, I also check scripts they have for their own use (like a script to deploy a personal blog).

Since the process is manual and tedious and the list is long, I might be wrong in some cases. Contributions are welcome.

The list

Legend:

• ✅: uses type annotations (in any capacity).
• ❌: no projects with type annotations.
• 🤷: no public projects in the past 5 years.
• ?: no GitHub profile. They might have projects somewhere else.

From new to old:

Summary

Numbers:

• Total: 190
• Currently active: 109
• ✅: 39
• ❌: 61
• 🤷: 36
• ?: 54

All results from old to new:

✅ 🤷 ❌ ❌ ❌ 🤷 🤷 🤷 ❌ ? ? ? ? ? ❌ 🤷 ? ❌ ❌ ? ? 🤷 ? 🤷 ? ❌ ❌ ? ? ? ? 🤷 ? ? ? ? ✅ ? ? ✅ ? ❌ ? ❌ ✅ ? ? ? ✅ 🤷 ? ? ? ❌ ❌ 🤷 🤷 ? ? ❌ ? 🤷 🤷 ❌ ❌ ✅ ? ? ? 🤷 ? ? ? ❌ ❌ ? 🤷 ? ? ? ❌ 🤷 ❌ ❌ ❌ ❌ ? ? 🤷 ? ❌ ❌ ❌ ? ❌ ✅ ❌ ✅ 🤷 ❌ ? ❌ 🤷 ❌ ❌ 🤷 ? ❌ ? ❌ ❌ ❌ ✅ 🤷 ? ✅ ✅ ❌ 🤷 ❌ ? ✅ 🤷 ? ? ❌ ❌ 🤷 🤷 ❌ ✅ ? ✅ ? ❌ ❌ ✅ ❌ ✅ ❌ ✅ 🤷 ✅ ❌ ❌ 🤷 ✅ ❌ 🤷 🤷 🤷 ❌ ❌ ❌ ✅ ✅ ❌ ✅ 🤷 ❌ ❌ ❌ 🤷 ❌ ❌ ✅ ❌ 🤷 ❌ ✅ 🤷 ✅ ✅ ✅ 🤷 ✅ ✅ ❌ ✅ 🤷 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ❌ ✅

Results from old to new with removed unknowns:

✅ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ✅ ✅ ❌ ❌ ✅ ✅ ❌ ❌ ❌ ❌ ❌ ✅ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ✅ ❌ ✅ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ❌ ✅ ✅ ✅ ❌ ❌ ✅ ❌ ❌ ❌ ✅ ✅ ❌ ❌ ✅ ❌ ✅ ❌ ✅ ✅ ❌ ❌ ✅ ❌ ❌ ❌ ❌ ✅ ✅ ❌ ✅ ❌ ❌ ❌ ❌ ❌ ✅ ❌ ❌ ✅ ✅ ✅ ✅ ✅ ✅ ❌ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ❌ ✅

Results from old to new for currently active members:

✅ ❌ ❌ ❌ ❌ ❌ 🤷 ❌ 🤷 ❌ 🤷 ✅ ✅ ❌ ❌ ✅ 🤷 ❌ ❌ 🤷 ❌ 🤷 ❌ ❌ ✅ ❌ ❌ ❌ ❌ 🤷 ❌ ❌ ✅ ❌ ✅ ❌ ❌ ❌ 🤷 ❌ ❌ ❌ ❌ ✅ 🤷 ✅ ✅ 🤷 ✅ 🤷 ❌ ❌ 🤷 ✅ ✅ ❌ ❌ ✅ ❌ ✅ ❌ ✅ 🤷 ✅ ❌ ❌ 🤷 ✅ 🤷 🤷 ❌ ❌ ❌ ✅ ✅ ❌ ✅ 🤷 ❌ ❌ ❌ 🤷 ❌ ❌ ✅ ❌ 🤷 ❌ ✅ 🤷 ✅ ✅ ✅ 🤷 ✅ ✅ ❌ ✅ 🤷 ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ❌ ✅

• The total number of Python core devs using type annotations depends on how you count:
  • 21% (39/190) if you count unknowns.
  • 39% (39/100) if you consider only people with recent open-source activity.
  • 35% (38/109) or 44% (38/87) if you count only current team members (including and excluding unknowns).
  • 76% (16/21) if you count only people who joined the team since 2020.
• Around 47% ((36+54)/190) of all Python core developers don’t have their own open-source projects and haven’t made any open-source contributions in recent years. Probably, many of them are simply retired; the language is over 30 years old.