← Back to all briefings
Developer 5 min read Published Updated Credibility 40/100

Developer Briefing — Python 3.8.0 release

Python 3.8.0 shipped on 14 October 2019 with assignment expressions, positional-only parameters, and a new C API vectorcall protocol that changes performance baselines and linting rules for teams planning migrations off Python 3.6/3.7.

Zeph Tech Research Lead

Research lead, Zeph Tech

Horizontal bar chart of credibility scores per cited source.
Credibility scores for every source cited in this briefing. Source data (JSON)

Python 3.8.0 was released on 14 October 2019. The version introduces assignment expressions (:=), positional-only parameters, improved typing support, and the new vectorcall calling convention in the C API. Migration plans must account for syntax changes that will fail on earlier runtimes and for packages that embed CPython and need recompilation to take advantage of vectorcall speedups. Teams targeting long-term security support should plan for Python 3.8 because upstream mainstream support for Python 3.6 ends in December 2021 and for 3.7 in June 2023.

Key language and runtime changes

Assignment expressions allow inline binding within expressions, reducing duplicated calls in comprehensions and while loops. Static analysis tools may flag misuse that hurts readability, so code review checklists should clarify when := is acceptable. Positional-only parameters (PEP 570) enable API designers to prevent callers from using keyword arguments for specific parameters, avoiding accidental coupling when public APIs change. The runtime also adds parallel filesystem cache invalidation for .pyc files, reversing some performance regressions in containerized deployments that mount networked volumes.

The vectorcall protocol (PEP 590) changes how C extensions call Python objects, reducing overhead in tight loops. C extensions must be rebuilt to use the new fast-call path, and extension authors should review macro changes before upgrading. Python’s initialization configuration now supports isolated mode improvements, which alter how environment variables and configuration files are discovered during embedded interpreter startup—important for applications bundling Python.

Impact on packaging and CI

Because the walrus operator and positional-only parameters are syntax-level features, linters and formatters must be upgraded. Black 19.10b0 and later understand assignment expressions, while older releases will fail formatting jobs. Flake8 users should pin to releases that include pyflakes support for the walrus operator to avoid false positives. Type checkers such as mypy need to be upgraded to versions after October 2019 to handle typing.Final and Literal improvements included in 3.8.

CI systems should expand matrices to test against 3.8 while retaining 3.6/3.7 coverage. Wheels and manylinux builds must be regenerated because ABI tags change to cp38; deployment artifacts built for older versions will not load in 3.8 environments. Pip bootstrapping also changed with the bundled ensurepip version, so hermetic build pipelines should verify that pinned tooling remains reproducible under the new runtime.

Operational and performance considerations

Vectorcall can yield measurable performance improvements for frameworks like NumPy and asyncio-heavy services once dependencies ship compatible builds. SREs should run comparative benchmarks on critical services to verify latency profiles and memory consumption, especially for workloads with many small function calls. The new runtime adds audit hooks (PEP 578) and an initialized configuration API (PEP 587), which affect security hardening and embedding scenarios; teams embedding Python must adjust initialization code to set audit callbacks and to avoid loading untrusted sitecustomize files.

Logging and observability pipelines should add markers for Python 3.8 deployments so that crash signatures and performance counters can be correlated with runtime changes. The standard library added statistics.fmean, math.prod, and importlib.metadata; import paths that previously used importlib_metadata backports should be simplified to the standard library when running exclusively on 3.8.

Migration playbook for the next quarter

  • Upgrade linters, formatters, and type checkers to releases compatible with assignment expressions and positional-only parameters, and add CI guards to block older tool versions.
  • Rebuild C extensions and native wheels for cp38 and run smoke tests on services embedding CPython to validate initialization changes and audit hooks.
  • Run performance benchmarks for representative workloads to measure vectorcall gains and confirm memory profiles before promoting 3.8 to production tiers.
  • Update developer documentation and API guidelines to clarify acceptable use of the walrus operator and positional-only parameters to preserve readability.

Security teams gain new audit hooks (PEP 578) that emit events for import operations, subprocess creation, and socket connections. To benefit, organizations must register audit callbacks and ensure log pipelines can ingest the higher event volume without dropping records. The runtime also exposes sys.audit for application-level events; developers should add calls around sensitive workflows such as deserialization and dynamic code execution to make incident response faster.

PEP 587 overhauls the initialization configuration, allowing embedders to pass structured settings instead of relying on environment variables. Teams that ship Python inside desktop or mobile applications should migrate to the new API to avoid unexpected module search paths and to explicitly disable reading PYTHONPATH from the environment. This matters for sandboxed packaging systems where users could otherwise inject modules.

Documentation and training should stress compatibility rules: binaries compiled for Python 3.7 cannot run on 3.8 due to ABI changes, and features like positional-only parameters will break callers pinned to older runtimes. Maintaining dual support requires conditional imports and feature flags in shared libraries, with continuous testing on all supported Python versions until clients complete their migrations.

Organizations that rely on older OpenSSL features should note that Python 3.8 ships with OpenSSL 1.1.1, enabling TLS 1.3 by default on many platforms. Network teams should validate inspection and monitoring tools for TLS 1.3 compatibility, and update service allowlists to accommodate the new cipher suites.

Platform teams should formalize rollout stages: enable Python 3.8 in non-production builds, gather telemetry on memory usage and startup time, then graduate a small set of stateless services before tackling machine-learning workloads that bundle complex C extensions. Document rollback steps for container images and virtual environments so that production incidents can revert to 3.7 without dependency drift.

Education efforts are essential. Offer brown-bag sessions that demonstrate valid and invalid walrus operator usage, show how positional-only parameters can simplify API stability, and remind developers that readability remains the primary gate for accepting new syntax. Include lint rules and code review checklists in engineering handbooks to reduce subjective debate during adoption.

Consider adding canary feature flags that restrict walrus usage in shared libraries until downstream consumers finish their interpreter upgrades, reducing surprises for integrators.

Document dependency minimums in project templates so new services start with Python 3.8-ready tooling rather than retrofitting after the fact.

By executing this playbook, teams can adopt Python 3.8 to gain performance and security improvements while keeping multi-version compatibility for consumers still on Python 3.6 and 3.7.

Horizontal bar chart of credibility scores per cited source.
Credibility scores for every source cited in this briefing. Source data (JSON)

Related briefings

Curated signals from the same pillar or overlapping topics.

Continue in the Developer pillar

Return to the hub for curated research and deep-dive guides.

Visit pillar hub

Latest guides

  • Python
  • Runtime Lifecycle
  • Language Features
  • Performance
  • Tooling
Back to curated briefings