pre-release: Big Apple Py 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: Big Apple Py at Room CR6 Sat July 16, 10p
Big Apple Py
=========================
When: 10 AM Saturday July 16, 2016
Where: Room CR6
https://2016.pygotham.org/api/v1/events/3/schedule/
file://schedules/pyg16.json
https://2016.pygotham.org/talks/schedule/
Topics
------
1. 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.
recording release: yes license: CC BY-SA
2. 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.
recording release: yes license: CC BY-SA
3. 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.
recording release: yes license: CC BY-SA
4. 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.
recording release: yes license: CC BY-SA
5. “THAT’S A REALLY GREAT IDEA”: SYNTHESIZING SARCASTIC AFFECT
Rachel Rakov
Sarcasm is inherently ambiguous. Frequently, sarcastic expressions can be disambiguated either by context (“I broke my leg and my dog died. Happy Birthday to me.”) or by prosody (“Youre soooooo smart.”). Building on previous work modeling intonation for the task of sarcasm detection, we now investigate whether prosodic cues are reliable enough to be used to synthesize sarcastic speech. In this work, we develop a transparent heuristic to identify a particular type of sentence that can be expressed as sarcastic affect. We then use Twitter to identify individual sentences that can be made to sound sarcastic under our heuristic. Finally, we use prosodic features motivated by prior sarcasm research to synthesize sarcastic speech. We find that prosodic manipulation of synthesized speech leads listeners to perceive synthesized speech as sarcastic. This method presents a practical path forward for sarcasm synthesis, one that is possible without making use of large, annotated corpora.
recording release: yes license: CC BY-SA
6. Introduction to Microservices with Nameko
Thomas Peterson
An introductory overview of the microservice pattern for web applications, made concrete with working examples using Nameko.
recording release: yes license: CC BY-SA
7. 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.
recording release: yes license: CC BY-SA
8. Why and how to GraphQL
Victor
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.
recording release: yes license: CC BY-SA
9. Making Games
Piper Thunstrom
From your first 'while True:' to your first framework.
recording release: yes license: CC BY-SA
10. 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.
recording release: yes license: CC BY-SA
11. 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.
recording release: yes license: CC BY-SA
12. 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.
recording release: yes license: CC BY-SA
13. 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.
recording release: yes license: CC BY-SA
14. 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.
recording release: yes license: CC BY-SA
15. 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.
recording release: yes license: CC BY-SA
16. 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.
recording release: yes license: CC BY-SA
17. Lightning Talks
Ministry of Silly Talks
Go to http://bit.ly/pygotham2016lt 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 `_.
recording release: yes license: CC BY-SA
18. 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.
recording release: yes license: CC BY-SA
19. 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.
recording release: yes license: CC BY-SA
20. Piecing it Together: A beginner's guide to application configuration
Mary
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.
recording release: yes license: CC BY-SA
21. 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.
recording release: yes license: CC BY-SA
22. 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.
recording release: yes license: CC BY-SA
23. 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.
recording release: yes license: CC BY-SA
24. 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.
recording release: yes license: CC BY-SA
25. Using PyStruct to Classify MOOC Discussion Forum Posts
Kyle Shaffer
This talk will detail how I approached the task of classifying discussion forum posts in a massive open online course (MOOC). In particular, the talk will focus on using the PyStruct library as a tool to implement a conditional random field for this problem. Many linear classifiers have been shown to be effective at text classification, however discussion forums present a distinct sequential structure that can be leveraged. This makes this problem an excellent candidate for the application of structured prediction models. After presenting the study background, a brief overview of structured prediction will be presented focusing on the PyStruct library. In addition to presenting how PyStruct was used for this task, I will also present an overview with code examples for constructing features that were fed to the models and will detail any Python tools (such as scikit-learn and NLTK) used for these tasks. The results of the study show that framing this as a structured prediction task leads to substantial improvements in precision and F1 scores compared with a linear classifier.
recording release: yes license: CC BY-SA
26. 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.
recording release: yes license: CC BY-SA
27. Understanding GPU Programming
Daniel Kronovet
Introduction to GPUs and how they are exploited by libraries like Theano.
recording release: yes license: CC BY-SA
28. 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.
recording release: yes license: CC BY-SA
29. Best Practices for Writing Reusable Python
Aaron Hall
We all want to write reusable maintainable code that follows best practices, but how? The "what" is easy, but the nuts and bolts are elusive. This talk discusses various ways of accomplishing this with multiple tested pathways. Who should come to this talk? Data Scientists, Web-Devs, Dev-Ops, if you've written code you want others to use, if you want to write code that others will use, this is for you. Who shouldn't come to this talk? If you already publish your own packages on PyPI and you get no joy out of critiquing people who give Best Practices talks, you might benefit more from one of the other talks.
recording release: yes license: CC BY-SA
30. 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.
recording release: yes license: CC BY-SA
31. 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.
recording release: yes license: CC BY-SA
32. 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.
recording release: yes license: CC BY-SA
33. 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
recording release: yes license: CC BY-SA
34. 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 myscript.py`? 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.
recording release: yes license: CC BY-SA
35. 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.
recording release: yes license: CC BY-SA
36. Young Coders (or, 'How to Teach Python to Kids')
Barbara Shaurette
Since PyCon 2013, interest in the Young Coders class has intensified. Several Python conferences have run their own, and classes outside of conferences - from one-time workshops to after school clubs - have sprung up as well. With more people than ever interested in teaching Python to kids, I'm here to talk about what you'll need to get started, and the immense amount of satisfaction you'll get out of it.
recording release: yes license: CC BY-SA
37. 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?
recording release: yes license: CC BY-SA
38. How to build an Event Driven Financial system in sixty days with Python
Federico Kamelhar
F.A.S.T(Financial Accounting System Technology) is an open source financial system that has the intention to capture all types of financial transactions in a fast paced startup company like Warby Parker.
recording release: yes license: CC BY-SA
39. 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.
recording release: yes license: CC BY-SA
40. 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.
recording release: yes license: CC BY-SA
41. 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.
recording release: yes license: CC BY-SA
42. 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.
recording release: yes license: CC BY-SA
43. InvestiGator
Eric Schles
How I use Python to fight slavery.
recording release: yes license: CC BY-SA
44. 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.
recording release: yes license: CC BY-SA
45. Exploring Cryptography
John Downs
A hacker's introduction to cryptography
recording release: yes license: CC BY-SA
46. 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.
recording release: yes license: CC BY-SA
47. 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.
recording release: yes license: CC BY-SA
48. 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.
recording release: yes license: CC BY-SA
49. 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.
recording release: yes license: CC BY-SA
50. 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.
recording release: yes license: CC BY-SA
51. 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!
recording release: yes license: CC BY-SA
52. 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.
recording release: yes license: CC BY-SA
53. 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.
recording release: yes license: CC BY-SA
54. wat‽ Mind-bending Edge Cases in Python
Dustin Ingram
In this talk, we'll explore ten of the most paradoxical and mind-numbing "Python wats" -- unique edge cases in the language. We'll even go so far as to re-implement the stdlib functions which cause them to understand just why they actually make sense.
This is a fun and entertaining talk. In the end, attendees will gain insight into functions they use every day, including `zip`, `max`, `min`, `any`, `all`, and more. Even the simplest of tools, when combined, can produce really weird results!
recording release: yes license: CC BY-SA
55. 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.
recording release: yes license: CC BY-SA
56. 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
recording release: yes license: CC BY-SA
57. 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!
recording release: yes license: CC BY-SA
58. 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.
recording release: yes license: CC BY-SA
59. An End to Boring Data with Visualizations
Heather Shapiro
Put the days of trying to decipher meaning from boring spreadsheets behind you. Visualize data to give greater and immediate meaning to all those numbers with Python. Explore the variety of options available for data visualization in Python using different libraries and understand which ones excel for what type of task. Create maps, statistical graphs and more detailed or interactive visualizations that can also be used on the web, ideal to take that blog post to a whole new level.
recording release: yes license: CC BY-SA
60. 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?
recording release: yes license: CC BY-SA
61. 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.
recording release: yes license: CC BY-SA
62. 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.
recording release: yes license: CC BY-SA
63. 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.
recording release: yes license: CC BY-SA
64. 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.
recording release: yes license: CC BY-SA
65. 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.
recording release: yes license: CC BY-SA
66. 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.
recording release: yes license: CC BY-SA
67. 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.
recording release: yes license: CC BY-SA
68. 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.
recording release: yes license: CC BY-SA
69. 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.
recording release: yes license: CC BY-SA
70. 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!
recording release: yes license: CC BY-SA
71. 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.
recording release: yes license: CC BY-SA
72. 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.
recording release: yes license: CC BY-SA
73. MacroPythonic
Jerry Meeker
Using macros, skeleton files, and snippets to make writing a simple program even simpler.
recording release: yes license: CC BY-SA
74. 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.
recording release: yes license: CC BY-SA
75. 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 )~~~~
recording release: yes license: CC BY-SA
76. 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.
recording release: yes license: CC BY-SA
77. 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.
recording release: yes license: CC BY-SA
78. Wrapping Go in Python
Marcus Willock
I love python, and I am interested in Go. Recently, Go has gain the ability to create shared object files, which allows you to dynamically link Go code with other languages. This talk goes over the how, why, pros and cons of wrapping Go's shared object files in python.
recording release: yes license: CC BY-SA
79. 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.
recording release: yes license: CC BY-SA
80. 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.
recording release: no
81. Python for Home-Ec
Adam Forsyth
Have you ever tried to make something with scrap wood, and wondered how to use it optimally? Do have a bunch of pickles and jams you made, and you want to eat them in an order that maximizes variety? These are real problems a co-worker of mine had, and we used Python to solve them. I'll show the data we started with, the solutions we came up with, and a bit of the computer science behind them.
recording release: yes license: CC BY-SA
82. When the database can't keep up
Adam DePrince
An overview of Peloton's custom leaderboard database.
recording release: yes license: CC BY-SA
83. 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.
recording release: yes license: CC BY-SA
84. 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.
recording release: yes license: CC BY-SA
85. 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.
recording release: yes license: CC BY-SA
86. 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?
recording release: yes license: CC BY-SA
Location
--------
Room CR6
About the group
---------------
"Paul Logston" , Jon Banafato , PyGotham Organizers