Learning Python - Migration, Scaling Teams & Governance

#Introduction

You've built, tested, deployed, and monitored applications. Episode 22 closes the journey with the aspects that determine long-term success: migration, scaling teams, and governance. This is about how Python projects are managed as teams and codebases grow.

We'll cover safe Python version upgrades, deprecation policies, monorepo versus polyrepo, internal packages, plus coding standards and contribution guidelines. This is the senior engineer perspective that separates amateur teams from professional ones.

#Python Version Migration

#Upgrading Python Safely

Upgrading a Python version needs planning, not just swapping the interpreter:

Memeriksa kode untuk migrasi

import warnings
 
def fungsi_lama():
    warnings.warn(
        "gunakan fungsi_baru sebagai gantinya",
        DeprecationWarning,
    )
    return "hasil lama"
 
with warnings.catch_warnings():
    warnings.simplefilter("error")
    try:
        fungsi_lama()
    except DeprecationWarning:
        print("deprecation terdeteksi")

warnings.warn(..., DeprecationWarning) marks a function that will be removed. warnings.simplefilter("error") turns warnings into errors during testing — forcing migration before the old version is actually removed. This strategy smooths the transition between Python versions.

#Deprecation Policies

#The Deprecation Lifecycle

Deprecation gives users time to migrate. A good policy follows a clear lifecycle:

• Release a version that marks the feature as deprecated.
• Provide a transition period with clear warnings.
• Remove the feature only in the next MAJOR version.
• Document the deprecation schedule openly.

This policy protects your library's users and maintains trust. A real example is the deprecation in popular libraries, always announced months in advance.

#Compatibility Testing

Compatibility testing ensures the library keeps working on supported versions:

    strategy:
      matrix:
        python-version: ["3.10", "3.11", "3.12", "3.13"]

matrix: python-version: [...] tests the library on every promised version. The results are published in badges and documentation. Consistent compatibility testing is the foundation of trust in a library.

#Monorepo vs Polyrepo

#Understanding the Two Strategies

Code organization uses two main approaches:

• Monorepo: all projects in one repository.
• Polyrepo: one repository per project or service.

A monorepo makes cross-project changes and consistent versioning easier, but can grow large and slow. A polyrepo isolates projects and enables granular permissions, but makes cross-project coordination harder.

#Choosing a Strategy

The monorepo versus polyrepo decision depends on:

• Team size: large teams with many services fit polyrepo.
• Code-sharing needs: lots of sharing fits monorepo.
• Release cycles: independent releases fit polyrepo.
• Cross-project changes: frequent cross-cutting fits monorepo.

There's no universal answer — many companies use a hybrid of both. What matters is consistency and fit with the team's needs.

#Internal Packages and Dependencies at Org Scale

#Building Internal Packages

Large teams often build internal packages to share code:

mkdir belajar-internal
cd belajar-internal
python3 -m venv .venv
pip install -e .

mkdir belajar-internal starts an internal package. With an internal pip index like Nexus or Artifactory, packages can be shared across teams. This structure uses all the packaging skills from episode 19.

#Dependency Management at Org Scale

At organization scale, dependencies need centralized management:

• Standardize the Python version across all projects.
• Manage shared dependency versions in one place.
• Audit dependencies regularly with pip-audit.
• Enforce a scheduled dependency upgrade policy.

Version consistency across teams reduces conflicts and eases migration. Tools like uv and Poetry help enforce these policies automatically.

#Coding Standards and Contribution Guidelines

#Setting Code Standards

Professional teams set code standards that run automatically:

[tool.ruff]
line-length = 100
 
[tool.black]
line-length = 100
 
[tool.pytest.ini_options]
addopts = "--strict-markers"

[tool.ruff] and [tool.black] set formatting and lint rules centrally. With these tools, all contributors produce code with an identical style, without debate. Standards are enforced in CI, not just suggestions.

#Contribution Guidelines

Contribution guidelines make collaboration clear and efficient:

• Tests are mandatory for every new feature.
• Run the linter and formatter before pushing.
• Include a changelog and documentation with changes.
• Review pull requests with a clear checklist.

This document usually lives in CONTRIBUTING.md. Good guidelines lower the barrier to contribution while keeping quality high — the balance that lets open source and internal teams thrive.

#Closing the Learn Python Journey

#What You've Mastered

In 23 episodes, you've completed a full journey:

• From prerequisites to Python's architecture and syntax.
• From data structures to testing and type checking.
• From databases to APIs, security, and deployment.
• From observability to team governance.

This is a curriculum equivalent to years of industry experience. What sets you apart now is the ability to turn it into the right decisions when building real systems.

#Next Steps

Keep practicing: build personal projects, contribute to open source, and explore specific domains like data science or web engineering. The official Python documentation and PEPs are your primary references. The learning journey never stops — and you now have a strong foundation to pursue it.

#Closing

Key takeaways:

• Python upgrades are planned gradually with deprecation warnings.
• Compatibility testing in matrix builds guarantees multi-version support.
• Monorepo and polyrepo have trade-offs to consider.
• Internal packages are shared through an internal pip index.
• Coding standards are enforced automatically with ruff and black.
• Contribution guidelines keep team collaboration healthy.

This is the end of the Learn Python series — 23 episodes from prerequisites to governance. You now have a complete Python foundation, from the language level to organizational scale. Keep writing code, keep learning, and apply everything you've learned in real projects!