Picture this: Your Python code is finally bug-free, readable as a novel, and supercharged with IDE magic. But is this utopia worth the potential headaches of a rigid type system? Dive into the 2025 Python Typing Survey, where the community weighs in on the highs, lows, and hot debates surrounding type hints – and trust me, it's more controversial than you think.
Welcome to our deep dive into the 2025 Typed Python Survey, a collaborative effort spearheaded by experts from JetBrains, Meta, and the vibrant Python typing community. This year's report, boasting 1,241 responses – that's a solid 15% jump from last year – paints a vivid picture of Python's type system and the tools developers are using to harness it. In this piece, we'll unpack the major findings and trends, offering insights that could reshape how you approach coding in Python's open-source world. Whether you're a seasoned pro or just dipping your toes into typing, we'll break it down step by step to make it accessible and engaging.
But here's where it gets interesting: Who exactly is sharing their thoughts on this evolving landscape?
The survey kicked off on official social media channels from its creators and spread like wildfire through organic sharing on platforms like Reddit, email newsletters, Mastodon, LinkedIn, Discord, and Twitter. When we polled participants on how they first heard about it, Reddit came out on top as the most effective conduit, closely followed by email newsletters and Mastodon. This mirrors the eclectic online spaces where Python enthusiasts gather, exchange ideas, and build knowledge – a testament to the community's diverse and interconnected nature.
The crowd was heavily skewed toward experienced Python hands and typing aficionados. Roughly half of them claimed over a decade of Python know-how, with another third clocking in five to 10 years. Newcomers were present, but the bulk brought years of expertise to the table. Their familiarity with type hints was equally impressive; most had been using them for years, with only a tiny fraction reporting zero experience. It's like surveying car enthusiasts and finding out most have been driving for decades – insightful, but possibly not fully representative of the whole road.
And this is the part most people miss: Adoption rates that challenge assumptions about who embraces typing.
The results make it clear: Python's type hinting has embedded itself into the development workflow for the vast majority of engineers. A whopping 86% of respondents said they "always" or "often" incorporate type hints into their code – a steady figure from last year's survey (you can check it out here: https://engineering.fb.com/2024/12/09/developer-tools/typed-python-2024-survey-meta/). For beginners, this might sound straightforward, but let's clarify: type hints are like labels on your code's variables and functions, helping catch errors early without changing how Python runs.
For the first time, we dug into respondents' years of experience with Python and typing specifically. Adoption held steady across levels, but with intriguing twists:
- Developers with 5–10 years under their belt were the biggest fans, with 93% regularly using type hints.
- Junior coders (0–2 years) lagged a bit at 83%, possibly due to the initial hurdle of learning the ropes – a theme that echoed in other questions.
- Veterans with 10+ years were the least enthusiastic, at just 80%, which could stem from habits formed before type hints existed or struggles with retrofitting older, sprawling codebases.
Overall, type hints enjoy broad acceptance in the Python realm, with backing from all experience tiers. That said, keep in mind potential selection bias: folks who love and use typing might be more inclined to chime in on a survey about it, possibly skewing the picture rosier than reality.
Now, for the love-hate relationship: What do developers cherish about Python typing?
We asked what they adored about the system, and while some bluntly said "nothing" (hey, opinions are like type annotations – optional!), positivity dominated. Here are the standout themes, explained simply for those new to the concept:
- Flexibility in Adoption: Unlike mandatory systems in other languages, Python's typing is optional and gradual. You can add hints bit by bit to existing projects without overhauling everything, giving developers control over their pace – think of it as upgrading your bike with gears one at a time rather than buying a whole new model.
- Boosted Readability and Documentation: Type hints act like built-in comments, clarifying what your code does. For larger teams or complex projects, this makes understanding and maintaining code much easier – imagine reading a recipe with clear ingredient lists versus guessing what "a dash of that" means.
- Superior Tooling and IDE Magic: Typing unlocks powerful IDE features, such as smart autocomplete, jumping straight to definitions, and inline hints. Tools like VS Code or PyCharm transform your coding experience, catching issues before you even run the code.
- Bug Busters and Reliability: By spotting errors during development or refactoring, typing builds confidence in your code's robustness. It's like having a safety net that prevents subtle bugs from slipping through – especially handy for beginners learning to debug.
- Expressiveness and Power: Fans rave about features like protocols (customizable interfaces), generics (reusable types for different data), and runtime inspection for libraries like Pydantic or FastAPI. For example, generics let you create a list that works with any type, making your code more versatile without repetition.
But here's where it gets controversial: The flip side – challenges that make some developers groan.
Balancing the positives, we inquired about the toughest hurdles. Over 800 responses highlighted these pain points, and they're worth exploring because they reveal where the type system might not be living up to everyone's dreams:
- Third-Party Library Woes: Integrating with libraries lacking proper type annotations (think NumPy for data science or Django for web apps) can be frustrating, as incomplete or wrong hints lead to confusion.
- Advanced Feature Complexity: Concepts like generics, TypeVar (for varying types with rules), and decorators often feel daunting – picture trying to juggle multiple balls while learning the rules of a new sport.
- Tooling Chaos: Inconsistencies between checkers like Mypy and Pyright, plus slow performance, create a fragmented ecosystem. Many yearn for an official, fast, built-in checker to standardize things.
- No Runtime Muscle: Since typing isn't enforced by Python itself, it's hard to mandate its use or trust hints fully, especially in dynamic code that changes behavior on the fly.
- Verbosity and Readability Dips: Complex hints can clutter code, making it feel less "Pythonic" (that is, not aligning with Python's clean, readable ethos). For instance, describing a nested dictionary might require verbose annotations that distract from the logic.
- Legacy Code Struggles: Retrofitting typing into old, dynamic codebases is tough, as Python's freedom with types clashes with static expectations.
- Evolving Limitations: Compared to TypeScript, Python's system feels incomplete, with rapid changes meaning best practices shift constantly.
This sparks debate: Is the verbosity a necessary evil or a deal-breaker for Python's zen?
Diving deeper into desires: What features are developers begging for?
Almost half the group shared wishlist items for Python's type system. Their top requests include:
- Borrowing from TypeScript: Ideas like intersection types (combining types with an & operator), mapped types (transforming structures), and utility types (tools like Pick for selecting parts of objects) could make typing more flexible. For example, structural typing for dicts might allow more intuitive handling of dictionaries without rigid schemas.
- Runtime Power and Speed: Optional enforcement at runtime, plus optimizations like JIT compilation using hints, to make code faster and more trustworthy.
- Stronger Generics and ADTs: Higher-kinded types, better TypeVarTuple support, and algebraic data types (like Rust's enums for safe error handling or options) would add expressiveness – think of ADTs as predefined patterns for common scenarios.
- Tooling and Syntax Upgrades: An official checker for consistency, shorthand like ? for nullable types instead of | None, and clearer docs for complex patterns like NumPy arrays.
- Dynamic Pattern Mastery: Better typing for decorators, ORM attributes (in frameworks like Django), and type narrowing (refining types based on conditions).
Here it gets provocative: Adding TypeScript-like features could make Python typing a powerhouse – or dilute its unique charm?
Tooling trends: The evolving arsenal.
Python's typing tools are in flux, with veterans and newcomers vying for developers' hearts. Mypy remains the king, used by 58% (a slight drop from 61% last year – see https://engineering.fb.com/2024/12/09/developer-tools/typed-python-2024-survey-meta/), but Rust-powered checkers like Pyrefly, Ty, and Zuban are surging, now claiming over 20% of users collectively. For beginners, this means exploring these tools could level up your code quality, much like switching from a basic bike to an electric one.
In IDEs, VS Code reigns supreme, trailed by PyCharm and vim variants. Type-checking integrations mirror this, with VS Code's Pylance/Pyright and PyCharm's built-in support leading the charge.
And this is the part most people overlook: How the community learns and evolves.
Education on typing blends official sources, community vibes, and AI smarts, echoing last year's trends (https://engineering.fb.com/2024/12/09/developer-tools/typed-python-2024-survey-meta/). Official docs are the cornerstone, with 865 citing them for learning and 891 for troubleshooting. Dedicated typing guides and checker docs are also staples, proving authoritative materials are timeless.
Blog posts have risen to second place for learning, surpassing online tutorials, code reviews, and YouTube. Community hubs like Reddit (now third for news) are booming, alongside newsletters, podcasts, and Mastodon.
AI is making waves: Over 400 use LLM chat tools, and nearly 300 rely on in-editor AI suggestions for typing woes.
Opportunities ahead: Shaping Python's typing future.
The survey underscores typing's growth and spotlights improvement areas:
- Broader Library Support: Expanding annotations in key packages will make typing practical for all – imagine if every recipe book came with nutritional labels.
- Enhanced Learning Paths: Beyond docs, tapping blogs, newsletters, and Reddit can spread knowledge widely.
- Tooling Harmony: Standardizing checkers or clarifying differences will reduce confusion, fostering a unified ecosystem.
For more on Meta Open Source, head to https://opensource.fb.com/, subscribe to our YouTube (https://www.youtube.com/channel/UCCQY962PmHabTjaHv2wJzfQ), or follow on Facebook (https://www.facebook.com/MetaOpenSource), Threads (https://www.threads.net/@metaopensource), X (https://x.com/MetaOpenSource), Bluesky (https://bsky.app/profile/metaopensource.bsky.social), and LinkedIn (https://www.linkedin.com/showcase/meta-open-source?fbclid=IwZXh0bgNhZW0CMTEAAR2fEOJNb7zOi8rJeRvQry5sRxARpdL3OpS4sYLdC1npkEy60gBS1ynXwQaem_mJUK6jEUApFTW75Emhtpqw).
Acknowledgements
This survey ran from August 29 to September 16, 2025, collecting 1,241 responses.
A huge thank you to all participants – your insights drive Python typing forward!
Special shoutout to the JetBrains PyCharm team for the graphics.
So, what's your take? Do you think Python's optional typing strikes the perfect balance, or should it borrow more from stricter languages like TypeScript? Is the learning curve worth the bug-busting perks? Share your thoughts in the comments – agree, disagree, or drop a counterpoint. Let's discuss!
