Accepted Talks

Creating a more diverse Programming community using Libraries as a gateway to reach diverse and under-served populations. How Python and Computer Science can be used to create opportunities for under served populations. Creating Diversity by meeting people where they are instead of trying to entice them to join you.

At Eventbrite, engineers are tasked with building systems that can withstand dramatic spikes in load when popular events go on sale. There are patterns that help us do this. Come learn about these patterns, how Eventbrite has adopted them, and how to implement them within your own code and infrastructure.

How can you be a better manager? How can you help your manager be a better manager for you? In this talk we'll talk about these things and build a better bridge between developers and their managers so we can build stronger teams together from the bottom up.

In June 2012, podcaster and vet web dev Ed Finkler spoke openly about his lifelong struggles with mental illness. 4 years later, a non-profit corporation with 3 dozen volunteers is working to change the tech and open source community. In this talk, Finkler tells the story of how the episode happened, the incredible response, and how it grew into a charity dedicated to changing an industry.

Testing is generally seen as a Good Thing™ that one should do. Writing tests that are comprehensive and cover all possibilities however can be time-consuming, hard, or even downright impossible. Property-based testing is one method that can help with this. This talk will introduce the concept of property-based testing and how to do it yourself using the Python library Hypothesis.

The Python Package Index, lovingly known as The Cheeseshop to some, has grown enormously since it's introduction in 2002. As a critical piece of the Python Community's infrastructure, it has suffered many growing pains over the years. Let's review the recent history of PyPI, lessons learned, and techniques applied to keep it running.

Zulip is a beautiful open source alternative to Slack, optimized for productivity.

The Zulip project has grown from 1 to 300 contributors in about 18 months, with more commits merged per week than Docker and Django combined.

This talk will tell Zulip's story, emphasizing the specific, reusable, techniques we used to build our open source project and make the community successful.

You just finished a patch for your API. Your unit tests pass. You have some end to end tests that cover most of the user facing features. You merge in your code and after a smooth deployment, all hell breaks loose. The microservice that the other team was developing doesn't understand what your new patch is sending as a response! What went wrong? This is a quick talk about contract based testing.

This is a story about the creation, maintenance and on-going features built onto an IoT device to measure the amount of coffee in a coffee pot.

There's a been lot of talk over the past few years about workforce retraining and software bootcamps. So what's the reality? I will tell the story of rebooting my career at 30 from working in lumber & building materials to becoming a developer, share some thoughts on why it worked for me and some of the lessons learned from my first year on the job.

Client libraries for your API in the languages your users are coming from are vital to getting adoption and establishing the best practices for putting your API to work. We discuss how and why you need to provide the client libraries and why this may drive adoption more than the API itself.

Did you learn Java in school but want to get into Python? Are you a decision maker trying to choose between Java and Python for your next project? This talk will cover a variety of differences between Java and Python and why they matter.

Testing the code we write is important, so we should use available tools to write tests that are readable, thorough, and DRY (Don't Repeat Yourself). Subtests, added in Python3.4, make accomplishing each of these three goals easier. This talk goes through some examples of how subtests make testing 1) more readable, 2) more thorough, and 3) more DRY. The result: better apps and fewer bugs.

There's nothing better than helping someone learn a tricky concept: a complex regular expression, a build tool, or even running their first script ever! Unfortunately, though, teaching is hard! For many, going beyond the show-and-tell we do with coworkers is just too intimidating. Let me teach you tips, tricks, and tools I've collected over years of teaching Python to thousands of people.

Today, chess engines contain many lines of code handcrafted under the guidance of grandmasters. Are you interested in being knee deep in chess theory just to crank out a half decent engine? No? This talk is for you. Why not create an engine that learns to improve itself?

The Python data ecosystem provides amazing tools to quickly get up and running with machine learning models, but the path to stably serving them in production is not so clear. We'll discuss details of wrapping a minimal REST API around scikit-learn, training and persisting models in batch, and logging decisions, then compare to some other common approaches to productionizing models.

The IoT market is set to grow to over 250 BILLION dollars by 2020- it’s time to get YOUR piece. This session will give attendees an interactive demonstration on the amazing Python IoT-stack using Mosquitto, MicroPython, and the Paho Library. You will walk away with a solid understanding of the architecture and frameworks necessary to build a complete IoT solution of your own.

Changing careers can be intimidating! In this talk, I'll share how I made the transition from astronomer to full stack web developer, and built up a career in tech.

Spreadsheet files are often used to share interesting & important data. But spreadsheet applications aren't always the best tool for processing that data. I'll show you how to use OpenPyXL to work with that data in a way that's better than using .csv files. I'll also discuss common problems faced when working with spreadsheets via code. "State of the art" moves fast here, thus the title.

A benefit of using a dynamically typed language like Python is the ability to create a function that can operate on arguments of unknown types. Unfortunately, this freedom can lead to a common antipattern where the function is responsible for type-cheaking each argument before operating accordingly. This talk will explore avoiding this antipattern with multimethods.

To many developers the database is a black box. You expect to be able to put data into your database, have it to stay there, and get it out when you query it... hopefully in a performant manner. We'll go from basics to the more advanced of what you need to know to keep things running smoothly.

This talk will attempt to resolve some of the mystery and confusing behavior about Unicode (and other text encoding issues) in Python. It will cover Python handles text in general, the differences in Unicode text between Python 2 and Python 3, how various standard library APIs handle Unicode text, and a bit about detecting the encoding of unknown text.

We all have someone on our team who writes code with bugs in it. Not us, of course, but someone else. This code somehow gets into production and this code just maybe sometimes crashes. How can we detect these issues and extract useful information at runtime so we can fix these bugs? What kind of stuff should we even be looking for?

This talk aims to give introduction to web development using Flask.

After an introduction to Python web development ecosystem, we will focus on developing a production ready application using Flask, a suggested structure for your application, and how to tackle some unique challenges we encountered.

This talk is about computer vision and image processing. It covers applications in astronomy, as well as more terrestrial ones. Next, it outlines how you can use them with the photos you already take. Finally, it discusses how developers can build specialized tools to enhance their abilities, and why actually doing so is often surprising.

Ever since a moth was discovered in the Mark II computer we've dealt with bugs in software. This talk will show different methods for determining what the code is doing. We'll start with the lowly print statement and introduce advanced forms of logging. We'll also cover several Python debuggers and talk about best practices for debugging and preventing bugs in Python code.

Roughly 1 in 5 people in America live with a disability. It would be irresponsible to ignore the needs of all our users when developing our code, but isn't this just something for people who wrote client side code to worry about? In this talk, I'll explain the basics of accessibility and how you can advocate for it across the stack.

Jupyter notebooks make it easy to create reproducible workflows that can be distributed across groups and organizations. This is a simple process provided that our end-users have access to the data along with a compatible Python environment. Learn how to use Docker to package a shareable image containing the libraries, code, and data required to reproduce every calculation.

Let's make forms accessible! We're going to make forms more accessible in Flask with Jinja templating and JavaScript. We'll go through what's possible in Jinja and what may need extra work.

This talk is an introduction to Google's protocol buffers (aka protobuf). Protocol buffers are a language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler. This talk will include a demonstration of using protobuf with Python to communicate with an embedded, processing- and memory-restricted device.

At Brokersavant, we process large quantities of real estate assets ranging from commercial property flyers to large real estate leases and our customers expect a lightning fast turn around. Learn how we leveraged open source technologies and Python libraries to create a system that scales to millions of assets per day without missing a beat.

Nearly everyone in tech has to take part in a technical interview during their career, but are we doing them right?

Lazy is too hard. When I had 40,000 PDFs and needed to extract their data, I knew that the "lazy" approach was insufficient. This talk reviews tools to tame PDFs with confidence. I'll use my open-data project's workflow as an example (ETL anyone?). It's also a follow-up/response to PyOhio2016's "We Don’t Need No Stinkin’ PDF Library: Build PDFs with Python the Lazy Way".

We've all sat through boring/wasteful meetings. I wanted to find a solution. So I made a Python app that connects with the Google Calendar API, gets all the events in a period and posts the costs of each event to Slack. A following poll asks if it was worth the costs. I would like to describe how it was made and how we can make meetings valuable and engaging, instead of boring wastes of time.

Rapid prototyping in data science often hits a wall when data is too large to fit into memory. When this happens, teams are often confronted with two options: sampling techniques or porting to Apache Spark. Both have significant drawbacks. In this talk, I'll demonstrate how to leverage Dask and Scikit-learn to solve this problem.

Jenkins is the "leading open source automation server". New in 2016, Jenkins version 2 introduced a robust, extensible approach to managing complex automation pipelines as code. Jenkins' Pipeline as Code serves as a solid foundation for a team's continuous delivery practices. Kevin Fox provides a practical overview of this important new capability for a popular open source platform.

The use of search is ubiquitous. As a developer you need search in your technology tool belt. This talk introduces Elasticsearch, a front-running, open source search technology. We'll create an application, execute a search, and dive into internals so that you'll know where search is most useful.

Using python to interact with aftermarket engine management controllers. Part 1 will focus on the initial discovery of the controller's serial protocol, communicating with the controller over a serial port, unpacking the byte stream, and using Redis as a mechanism to store and radiate data.

Let’s explore the lifecycle of a mentorship. Mentorships are relationships like any other that need to be started, maintained, and ended with intentional effort and care. We’ll talk about how to identify, grow, and gracefully end mentoring relationships.