99 advanced Python topics

Some topics covered in Powerful Python Bootcamp this year:

• Advanced uses of super()
• A live troubleshooting session, figuring out a bug in a lab under Pytest
• Optional arguments in dataclasses
• Spilling some secrets from the Coder Dream Job course
• The three ways to use type annotations
• Aaron's opinions on Javascript
• Reducing operations in Pyspark
• The decorator pattern that should be ILLEGAL
• Peering under the hood of Powerful Python's marketing automation code
• The C3 Linearization algorithm
• How to inspect the source of your imported libraries
• Why we never use f-strings in logging
• Module organization
• Is Python high level or low level? How does it compare to other languages? What does ‘high level’ even mean? And what does one of the most famous Python libraries of all time have to teach us about this?
• Sentinel values, and how they relate to None, pandads.NA, and np.nan
• Higher-order function tricks
• The @functools.cached_property decorator (which is totally and completely different)
• When to use notebooks, and when to avoid them
• Walking through the codebase of a Django web application I recently cooked up, demonstrating many advanced techniques from Next-Level Python and other Powerful Python courses.. A real-world production application with a STACk of money on the line
• Exploratory mutations of the webviews.py lab
• Core concepts in the Twisted framework
• Levels of technological abstraction, and how understanding lower levels affects the effectiveness with higher levels
• How to learn a new programming language that's different from what you are familiar with
• A detailed walkthrough of how to do the labs in the most systematic way, and working with mocks in unittest.
• Deep dive into the webframework.py lab from Next-Level Python
• How to handle it when you start to become better than your peers
• How IDEs can get in the way of your learning (and how to deal with it)
• Testing functions that are inherently difficult to test
• Bash wrappers for Python programs
• The evolution of built-in exceptions from Python 2 to Python 3, and the lessons that evolution has for our coding today
• Higher-level strategies of automated testing
• Subclassing built-in types, and why str is different there
• Unconventional decorator patterns
• How to read PEPs
• Deferred Reference
• The security risks and other hazards of eval()
• The essence of super()
• Revealing the source of a script I wrote to generate the HTML version of the Powerful Python book
• Strategy for navigating multiple layers of abstractions
• A small distributed Pythonic app to get around a corporate firewall
• Details of the iterator protocol (and how generator objects fit into that)
• Understanding the Liskov Substitution Principle, and how it relates to Python's OOP syntax
• How to think about mocks
• Covering many advanced details of working with web services and the HTTP protocol
• Complexity trade-offs for code calling APIs
• Talking through a challenging network-engineering issue with strong security considerations
• The @functools.cache decorator, and how it relates to the memoization labs in Next-Level Python
• Adding exception context in the "catch and re-raise" pattern
• Why DownloadDir.wait_for_chrome_download() (from Code Walkthroughs) is like a state machine
• The three pillars of concurrency in Python
• How @functools.cached_property relates to the memoize.py lab in Next-Level Python
• Object lifecycle in Python, and the __del__() magic method
• A partial code walkthrough of the metaleads.py program, including comments on environment variables
• Prompt engineering troubleshooting
• Many fascinating details of generators and decorators
• A non-Python database design question
• Learning more advanced Git
• Deep distinctions on Python’s generator model
• Is the GIL finally going away? And why it is important for Python concurrency. How threading, asyncio, and multiprocessing compare now... and how PEP 703 will change that.
• Looking at a multithreaded production codebase
• how object identity is defined in Python's language model
• A small distributed Pythonic app to get around a corporate firewall
• My blasphemous opinion on Linus Torvald's greatest achievement
• Scoping rules around nonlocal variables
• A broad survey of the different collection types in Python, beyond lists and dicts
• The different roles of type attributions
• System paths vs Python paths vs other paths
• Debugging diabolical decorators
• The concept of "cognitive cost" when coding
• Method Resolution Order
• Deeper understanding of lambdas (anonymous functions), including how Python does them differently than other languages
• Choosing good inheritance hierarchies
• Book recommendations for Python pros
• The right way to use Stack Overflow (and how to avoid mis-using it)
• Generator objects/comprehensions/functions
• Troubleshooting a bug so subtle, that we had to dig elbows-deep into the Pandas source code to crack it
• Peering into the Asciidoc source of the Powerful Python slide decks (the same format used by O'Reilly for its books)
• How instance, static and class methods differ in Python, and how that's all different from how it works in languages like Java
• Defensive asserts
• Talking about defaultdict... not just how to use it, but going deep into WHY it was designed the way it was, and the lessons it has for your own code
• Multithreaded/multiprocessor programming, and the best book for learning it deeply
• Diving deep into exception patterns
• Troubleshooting a high-throughput messaging architecture problem
• Many insights about automated testing
• What to do when you are facing an overwhelmingly complex coding problem
• A demonstration of expanding the test suite with more refined requirements, and how that affects the evolution of the application
• Strategies for cramming for a FAANG interview
• Classmethod vs. staticmethod
• Should you be worried about being replaced by a bot? In fact, many Python developers SHOULD be worried, but a small fraction will come out of this as big winners. Today's session tells you how to be one of them
• Generator algorithms
• Talking about the "walrus operator", formally called "assignment expressions" (PEP 572)
• Talking about generator-based coroutines
• The intersection of module organization + dependency management
• Inter-Python-process communication
• How Github Copilot, ChatGPT, and other AI tools coming in the future affect your career
• A stateful low-level parsing algorithm
• Pyspark
• The why and how of functools.wraps()
• How to catch exceptions in twisted

Which of these is most interesting to you? Email me to tell me.

And if you'd like to get in on these group mentoring calls, for live discussions on topics like the above, go here.