Make your team more productive with my hands-on training classes

There’s always more to learn in the world of Python, an ever-growing number of tools and techniques—but there’s only so much time in the workday. While your team is focusing on shipping the features that matter to your business, it’s easy for their technical skills to fall behind. Out-of-date tools, stale techniques, and missing skills can kill your velocity.

In contrast, investing in new skills and best practices can speed up your feature delivery—and keep your team happy and engaged.

My training classes build on 20 years’ experience working with Python, and years of experience explaining and teaching complex software concepts. My classes are taught online using Zoom, at least until the pandemic is over.

  • I’ve taught online and in-person training classes to developers at Deloitte Digital and Cisco, and students around the world, from the US, UK, Germany, Norway, and Australia.
  • I’ve spoken at EuroPython 2020, PyCon 2020, PyData NYC 2019, PyGotham 2019, PyCon 2019, PyCon 2017, and many more conferences over the years.

Interested in upgrading your teams’ skills? Get in touch.

Note: I prefer not to take money from teams working on projects for (A) the military, surveillance, national security (B) prisons, police, (C) fossil fuel extraction, blockchain. If any of these categories apply to you, please don’t purchase this product.

Available corporate training courses

Docker packaging for Python: The basics

“I thought it was really really good, and feedback from the team was that we would love to have you back again for another class.”

—Julian Berman, VP of Decisioning, Deloitte Digital

Two 4-hour sessions

Whether you want reproducible builds, the ability to build isolated environments, or you’re running software with frameworks like Kubernetes, you’re likely using Docker to package your software. Unfortunately, most online tutorials won’t help you understand how Docker works: when builds break, new users won’t know what to do or how to fix it.

This hands-on class will teach your team how Docker packaging works, not just the syntax but also the underlying model of how it works.

Syllabus

  1. What is this Docker thing?
    1. Docker as client/server application.
    2. Containers as isolated processes: networking, filesystem, processes, and users.
    3. Running containers interactively.
    4. Port-forwarding.
    5. Images as self-contained executables.
  2. Minimal packaging, from Python code to runnable image:
    1. Getting an image with Python.
    2. Installing dependencies.
    3. Installing the code.
    4. Setting the entrypoint.
  3. Networking inside and outside containers.
    1. Understanding port forwarding and its implications for interface binding.
    2. Identifying network servers with environment variables and well-known hostnames.
  4. Configuring your application to run in a container:
    1. Persistent data: logs.
    2. Persistent data: volumes.
    3. Command-line arguments.
  5. Sharing images:
    1. Pulling vs. building.
    2. Understanding image names: image registry, image name, tag.
    3. Tagging images.
    4. Pushing images.
    5. The Docker Hub and official images.
  6. Faster and smaller builds, the basics:
    1. The Docker build caching model.
    2. Improving caching by changing Dockerfile order.
    3. Reducing image size with .dockerignore.
  7. Debugging techniques.

Interested in upgrading your teams’ skills? Get in touch.

Docker packaging for Python: Production-ready packaging

“This intensive training goes really deep into very practical topics. I learned a lot about why I need to do things in a certain way. Highly recommended if you want to take your Docker knowledge to the next level.”

–Dr. Mike Müller, CEO and Trainer at Python Academy

Three 4-hour sessions

Bad packaging can result in security and production problems, not to mention wasted time: waiting for slow builds, debugging the build system, and debugging issues caused by non-reproducible builds.

Your team wants to know best practices, so they can build and ship secure, fast images with confidence. To help you get there, I can teach your team how to build production-ready Docker images for Python applications, based on my extensive guide.

Syllabus

  1. Securing your images:
    1. Don’t run as root.
    2. Dropping capabilities.
    3. Build secrets.
    4. Ensure security updates, and the problem with caching.
  2. Build secrets:
    1. Insecure options (COPY, ARG).
    2. BuildKit secrets.
    3. Other alternatives.
  3. Running in CI:
    1. Writing smoke tests for your build.
    2. Warming the cache.
    3. Warming the cache with multiple branches.
    4. Avoiding latest.
  4. Identifiable images:
    1. Why tags aren’t useful, but not enough.
    2. Labels.
    3. Build arguments.
  5. Preparing for failure:
    1. Debugging C crashes with faulthandler.
    2. A python prompt in your process with Manhole.
  6. Operational correctness:
    1. Why bash is broken, and how to make it a little less so.
    2. Ensuring signal delivery for clean, fast shutdown.
  7. Health checks.
    1. Docker-style.
    2. The problem with slow queries.
  8. Persistence and container lifetime.
    1. The problem with coupling database migrations to startup.
    2. An alternative.
  9. Reproducible builds:
    1. Choosing a stable base image.
    2. Installing specific versions of Python dependencies.
    3. Maintaining two versions of Python dependencies, logical and pinned.
    4. Custom base images.
  10. Faster and smaller images, advanced topics:
    1. Don’t use Alpine.
    2. System packages.
    3. Pip packages.
    4. Separate dependency installation from code installation.
    5. Build arguments and cache invalidation.
  11. Faster and smaller builds, using multi-stage builds:
    1. The problem with build tools, and multi-stage builds as a solution.
    2. Setting up virtualenvs in Dockerfiles.
    3. Multi-stage builds for Python.

Interested in upgrading your teams’ skills? Get in touch.

Planned courses

There are other topics I am planning on teaching; I can teach them, but with increased lead time.

Processing large amounts of data, for data scientists and scientists

Scientists and data scientists need to write software, but don’t always have the same software engineering background that software developers do. To help fill those gaps, this particular class will cover the techniques you will need processing large amounts of data without having to switch to a complex distributed system.

The focus will be on managing memory usage, the critical bottleneck in computing:

  1. Understanding memory usage as a critical bottleneck.
  2. Measuring memory use.
  3. Python-level techniques for reducing memory usage
  4. Generic data techniques (compression, indexing batching).
  5. Applying the generic techniques to Pandas and NumPy.

Interested in upgrading your teams’ skills? Get in touch.