Flexible, Maintainable Python: A Gentle Intro to Dependency Injection
(30 Minutes)
By: Paul Zuradzki
Experience Level: Intermediate

Dependency injection (DI) isn’t just for enterprise Java. DI is a simple, versatile design technique that can help you write less coupled, more modular, and more testable code. By the end of this talk, you'll be able to:

• Spot implicit dependencies in your code

• Understand what dependency injection is and why it matters

• Apply simple DI in your Python code using functions or parameters

• Know when not to use it

 

Outline

• Motivation: Good Design and Why DI

• Recognizing Dependencies

• What is Dependency Injection (DI)

• Dependency Injection (DI) vs Dependency Inversion Principle (DIP)

• Practical Examples

• Styles of Dependency Injection

• DI for Testing

• DI for Decoupling

• DI for Flexibility

• Composition Root: Where to Wire Dependencies

• When Not to Use DI

• Patterns that Use DI

• Strategy

• Factory

• Service, Repository, and Domain

• DI and Python Idioms

• DI Containers and Frameworks for Large or Complex Projects

 

To pickle or not to pickle
(45 Minutes)
By: Joshua Herman
Experience Level: Intermediate
Slides Link

We will go over the implications of how deciding a serialization format (also known as a data interchange format) can have on your performance, security and readability. We will study JSON, pickle and safetensors and understand the decision making and the specifications of those formats have and why you should choose one over the other. We will also show the implications of how others have used and when these formats while are a good idea before start to change in such a manner where you need to migrate to a format for the previous reasons mentioned (performance, security and readability). Also, at the end there will be a security demo derived from a blogpost.

Scale your Machine learning with Sagemaker Pipelines
(30 Minutes)
By: Drake Loud
Experience Level: Intermediate

In this session, we’ll introduce key machine learning concepts and explore how Amazon SageMaker Pipelines simplifies and automates the end-to-end ML workflow, allowing you to scale your projects to your needs.

We will start at a high level, then dig into the code and discuss the core concepts and how it all works behind the scenes.

LLMs, PDFs, and Load Balancers: A Love Story
(15 Minutes)
By: Eugene Scray
Experience Level: Intermediate

Join me for a whirlwind tour of building real apps with Large Language Models, where the PDFs are endless, the prompts are moody, and the alerts come at 2AM.

We’ll cover:

• Semantic search with KNN, Lucene, and TF-IDF (because one search method is never enough)

• Parsing PDFs at scale without crying (much)

• Prompt engineering with Semantic Kernel (AI therapy sessions included)

• Web apps behind load balancers (hello, uptime!)

• Datadog alerts when things catch fire (they will)

Come for the LLMs, stay for the tech glue and mild existential dread.

MCP Tool Kit
(15 Minutes)
By: Jack Thompson
Experience Level: Intermediate

Microsoft sponsored. Best way to build vertical agents. Server and Tool kit for Model Context Protocol server written in python. Run multiple tools on a single server.

Designing and Building Custom Keyboards ⌨ with Python
(30 Minutes)
By: Carlos A Aranibar
Experience Level: Novice

As programmers, we spend a lot of time typing, but we often overlook how keyboard designs affect our comfort and productivity. In this talk, we'll explore custom keyboards and how Python can help us create our own typing experiences. 

We'll start by looking at the history of keyboard design and the limits of standard layouts like QWERTY. Then, we’ll discuss the advantages of alternative layouts, such as ortholinear and split designs, which can help reduce strain and improve typing speed. 

Next, we’ll go through how to design a custom keyboard PCB and learn from Python tools like GDSFactory. You’ll learn to arrange the keys based on your hand shape and create a layout that focuses on the keys you use most in your favorite programming languages. 

Once we have our PCB design, we’ll move on to building our custom keyboard. We’ll cover basic assembly to turn our design into a real device. Finally, we’ll talk about getting used to our new keyboard layout. We’ll look at online tools and Python scripts to analyze our typing habits, helping us identify our most common keys and monitor our progress as we retrain our fingers. 

No prior experience with keyboard building or PCB design is needed – just bring your curiosity and eagerness to create a custom typing experience. By the end of this talk, you’ll know to question the design of your current keyboard and might want to build and improve your own custom keyboard using Python.

If This, Then That: Tools for Refactoring Conditional Logic
(30 Minutes)
By: Paul Zuradzki
Experience Level: Intermediate

Outline

• Setting up a test harness. How to use parameterized tests to refactor safely.

• Simplifying conditionals 

• Guard clauses and early returns

• Method extraction vs inlining. Tradeoffs (“Clean Coder Uncle Bob” vs “Philosophy of Software Design Ousterhout).

• Pattern matching with Python 3.10+ `match-case`

• Boolean logic tricks (from discrete math)

• DeMorgan’s Law

• Double negation

• Distributive laws

• Understanding Python boolean semantics

• Short-circuit evaluation

• `and` / `or` behavior return-value behavior

• Tripwires: when truthy expressions return unexpected values

• Decoupling Behavior from Branching

• Intro example

• Strategy pattern in functional style. Dispatching callables with dicts.

• functools.singledispatch for type-based dispatch

• Strategy pattern in OOP style

• With duck typing

• With inheritance-based polymorphism

• With protocol-based structural typing

• If IF ain’t broke, then don’t fix it. 

• Evaluating design tradeoffs. 

• When the overhead of encapsulation or indirection might not be worth it.

• Recap: when to use what

• Summary of techniques, tradeoffs, and when each is favorable