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.

“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

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 (upcoming), 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 the military, prisons, police, fossil fuel extraction, surveillance, national security, or the like.

Available corporate training courses

Docker packaging for Python: The basics

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. Configuring your application to run in a container:
    1. Understanding port forwarding and its implications for interface binding.
    2. Persistent data: logs.
    3. Persistent data: volumes.
    4. Identifying network servers with environment variables and well-known hostnames.
    5. Command-line arguments.
  4. 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.
  5. 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.
  6. Debugging techniques.

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

Docker packaging for Python: Production-ready packaging

Two 6-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. Deterministic, reproducible builds:
    1. Choosing a stable base image.
    2. Making images identifiable (tags, labels, files).
    3. Installing specific versions of Python dependencies.
    4. Maintaining two versions of Python dependencies, logical and pinned.
  2. Securing your images:
    1. Don’t run as root.
    2. Dropping capabilities.
    3. Build secrets.
    4. Ensure security updates, and the problem with caching.
  3. Startup and shutdown:
    1. Why bash is broken, and how to make it a little less so.
    2. Ensuring signal delivery for clean, fast shutdown.
    3. Health checks.
  4. Preparing for failure:
    1. Writing smoke tests for your build.
    2. Debugging C crashes with faulthandler.
    3. A python prompt in your process with Manhole.
    4. Pre-installing useful packages, like glances and psutil.
  5. 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.