Advanced Programming with Python
Upcoming Course Dates:
Course Hours:
- This is an immersion course.
- 9:30am-5:30pm US Central Time/Chicago
Cost:
- $1500
Registration (no payment required now):
Instructor: David Beazley
Overview
This is an intense hands-on course that focuses on problem solving, design, abstraction, and advanced programming topics. Major subjects include data abstraction, object-orientation, functional programming, event-driven systems, problem modeling, and testing. However, a greater theme of the course concerns the idea of "composibility." Much of what we do in modern programming isn't driven by the need to code low-level algorithms. Instead, we often need to pull existing components together to form greater systems. When doing this, it's useful to think about how the parts interact with each other and how our design choices might have a far-reaching impact. Ultimately, the goal is to manage software complexity and to make informed choices in your own projects.
Target Audience and Prerequisites
This course is aimed at experienced Python programmers who want to move beyond the writing of scripts that glue together existing libraries into the land of creating custom libraries, frameworks, and larger applications. Much of this involves thinking about "big picture" issues about how the parts of such systems are put together, how they can be tested, and more. You should already be comfortable using Python's builtin types, writing functions, and defining simple classes. It is not necessary to have deep knowledge of "advanced" Python features. However, a wide variety of advanced Python topics will naturally arise as we proceed through the course.
Instruction Format
This course is heavily focused on hands-on programming and group discussion. The course consists of approximately 10 coding projects that explore different facets of programming, problem solving, and design.
Topic Overview
The course aims to cover the following core topics:
- The Elements of Programming: A review of some basic ideas
about programming, problem solving, and abstraction.
- Data Abstraction: Principles of data structures, data encapsulation, layering, and the Python protocols/magic methods used when manipulating data.
- Adaptation: Building upon the ideas of data abstraction,
we explore the idea of being able to adapt existing objects to look
like other things. Ultimately, this is more about the idea of owning your
own abstractions as opposed to only using those that are provided.
- Programming with objects: When and how to effectively use class definitions in a program. A major focus of this section is on modular design, managing the relationship between classes, and controlling complexity. This includes inheritance, composition, and common design idioms. Also, designing code for testability.
- State machines: Certain problems, especially those in distributed systems, are often described by state machines and stateful objects. This section focuses on strategies for implementating state machines and event driven systems.
- Functional programming: The usage of functions as a foundation for problem solving and abstraction. Topics include higher-order functions, closures, and function composition. Difficulties associated with API design, error handling, and exceptions are also discussed.
- Advanced testing strategies: Testing is an important part of software development and most programmers are familiar with concepts such as unit testing. However, sometimes you're faced with a problem of an unusual complexity that defies more traditional testing approaches. Throughout the course, we'll explore different aspects of testing including defensive programming with invariants, randomized testing, model checking/verification, and the use of solvers. A major focus will be on designing software that can be effectively tested in multiple ways.
- Problem focused programming: When solving a problem, it is sometimes too easy to get fixated on programming-language or library specific features. However, in many cases it makes a lot of sense to flip things around to focus more on the core problem itself. What are the essential parts of a problem? What are the non-essential parts? Such questions are discussed throughout the course.
It's important to note that the main focus of this course is on programming. Although a wide range of Python language features will be covered by neccessity, the course is not organized around learning Python language features. Also, this is not a course on software project management--it does not cover tooling, teamwork, packaging, deployment, agile, and other related topics. It's about problem solving and creating well organized software that ultimately makes all of those things much easier.
How Does This Compare to Your Other Python Courses?
For more than a decade, I taught two Python courses, Practical Python Programming and Advanced Python Mastery. Those courses were strongly focused on the Python language itself. This is a new course with a completely different emphasis on programming practice and design. There is no overlap in course materials, exercises, or presentation format.
About the Instructor
The course is taught by David Beazley, author of the Python Distilled (Addison-Wesley) and Python Cookbook, 3rd Edition (O'Reilly Media). David has been actively involved with the Python community since 1996 and was one of the early adopters of Python with scientific software. From 1998-2005, he was an assistant professor in the Department of Computer Science at the University of Chicago. You might also know Dave from this somewhat infamous bit of live coding. Most relevant to this course might be this talk at PyCon Sri Lanka 2022.