Taking Python to Production: A Professional Onboarding Guide

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course introduction

Lecture 2: IMPORTANT! Course Notes and Course Website

Lecture 3: Linux and terminal crash course

Chapter 2: Environment Setup

Lecture 1: Install VS Code

Lecture 2: Make sure you have the `code` command

Lecture 3: Mac users only: Install Homebrew, Xcode, and iTerm2

Lecture 4: Windows users only: Install the Windows Subsystem for Linux (WSL2)

Lecture 5: Windows users only: Integrate VS Code with the WSL2

Lecture 6: Resources: Installing git

Lecture 7: Installing the git CLI tool

Chapter 3: Improving the terminal with ZSH

Lecture 1: Introduction

Lecture 2: Installing OhMyZSH

Lecture 3: Navigating using ZSH and installing ZSH plugins

Lecture 4: The ~/.zshrc file and ZSH themes

Lecture 5: Disabling/enabling ZSH plugins; All-in-one Markdown extension; web-search plugin

Lecture 6: Typeahead auto-completion with zsh-autosuggestions

Lecture 7: Syntax highlighting with zsh-syntax-highlighting

Lecture 8: Cheat sheet: quick ZSH setup

Chapter 4: Managing multiple Python versions

Lecture 1: Introduction to Semantic Versioning (semver)

Lecture 2: Semantic Versioning (continued)

Lecture 3: Why developers need to be able to switch between multiple Python versions

Lecture 4: Resources for installing pyenv

Lecture 5: Installation and overview of pyenv for managing multiple Python versions

Lecture 6: History of Python changes; Overview of how Python evolves

Chapter 5: VS Code: shortcuts, auto-completion, and virtual environments

Lecture 1: VS Code keyboard shortcut reference

Lecture 2: VS Code: layout and key shortcuts

Lecture 3: Python/Pylance: improve refactoring and syntax highlighting support

Lecture 4: Step debugging in VS Code

Lecture 5: Preview of virtual environments

Lecture 6: Python virtual environments and the PATH variable

Chapter 6: Git and VS Code

Lecture 1: Introducing git by comparing it to Google Docs

Lecture 2: Git lens extension

Lecture 3: Git command reference

Lecture 4: git CLI and commits

Lecture 5: Making a commit

Lecture 6: Time traveling and best practices for making commits

Lecture 7: git stash

Lecture 8: (Part 1) git branching – visual intuition

Lecture 9: (Part 2) git branching – hands-on in VS Code

Lecture 10: Merging git branches

Lecture 11: Resolving merge conflicts

Lecture 12: [Extra] git branching game

Lecture 13: git tags

Lecture 14: Recap: the local git workflow

Chapter 7: GitHub and Code Review

Lecture 1: Preview of the rest of the course

Lecture 2: What is GitHub?

Lecture 3: Creating a repository in GitHub

Lecture 4: Cloning and git remotes

Lecture 5: Pull Requests and Code Review

Lecture 6: Conducting Code Review with a Pull Request

Lecture 7: Recap: the remote git workflow

Chapter 8: Continuous Integration: clean code, formatters, linters and VS Code integrations

Lecture 1: Section guide: resources, links, assignments, summary notes, etc.

Lecture 2: Clean code and why it's important

Lecture 3: Python style guides: Google and PEP 8

Lecture 4: Refactoring for better readability

Lecture 5: Introduction to Continuous Integration and best practices for PRs

Lecture 6: "PR hell" and more discussion of Continuous Integration

Lecture 7: Autoformatting with Black, VS Code's settings system, and "Holy Wars"

Lecture 8: Pylint Part 1 – Introducing Linters

Lecture 9: Pylint Part 2 – Integrating with VS Code

Lecture 10: Pylint Part 3 – Configuring Pylint w/ a config file and CLI arguments

Lecture 11: Flake8 Part 1 – Usage and background

Lecture 12: Flake8 Part 2 – Flake8 plugins w/ Darglint as an example

Lecture 13: isort: sorting import statements

Lecture 14: "Code metrics" like "cyclomatic complexity" with Radon, Xenon, and McCabe

Lecture 15: Typing Part 1 – type hints, autocompletion, static vs dynamic type checking

Lecture 16: Typing Part 2 – Mypy and basic typing

Lecture 17: Typing Part 3 – Simple and Complex Types

Lecture 18: Typing Part 4 – Union and Optional

Lecture 19: Typing Part 5 – TypedDict, dataclasses, NamedTuple, self-referential types

Lecture 20: Typing Part 6 – Generic Types

Lecture 21: Typing Part 7 – Type Stubs and incrementally adding types to existing codebases

Lecture 22: Darker: incrementally lint legacy projects

Lecture 23: Ruff: the last Python linter ever?

Chapter 9: Continuous Integration – The pre-commit framework

Lecture 1: A Continuous Integration workflow with code quality tools

Lecture 2: CI Approach 1 – Writing a script that calls each tool

Lecture 3: Git pre-commit hooks

Lecture 4: CI Approach 2 – The pre-commit framework

Lecture 5: Pre-commit hook roundup

Lecture 6: Tour of an advanced pre-commit config file

Chapter 10: GitHub Actions

Lecture 1: Our first GitHub Actions "workflow"

Lecture 2: GitHub Actions: running a workflow

Lecture 3: Fixing the build and using pre-commit

Lecture 4: Branch permissions, merge checks, and pull requests

Lecture 5: Understanding GitHub Actions Pricing

Lecture 6: Optimizing for cost by using GitHub Actions Triggers

Chapter 11: Python Packaging

Lecture 1: Section Intro – Python Packaging

Lecture 2: PYTHONPATH and imports in Python