pre-release: PyOhio meeting announcement

Please take a moment to review your details and reply with OK or edits.
Subject and below is what will go out and also will be used to title the videos.

Subject: 
ANN: PyOhio at Cartoon 1 Sat July 28, 9p


PyOhio
=========================
When: 9 AM Saturday July 28, 2018
Where: Cartoon 1

https://www.pyohio.org/2018/schedule/

Topics
------
1. Saturday Welcome
Dave Forgac

Welcome and overall event information.
 recording release: yes license: CC BY-SA  

2. From Support to Engineering and Beyond: What to Take with You, and What to Leave Behind
Adrienne Lowe

I've had the special experience to, in an extraordinarily short amount of time, move from studying code independently to working full time on a customer-facing technical support team, to working as an full-stack engineer, to finally, leading an organization as Director of Engineering. In each transition, I've had to learn and use certain work skills to both get the current job done and prepare myself for my next. Come hear what attitudes, behaviors, work habits, and lessons I learned and chose to take with me, and what I intentionally left behind, as I made these transitions -- and consider what you might take and leave behind in your own journey.
 recording release: yes license: CC BY-SA  

3. Natural Language Processing in Python
Alice Zhao

Natural language processing (NLP) is an exciting branch of artificial intelligence (AI) that allows machines to break down and understand human language. As a data scientist, I often use NLP techniques to interpret text data that I'm working with for my analysis. During this tutorial, I plan to walk through text pre-processing techniques, machine learning techniques and Python libraries for NLP.

Text pre-processing techniques include tokenization, text normalization and data cleaning. Once in a standard format, various machine learning techniques can be applied to better understand the data. This includes using popular modeling techniques to classify emails as spam or not, or to score the sentiment of a tweet on Twitter. Newer, more complex techniques can also be used such as topic modeling, word embeddings or text generation with deep learning.

We will walk through an example in Jupyter Notebook that goes through all of the steps of a text analysis project, using several NLP libraries in Python including NLTK, TextBlob, spaCy and gensim along with the standard machine learning libraries including pandas and scikit-learn.

## Setup Instructions
[ https://github.com/adashofdata/nlp-in-python-tutorial](https://github.com/adashofdata/nlp-in-python-tutorial)
 recording release: yes license: CC BY-SA  

4. Reproducible Environments for Reproducible Results
Dana Walker, Bihan Zhang

* Why environmental reproducibility is important
* Overview of best practices for environmental reproducibility (~3-4 min per topic)
    - Dependency Management
        + pip freeze > requirements.txt
        + Pipfile.lock
    - Containerization
    - Automated Provisioning
    - Environment management
        + Pulpproject
 recording release: yes license: CC BY-SA  

5. A Hands-On Guide to Teaching Programming with GitHub, Travis CI, and Python
Gregory M. Kapfhammer

Real-world software engineering is collaborative, commonly involving the use of
Git, GitHub, and continuous integration with Travis CI. Suitable for both
full-time educators and members of industry who educate their peers, this
presentation will explain how to use these technologies and platforms to teach
interdisciplinary and introductory courses in computer programming and software
engineering.

The presentation will first show how to create a GitHub organization connected
to a GitHub Classroom with unlimited private repositories that contain
instructor solutions and starter kits and assignment submissions from both
individual and team-based programming assignments. The talk will next explain
how to connect GitHub repositories to continuous integration servers hosted by
Travis CI, thus supporting the cloud-based execution of tests and checks.

The presentation will subsequently introduce a Python program that supports the
local and cloud-based checking of a student's source code and technical writing
for a programming project. Ultimately, people who attend this talk will learn
more about how to use open-source software and the Python programming language
to effectively deliver instructional materials and assess assignment
submissions.
 recording release: yes license: CC BY-SA  

6. Guide to Software Engineering for Visually Impaired
Abrar Sheikh

I am a backend Software Engineer at Yelp who uses Python extensively for building Yelps infrastructure and internal tools. I also suffer from a genetic disorder called Albinism which often results in limited visual acuity that can range from 20/120 to 20/200 in most common cases. With such a low vision it's extremely difficult to read the computer screen without the use of on-screen magnifiers. In this talk, we will see how a person with adverse visual acuity can thrive and be successful in the field of Software Engineering. We will address the importance and meaning of accessibility for Software Engineers with partial vision and recommend some best practices that are available today. We will also talk about the importance of an inclusive work culture that can help foster creativity and ease ramp up for a Software Engineer with a disability.
 recording release: yes license: CC BY-SA  

7. Easier Classes: Python Classes Without All the Cruft
Trey Hunner

When bundling up data, sometimes tuples and dictionaries don't quite cut it. Python's classes are powerful tools for data storage and manipulation, but it can take quite a bit of boilerplate code to make a well-behaved Python class. In this talk we're going to discuss how a well-behaved class should work and take a look at a number of helper libraries for creating well-behaved classes.

We'll first see how to make classes with proper string representations, comparability, iterability, and immutability. Then we'll dive into helper tools built-in to the standard library and available in third-party libraries.

We'll look at namedtuple, NamedTuple (not a typo), attrs, and the new Python 3.7 dataclasses.

Most of the libraries discussed in this talk are only available in Python 3, so if you're not using Python 3, hopefully this talk will encourage you to upgrade.
 recording release: yes license: CC BY-SA  

8. The Modern Command-Line Tool Stack: Pipenv, Click, and Friends
Matt Behrens

I've been a Python developer since 2001, and when I sit down to make a new command-line Python tool, I often write them like it's still early last decade. Late last year, I built a new command-line program that has proven to be reasonably popular, but I found that getting my tool up and running cleanly, with predictable dependencies, was a problem.

Early this year, I decided to modernize this particular project, simplifying it so that anyone could get set up with exactly the same dependencies I had, and improving the user experience by making the tool a modern one.

This talk will cover how I use Pipenv to modernize the experience of using my tool after cloning it from GitHub, transparently setting up a virtualenv in one command without reconfiguring their working environment.

I'll also talk about libraries I now use to build the app, including Click, and a number of other things both in and out of the standard library that give the tool a modern command-line UX and make it a good citizen of the OS.
 recording release: yes license: CC BY-SA  

9. Playtime in the Dunders: Mastering Python with Misfit Objects
Eric Appelt

Gaining a high degree of expertise with a programming language often requires a deeper understanding than is typically gained through normal work environments following best practices. To become a true expert, one needs to understand the consequences of not following these practices, and to be able to develop new techniques to best handle ever changing requirements and environments. While expertise can be developed through hard work and painful failures, I suggest that it is more fun to develop expertise in the same manner that small children learn - through free play and silly experimentation.

This presentation will go through a few examples of using the python [special methods](https://docs.python.org/3/reference/datamodel.html#special-method-names) (dunders) to playfully construct oddly behaving objects and use them to better understand how specific components of the python language and interpreter really work. While this presentation is far to short to foster language expertise on its own, I hope that it may serve as inspiration to perform your own experiments with special methods, make your own strange objects, and work to understand why they behave in the manner that they do.
 recording release: yes license: CC BY-SA  

10. Smart and Simple Data Driven Hydroponic Sensing Applications Using Python, Flask & Raspberry Pi
Bethany Poulin

My intent is to present for 30-45 minutes with the primary focus on explaining the pieces and parts of the system, how they come together and working through the code to build a data driven flask application which monitors and records information about a home hydroponic garden autonomously.

Although most of the presentation will be a guided tour of the project from beginning to end, there will be hands on demonstrations of the code, including the launching of the flask application and as well as code supporting the graphical plotting of a live data stream. 

A major component of this presentation will be the problem-solving process involved in executing a small-scale IoT project from beginning to end, with humbling tails of failure and rebirth while maintaining a clear and present focus on Python, Flask and the Raspberry Pi sensor platform as a vehicle for building development skills.

For a novice programmer this could serve as a first introduction to simple Internet of Things programming, module building and IoT integration in a compact package that most dedicated hobbyists could accomplish. It should also, because of the variety in content and application, be interesting to Python enthusiast of varied skill levels who find geeky home projects irresistible. 

As is always the case with my presentations, the absurd could happen, and I am shameless about finding humor in my own epic failures, so it might just be amusing. And because I have extensive classroom experience, I can be both patient and engaging even when a live experiment goes awry.  

Supporting Materials to be Posted on Github:

Full Parts List (with links to vendors)
Step-by-step instructions Including:

Full Code Files, with Useful Comments
Documentation About Major Decisions
An Integrated Bibliography of Links to Resources (both mechanical and programming)
Blueprints for a Simple Hydroponic System
 recording release: yes license: CC BY-SA  

11. Go with the Flow: Automating Your Workflows with Airflow
Leo Guinan

Apache Airflow is an open-source Python project that, in the words of Apache, "is a platform to programmatically author, schedule and monitor workflows.". In this talk, I will focus on the basics of Airflow: what is it, and what can it do for me? In a nutshell, Airflow is a library for workflow management. The most common uses of Airflow revolve around data pipelines and processing, e.g. ETL pipes, but in reality, it can be used for pretty much any workflow that has discrete steps which can be performed independently. In addition, the scheduling capabilities of Airflow provide a high powered replacement for cron tables. I will discuss how to set up workflows, connect to other systems, and leverage the automation power of Airflow. Concepts covered will include DAGs, Operators, and Hooks. Finally, I will share some gotchas that I have come across while setting up my own workflows.
 recording release: yes license: CC BY-SA  

12. Exploration of Neural-Gestural Interfaces for the Control of Robots
Rebecca Oet, Melissa Kazazic

As technology improves at a rapid rate, experimentation in the ways in which people interact with machines and computers becomes more significant. The most common interfaces today are a mouse, keyboard, and screen. However, these devices are limiting as they only interact with a user on a basic level, usually on a two-dimensional plane. This project aims to create a more natural communication between the user and a machine, in this case a robot, through gestures and neural feedback. The data of hand and arm gestures are taken using the MyoBand, which records electrical impulses, to give the robot directions. The Emotiv headset is used to record the level of concentration of the user, so that the robot may only be controlled if the user is paying close attention.

We'll discuss:

+ Background on neural interfaces, gestural interfaces, and robots
+ Overview of technology used in the project: Emotiv headset, Myo Band, Raspberry Pi
+ Python scripts
+ Applications and future directions
 recording release: yes license: CC BY-SA  

13. Advanced Pickle Security
lvh

Python's standard library comes with an object serialization framework called `pickle`. It's no secret pickles are unsafe. Any time you load a pickle, you really have no guarantee what it'll do. While it's designed to just reconstitute objects from some bytes, it could open network connections, delete all your files, or really anything else it wants.

Despite all of these flaws, it's very popular, especially in the scientific Python community. Many of its users actually have pretty good reasons to use it, so just telling them not to isn't very helpful. For example, numpy's various array types have custom behavior to fine-tune how they are serialized and deserialized -- features explicitly supported by the Pickle module's extension points. Most scientific applications also don't just have a matrix: they might have fairly complex object graphs that require serialization. Pickle supports this out of the box, and that's great!

This talk is intended for intermediate and expert Python programmers. It's expected that you have heard of the Pickle module before and that you know it's unsafe. We'll (quickly) go through how Pickle works at a Pickle VM opcode level. Then we'll show how you can get arbitrary code execution, followed by some more advanced exploitation techniques (e.g. how you can put other behavior in a pickle while keeping equivalent functionality; e.g. the pickle still turns into the object you were expecting). Finally, we'll talk about how we can make this safe again in the end anyway, culminating in the practical implementation I have open sourced. 

If I have time (big stretch for the talk, but maybe not for the hallway track), I'll show techniques for how to attack Pickles that are "protected" by malleable encryption schemes like AES-CTR.
 recording release: yes license: CC BY-SA  

14. Large-Scale Recommendation System with Python and Spark
Phil Anderson

# Abstract
We will briefly cover the Kroger Company and its digital properties, along with its current recommendation systems and need for a new one.  We will then move into a deep dive of the system we developed, covering the Python APIs for large-scale data processing tool Spark, and the underlying Hadoop Distributed File System (HDFS) - focusing on how we utilized each in our implementation.  We’ll also discuss process scheduling and coordination via Apache Airflow, along with its Python API and use of Python eggs.  Finally, we will show the recommendation system in action, and discuss plans for testing and improvement. 

Talk will be organized as follows:

## Intro - Context Setting (5 min)

* What is Kroger?  
   * What is 84.51?  
      * What is Digital Personalization at 84.51?

* Landscape: Kroger’s digital properties 
   * Typically use Retention-focused Recommendation Systems 
      * These tend to work extremely well with grocery’s cyclic purchase cycles
   * Need for Acquisition-based Recommendation System

## Body - Technical Deep Dive (20 min)
### New Product Recommender - Ensemble Recommendation System

### Part 0:
* Hadoop & Spark, and their Python API

### Part 1: Collaborative Filtering 
* Overview 
   * Training (PySpark)
   * Implementation (PySpark)
      * Roadblocks

### Part 2: Regularized Regression
* Overview
   * Training 
   * Implementation (PySpark)

### Part 3: Process Scheduling
   * Overview of Airflow
      * Directed Acyclic Graphs
      * Python directive script layout
      * Python Eggs

### Part 4: Live view of system on kroger.com

## Conclusion (5 min)
   * Next Steps - Testing
 recording release: yes license: CC BY-SA  

15. Customizing Sphinx: Simple, Normal, and Hard
Paul Everitt

Many Python projects use Sphinx for documentation, so much so that Sphinx is like Python’s secret weapon. It’s a powerful, mature system for generating static content -- not just docs, but blogs and regular websites.

Sphinx can also be customized and extended in various ways, and here the trip gets wild and wooly. With such a venerable software stack, Sphinx can be inscrutable when you paint outside the lines.

This talk gives Sphinx civilians confidence to go beyond simply using Sphinx, towards adapting Sphinx to their needs: configuration values, local CSS and templates, installing extensions and themes, writing a small extension with a directive, and testing that extension. We’ll conclude with a roundup of challenges and benefits that come with diving into Sphinx.

As the talk provides shallow treatment of a wide topic list, follow-up and hands-on instruction will be given at an open space.
 recording release: yes license: CC BY-SA  

16. Making Games
Piper Thunstrom

1. Game Loops
    1. Anatomy of a long running process
    2. The Most Basic Loop
        1. Respond to events
        2. Update Simulation
        3. Draw the model
2. 2D Graphics
    1. The pixel grid
    2. Separation of draw space and simulation space
3. Constructing your game
    1. The simplest
    2. Loops in loops
    3. Scenes
4. Engine Design
    1. procedural loops
    2. Entity-Component-System
    3. Model-View-Controller
5. Libraries
    1. Pygame
    2. Arcade
    3. PursuedPyBear
 recording release: yes license: CC BY-SA  

17. How to Build a Plan to Migrate to Python 3
Philip Semanchuk

Many organizations haven't yet made the switch to Python 3. Time is running out for them since **Python 2 will no longer be supported past 2020**. Organizations with larger projects to migrate will need to start very soon in order to meet the deadline.

Migrating from 2 to 3 can seem overwhelming, but it doesn't have to be if you **make a plan, take it step by step, and use the right tools**. What's more, there's a great deal you can do immediately (while still in Python 2) to make your code more compatible with Python 3.

**This talk is for anyone facing a 2-to-3 migration that they'd like to feel more confident about.** The talk will discuss five areas of focus -- choosing a Python 3 version, identifying test gaps, reviewing dependencies, prepping one's code for Python 3, and the actual switchover. I'll discuss strengths and weaknesses of the tool `caniusepython3` for assessing dependencies. I'll also go into a fair amount of detail on Python's tool `2to3`, including how (and when) to use it effectively.

**Attendees will leave confident that the migration is manageable.** They'll have the outline of a plan, some specific areas on which to focus, a knowledge of helpful tools, and links to resources they can use after the talk.
 recording release: yes license: CC BY-SA  

18. Software Engineering For Beginners: A Jr. Developer's Guide
Kojo Idrissa

# An Outline of the Talk

# Version Control (Git)
-  Why
    *  Protect yourself from mistakes
    *  Enable yourself to take chances & try new things
    *  Learning to work w/ a team

#  When?
*  10 or more lines of working code that you're scared to change because it might break

#  What/How
*  Basic feature branch/merge workflow

#  Reference: Pro Git Chapters [1-3](https://git-scm.com/book/en/v2)

# Documentation

#  In Code vs About Code: Start w/ In Code

#  Why
*  Help your future self
*  Help your teammates help you
*  Avoid that form of technical debt

#  When
*  Writing code using a new technique
*  Writing functions, especially if they call other functions 

#  How
*  Docstrings for functions (minimums)
    -  What the function does
    -  What it takes as input (include data type)
    -  What it produces as output (include data type)

#  Next Step: Learn about ReStructured Text and/or Sphinx for general documentation

# Testing & TDD
##  Testing vs "PURE" TDD
##  Why
*  Tests protect you from future changes breaking things
*  TDD: "write tests first" forces you to think before you type

##  When
*  As soon as possible
*  Art + Science: experience helps

##  How
*  New coders: Python unittest and doctests
*  Experienced coders: pytest

##  Next Step
*  New coders: pytest
*  Experienced coders: Continuous Integration

# Other
##  Dependency Management/Deployment
*  VMs
*  Containers
*  Virtual Env

##  Development Environment
*  CLI vs. GUI
*  Linux/Unix/Windows/OS X
 recording release: yes license: CC BY-SA  

19. Give Feedback Fearlessly
Aisha Blake

For many of us, it’s hard to speak up when we notice our teammates struggling. We don’t want to hurt anyone’s feelings or make things awkward. Sometimes it just feels like too much work to organize our thoughts into a coherent message that could help someone who’s falling behind move forward. Even knowing when it’s time to draw attention to a problem can be challenging.

We’ll start the session by covering our bases. When should we address uncomfortable situations at work? How can we keep personal feelings from derailing the conversation? And what happens afterward? Can we evaluate the effectiveness of our feedback? How can we move forward, growing as a team? We’ll answer these questions as we begin to build the skills necessary to provide teammates with specific, actionable feedback.

From there, the remainder of the time will be spent in hands-on role-playing scenarios. Participants will be broken up into small groups and given several scenarios to work through. Each scenario will outline a challenging situation from multiple points of view to help participants further explore the techniques and principles covered in the lecture portion of the session.
 recording release: yes license: CC BY-SA  

20. Generating Music with Python and FoxDot
Jessica Garson

Audience:
This talk is suited well for all audiences due to the live coding nature of this talk. Since making music with Python is something that beginner programmers can start with and advanced audiences could find interacting with Python in this way meaningful.

An outline of my talk is as follows: 

Set Up
This talk will be live coded using the Python. There will also some slides that will be available on my website jessicagarson.com/Making-Music-with-Python, All code samples will also be up on my GitHub.

Introduce Myself
Quick intro to set up the narrative of my presentation - Starting with something like: “Hi, my name is Jessica Garson. I’m currently teaching Python at NYU. I’m also a live coding DJ know as Messica Arson, I’ve performed with Live Code NYC, the Future of Funk Labs as part of the DC Funk Parade and Hack && Tell DC ”. I’ll  also cover administrative topics such where to find slides, and code samples from today’s talk, and a link to code samples on my GitHub. I’ll also provide my twitter handle. These will be displayed on a slide as well. 

There is Something Magical About Hearing a Computer Make Sounds You Told It To
I’ll tell the story about how I started a live coding and discuss why making music with code is so powerful.

FoxDot Installation 
We'll discuss how install FoxDot and some errors I ran into while setting up.

Tour of the IDE 
This will be a walkthrough the IDE.

The Coolest Part - The Tutorial Is Built In
We'll run an example from the tutorial.

Basic Syntax 
We'll discuss what the syntax looks like and how to create sounds easily. 

p1, s1, d1?
We'll discuss what this means and how each channel helps layer sound differently. 

Errors 
What happens when you get errors, how do you solve them.

Creating Our Melody
We'll create our melody to our song, and discuss how to keep your changes in sync with the flow of your song.

Adding Effects and Changing Our Sound
We'll make changes to our sound by arranging the effects.

Using Samples
We’ll discuss how to use samples. There are a bunch pre-loaded in and we'll discuss how to find them

Adding Outside Samples
I’ll add in a sample of my own voice assigned to a variable and create a loop which plays this sample. 

Creating a Melody
I’ll create a loop that creates a melody and explain what the code is doing to create this sound. 

How does FoxDot compare to the rest of the live coding ecosystem?
We'll compare FoxDot to TidalCycles and SonicPi and discuss the future of live coding.

Dance Party
We will listen to our song we created (hopefully a dance party will break out). 

Next Steps
I’ll point to a list of resources on my GitHub repository for the talk for learning more about a Python and FoxDot. I’ll also give my contact information for keeping in touch and thank attendees for coming to the talk.
 recording release: yes license: CC BY-SA  

21. You Can Do Deep Learning!
William Horton

You know how to code in Python, and you want to learn more about deep learning. This talk will put the tools in your hands to complete your first deep learning project, and put you on the path to growing your knowledge of this exciting field.

Along the way, we’ll discuss the learning process, and how you can leverage what you already know in order to jump start your progress tackling something new. I’ll even take a detour to talk (briefly) about how I got started in web development with Rails, and the benefits you can get from open-source frameworks with high levels of abstraction.

I’ll walk through the pieces you can put together to build a powerful image classifier with deep learning: hardware (GPUs), training data, model architectures and pretrained weights, and software libraries for running training and prediction with your models. Since all of these things are becoming increasingly available for free on the internet, it’s never been a better time to give deep learning a try.

In the end, you don't need a PhD to get started doing deep learning. You can have fun learning enough to do a simple project, like a cats vs. dogs image classifier. From there, you can go wherever your curiosity takes you!
 recording release: yes license: CC BY-SA  

22. Inside the Cheeseshop: How Python Packaging Works
Dustin Ingram

Questions and confusion about the Python packaging ecosystem abound. What is this `setup.py` file? What's the difference between wheels and eggs? Do I use setuptools or distutils? Why should I use twine? Do I put my projects dependencies in a `requirements.txt` or in `setup.py`? How do I just get my module up on PyPI? Wait, what is Warehouse?

This talk will identify the key tools one might encounter when trying to distribute Python software, what they are used for, why they exist, and their history (including where their weird names come from). In addition, we'll see how they all work together, what it takes to make them work, and what the future has in store for Python packaging.

This talk is for any Pythonista that has been confused by Python Packaging (read: everyone).

This talk requires that the audience has just the slightest familiarity with how Python Packaging works -- that you need to upload your source code, that there are a few popular and familiar tools, and that they are all a little confusing. Attendees do not need to be publishers of Python Packages but likely will be people interested in publishing someday.

After watching this talk, attendees should have a significant amount of their confusion about the Python packaging ecosystem resolved, and should be able to make informed, reasonable decisions when they want to publish a package (without having to be told step by step instructions, or given extremely opinionated advice).
 recording release: yes license: CC BY-SA  

23. You Don't Need That!
Christopher Neugebauer

Software design is hard. That's why we invented design patterns. Design patterns abstract common approaches to problem solving into generic approaches that can be modified to suit the application at hand.

Many of the design patterns in common use today are inspired by static object-oriented Enterprise languages like Java. These languages have a feature set that is somewhat more restrictive than Python's, and many design patterns are built to provide elegant ways around these restrictions.

Design patterns, like Dependency Injection, and the Visitor Pattern arise from restrictions on how you can pass code around at runtime. Other patterns, like Iterators, have been replaced by first-class language features of their own.

And some patterns, like Threads just never worked at all.

In this talk, we'll build up several design patterns, and then look at the Python features that make each pattern unnecessary. In doing so, you'll get a view into idiomatically translating code into Python, and a greater understanding of design decisions users of other languages need to make.
 recording release: yes license: CC BY-SA  

24. A Beginner's Guide to Tackling Recursion
Al Sweigart

Recursion has an intimidating reputation for being the advanced skill of coding sorcerers. But in this tutorial we look behind the curtain of this formidable technique to discover the simple ideas under it.

If you've ever said or thought the words "recursion is confusing", this tutorial is for you.

Through hands-on exercises in the interactive shell, we'll answer the following questions:

* What is recursion, and when is it a good idea and bad idea to use it?
* What are all the confusing ways that recursion is commonly taught?
* What's a stack, and what's the call stack?
* What are stack overflows, and how do we avoid them?
* Do some problems require recursion? How do I transform recursive code into iterative code, and vice versa?
* What are some common recusive problems in whiteboard coding interviews?
* What is memoization and tail call optimization?
* How do I draw that cool-looking fractal artwork using recursion?

We'll cover a number of common recursive algorithms:

* Factorial and Fibonacci calculation
* Exponent calculation
* The Towers of Hanoi
* The flood fill algorithm
* Binary search
* Generating permutations and combinations

This tutorial is for a wide range of developers. Beginners who only understand the basics of Python will be able to follow along. Experienced developers who have hoped no one would notice the recursive-coding gap in their knowledge will be able to breath with relief after taking this tutorial. All that is required is a willingness to learn, and a willingness to have the willingness to learn, and a willingness to have the willingness to have the willingness to learn, and... so on.

## Setup Instructions

[https://inventwithpython.com/blog/2018/08/24/pyohio-2018-recursion-tutorial/](https://inventwithpython.com/blog/2018/08/24/pyohio-2018-recursion-tutorial/)
 recording release: yes license: CC BY-SA  

25. Egad! How Do We Start Writing (Better) Tests?
Andrew Knight

To show how to develop a test automation solution for champions, we will follow the story of “Amanda the Panda” (representing the everyday Pythoneer) as she jumps into testing and automation with Python.

Her journey includes:

1. How do I play “buzzword bingo” for testing?
2. Why do we need feature tests and not just unit tests?
3. What skills do I need?
4. What framework should I use?
5. How do I avoid duplicating test code?
6. How do I handle test data?
7. There are too many tests! Which ones should I automate?
8. How do I run tests in continuous integration?
9. How do I make tests reliable so they stop failing again and again?
10. How do I hire Software Engineers in Test?

All examples will be given in Python (of course).
 recording release: yes license: CC BY-SA  

26. Going Passwordless
Jon Banafato

- The problem with passwords
    - Flaws in how passwords are used today
    - Some real life examples of how passwords fail us

- Past attempts to fix this (and their issues)
    - SSL/TLS client certificates
    - Single sign on providers
    - Biometrics

- Better approaches (and their implementations)
    - Magic links (email-based authentication)
    - Hardware tokens
    - WebAuthn

- Putting it all together
    - A quick tour of the `py_webauthn` library
    - Building a custom Django authentication workflow with these concepts

- Pros and cons
    - Advantages over conventional password-based authentication
    - Barriers to implementing this today and how to overcome them

- Conclusion
 recording release: yes license: CC BY-SA  

27. Building a Twitter Metadata Scraper: Learnings from Working with a New Twitter API
Elizabeth Wehner

BuzzFeed (especially our News team) creates a lot of time-sensitive content. But when shared on Twitter, the twitter-share data would remain fixed. This could lead to articles that changed from "So-and-so leads in election" to "so and so won the election" still being shared with an old title. BuzzFeed worked with Twitter on the development of a new API that could be used to rescrape the metadata to update share card information on request. I then built a "twitter scraper" using Python 3.5 that would request a rescrape every time we updated a published article. This proved especially tricky as existing twitter API support did not not quite fit our needs, requiring new solutions on our end. In this talk I'll go through the challenges involved in working with the new Twitter API and how I ultimately solved them.
 recording release: yes license: CC BY-SA  

28. Serverless Anywhere, Including On-Prem
Don Schenck

Serverless computing -- they’re functions, but that doesn’t sound as provocative -- is here to stay. Some people even think it will take over and be the future of computing. But there’s one problem: Vendor lock in.

Azure Functions, AWS Lambdas, Google Cloud Functions … they will all meet your needs, but do you really want to put all your proverbial computing eggs into one vendor basket? Also; what if you just want to learn (“play around with”) functions without spending money?

Enter OpenWhisk, the open source serverless (“THEY’RE FUNCTIONS!”) computing engine that runs anywhere: Azure, Amazon, Google, your hosting platform of choice, or in-house. Or everywhere. Your choice, you decide, you are in control.

This session will demonstrate how one code base -- no matter the programming language! -- can run on any platform, avoiding vendor lock in and putting you back in control of your cloud native development.
 recording release: yes license: CC BY-SA  

29. Conversational Interfaces for Chatbots and Artificial Intelligence
Don Holloway

Attendees will get an understanding of key concepts for conversational interfaces which are used to create chatbots, as well as, some examples of the python libraries and code which can be used to create them.  

Conversational interfaces are increasingly becoming a preferred way for users to engage with information.  This is particularly true for younger users.  Conversational interfaces offer a more personalized user experience, as well as, a means to walk a user through a potentially complex series of requirements.

That ability to determine the user’s intent, combined with the ability to step them through a series of relevant questions makes it particularly well suited for interfacing with artificial intelligence systems which often require precisely structured input to deliver meaningful insight.

The presentation will provide an overview of conversational interfaces, integration with front end communications channels, and back end artificial intelligence systems.  

An example will be shown which illustrates the end to end concepts covered. The presentation will use RASA Core, an open source Python machine learning based dialogue engine for conversational software, to show the process and benefits for training data on specific domains.   The example will show the framework integrated with Twitter and Facebook messenger as communications channels, and the ability to direct actions to multiple AI backends.
 recording release: yes license: CC BY-SA  

30. An Only One Step Ahead Guide for Machine Learning Projects
Chang Hsin Lee

## Abstract

What does a data scientist’s day look like? On the one hand, people say that a data scientist's day is 5% modeling and 95% cleaning data and other stuff. On the other hand, there are many more machine learning tutorials and blog posts on modeling than posts on the "other stuff" when I search online. There seems to be a lack of guidance for junior data scientists when they enter into the field who are trying to complete their first few projects. 

In the last few years, I have worked on several data science projects like this, where the path to success is unclear and the journey is full of pitfalls. In this talk, I will provide practical tips on machine learning projects that I learned the hard way. I will give you 2-3 tips with examples in each stage of a machine learning project --- before, during, and after --- that will help junior data scientists or anyone working on a machine learning project navigate through the muddy data waters better.

## Outline

There are a few stages of a machine learning (ML) project, and I will give a few tips for each.

**Before ML** (7-8 minutes)

What kind of questions should I ask to the most out of the preparation stage of a machine learning project? 

**Starting ML** (8-10 minutes)

How do I define success and how do I get there? What kind of model should I pick? What are some Python tools that can help me work through a project?

**Pitfalls** (8-10 minutes)

I will share examples and stories of pitalls I saw or fell into in my past projects that I wasn't aware of at the time.
 recording release: yes license: CC BY-SA  

31. Tracking the International Space Station in Django with Redis-Queue and RQ Scheduler
Samuel Agnew

The international space station (ISS) is an orbital outpost circling high above our heads. Given a location on Earth (latitude, longitude) the ISS Open Notify API will compute the next `n` number of times that the ISS will be overhead. I will cover step by step how to build a web application that notifies users via text message when the ISS is passing over them. 

This talk is live coded and will involve me switching between writing code in my text editor (vim), terminal windows and web browser. It is based off of a [tutorial post I wrote for the Twilio blog](https://www.twilio.com/blog/2015/11/international-space-station-notifications-with-python-redis-queue-and-twilio-copilot.html). 

In this session, attendees will learn how to:
- Access and interpret data from the [ISS Open Notify API](http://open-notify.org/Open-Notify-API/ISS-Pass-Times/) on the exact timing on when the ISS will next pass a given geolocation.
- Use Redis Queue as a lightweight alternative to Celery for executing asynchronous tasks.
- Use RQ Scheduler to schedule tasks to be performed at a specific datetime.
- Integrate RQ and RQ Scheduler into a Django web application.
- Respond to webhook requests with Django.
- Access client-side geolocation data using JavaScript.
- Send text message notifications using the Twilio SMS API.

In the Django app built during this talk, Redis will be used to store subscriber information such as a user's phone number and geolocation. RQ and RQ Scheduler will be used to execute a function that sends a text message notification using the Twilio API at a given datetime. 

At the end of my talk, I will send a text message containing the code I wrote, and a walkthrough on how to get it running to all of the audience members who interacted with the live-coded web application from my session.
 recording release: yes license: CC BY-SA  

32. Automated Regression Testing with Splinter and Jupyter
Jace Browning

This talk will start with a background on testing and quality assurance:

- Terminology
  - Unit vs. Integration vs. System (end-to-end)
  - Automated vs. Exploratory

- Goals of end-to-end testing
  - Test production server configurations
  - Test JavaScript engines in browsers
  - Responsiveness/visual testing
  - External API hookups

The next section will outline a layered approach for writing end-to-end tests with each step building on the last:

- Selenium basics
- Language bindings (Python examples)
- Sequential test scripts
- Adopting the “Page Object Model”
- Using a WebDriver API wrapper (Splinter examples)
- Helper functions to enable automated exploratory testing

Before the final section, there will be a demo of the previous examples run against a live website.

The final section will recommend an approach to building tests against your own site:

- Alternatives
  - Dogfooding
  - Beta testers
  - Manual testers

- Make your site testable
  - Name your forms and fields
  - Accessible sites are testable sites
  - Test mode for account signups
  - Expose internal state when possible
  - Allow “cheats” on your staging server

-  Writing tests
  - Start with under-tested, high-risk features
  - Make your bot users identifiable for easy cleanup
  - Run your tests every time you deploy
  - Incorporate logging, screenshots, and reports
 recording release: yes license: CC BY-SA  

33. Saturday Lightning Talks
Dave Forgac

delay=1.0
- Lock Your Mock - Aly Sivji
- Abusing Type Annotations - Zach Mitchell
- How does U2F / Yubikeys work? - LVH
- Blast Asteroids with Arcade - Paul Everitt
- Chocolate in PB - Dan Lindeman
- Good Hacker / Bad Hacker - Dustin Ingram
 recording release: yes license: CC BY-SA  

34. Sunday Welcome
Dave Forgac

Information about Sunday's events.
 recording release: yes license: CC BY-SA  

35. Now is better than Never: What the Zen of Python can teach us about Data Ethics
Lorena Mesa

We Pythonistas welcome newcomers with the wisdom of Tim Peter's "import this". Okay, well maybe. The Zen of Python provides us as a community general aphorisms on how to write Python and how to be a good Pythonista by offering loose guidelines that promotes discussion. What lessons, then, can the Zen of Python teach us about Data Ethics?

Data ethics is a nebulous concept, a necessity in the era of algorithms and the data economy. Together we'll review some stories from the headlines about the data economy where there were ethical concerns and apply the Zen of Python. Starting with the impact of social media likes on political campaigns to censorship on social media in the #MeToo movement, we'll use big challenges to highlight obvious and not so obvious lessons. 

Ultimately the Zen of Python teaches us that 'Now is Better than Never' and we must ask as data practitioners - what principles will we develop and champion to respond to ethical dilemmas?
 recording release: yes license: CC BY-SA  

36. Welcome to CircuitPython!
Kattni Rembor

CircuitPython is Python that runs on microcontrollers. It's designed for learning and it's super simple to use. If you're new to programming or electronics, CircuitPython can help you get started with both. All you need to do is plug in a microcontroller board, open any code editor, and start editing. Participants will be provided with a Circuit Playground Express microcontroller board to use. We will be using Mu as our code editor - Mu is an editor that has the serial REPL and a plotter built in, and makes getting started with CircuitPython quite easy. This beginner-friendly tutorial will cover what CircuitPython is and why you would use it. I will discuss the community built around CircuitPython. Then we will get into working with code. There will be a series of examples that utilise the various sensors, lights and switches built into the Circuit Playground Express board. We will start simply with the CircuitPython "Hello, world!" Then we will use the plotter in Mu to graph the data live from a few of the sensors. Next, we'll begin exploring the various other inputs and sensors on the board. From there, we'll build on the concepts learned, combining them as we go to eventually build a light up, capacitive touch tone piano. All code will be provided on [GitHub](https://github.com/kattni/pyohio_2018_cp).

## Setup Instructions

Prerequisite setup instructions can be found [here](https://github.com/kattni/pyohio_2018_cp/blob/master/README.md).
 recording release: yes license: CC BY-SA  

37. Python, Robotics, OpenCV and Vision
Robert Seward

A brief overview of using Python to power the Computer Vision function of our FIRST FRC Robotics Robot.
 
A FIRST robotics team mentor briefly talks about using Python to teach students how to integrate Computer Vision into our team's robot.

First we meet the robot. Robot baby pictures (yay!) and other fun stuff. Followed by a quick overview of what it means to be a mentor on a FIRST FRC robotics team. We end the section discussing the components of our robot and how they all fit together to integrate vision.

We explore working with the students to build GRIP pipelines. GRIP is an FRC tool to allow students to quickly build opencv feature detection routines for game elements. We discuss what opencv is and why you should care! The GRIP tool is a flexible development environment to quickly chain together opencv primitives and observe the end results. When game element features are being detected as the students need, the tool can export into our favorite language! Python!

Our team in the past has run this generated opencv GRIP Python "pipeline" on an external CPU. Due to our Team's budget constraints we use a Raspberry PI 3 with a USB web cam. (< $150) We mount and power the pi and camera on the robot. We run the "pipeline" and see things. Well almost!

In addition to the student generated pipeline, we also have a small python program that reads images from the camera as often as possible and detects features for the robot to target. This python code does some basic filtering and then sends the information to the robot control board (RoboRIO).

We end the talk with a brief description of using the vision information to control the robot.
 recording release: yes license: CC BY-SA  

38. Penetration Testing The Dev Interview: Attacks to Ace Interviews and Defenses to Build Better Teams
Wes Winham

* Heuristics
* Cognitive bias
* Resume attacks
* Phone screen attacks
* Take-home test attacks
* Resume defense
* Phone screen defense
* Take-home test defenses

Learning: Attendees will leave armed with both a) tools to be a more effective interviewer and b) tools to presents their best self as a candidate.
 recording release: yes license: CC BY-SA  

39. Community - From the Inside Out
Yarko Tymciurak

# Community - From the Inside out
##  towards an attractive Community API

- Everybody is drawn to Community?
  - list of talks, quotes, other communities which mirrored this;

- Why is that?
  - evolution
    - benefits & shortcomings (community & congintion basics)
    - mirrored in biological structures (Panksepp)
    - the architecture of biology
    - cognition and feedback structures;
    - the interesting structures: play, joy/sadness, exploration
    - dynamic modulation
  - how widely favored (evolutionarily) is it?
    - bees, rats, chimps, us, ... (examples)

- Why - a functional description
  - the limits of cognition, and the benefit of social sharing
    - Edelsons's checker shadow demonstration
    - Eagleman on more complex functions
    - how personal, encapsulated our experiences are
  - how the benefit works
    - code reviews
    - scientific method
    - work teams
    - open-source communities
    - open societies / governments

- Skills:
  - encapsulation and structure in software (hey! it's like cognition!)
  - the parallels for Community interaction (and for architectural guidance too);
  - fundamental data structures;
  - explicitly aware == explicit benefits
    - the core API rule (encapsulation)
    - personal data structures
    - data structures vs. interfaces
    - channels (modes) of communication
      - their uses, their limits
        - how to switch channels
  - putting into practice in community

- Where to go from here

- Q/A
 recording release: yes license: CC BY-SA  

40. An Intuitive Grasp of RegEx’s in Python
Tom Fetherston

## Overview & Purpose

Regular expressions are used to define search patterns and are an important technique for validating data, scraping data, data wrangling, (i.e re-formatting.), the content of strings.  Additionally, the’re used to enable syntax highlighting in some applications.  Python provides regular expressions via the built in ‘re’ module, and there is a third party ‘regex’ module with added functionality.
The problem is, writing regex patterns to do what you want is hard, and even when you’ve got one, figuring out what it is or isn’t going to match can be baffling.
This talk will give you two tools conquer regex’s, a mental model, (demonstrated with props), of how they work, and a mini-language, “Simple Regex Language”, to create readable regex’s that easily translate into Python’s regex syntax.

## A Physical Model of RegEx’s

1. Picture the string we are searching as a line of tiles, (like those in scrabble), where the character each represent has been routed into its surface.
2. This lets us talk about the two categories of places a regex start or continue a match:
   1. At a character specified in the regex: (modeled by a vacuum-formed sheet of plastic whose profile can nest in the character’s incised relief).
   2. At a position called an anchor, specified in the regex: (represented by the insertion of a strip of plastic into the crack between tiles)
      1. Note: whether a give ‘crack’ matches the given anchor is determined by what is to its left and right; more specifically, the categories they belong to, i.e. whitespace, printable, alphabetic, numeric, eol,  buffer-wall, etc.
3. This model lets us illustrate how the regex engine goes about making a match; e.g., if our pattern wants to match ‘ABC’, and our string contains ‘ABD’, we slide along a piece of plastic with a  ‘A’ profile, from the start of the buffer to where we encounter the ‘A’ tile. The plastic will sink into ‘A’ tile, allowing us to swing down ‘B’ plastic that is taped the the right edge of ‘A’ overlay which also sinks down flush matching the ‘B’ tile.  When we try to swing down the next taped on plastic overlay, ‘C’, it crashes into the surface of the ‘D’ tile and instead levers out the ‘B’ overlay, which levers out the ‘A’ overlay and gets us back to sliding along the ‘A’ overlay looking for the next place to pause and try for a match.
4. At this point we introduce SRL, (below), then show how its patterns translate into Python regex’s, then we return to this model and extend it to cover all the different regex ‘atoms’ we can now write.
5. This “Tile and Overlay” model provides a visual metaphor to see how the regex engine works, but there are no tiles and overlay chains in the computer, there are only strings of bytes and double-bytes, (if we are talking UTF-8), so we briefly introduce a model that use height to represent characters.  This lets us talk about Unicode strings, and hints at the kind of optimizations compiling regex’s might allow Python to do.
6. For the presentation, there will be a physical model to show the example in covered in point three above, but to make things manageable, we'll then switch to illustrations done in Skecthup, (maybe even animations).

## SRL: Simple Regex Language

1. SRL is what is known as a “Little Language”, or a “Domain Specific Language” which are built to handle a small problem area.  In SRL’s case, the problem is that of the unreadability of regex’s, and that each language has a different way of writing them.
   1. You’d think we could skip this as we are only concerned with Python here, but it is useful to have this level of abstraction, even if you only do Python. You are likely to find that your editor uses a different flavor of regex’s.
1. An overview, live demos, and documentation can be found at the project’s website, .  I won’t duplicate them here,I’ll just say that the exposition of what we need for this talk will follow this source material, and include a SRL to Python cheat sheet that covers their translation and how they are expressed in the “Tile and Overlay” model.
1. To give reviewers a feel for what the illustration of SRL will look like, I intend either add them to the proposal, or provide a link to them on my github so you can look at them as they are created for this talk.
 recording release: yes license: CC BY-SA  

41. Auditing Your Site for Accessibility: Now What?
Kat Passen

So you’ve heard about web accessibility - maybe you’ve only heard it in passing, or maybe you’ve read some docs or blog posts, or perhaps you’ve even attended a conference talk about it.  But oftentimes this is where you’re left hanging, holding a toolbag with a gigantic “now what?”.  Starting out can feel daunting, especially if you have a large application to deal with.

Here are the steps we’ll cover:

1. Identify - how do you find potential or actual problems
2. Verify - are these real problems, or potential false positives
3. Plan - finding the most efficient ways to handle the critical path
4. Due diligence - fixing, testing, future proofing

We’ll talk about all of these in the context of a familiar website that recently went through this same process.
 recording release: yes license: CC BY-SA  

42. Build GUIs with Python and Glade
Terry Howald

Build GUIs with Python and Glade

Python gets a lot of attention these days, but many still see it as a scripting language for command line applications. Or do they? A recent survey reveals approximately 25% of Python applications being developed include some form of graphical user interface (GUI). Seeing this statistic encouraged me to experiment with my own Python GUI projects. However I quickly learned that choosing to develop a Python GUI was just the first of many decisions that had to be made. This talk walks the audience through the many challenges one faces when building GUIs with Python.

The first step in building GUIs with Python is to consider the target platform. Although it may not be obvious up front, this choice may constrain decisions made later. Next one has to choose a version of Python because the target platform may have both Python2 and Python3. Where to code the selected Python version is the next choice. Developers are often passionate about their editors, but the target platform my dictate the editor choice. Next we have to decide on a GUI toolkit to utilize, since we won't be programming GUI widgets from scratch. Also we have to decide if we plan to layout the GUI widgets programatically, or use a rapid application development (RAD) tool such as Glade. And finally we have to consider how we'll deploy our Python-based GUI application into the field.

The presentation will conclude with code demonstrations using Glade to construct Python GUIs. Time will be allocated for the audience to ask questions about the coding examples presented, as well the thought process that led me to choose the software development tools used.
 recording release: yes license: CC BY-SA  

43. How I Learned to Code with My Dad
Alexander Preston, Hank Preston

My name is Alexander Preston, I’m nine years old, and I love coding with my Dad.  To me, coding is like a “sport”.  It’s a fun activity you can do, and become better at.  I’m hoping to become a video game developer, because (almost) everyone likes games.  I learned about coding by watching my dad, and asking what he was working on.  I started programming by using Scratch on a Raspberry Pi and building some games, and now I’m learning to code in Python with Minecraft.  I think that lots of kids would love to code, and I’d like to give some ideas about how to help them get started.  

In this talk I, with some help from my dad, will show how you can use Python with Minecraft to connect to and control the world.  We'll build buildings, blow them up, see what happens when Zombies invade, and other fun stuff we come up with.
 recording release: yes license: CC BY-SA  

44. Python in Serverless Architectures
Daniel Lindeman

You're familiar with backend web development in the Python ecosystem, Flask, Django, Pyramid, all of it. Things are going smoothly in the world of backend. Great! 

One day you're cruising through HackerNews and all of a sudden see the words "Serverless Architectures" pop up. Oh dear. "Servers? That's where backend code lives!", you protest, "what is the racket all about?" 

Lucky for us, we know Python. A first-class citizen in the world of serverless architectures. 

Serverless architectures are on the rise, so lets take a look at all the moving pieces that go into making one. We begin our journey in the familiar land of Flask with a small, but useful, backend application. We will demystify serverless architectures using a very-confusingly-named utility called...ahem...Serverless. Piece by piece we will come to understand ways of doing user authentication, database interaction, deployment, and testing for our new fangled serverless application. We'll explore the pros and the cons of our choices as we make them.

By the end of our time together serverless architectures will transform from meaningless buzzword to a valid architecture decision you have all the tools to evaluate.
 recording release: yes license: CC BY-SA  

45. CSS as a Service: Maintaining Style
Shay Howe

We often build multiple websites and applications that share the same styles across multiple code bases (style guides/pattern libraries). Maintaining these styles becomes quite a task, and causes increasing frustration overtime. Fortunately it doesn’t have to be this way.

Within this talk we’ll cover a service-oriented architecture approach to writing HTML and CSS, including Sass, and keeping our code modular and performant. Geared towards designers and front-end developers, we’ll discuss at how to best structure and write front-end code for maintainability and reuse, as well as how to properly package these styles to be used within different development environments. Consistency shouldn’t take a back seat to maintainability, and this talk covers how to have the best of both worlds.
 recording release: yes license: CC BY-SA  

46. Containers Without the Magic
Vince Salvino

This talk is designed to explain container concepts in a way that is familiar to Python developers. We will *not* focus on specific frameworks or cloud services that help deploy containers. We *will* explain what containers are, how they work, and how to get started containerizing your app.

What are containers?
----------------------
* What is a container.
* Conceptual difference between running your app in a container versus "normally".
* Pros and cons of container concepts.

How do containers work?
---------------------------
* Comparison to virtualenv.
* Overview of LXC (Linux containers).
* Overview of Docker.
* How to shift your thinking from LAMP stack mentality to Docker mentality.

Containerizing your app
-------------------------
* Treating new shiny syndrome: real-world use-cases why you should or shouldn't containerize your app.
* Getting started checklist for dockerizing your existing python web app.
 recording release: yes license: CC BY-SA  

47. A Son, a Father, and a Computer - How I'm Using Tech to Ease the Suffering of my Dying Father
Greg Svoboda

*WIP*

Using Python, I built:

* An Emergency notification system that texts family members.
* A "help button" where a mother who *never* asks for help can simply push it, and her closest friends will get a reminder to call and encourage her.
* A python-powered, Voice-activated IR system to turn on music, tv, and more. Engaged with custom wake words, and powered by a Raspberry Pi.
* A music player that will allow my dad to listen to his favorite music when he's feeling down, without having to push a single button.
 recording release: yes license: CC BY-SA  

48. Duck Typing Is For The Birds
Brad Hurley

In this presentation I would like to introduce implementing static typing to people who may not be familiar, and give reason for why static types can be valuable, and discuss how it can reduce the potential for bugs.  I will briefly talk about the history that led to the current and future state of static type support within Python. 

- Code examples for implementing type checking for common scenarios
- Auto-generating static type annotations with MonkeyType
- Comparing mypy and Pyre for type checking
- Questions and answers

### Relavent PEPs:
[PEP483](https://www.python.org/dev/peps/pep-0483/)
[PEP484](https://www.python.org/dev/peps/pep-0484/)
[PEP526](https://www.python.org/dev/peps/pep-0526/)

### Libraries:
[mypy](http://mypy-lang.org/)
[Pyre](https://github.com/facebook/pyre-check)
[MonkeyType](https://github.com/Instagram/MonkeyType)
 recording release: yes license: CC BY-SA  

49. Intro to Automation Using StackStorm and Python
Nick Maludy

Python is an amazing language that allows developers to accomplish tasks quickly.
StackStorm is an even-driven automation platform that enables developers and 
operations to take their Python scripts to the next level. 

First we will learn about the StackStorm platform and its building blocks:
actions, workflows, sensors, triggers and rules. 

Second we will discuss how these building blocks are tied together using 
StackStorms event bus.

Finally we will demonstrate some of the amazing capabilities we're able to 
realize once a Python script is brought into the StackStorm ecosystem such as:
automatically invoking the script when an event occurs in an external system,
invoking the script via the API, or invoking the script via Slack.

## Outline

 - About myself
 - StackStorm intro
   - automation platform
   - event driven
   - everything is code
   - everything available via the API
   - everything available via the CLI
 - StackStorm Actions 
   - what is an action 
   - create a metadata file 
   - convert our python script 
   - run it via the CLI
     - show how st2 CLI writes curl commands for the API in debug mode
 - StackStorm ChatOps 
   - what is ChatOps 
   - create a alias for our action
   - demo execution of the alias in Slack 
 - Questions

 - If there's time 
   - Packs
     - collection of artifacts (actions, aliases, workflows, rules, etc)
     - github repo
     - requirements.txt for python dependencies
   - Webhooks
     - create a webhook rule
     - invoke the webhook via curl
   - Workflows
     - mistral
     - composable actions
     - passing data between actions
     - handling errors
   - Datastore
     - read/write data
     - secret keys
     - reading in data in an action
     - reading in data in a workflow

## Setup Instructions

[https://gist.github.com/nmaludy/21c403d98eaf13f2accfd85e68dadb9c](https://gist.github.com/nmaludy/21c403d98eaf13f2accfd85e68dadb9c)
 recording release: yes license: CC BY-SA  

50. Distributed Software (with Python)
Alexandru Barbur

This talk gives an introduction to several aspects of designing and implementing distributed software with a focus on control systems and Python development. Topics include code layout, server architecture, serialization, APIs, networking, and control system design. Relevant tradeoffs, external libraries, and implementation details for one variant are covered for each topic with Python specific example code. A few minutes are set aside at the end of the talk to ask specific questions and discuss Python specific implementation details.

* About the author (2m)
* About the example project (3m)
* Code Layout (5m)
* (Extended) Server Architecture (5m)
* Serialization (7m)
    * Versioning
    * Binary Data
    * Bandwidth
    * Speed
* Component APIs (5m)
* Network IO (3m)
* Network Discovery (5m)
* (Extended) Control System Design (5m)
* Questions and Links (5-10m)
 recording release: yes license: CC BY-SA  

51. Cheating on Your Math Homework with SymPy
John Cassidy

- Installation
- Basic Algebra Stuff (about 40% of talk)
  - Define symbols
  - Build expressions
  - How Sympy uses exact values i.e. pi * exp(5) + sqrt(8) until told to evaluate as float
  - Expand an expression
  - Factor expression
  - Build an expression from a string (sym-pify)
  - Substitute a value or expression
  - Define an equation
  - Solve for X
  - Systems of Equations
  - Printing
- Trigonometry (just some basic stuff using trig expressions)
- Just a little calculus (examples, limits, derivatives, integrals)  
- Linear Algebra (Focus about 40% of talk on this to aid students in statistics, analytics, and machine learning)
 recording release: yes license: CC BY-SA  

52. Bit Splotches: Dot Matrix Printing with Python
Thomas Winningham

- Brief history of consumer printing in the late 80's
    - Dot Matrix
    - Epson "Compatible" and not
    - Parallel and Serial Interfaces
    - Rejuvenating ribbons with WD-40
- Interfacing with the device over USB
- Trying (and failing) with available printer drivers
- Being lucky and having the manual for the printer
- NetPBM (a textual bit representation of images)
- Dithering with GIMP, ImageMagick, and Pillow
- Mapping printer pins to NumPy matrices
- Python integration with CUPS using Tea4CUPS
- Custom fonts using NumPy and the Read-Font library (ported to Python 3)
- Demo and Examples
 recording release: yes license: CC BY-SA  

53. Useful Python Libraries for Network Engineers
Hank Preston

Python has quickly become THE language for network automation and programmability due to it’s combined simplicity and power.  Add to that the robust assortment of tools, libraries and modules related to networking available to “import" and I doubt another language will take over the title anytime soon.  In this session we’ll explore some of the most useful libraries for network engineers and developers looking to interact with the network from a configuration and operational perspective.  Plenty of code will be shown, and all examples will be available to take away and leverage in your own environments.  

Through the session you'll learn how to leverage the tried and true interfaces of CLI and SNMP to manage your network before we jump up to newer options like NETCONF, RESTCONF and REST APIs.  We'll even explore full configuration management solutions and discuss when and how they should fit into your overall automation strategy.  

Some of the great modules that will be covered include: 

* netmiko
* PySNMP
* ncclient
* requests 
* Ansible 
* NAPALM
 recording release: yes license: CC BY-SA  

54. Pandas on Jupyter: Improving Your Data Analysis Workflow
Nick Macro

The need to clean, manipulate, and visualize data is a skill that is increasingly in demand due to the abundance of data available. There are many methods of performing data analysis, each with its own benefits and drawbacks. Of the many features that can be used to evaluate a data analysis method, we will focus on ease of use and reproducibility.  

It is crucially important for data analysis to be reproducible from starting data. A reproducible workflow allows others to review your work and can help catch assumptions, bugs, and steps that are not transparent in the final result. Reproducibility improves the transparency of your analysis and therefore makes your results more resistant to misinterpretation.   

Python and, more specifically, Jupyter Notebooks enable workflows to be reproducible with very little overhead. Due to these characteristics, Jupyter Notebooks are the current medium for most data science work.  
One of largest problems with switching to a reproducible workflow is amount of time you need to sink into converting to the new workflow. I will demonstrate how a data analysis workflow can be modified using python libraries and Jupyter Notebooks.
 recording release: yes license: CC BY-SA  

55. Oh the Places You'll Go to Find Memory Leaks
Ilya Gotfryd

At the core of your company's flagship app is a long running process that eventually becomes hungry for memory. You have to watch it like a hawk and run rolling restarts randomly throughout the day. It sure would be nice to know exactly what's happening to memory!
In this talk, you'll learn about available Python memory profiling tools, using Elasticsearch to track per request memory use on a live system, memory pools and arenas for tiny object memory management, system memory versus process memory visible to a garbage collector, use of interprocess communication to manage your instrumentation, querying garbage collector for object inventory, memory allocation during package loading, and plain human perseverance. Also, we'll discuss the fact that you absolutely must get off Python 2.7.x for any long running processes.
 recording release: yes license: CC BY-SA  

56. Creating an IoT Baseball Scoreboard with Python
Christian Wyglendowski

This talk will cover the hardware, code and libraries I used to build a digital baseball scoreboard for tracking my favorite MLB team.  If sports aren't your thing, that's OK - there will be plenty of information applicable to other IoT/maker projects.

I'll cover use of the threading, queue and sched modules from the standard library. I'll also share how I used the mlbgame and gpiozero libraries. Finally, as a novice hardware hacker myself, I'll share what I've learned about hardware hacking including soldering tips, useful equipment, etc.

* The Scoreboard Project
* 7-segment displays
* Shift registers
* Transistors and multiplexing
* Soldering
* Raspberry Pi Zero W and gpiozero
* MLB API and the mlbgame package
* sched, threading and queue(s) (oh my!)
* Opening Day
* Future Directions
 recording release: yes license: CC BY-SA  

57. Solving an NP-Hard Problem for Fun and Profit
Raymond Chandler III

Last year I was given a task by the publishers of the CATAN board game. They wanted a tournament management tool that could help them organize, run, seat, and rank players in their world championships and several local qualifying events around the world. Most of the application was straightforward but they also had a very specific seating problem, and after doing some investigation I learned that their specific requirements made the task an NP-hard problem. The problem is this:

Given some number of players. Generate a number of tables where each table has 4 or 3 seats. Then from round to round seat players in such a way so that A) no player plays in the same seating position they previously sat in, and B) no player plays against someone they played against previously. Players should be seated as fairly as possible from round to round, and where there is a perfect solution the algorithm should arrive at it, and when there isn't it should arrive at the "fairest" solution possible. It should be able to handle any arbitrarily large number of players, and should run in seconds.

In this talk, I'm going to talk a bit more about this specific problem and how I solved it using Python. I will walk you through my different attempts and thought processes while attempting to develop a good solution. You will walk away with a process and framework to solve your own difficult problems and develop a scientific mindset that can help lead you to new discoveries.

Finally, I will present how the algorithm works, and make suggestions to how it can be applied to solve other similar types of problems. I proudly present to you: The Gamer's Algorithm.

P.S. The algorithm will be used for the first time in the wild at the CATAN World Championships at Origin Games Fair and the U.S. National Championships at Gencon in 2018.
 recording release: yes license: CC BY-SA  

58. Sunday Lightning Talks
Dave Forgac

* Extending Python w/ C/C++ - Devyn Spillane
* Even More Significant Whitespace - Tom Fetherston
* Don't Hire Rockstars, Train Idols - Kojo Idrissa
* I Want a Descriptor in my Dataclass - Rick Teachey
* Saving An Animation in Matplotlib - Brandon Rhodes
* fuzzywuzzy String Matching - Ann Elliott
* PPB: 15 Lines to Takeoff - Piper Thunstrom
* Get Setup with setup.cfg - Andrew Kubera
* Wagtail – Vince Salvino
 recording release: yes license: CC BY-SA  



Location
--------
Cartoon 1


About the group
---------------
===
https://pyohio.org

A FREE annual conference for anyone interested in Python in and around Ohio, the entire Midwest, maybe even the whole world.