Accepted Talks

  1. Abstractions and building up: A case study with chess_py, an open source chess platform

    Aubhro Sengupta

    Programming can seem difficult because of the enormous level of abstraction involved. Objects are being dealt with that have very little to do with the real world. They are hard to grasp, touch, and feel. Chess on the other hand is a very concrete and physical game. Objects such as the board, pieces, and even logic such as the basic rules of the game are much easier to understand. How the pieces in chess interact, their capabilities, and their placement on the board can be similar to the way objects interact in python. Using chess_py, an open source platform for chess written by me in python, we can delve into the different classes and data structures to understand how they work and gain a deeper understanding of the language of python.

  2. A custom language (PPCL) plugin and syntax for Sublime Text 3

    Brien Blandford

    PPCL (Powers Process Control Language) is a custom language for building systems controllers by Siemens. It is similar to Basic (and essentially the same vintage), and is very difficult to use in the Siemens-provided text editor. It is incredibly cumbersome to bulk edit (if at all possible), and doesn't have customizeable syntax highlighting, or the freedom to modify any of the editing parameters.

    When writing a lot of Siemens PPCL, it is very time consuming and frustrating. In having to write and edit large amounts of this code, I made a plugin for Sublime Text 3 and a syntax that allow me to edit code much more quickly.

  3. Advanced Git

    David Baumgold

    You know clone, commit, push, and pull. Now you're ready for the fun stuff. This talk will give you the advanced knowledge you need to take control of your Git repository: rebase, cherry-pick, bisect, blame, squashing, and the reflog. You'll also get a better conceptual understanding of how Git works, allowing you to chain these tools together to accomplish whatever task you need.

  4. Advanced Permissioning

    Jack McCloy

    In many Django applications, permissioning (building rules for who has access to what) is pretty easy. Logged out users can see some stuff, logged in users can see more stuff, and superusers can see (and edit, and delete) all of the stuff! But when you want to handle more complex permissioning (like object-level permissions), it can get pretty ugly. This talk will help to de-uglify things for you.

  5. Algorithmically Generated Music Using Pyo Based on User Data

    David Groff

    At Peloton our data is pedaling speed and resistance from every second while a user rides their bike. We can use this data to generate music that plays back to the user. One way to generate unique and interesting sounds is using Pyo, a python-based DSP library, in combination with custom MIDI samples. This talk will cover how we structure this data, turn the data into music, and stream it to the user using a python-based pipeline.

  6. Algorithms to Sample From Streams

    Jonathan Arfa

    Sampling is often necessary when you want to understand some aspects of your data but you don’t have the memory or time to analyze the full data set. This is a simple task when your data is on disk - but is much more complicated when your data is an incoming stream of unknown (but very long) length. In this talk I’ll present several methods to do this, some of which get you samples that are unbiased over the entire stream and some of which produce samples that are biased towards the present, and the tradeoffs these algorithms entail.

  7. An End to Boring Data with Visualizations

    Heather Shapiro


  8. An Introduction to Reinforcement Learning

    Jessica Forde

    Reinforcement learning is a subfield of machine learning focused on discovering ‘optimal policies’: robust strategies to achieve a desired objective under varying states of the world. In this talk, we will provide an overview of terminology in reinforcement learning and sample Python programs for basic algorithms to learn policies. We will also discuss the state of the art in reinforcement learning and the ways in which reinforcement learning can be applied to real world problems.

  9. An Intro To Building GUI Applications Using PyQt

    Monica Chelliah

    PyQt is one option for GUI programming in python, and is well suited for building applications on multiple platforms. This introduction will feature examples on how to programmatically setup the GUI or use QDesigner to build, as well as on how to use signals / slots and stylesheets.

  10. Anomaly Detection Algorithms and Techniques for Real-World Detection Systems

    Manojit Nandi

    Finding outliers in a dataset is a challenging problem in which traditional analytical methods often perform poorly. As a result, researchers have developed special algorithms for detecting anomalies. In this talk, I will take about three different families of anomaly detection algorithms: Density-based methods, data streaming methods, and time series methods. I will cover both the mathematical and statistical theory behind these algorithms and provide code implementations. Afterwards, I will discuss useful tips I have learned while implementing threat detection systems in practice.

  11. A tale of two cellphones: Python on Android and iOS

    Russell Keith-Magee

    Python is enjoying a surge in popularity due to it's features as a language. However, over the last 10 years, mobile platforms have increased in importance, and Python doesn't have a good story on these platforms.

    In this talk, Dr Russell Keith-Magee will give a technical dive into the work the BeeWare project has been doing to make Python as simple to use on Mobile as it is on other platforms.

  12. Beginner Pythonistas: Setting up Your Workspace (Life pre-Python)

    Reshama Shaikh

    Learn to work more efficiently. If you're new to Unix and Markdown, this session will help you save time on all the peripheral tasks so you can spend more time on Python.

  13. Best Practices for Writing Reusable Python

    Aaron Hall


  14. Building Command Line Tools in Python

    Erik Taubeneck

    Do you often catch yourself opening a Python script, changing a couple variables at the top, and then running python Turn that script into a Command Line Tool! Learn how to use docopt to easily build a Command Line Tool, how to use pip to make your tool directly callable, and how this strategy can improve your code.

  15. Build your own python pet!

    Tatiana Tylosky

    Build your own tamagotchi style "py-pet" with this beginner friendly workshop. You will learn basic python skillz by spawning and feeding your adorable creation in the terminal. (=^o.o^=)__ <:3 )~~~~

  16. Care and feeding of Pythons

    Ewa Jodlowska

    The Python Software Foundation was founded in an open source culture with a focus on volunteer work. As the Python ecosystem has grown, so have the volunteer efforts. However, some jobs are of a scale where they can’t reasonably be asked of a volunteer. The PSF also has an important role in financially supporting the Python community. In this keynote, we’ll see how the Python community is growing, what new challenges that brings, and how we can sustainably address them, so that the PSF can continue its mission to grow and nurture our community.

  17. Creating a BitTorrent Client using Asyncio

    Ahmed Abdalla

    The purpose of this talk is explain the BitTorrent protocol and relevant Asyncio API used to create a BitTorrent client that can actually download a ".torrent" file. The BitTorrent application will be built and presented as a set of steps (code snippets, i.e. coroutines) that implement various parts of the protocol and build up a final program that can download a file.

    Attendees need not know Asyncio and will learn the relevant functions needed to accomplish the task. No prior knowledge of the BitTorrent protocol is necessary either.

  18. Creating a culture of Computation - Scientific, Social and Humanitarian

    Evan Misshula

    The Python User Group at Queens College seeks to broadly distribute knowledge and enthusiasm about data and inquiry facillitated by compuation. The official languages of the computer science department remain Java and C++ which certainly have their place. However, we are trying to make Python the /lingua franca/ of student research. Please come to hear our triumphs and failures. The presentation will be given emacs org mode with an IPython shell and a Jupyter notebook.

  19. Cryptography in Python

    Amirali Sanatinia

    Today we use cryptography in almost everywhere. From surfing the web over https, to working remotely over ssh. However, many of us do not appreciate the subtleties of crypto primitives, and the lack of correct and updated resources leads to design and development of vulnerable applications. In this talk, we cover the building block of modern crypto, and how to develop secure applications in Python.

  20. Demystifying Python Method Resolution Order

    AMiT Kumar

    This talk is based on the method resolution order which defines the "class search path" used by Python to search for the right method to use in classes having multi-inheritance.

  21. Design for Non-Designers

    Tracy Osborn

    Designing, when you are a programmer, can be super intimidating. This talk will highlight the best ways to improve your design and UX skills so you can create an interfaces that are usable and at least semi-attractive without hiring a designer — guaranteed no designer-y jargon.

  22. Distributed Consensus with Raft

    John Feminella

    Getting people to agree to things is sometimes hard. But getting computers to agree is even harder -- this is the "consensus problem". When the computers are far apart, we need to achieve distributed consensus, which is especially pernicious. How do we do it, why is this important for many Python applications, and how can an algorithm called Raft help us out?

  23. Distributed Python with Dask

    Matthew Rocklin

    Dask is a Python library for parallel and distributed computing. It was built with the needs of the numeric Python ecosystem in mind, emphasizing common interfaces (NumPy, Pandas, Toolz) and full flexibly in supporting custom analytic workloads and complex algorithms. This talk describes the motivations behind creating Dask, gives interactive examples of its use, talks about how it is used in practice, and compares its capabilities against other parallel computing frameworks.

  24. Distributed Tracing in Python

    Yuri Shkuro

    We take a look at distributed tracing as an irreplaceable tool for troubleshooting performance issues in highly distributed systems built with microservices.

  25. Don't Overreact: Moving from Twisted to Asyncio

    Brian Muller

    This talk covers the basics of the Twisted and Asyncio libraries for asynchronous I/O and then delves into an experience porting the Kademlia distributed hash table (DHT) library from Twisted to Asyncio. The talk will start with a high level discussion of asynchronous I/O and describe some example cases where it might be useful. Concrete examples in both Twisted and Asyncio will be provided to demonstrate two different approaches to asynchronous libraries. Then, in the primary focus of the talk, the process, challenges, and lessons from converting a complex library from Twisted to Asyncio will be covered. This will include covering cases when a conversion should and shouldn't be undertaken, along with advice for anyone who wants to convert an existing library.

  26. Dplython: Intuitive Data Analysis, Funky Python

    Chris Riederer

    The goal of data analysis is to write code that manipulates data to give us answers. Ideally, we could translate our questions into code as quickly as we could think! Dplython is an open source Python library (inspired by R's "dplyr") that improves productivity by constraining analysis to a core set of the most common data manipulation operations. By mapping the way we think about typical tasks to functions, dplython moves data analysis closer to "speed-of-thought." In this talk, I'll describe the core ideas behind dplython, present a tutorial on using it for data analysis, and give a technical peek at Pythonic lazy evaluations created with operator overloading.

  27. Empathy and Teaching

    Katie Cunningham

    Even if you never stand behind a podium, every developer is eventually a teacher, whether to someone right next to them, or to someone who follows in their footsteps long after they're gone. What often keeps us from being good teachers? A lack of empathy. How do we fix that?

  28. Everything You Always Wanted to Know About NLP but Were Afraid to Ask

    Steven Butler and Max Schwartz

    Natural language processing can be a daunting field to dive into for a beginner. The need for a working knowledge of machine learning, statistics, linguistic theory, and data management techniques can seem like a high bar to meet for a person who just wants to write a Twitter bot, so our aim is to give a crash-course in the basic ideas and tools people might need to get started building something cool. We will cover core concepts in linguistics and explain how Python can be used to analyze, interpret, and even mimic natural language.

  29. Exploring Cryptography

    John Downs

    A hacker's introduction to cryptography

  30. Fighting the Flu with Machine Learning

    Rohan Koodli

    Everyone despises falling sick. In this talk, I will present how I used Python and machine learning to predict future sequences of the flu. My Random Forests model learns patterns in how the flu mutates from previous flu seasons, and creates decision trees based on those inferences. I will also cover how using a library (scikit-learn) was much easier and accurate than creating a Random Forests Classifier.

  31. Hacking/typing/writing at 200 words per minute

    Ted Morin

    Plover is free software written in Python that enables you to type on a computer at over 200 words per minute. Plover brings machine stenography, an art older than computers, into everyone's hands. Plover's current lead developer, Ted Morin, will talk about what stenography is, why Plover was created, how Plover works, and explain the role stenography might have in the modern world, as it moves beyond transcription and into the hands of hackers.

  32. Hassle Free ETL with PySpark

    Rob Howley

    While the models of data science get all the press, the real work is in the maze of data preprocessing and pipelines. The goal of this talk is to get a glimpse into how you can use Python and the distributed power of Spark to simplify your (data) life, ditch the ETL boilerplate and get to the insights. We’ll intro PySpark and considerations in ETL jobs with respect to code structure and performance.

  33. Higher-level Natural Language Processing with textacy

    Burton DeWilde

    Although the Python community is already served by many open-source packages for NLP, few if any offer state-of-the-art performance; a holistic, higher-level feature set; and a user-friendly API. textacy was built to fill the gap. In this talk, I will demonstrate some of textacy's functionality by working through an end-to-end example of topic modeling.

  34. Introduction to Microservices with Nameko

    Thomas Peterson

    An introductory overview of the microservice pattern for web applications, made concrete with working examples using Nameko.

  35. Introduction to Neural Networks with Tensorflow

    Mike Craig

    Neural networks are a powerful machine learning model that are used in many applications, from computer vision and speech recognition to time series modeling and natural language processing. TensorFlow is an open source machine learning library developed by Google that can be used to easily create these types of models. I will give an overview of neural networks, and show how to implement and use these models using TensorFlow's Python API.

  36. Introduction to Web Scraping using Scrapy

    Kaira Villanueva

    Have you wanted to grab data from websites and automatically categorize it into a formatted list? Or maybe you want to opt out of registering for API keys and want data straight out of a web page? This is an introduction to web scraping and we will cover building bots through Scrapy to crawl a few sample web pages and have it extract information that we want. Prior knowledge not required; we’ll break down the steps in creating your own bot, and before you know it you'll be scraping the web.

  37. It's Raining, It's Pouring? A web and SMS application in Flask and Twilio to call Farmers.

    Katya Vasilaky

    This talk is about the use of python in building a web application with which we call farmers in less developed countries to capture rainfall occurrence. These data are used to complement lower resolution satellite data, and to potentially update climate models. The application is built in Flask and uses Twilio's API to deliver voicemails to farmers in less developed countries. Twilio's API records farmers' touch tone responses regarding the occurrence of rainfall.

  38. Lightning Talks

    Ministry of Silly Talks

    Go to to sign up.

    Note: By agreeing to give a lightning talk, you agree to give permission to Big Apple Py to record, edit, and release audio and/or video of your presentation under the terms of PyGotham's recording release.

  39. Lightning Talks

    Ministry of Silly Talks

    Go to to sign up.


  40. MacroPythonic

    Jerry Meeker

    Using macros, skeleton files, and snippets to make writing a simple program even simpler.

  41. Make data cleansing fun again with Pandas

    Joe Hooper

    This talk will provide a fast-paced introduction to cleansing text data with Python. We'll cover specific Pandas tools as well as strategies for managing the cleansing processes. Topics include: slicing/splitting/joining, transforming text, working with missing values, supplementing with additional sources, and dealing with duplicates.

  42. Making Games

    Piper Thunstrom

    From your first 'while True:' to your first framework.

  43. Making Sense of 100 Years of NYC Opera with Python

    Suby Raman

    In late 2014, I discovered that the Metropolitan Opera of New York was maintaining a database of their performances, stretching back over a hundred years. As a classical composer and Python fanatic, I immediately sensed that there were potentially amazing stories hidden in this data. Using asyncio, SQLAlchemy, and BeautifulSoup, I got to work making sense of the database, and eventually posted some surprising findings. The article caught fire in the classical music world, receiving mentions in mainstream outlets like the Washington Post and New Yorker. In this talk I will discuss my technical approach to handling the data. I will also discuss the social importance of Python as a basic research tool, and I’ll make the case for teaching Pythonesque programming to artists like myself.

  44. Migrating to Python, slowly

    Roger López

    You probably already know the reasons why you should migrate your project to use Python 3. But if you're anything like me, that process seems perilous and disruptive, and you can't see a path to get there that doesn't involve pain and suffering. In this talk, I will present a strategy to help you migrate your project to Python 3, while minimizing risk and disruption.

  45. Modeling State in Text Adventure Games

    Katie Silverio

    Although text adventure games, like Colossal Cave Adventure or Zork, don't have graphics, they still have in-game objects to model. I've been working on a framework for writing text adventure games in Python, which means setting on a system for modeling stateful things. In this talk, I'll discuss choosing a design pattern, modifying the pattern to work better in Python, and then use it to make a mini text adventure game!

  46. Modular SQL Using SQLAlchemy

    Bo Du

    SQLAlchemy is a powerful library which provides a number of powerful abstractions and patterns for SQL. One of these patterns is the ability to build "composable" queries.

    This talk will cover:

    • When to use SQLAlchemy to modularize your SQL into composable parts
    • How to reason about the deconstruction of a query
    • Step by step example of how to write modular SQL using SQLAlchemy
  47. Opening the Magic Box: Creating transitional Python libraries and IDE tools for young learners

    Meg Ray

    The next generation of developers will have written their first program in Kindergarten. How they will learn programming is in the process of being defined, but it will look much different than the way that the current generation of developers learned. Meg and Juan are taking on the challenge of creating a transitional learning environment for middle school students. In our experience, most students at this age are ready for the challenge of writing a program that combines different basic CS concepts (loops, conditionals, UI, etc), but many become overwhelmed or confused by professional tools. We work on custom versions of professional libraries and IDE tools to give middle school students a transition between basics block-programming and AP or adult curriculum using professional tools.

  48. Piecing it Together: A beginner's guide to application configuration


    What makes a Python app "run"? If you spend most of your time working on a well-established application, you might not often think about the configuration and setup that supports it. This talk will explain what to consider when creating a development environment and how your app's structure interacts with said environment.

  49. Playing with Python Bytecode

    Scott Sanderson and Joe Jevnik

    Ever wondered what Python is actually doing when it executes your code? Want to learn to hand-craft artisanal Python bytecode? In this talk, we explain CPython's internal code representation, and we demonstrate techniques for modifying code objects for fun and profit.

  50. Postgres Present and Future

    Craig Kerstiens

    Postgres 9.5 was just released a few months ago and has a number of of new improvements we'll walk through including new JSONB functions, some analytical tooling, and of course upsert. Then we'll dive into what's coming in Postgres 9.6, the next Postgres release. Finally, we'll round it out with some look at the ecosystem of extensions.

  51. Probabilistic Graphical Models in Python

    Aileen Nielsen

    This talk will give a high level overview of the theories of graphical models and a practical introduction to and illustration of several available options for implementing graphical models in Python.

  52. Pulling Cloud data into a database using Requests and Pandas

    Matthew Freihaut

    Using the popular Request and Pandas modules see how one data geek brings the clouds back into the house

  53. Push Data, Pull Data, Present Data

    Adrian Cruz

    In this day and age, data plays such an important role in so much of what we want to do. Whether it be an analysis of visitor traffic, monitoring data for fraud transactions, or making a business decision of whether a certain color would be accepted with your users, the data is your best friend in helping you find your way.

  54. PyPy & Us Could Be PyPy & You

    Julian Berman

    You've probably heard of PyPy. It's an interpreter that can make your Python fast. Really fast. We'll talk about some fundamentals & lessons learned from running PyPy in large scale production deployments for the last ~3 years.

  55. python-dateutil: A delightful romp in the never-confusing world of dates and times

    Paul Ganssle

    The dateutil library provides a number of extensions to Python's standard datetime handling libraries. This talk will provide an overview of how to use (and not use!) dateutil to improve your datetime-handling experience, and also cover some of the recent changes to the library.

  56. Python for Home-Ec

    Adam Forsyth

  57. Python for segregated signal averaging of cardiac baroreflex response in humans

    Trevor Witter

    The cardiovascular system is regulated through complex interactions between the central nervous system, the heart and systemic arteries. Quantifying the underlying interactions can provide detailed diagnostic information on an individual’s health. Python and libraries such as pandas, scipi, numpi and matplotlib provide the tools needed to process and quantify the relationship between recordings of multiple simultaneous cardiovascular signals.

  58. Python Gone Bananas: Monkey Patching Isn't Monkey Business

    James Powell

    Python is an extremely dynamic language with a very "rich runtime." Unlike in a compiled language like C or go, symbols (functions and data objects) can be bound and rebound at runtime; swapped out without the need for complicated syntax and without the risk of unsafe complications. In the Python community, this is called "monkey-patching." But it's not as bananas as it sounds! In fact, it can be a very useful mechanism for extending functionality or for making robust, surgical fixes to a code-base!

  59. Python Performance Profiling: The Guts And The Glory

    A. Jesse Jiryu Davis

    Your Python program is too slow, and you need to optimize it. Where do you start? Optimization is a scientific investigation, just like debugging is: you generate hypotheses about how to make your program faster, then use benchmarks as the experiments that test your hypotheses. With the right tools, you can optimize your code where it counts. With the Python profiler “Yappi” to understand its features and limitations we’ll learn how to find the maximum performance wins with minimum effort.

  60. RESTful Service Design: Patterns and Anti-Patterns

    Jeff Revesz

    Drawing on more than a decade of combined experience in RESTful service design, your speakers will discuss many of the key architectural questions that every API developer needs to answer. The goal of this talk is to move quickly beyond the basics, and explore larger questions of how to build a sane and scalable service that your users will love. We will draw on our own experience of implementing bad (and later, less-bad) answers to these questions in multiple real-world situations, with specific examples demonstrated using Django REST Framework.

  61. Scalable code design with slimmer django model and more

    Dawa Sherpa

    When you first start your Django project, adding functionality to your model comes really easy, because IT IS really easy to do so. However, as your application size grow, the code you end up might not be easy to work on anymore. As engineers, we should pay attention to scalability not only in terms of number of requests your server can handle, but also how your application can grow with more features, and more engineers working on it.

    Code scalability is the ability to grow, modify, adopt your code without a major refactor, lets say every 6 months with many people working on it at the same time. While I know that it is really hard to predict the future needs, and designing for future proof architecture blindly is a waste of time and effort, I do see the need for some forethought when you put together a solution. A good balance between current need and future need can be achieved without sacrificing a lot of productive time. Common smells that indicate you do not have scalable code design are :

    • Engineer cannot gain insight into what the code is doing by quickly reading the code ( bug introduction because of mis-understanding )
    • Engineer cannot confidently make change to small area of the code (productivity delay, bug introduction )
    • Engineer cannot easily evolve the data structure to support new use cases
    • Engineer cannot easily to test, modify isolated business logic

    All the the above are usually seen when you have a big Django model file with each model having multiple functionality. I would like to review some basic principles to help us build a scalable software system.

  62. Sensely: Office Automation with the Internet of Things and Python

    Luigi Patruno

    Many of us have heard the hype surrounding the Internet of Things (IoT). Leveraging a network of wireless sensors to facilitate decision making with real-time data does sound awesome, but how do I get started? In this talk we’ll examine the wireless sensor network my team created for office automation in a 24 hour company sponsored hackathon. Along the way you’ll learn how to connect real sensors to the NodeMCU IoT platform, transmit information over a network using the MQTT messaging protocol, aggregate data with a Dockerized Python microservice, and display it in real-time with various Python packages. By the end of the talk you’ll be ready to set up a sensor network of your own for some home or office automation!

  63. Simple Serverless ETLs in AWS

    Ryan Tuck

    A brief introduction to leveraging AWS services to design simple and powerful python-based ETLs without ever SSHing onto a server. Learn about running code in response to events with Lambda, and configuring a cron, notifications, metrics collection, and database both in-browser and with boto3, AWS's python SDK.

  64. Snakes in a browser

    Russell Keith-Magee

    We all know that Python and Django can be used to write server-side software, but what about the client side? What about the browser? Can you use Python to power client-side interactions? Can you deploy Python logic (such as validation logic) on both the client and the server?

  65. Spark Dataframes for the Pandas Pro

    Alfred Lee

    Pandas has been a mainstay of data analysis in Python for years now. With Spark gaining wider and wider adoption, more analysts are learning this new distributed processing engine. I will explain some of the important, essential differences, the understanding of which will ease the transition into this new, promising tool.

  66. Summarizing documents

    Mike Williams

    Extractive summarization — finding the salient points in a document or corpus — is one of the most fundamental tasks in natural language processing. I’ll show you three ways to do it. One dates back to an IBM Journal article from 1958. One uses topic modeling, a technology from the 2000s. And one uses neural network-derived language embeddings and long short term memory networks — techniques that are only a couple of years old. I’ll explain the algorithms, show code and demos for all three, and I’ll discuss the engineering trade-offs.

  67. Teaching and Doing Digital Humanities with Jupyter Notebooks

    Matt Lavin

    This talk discusses our experiences using Jupyter Notebooks for digital humanities tutorials, workshops, and scholarship.

  68. The Colors, Duke! Steganography using the Python Imaging Library (PIL)

    Prakash Venkat

    Steganography is the practice, though some might say artform, of concealing messages within other types of media. The aim of my talk is to show how to write plaintext messages into images and then retrieve them. To do this I'll be using the Python Imaging Library, or PIL.

  69. The Sound of Data: Using Python to transform data streams into music.

    Gabriel Levine

    We visualize complex data in order to understand it, find patterns in it, and gain perspective on it. But what happens when we transform data streams into sounds and music, and how can we do this with Python? Sound crazy? Probably, but as a musician turned Developer, I find the intersection of music and code to be fascinating. And I think others will too. This talk will go over the technologies and python libraries used to translate data streams (weather, financial data, anything) into MIDI that then is fed into synthesizers and virtual instruments.

  70. Understanding GPU Programming

    Daniel Kronovet

    Introduction to GPUs and how they are exploited by libraries like Theano.

  71. Using Python to Study Black Holes

    Daniela Huppenkothen

    Black holes are among the most fascinating objects in our universe, with hundreds of hours of astronomical observations available in public archives around the world. In this talk I will give a brief overview of why and how we study black holes. I will show how python helps us make sense of our data, leverage modern data analysis methods efficiently and help us understand how black holes form and the role they play in our universe.

  72. Vector space modeling on music data

    Tim Schmeier

    Vector space modeling is a popular machine learning approach with a wide variety of applications, including product recommendations, information retrieval, and image classification. In this talk we will go into detail of some of our innovative approaches to building these vector spaces on music data at iHeartRadio. We will also give several real-world examples of how we use these models, highlighting their power, flexibility, and simplicity.

  73. Visualization and Analysis for Multimodal Presentation (VAMP)

    Ben Leong

    VAMP is a Python-based toolkit consisting of a set of scripts that operate on set of synchronized video, audio and skeletal data, and transform them into feature contours for visualization and analysis. While the core function emphasized in this talk is the application of a recursive parser to extract expressive body language features using skeletal data from a Kinect sensor, VAMP is designed to be a general toolkit for the development and standardization of algorithms for extracting multimodal features and creating automated scoring models for multimodal educational assessments, e.g. public speaking in a classroom.

  74. wat‽ Mind-bending Edge Cases in Python

    Dustin Ingram



  75. Webscraping by Example: An introduction to BeautifulSoup

    Stevie Slotterback

    This is a basic tutorial on the various features of the popular html parser BeautifulSoup. In this tutorial, we will cover the basic functions and data structures that make up the BeautifulSoup package. We will utilize this knowledge as we automate some data extraction tasks on the Buildings Information System (BIS) published by the New York City Department of Buildings.

  76. We're All Database Engineers (WADE)

    Adrian Kramer

    WADE is a distributed database framework providing strong consistency and high throughput using chain replication, in lieu of the traditional primary/backup model. Quite unlike traditional databases, WADE is a framework. Programmers implement the storage interface themselves and write custom query or update functions in Python that are executed by the database avoiding the dreaded read-write update cycle that degrades performance. Since the storage layer is implemented by the programmer it can be hand customized to the use case at hand using tools such as LevelDB, RocksDB, or whatever the programmer desires. However, WADE takes control at the networking layer handling replication, message forwarding amongst nodes, and fault tolerance in the event of failure so long as a few simple functions are implemented by the end user.

  77. When the database can't keep up

    Adam DePrince

    An overview of Peloton's custom leaderboard database.

  78. Why and how to GraphQL


    Last year, GraphQL was introduced to the developer's world as the vaccine to our REST APIs addiction but looks like not many of us are looking for a cure. Why would we? What are the main differences in the development and how to get started with GraphQL on Python/Django are questions that are going to be answered during this talk.

  79. Wrapping Go in Python

    Marcus Willock


  80. Write Less Code with Algebra!

    Gene Callahan

    This talk will describe an ongoing effort to treat agent interactions as abstract algebraic structures. The primary motivations for this attempt it are to increase code reuse, and ultimately to enable the creation of agent-based models through the filling in of forms, choosing among various module operations and chaining them together to produce customized agent behavior.

  81. Writing Neural Networks from Scratch

    Eric Schles

    In this talk we'll go through neural networks, explaining them from scratch. The only background required is an understanding of Python, basic linear algebra and calculus.

  82. Yosai in the Wild

    Darin Gordon

    See how Yosai secures Python applications! This talk demonstrates Yosai "in the wild", highlighting some of its best features.

  83. Young Coders (or, 'How to Teach Python to Kids')

    Barbara Shaurette
