Home
Videos uploaded by user “PyCon 2018”
Kenneth Reitz - Pipenv: The Future of Python Dependency Management - PyCon 2018
 
35:45
Speaker: Kenneth Reitz This talk is about the history of Python packaging, the tools that have been historically available for application deployment, the problems/constraints presented by them, and presents a holistic solution to many of these problems: Pipenv. A live demo of the tool will be presented, as well as a Q&A session. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 22046 PyCon 2018
Ned Batchelder - Big-O: How Code Slows as Data Grows - PyCon 2018
 
28:51
Speaker: Ned Batchelder Big-O is a computer science technique for analyzing how code performs as data gets larger. It's a very handy tool for the working programmer, but it's often shrouded in off-putting mathematics. In this talk, I'll teach you what you need to know about Big-O, and how to use it to keep your programs running well. Big-O helps you choose the data structures and algorithms that will let your code work efficiently even on large data sets. You can understand Big-O even if you aren't a theoretical computer science math nerd. Big-O isn't as mystical as it appears. It's wrapped in mathematical trappings, but doesn't have to be more than a common-sense assessment of how your code will behave. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 7667 PyCon 2018
Larry Hastings - Solve Your Problem With Sloppy Python - PyCon 2018
 
30:24
Speaker: Larry Hastings Stop writing crappy shell scripts—write crappy Python scripts instead! Other talks will show you how to write clean, performant, robust Python. But that's not always necessary. When writing personal automation or solving one-shot problems, it can be safe (and fun!) to quickly hack something together. This talk will show examples of problems suitable for this approach, scenarios where it's reasonable to cut corners, novel techniques that can help break a problem down, and shortcuts that can speed development. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 14187 PyCon 2018
Nathaniel J. Smith - Trio: Async concurrency for mere mortals - PyCon 2018
 
32:00
Speaker: Nathaniel J. Smith Concurrent programs are super useful: think of web apps juggling lots of simultaneous downloads and websocket connections, chat bots tracking multiple concurrent conversations, or web spiders fetching pages in parallel. But *writing* concurrent programs is complicated, intimidating to newcomers, and often challenging even for experts. Does it have to be? Python is famous for being simple and straightforward; can Python make concurrent programming simple and straightforward too? I think so. By carefully analyzing usability pitfalls in other libraries, and taking advantage of new Python 3 features, I've come up with a new set of primitives that make it dramatically easier to write correct concurrent programs, and implemented them in a new library called [Trio](https://trio.readthedocs.io). In this talk, I'll describe these primitives, and demonstrate how to use them to implement a basic algorithm for speeding up TCP connections. Compared to the best previous Python implementation, our version turns out to be easier to understand, more correct, and dramatically shorter. This talk assumes basic familiarity with Python, but does *not* require any prior experience with concurrency, async/await, or networking. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 6359 PyCon 2018
Carl Meyer - Type-checked Python in the real world - PyCon 2018
 
32:10
Speaker: Carl Meyer You've heard about Python type annotations, but wondered if they're useful in the real world? Worried you've got too much code and can't afford to annotate it? Type-checked Python is here, it's for real, and it can help you catch bugs and make your code easier to understand. Come learn from our experience gradually typing a million-LOC production Python application! Type checking solves real world problems in production Python systems. We'll cover the benefits, how type checking in Python works, how to introduce it gradually and sustainably in a production Python application, and how to measure success and avoid common pitfalls. We'll even demonstrate how modern Python typechecking goes hand-in-hand with duck-typing! Join us for a deep dive into type-checked Python in the real world. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 9866 PyCon 2018
Raymond Hettinger - Dataclasses:  The code generator to end all code generators - PyCon 2018
 
45:08
Speaker: Raymond Hettinger The PEP 557 dataclasses module is available in starting in Python 3.7. It will become an essential part of every Python programmer's toolkit. This talk shows what problem the module solves, explains its key design decisions, and provides practical examples of how to put it to work. Dataclasses are shown to be the next step in a progression of data aggregation tools: tuple, dict, simple class, bunch recipe, named tuples, records, attrs, and then dataclasses. Each builds upon the one that came before, adding expressiveness at the expense of complexity. Dataclasses are unique in that they let you selectively turn-on or turn-off its various capabilities and it lets the user choose the underlying data store (either instance dictionary, instance slots, or an inherited base class). Dataclasses and typing.NamedTuple both use variable annotations which were new in Python 3.6. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 25020 PyCon 2018
James Bennett - A Bit about Bytes: Understanding Python Bytecode - PyCon 2018
 
29:45
Speaker: James Bennett At some point every Python programmer sees Python bytecode files -- they're those '.pyc' files Python likes to leave behind after it runs. But have you ever wondered what's really going on in those files? Well, wonder no more! In this talk you'll learn what Python bytecode is and how it's used to execute your code, as well as how to decipher and read it, and how to reason about bytecode to understand the performance of your Python code. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 4482 PyCon 2018
Dan Callahan - Keynote - PyCon 2018
 
30:10
Speaker: Dan Callahan
Views: 4623 PyCon 2018
Hillel Wayne - Beyond Unit Tests: Taking Your Testing to the Next Level - PyCon 2018
 
29:21
Speaker: Hillel Wayne You've used pytest and you've used mypy, but bugs are still slipping through your code. What's next? In this talk, we cover two simple but powerful tools for keeping your code problem-free. Property-based testing, provided by the [Hypothesis](https://hypothesis.readthedocs.io/en/latest/) library, lets you run hundreds of tests from a single template. Contracts, via [dpcontracts](https://github.com/deadpixi/contracts), make your program test itself. You'll learn how and why to use these tools and how to combine them with the rest of your testing suite. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 6991 PyCon 2018
Carol Willing - Practical Sphinx - PyCon 2018
 
27:21
Speaker: Carol Willing Each member of your project team uses something different to document their work -- RestructuredText, Markdown, and Jupyter Notebooks. How do you combine all of these into useful documentation for your project's users. Sphinx and friends to the rescue! Learn how to integrate documentation into your everyday development workflow, apply best practices, and use modern development tools and services, like Travis CI and ReadTheDocs, to create engaging and up-to-date documentation which users and contributors will love. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 4602 PyCon 2018
David Beazley - Reinventing the Parser Generator  - PyCon 2018
 
45:01
Speaker: David Beazley Writing lexers and parsers is a complex problem that often involves the use of special tools and domain specific languages (e.g., the lex/yacc tools on Unix). In 2001, I wrote Python versions of these tools which can be found in the PLY project. PLY predates a huge number of modern Python features including the iteration protocol, generators, decorators, metaclasses, and more. As such, it relied on a variety of clever hacks to layer a domain specific parser specification language on top of Python itself. In this talk, I discuss a modernization of the PLY project that abandons its past and freely abuses modern Python features including advanced metaclasses, guaranteed dictionary ordering, class decorators, type hints, and more. The result of this work can be found in the SLY project. However, this talk isn't so much about SLY as it is focused on how far you can push Python metaprogramming features to create domain-specific languages. Prepare to be horrified--and to write code that will break your IDE. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 9484 PyCon 2018
Russell Keith-Magee - Building a cross-platform native app with BeeWare - PyCon 2018
 
30:50
Speaker: Russell Keith-Magee Have you ever wanted to write a GUI application you can run on your laptop? What about an app that you can run on your phone? Historically, these have been difficult to achieve with Python, and impossible to achieve without learning a different API for each platform. But no more. BeeWare is a collection of tools and libraries that allows you to build cross-platform native GUI applications in pure Python, targeting desktop, mobile and web platforms. In this talk, you'll be introduced to the BeeWare suite of tools and libraries, and see how you can use them to develop, from scratch, a GUI ChatBot application that can be deployed as a standalone desktop application, a mobile phone application, and a single page webapp - without making any changes to the application's codebase. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 7356 PyCon 2018
Jake VanderPlas - Performance Python: Seven Strategies for Optimizing Your Numerical Code
 
23:10
Speaker: Jake VanderPlas Python provides a powerful platform for working with data, but often the most straightforward data analysis can be painfully slow. When used effectively, though, Python can be as fast as even compiled languages like C. This talk presents an overview of how to effectively approach optimization of numerical code in Python, touching on tools like numpy, pandas, scipy, cython, numba, and more. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 6678 PyCon 2018
Emily Morehouse-Valcarcel - The AST and Me - PyCon 2018
 
23:40
Speaker: Emily Morehouse-Valcarcel Get under the hood and learn about Python's beloved Abstract Syntax Tree. Ever wonder how Python code is run? Overheard people arguing about whether Python is interpreted or compiled? In this talk, we will delve into the lifecycle of a piece of Python code in order to understand the role that Python's Abstract Syntax Tree plays in shaping the runtime of your code. Utilizing your newfound knowledge of Python's AST, you'll get a taste of how you probably already rely on ASTs and how they can be used to build awesome tools. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1704 PyCon 2018
John Reese - Thinking Outside the GIL with AsyncIO and Multiprocessing - PyCon 2018
 
30:50
Speaker: John Reese Have you ever written a small, elegant application that couldn't keep up with the growth of your data or user demand? Did your beautiful design end up buried in threads and locks? Did Python's very special Global Interpreter Lock make all of this an exercise in futility? This talk is for you! With the combined powers of AsyncIO and multiprocessing, we'll redesign an old multithreaded application limited by the GIL into a modern solution that scales with the demand using only the standard library. No prior AsyncIO or multiprocessing experience required. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 5383 PyCon 2018
Amjith Ramanujam - How Netflix does failovers in 7 minutes flat - PyCon 2018
 
31:46
Speaker: Amjith Ramanujam During peak hours, Netflix video streams make up more than one third of internet traffic. Netflix must stream uninterrupted in the face of widespread network issues, bad code deploys, AWS service outages, and much more. Failovers make this possible. Failover is the process of transferring all of our traffic from one region in AWS to another. While most of Netflix runs on Java, failovers are powered entirely by Python. Python's versatility and rich ecosystem means we can use it for everything from predicting our traffic patterns to orchestrating traffic movement, while dealing with the eventual consistency of AWS. Today, we can shift all of our 100 million+ users in under seven minutes. A lot of engineering work went into making this possible. The issues we faced and solutions we created have broad application to availability strategies in the cloud or the datacenter. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 4045 PyCon 2018
Dustin Ingram - Inside the Cheeseshop: How Python Packaging Works - PyCon 2018
 
25:15
Speaker: 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. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2686 PyCon 2018
Nina Zakharenko - Elegant Solutions For Everyday Python Problems - PyCon 2018
 
32:58
Speaker: Nina Zakharenko Are you an intermediate python developer looking to level up? Luckily, python provides us with a unique set of tools to make our code more elegant and readable by providing language features that make your code more intuitive and cut down on repetition. In this talk, I’ll share practical pythonic solutions for supercharging your code. Specifically, I'll cover: - What magic methods are, and show you how to use them in your own code. - When and how to use partial methods. - An explanation of ContextManagers and Decorators, as well as multiple techniques for implementing them. - How to effectively use `NamedTuples`, and even subclass and extend them! Lastly, I'll go over some example code that ties many of these techniques together in a cohesive way. You'll leave this talk feeling confident about using these tools and techniques in your next python project! Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 19733 PyCon 2018
Andrew Godwin - Taking Django Async - PyCon 2018
 
40:17
Speaker: Andrew Godwin The Django Channels project has taken a major turn with version 2.0, embracing Python's async functionality and building applications around an async event loop rather than worker processes. Doing this, however, wasn't easy. We'll look through some of the techniques used to make Django coexist in this async world, including handing off between async and sync code, writing fully asynchronous HTTP and WebSocket handling, and what this means for the future of Django, and maybe Python web frameworks in general. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 3833 PyCon 2018
Lisa Roach - Demystifying the Patch Function   - PyCon 2018
 
37:07
Speaker: Lisa Roach One of the most challenging and important thing fors for Python developers learn is the unittest mock library. The patch function is in particular confusing- there are many different ways to use it. Should I use a context manager? Decorator? When would I use it manually? Improperly used patch functions can make unit tests useless, all the while making them look as if they are correctly testing code.Let’s learn how to wield patch with confidence! Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1683 PyCon 2018
Trey Hunner - Python 2 to 3: How to Upgrade and What Features to Start Using - PyCon 2018
 
25:59
Speaker: Trey Hunner The end of life for Python 2 is 2020. Python 3 is the future and you'll need to consider both your upgrade plan and what steps you'll take after upgrading to start leveraging Python 3 features. During this talk we'll briefly discuss how to start **the process of upgrading your code to Python 3**. We'll then dive into some of **the most useful Python 3 features** that you'll be able to start embracing once you drop Python 2 support. A number of the most powerful Python 3 features are syntactic features that are **Python 3 only**. You won't get any experience using these features until you fully upgrade. These features are an incentive to drop Python 2 support in existing 2 and 3 compatible code. You can consider this talk as a teaser of Python 3 features that you may have never used. After this talk I hope you'll be inspired to fully upgrade your code to Python 3. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1864 PyCon 2018
Barry Warsaw - Get your resources faster, with importlib.resources - PyCon 2018
 
28:42
Speaker: Barry Warsaw Resources are files that live within Python packages. Think test data files, certificates, templates, translation catalogs, and other static files you want to access from Python code. Sometimes you put these static files in a package directory within your source tree, and then locate them by importing the package and using its `__file__` attribute. But this doesn't work for zip files! You could use `pkg_resources`, an API that comes with `setuptools` and hides the differences between files on the file system and files in a zip file. This is great because you don't have to use `__file__`, but it's not so great because `pkg_resources` is a big library and can have potentially severe performance problems, even at import time. Welcome to `importlib.resources`, a new module and API in Python 3.7 that is also available as a standalone library for older versions of Python. `importlib.resources` is build on top of Python's existing import system, so it is very efficient. It also defines an abstract base class which loaders can implement to provide their own resource access. Python's built-in zipimporter uses this to provide efficient access to resources within a zip file. Third party import hooks can do the same, so resources can come from anything that is importable by Python. This talk will step through the motivations behind `importlib.resources`, the library's usage, its interfaces, and the hooks made available to third party packages. It will also talk about the minor differences between the standalone version and the version in Python 3.7's standard library. Hopefully audience members will come away with compelling reasons to port their code to this much more efficient library. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 6144 PyCon 2018
Alvaro Leiva Geisse - Systemd: why you should care as a Python developer - PyCon 2018
 
27:03
Speaker: Alvaro Leiva Geisse Done! Your shiny new application is functionally complete and ready to be deployed to production! But how exactly do you deploy properly on Linux? Wonder no more! In 30 minutes, this talk explains how you can harness the power of the init system and systemd to solve common deployment problems, including some that you didn't even know you had. Examples of things we will cover: * How to secure your system by having: private /tmp for your process, read-only paths so that your process can not write to them, inaccessible paths, protect users home, network access, bin directories, etc. * How to limit the resources you app can consume. * How to interact directly with systemd, so it can start transient units, start/stop services, mount disks, resolve addresses. * How to isolate your service without containers. * How to isolate your service using containers (using systemd to spawn a namespace). All this will be covered from a Python developer's perspective. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 4790 PyCon 2018
Daniel Pyrathon - A practical guide to Singular Value Decomposition in Python - PyCon 2018
 
31:15
Speaker: Daniel Pyrathon Recommender systems have become increasingly popular in recent years, and are used by some of the largest websites in the world to predict the likelihood of a user taking an action on an item. In the world of Netflix, this means recommending similar movies to the ones you have seen. In the world of dating, this means suggesting matches similar to people you already showed interest in! My path to recommenders has been an unusual one: from a Software Engineer to working on matching algorithms at a dating company, with a little background on machine learning. With my knowledge of Python and the use of basic SVD (Singular Value Decomposition) frameworks, I was able to understand SVDs from a practical standpoint of what you can do with them, instead of focusing on the science. In my talk, you will learn 2 practical ways of generating recommendations using SVDs: matrix factorization and item similarity. We will be learning the high-level components of SVD the "doer way": we will be implementing a simple movie recommendation engine with the help of Jupiter notebooks, the MovieLens database, and the Surprise recommendation package. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 5180 PyCon 2018
Jack Diederich - HOWTO Write a Function - PyCon 2018
 
41:31
Speaker: Jack Diederich A function is a small chunk of code that does useful work. Your job when writing a function is to do it in a way that it easy to read. Based on over 15 years of code reviews here are some tips and guidelines I give again and again. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 17263 PyCon 2018
Graham Dumpleton - Secrets of a WSGI master. - PyCon 2018
 
32:55
Speaker: Graham Dumpleton The WSGI (Web Server Gateway Interface) specification for hosting Python web applications was created in 2003. Measured in Internet time, it is ancient. The oldest main stream implementation of the WSGI specification is mod_wsgi, for the Apache HTTPD server and it is over 10 years old. WSGI is starting to be regarded as not up to the job, with technologies such as HTTP/2, web sockets and async dispatching being the way forward. Reality is that WSGI will be around for quite some time yet and for the majority of use cases is more than adequate. The real problem is not that we need to move to these new technologies, but that we aren't using the current WSGI servers to their best advantage. Moving to a new set of technologies will not necessarily make things better and will only create a new set of problems you have to solve. As one of the oldest WSGI server implementations, Apache and mod\_wsgi may be regarded as boring and not cool, but it is still the most stable option for hosting WSGI applications available. It also hasn't been sitting still, with a considerable amount of development work being done on mod\_wsgi in the last few years to make it even more robust and easier to use in a development environment as well as production, including in containerised environments. In this talk you will learn about many features of mod\_wsgi which you probably didn't even know existed, features which can help towards ensuring your Python web application deployment performs to its best, is secure, and has a low maintenance burden. Topics which will be covered include: * Easy deployment of Python web applications using mod\_wsgi-express. * Integration of mod_wsgi-express with a Django web application. * Using mod\_wsgi-express in a development environment. * How to make use of mod\_wsgi-express in a production environment. * Using mod_wsgi-express in a containerised runtime environment. * Ensuring consistency between development and production environments using warpdrive. * Using mod\_wsgi-express to bootstrap a system Apache installation for hosting WSGI applications. * Why you should be using daemon mode of mod\_wsgi and not embedded mode. * How to properly associate mod\_wsgi with a Python virtual environment. * Building a robust deployment that can recover from misbehaving application code, backend services, or request overloading. * Using hooks provided by mod\_wsgi to monitor the performance of your Python web application. If you are a beginner, come learn why mod\_wsgi is still a good option for deploying your Python web applications. If you are an old time user of mod\_wsgi, find out about all the features you probably didn't know existed, revisit your current Python web application deployment and make it even better. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2957 PyCon 2018
Christopher Fonnesbeck -  Bayesian Non-parametric Models for Data Science using PyMC3 - PyCon 2018
 
42:25
Speaker: Christopher Fonnesbeck Nowadays, there are many ways of building data science models using Python, including statistical and machine learning methods. I will introduce probabilistic models, which use Bayesian statistical methods to quantify all aspects of uncertainty relevant to your problem, and provide inferences in simple, interpretable terms using probabilities. A particularly flexible form of probabilistic models uses Bayesian *non-parametric* methods, which allow models to vary in complexity depending on how much data are available. In doing so, they avoid the over-fitting that is common in machine learning and statistical modeling. I will demonstrate the basics of Bayesian non-parametric modeling in Python, using the PyMC3 package. Specifically, I will introduce two common types, Gaussian processes and Dirichlet processes, and show how they can be applied easily to real-world problems using two examples. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 3219 PyCon 2018
Jiaqi Liu - Building a Data Pipeline with Testing in Mind - PyCon 2018
 
20:16
Speaker: Jiaqi Liu It’s one thing to build a robust data pipeline process in python but a whole other challenge to find tooling and build out the framework that allows for testing a data process. In order to truly iterate and develop a codebase, one has to be able to confidently test during the development process and monitor the production system. In this talk, I hope to address the key components for building out end to end testing for data pipelines by borrowing concepts from how we test python web services. Just like how we want to check for healthy status codes from our API responses, we want to be able to check that a pipeline is working as expected given the correct inputs. We’ll talk about key features that allows a data pipeline to be easily testable and how to identify timeseries metrics that can be used to monitor the health of a data pipeline. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2181 PyCon 2018
Justin Crown - "WHAT IS THIS MESS?" - Writing tests for pre-existing code bases - PyCon 2018
 
27:39
Speaker: Justin Crown Many of us practice test driven development, and pride ourselves in our code coverage. This is relatively easy to do when you begin a new project, but what happens when you take over an existing code base with little to no tests? Where and how do you start writing tests? This task can be very intimidating and frustrating, but can be accomplished! This talk will run through some common approaches and methodologies for adding test coverage to pre-existing code (that you might not even be familiar with at all). The next time you take over an untested monolith, you will be able to do the right thing and start writing tests instead of hoping for the best! Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1614 PyCon 2018
Jason Fried - Fighting the Good Fight: Python 3 in your organization - PyCon 2018
 
30:48
Speaker: Jason Fried Today, services built on Python 3.6.3 are widely used at Facebook. But as recently as May of 2014 it was actually impossible at all to use Python 3 at Facebook. Come learn how we cut the Gordian Knot of dependencies and social aversion to the point where new services are now being written in Python 3 while older Python 2 projects are actively migrated to Python 3. All accomplished by a small group of individual contributors in their spare time. Learn to fight the good fight and upgrade your organization to Python 3 like we did at Facebook. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2822 PyCon 2018
Nicholas Tollervey - Mu - How to Make a Kids' Code Editor - PyCon 2018
 
28:16
Speaker: Nicholas Tollervey [The Raspberry Pi Foundation][1] receives feedback about the difficulties beginner programmers encounter when learning Python from thousands of volunteer mentors at after-school CodeClubs and thousands of teachers from around the world. [Mu][3] is a Python code editor for beginner programmers based upon this feedback. This talk tells the story of Mu: why it was created, how we built it and includes a demonstration of how it works. [1]: http://raspberrypi.org/ [3]: http://codewith.mu/ Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1522 PyCon 2018
Sara Packman - The Journey Over the Intermediate Gap - PyCon 2018
 
27:09
Speaker: Sara Packman Congratulations on finishing your first tutorials or classes in python! In the parlance of the hero’s journey myth, you’ve had your ‘threshold moment”: you’ve started down a path that could lead to a long and fulfilling career. But the road to this glorious future is frustratingly obscured by a lack of guidance in the present. You know enough to realize that you don’t have all the skills you need yet, but it’s hard to know how to learn those skills, or even articulate what they are. There are no easy solutions to this problem. There are, however, a few fundamental things to know and advice to keep in mind. Drawing from my own experience and with input from others, I’ve compiled some helpful hints about the skills, tools, and guiding questions that will get you to mastery. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 4033 PyCon 2018
Paul Vincent Craven - Easy 2D Game Creation With Arcade - PyCon 2018
 
29:48
Speaker: Paul Vincent Craven Want to have fun with Python? Do something visual? Get started today? Learn how to draw, animate, and use sprites for games with the [Python Arcade](http://arcade.academy/) library. "Arcade" is an easy-to-use Python library for creating 2D arcade games. We'll show you how to get started creating your own game, and find plenty of example code to get an idea of what you can do with this library. If you are familiar with PyGame, Arcade is easier, more powerful, and uses recent Python features like type hinting and decorators. This talk is great for beginners, educators, and people who want to create their own arcade games. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2830 PyCon 2018
Alex Gaynor - Learning From Failure: Post Mortems - PyCon 2018
 
29:24
Speaker: Alex Gaynor Unless you work on pacemakers or at NASA, you've probably accepted the fact that you will make mistakes in your code, and those mistakes will creep into production. This talk will introduce you to post-mortems, and how to use them as a vehicle for improving your code and your process. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2593 PyCon 2018
Jake VanderPlas - Exploratory Data Visualization with Vega, Vega-Lite, and Altair - PyCon 2018
 
03:19:02
Speaker: Jake VanderPlas Exploring a new dataset visually can provide quick intuition into the relationships within the data. There are a few well-developed visualization packages in Python, but they often have very imperative APIs that force the user to focus on the mechanics of the visualization – tick locations, axis limits, legends, etc. – rather than the salient relationships within the data. This tutorial will introduce data visualization with [Altair](http://altair-viz.github.io), a package designed for exploratory visualization in Python that features a declarative API, allowing data scientists to focus more on the data than the incidental details. Altair is based on the [Vega](https://vega.github.io/) and [Vega-Lite](https://vega.github.io/vega-lite/) visualization grammars, and thus automatically incorporates best practices drawn from recent research in effective data visualization. The tutorial will provide an introduction to the Altair package and its API, but more importantly will dive into the core concepts of effective data visualization that can be applied using any visualization package or tool. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 12734 PyCon 2018
Miguel Grinberg - Oops! I Committed My Password To GitHub! - PyCon 2018
 
29:44
Speaker: Miguel Grinberg What do AWS, GitHub, Travis CI, DockerHub, Google, Stripe, New Relic, and the rest of the myriad of services that make our developer life easier have in common? They all give you secret keys to authenticate with. Did you ever commit one of these to source control by mistake? That happened to me more times than I'm willing to admit! In this talk I'm going to go over the best practices to follow when when writing Python applications that prevent this type of accident. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2504 PyCon 2018
Kyle Knapp - Automating Code Quality - PyCon 2018
 
29:45
Speaker: Kyle Knapp Writing quality Python code can be both tough and tedious. On top of the general design, there are many code quality aspects that you need to watch out for when writing and reviewing code such as adherence to PEP8, docstring quality, test quality, etc. Furthermore, everyone is human. If you are catching these code quality issues by hand, there is a good chance that at some point you will miss an easy opportunity to improve code quality. If the quality check can be done by a machine, then why would you even try to catch the code quality issue by hand? In the end, the machine will be able to perform the quality check with much more speed, accuracy, and consistency than a person. This talk will dive into how existing open source projects offload and automate many of these code quality checks resulting in: - A higher quality and a more consistent codebase - Maintainers being able to focus more on the higher level design and interfaces of a project. - An improved contribution process and higher quality pull requests from external contributors By diving into how these open source projects automate code quality checks, you will learn about: - The available tooling related to checking code quality such as `flake8`, `pylint`, `coverage`, etc. - How to automate code quality checks for both a development and team setting. - First-hand accounts of the benefits and lessons learned from automating code quality checks in real-life open source projects. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 4093 PyCon 2018
Code like an accountant: Designing data systems for accuracy, resilience and auditability
 
31:28
Speaker: Sophie Rapoport As engineers, we care a lot about the reliability of our applications. When a website falls over, pagers go off, and engineers burst into action to bring a site back to life. Postmortems are written, and teams develop strategies to prevent similar failures in the future. But what about the reliability of our data? Would _you_ trust financial reports built on your data? If not, what can you do to improve data health? If you _would_ trust these reports, how can you prove to customers, investors, and auditors alike that they should too? In this talk, you’ll learn to apply strategies from the world of dev-ops to data. You’ll learn about questions auditors ask that can help you pinpoint data problems. You’ll also learn some accounting-specific tools for accurate and timely record keeping that I’ve found fascinating and helpful! Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1826 PyCon 2018
Hynek Schlawack - How to Write Deployment-friendly Applications - PyCon 2018
 
44:20
Speaker: Hynek Schlawack The DevOps movement gave us many ways to put Python applications into production. But should your *application* care? Should it need to know whether it’s running on your notebook, on a server, in a Docker container, or in some cloud platform as a service? It should not, because environment-agnostic applications are easier to **test**, easier to **deploy**, easier to **handle**, and easier to **scale**. But how can you *practically* structure and configure your applications to make them indifferent to the environment they run in? How do secrets fit into the picture? And where do you put that log file? By the end of this talk you’ll know the tools and techniques that enable you to write such Python applications and you’ll be ready for the next big change. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 3124 PyCon 2018
Alex Petralia - Analyzing Data: What pandas and SQL Taught Me About Taking an Average - PyCon 2018
 
26:02
Speaker: Alex Petralia “So tell me,” my manager said, “what is an average?” There’s probably nothing worse than that sinking feeling when you finish an analysis, email it to your manager or client to review, and they point out a mistake so basic you can’t even fathom how you missed it. This talk is about mine: how to take an average. Averages are something we use everywhere - it’s a simple np.mean() in pandas or AVG() in SQL. But recently I’ve come to appreciate just how easy it is to calculate this statistic incorrectly. We learn once - in middle school no less - how to take an average, and never revisit it. Then, when we are faced with multidimensional datasets (ie. pretty much every dataset out there), we never reconsider whether we should be taking an average the same way. In this talk, we follow my arduous and humbling journey of learning how to properly take an average with multidimensional data. We will cover how improperly calculating it can produce grossly incorrect figures, which can slip into publications, research analyses and management reports. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 5187 PyCon 2018
Matt Davis - Python Performance Investigation by Example - PyCon 2018
 
30:36
Speaker: Matt Davis Occasionally we’ll find that some bit of Python we’ve written doesn’t run as fast as we’d like, what can we do? Performance bottlenecks aren’t always intuitive or easy to spot by reading code so we need to collect data with [profiling](https://docs.python.org/3.6/library/profile.html). Once we’ve identified the bottleneck we’ll need to change our approach, but what options are faster than others? This talk illustrates a Python performance investigation and improvements using an [Advent of Code](http://www.adventofcode.com/) programming challenge. I’ll walk through starting from a slow (but correct) solution, look at profiling data to investigate _why_ it’s slow, and explore multiple paths for improving performance, including more efficient algorithms and using third-party tools like [Cython](http://cython.org/). You’ll leave this talk with a recipe for analyzing Python performance and information about some options for improved performance. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2485 PyCon 2018
Janet Matsen - Programming microbes using Python - PyCon 2018
 
24:56
Speaker: Janet Matsen The genome of a typical microbe contains roughly 5 million base pairs of DNA including more than 4000 genes, which provide the instructions for cellular replication, energy metabolism, and other biological processes. At Zymergen, we edit DNA to design microbes with improved ability to produce valuable materials and molecules. Microbes with these edits are built and tested in high throughput by our fleet of robots. Genomes are far too large for exhaustive search, so identifying which edits to make requires machine learning on non-standard features. Our task to extract information from trees, networks, and graphs of independently representable knowledge bases (metabolism, genomics, regulation), in ways that respect the strongly causal relationships between systems. In this talk, I will describe how we use Python’s biological packages (e.g. BioPython, CobraPy, Escher, goatools) and other packages (NetworkX, TensorFlow, PyStan, AirFlow) to extract machine learning features and predict which genetic edits will produce high-performance microbes. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1367 PyCon 2018
Shohei Hido - CuPy: A NumPy-compatible Library for GPU - PyCon 2018
 
30:12
Speaker: Shohei Hido ![Logo][https://raw.githubusercontent.com/cupy/cupy/master/docs/image/cupy_logo_1000px.png] # CuPy : NumPy-like API accelerated with CUDA [**Website**](https://cupy.chainer.org/) | [**Docs**](https://docs-cupy.chainer.org/en/stable/) | [**Install Guide**](https://docs-cupy.chainer.org/en/stable/install.html) | [**Tutorial**](https://docs-cupy.chainer.org/en/stable/tutorial/) | **Examples** ([Official](https://github.com/cupy/cupy/blob/master/examples)) | [**Forum**](https://groups.google.com/forum/#!forum/cupy) CuPy is an open-source library with NumPy syntax that increases speed by doing matrix operations on NVIDIA GPUs. It is accelerated with the CUDA platform from NVIDIA and also uses CUDA-related libraries, including cuBLAS, cuDNN, cuRAND, cuSOLVER, cuSPARSE, and NCCL, to make full use of the GPU architecture. CuPy's interface is highly compatible with NumPy; in most cases it can be used as a drop-in replacement. CuPy supports various methods, data types, indexing, broadcasting, and more. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1991 PyCon 2018
Matthew Rocklin - Democratizing Distributed Computing with Dask and JupyterHub - PyCon 2018
 
32:06
Speaker: Matthew Rocklin We use JupyterHub, XArray, Dask, and Kubernetes to build a cloud-based system to enable scientists to analyze and manage large datasets. We use this in practice to serve a broad community of atmospheric and climate scientists. Atmospheric and climate scientists analyze large volumes of observational and simulated data to better understand our planet. They have historically used tools like NumPy and SciPy along with Jupyter notebooks to combine efficient computation with accessibility. However, as datasets increase in size and collaboration extends to new populations of scientists these tools begin to feel their age. In this talk we use more recent libraries to build a modern deployment for academic scientists. In particular we use the following tools: - **Dask:** to parallelize and scale NumPy computations - **XArray**: as a self-discribing data model and tool kit for labeled and index arrays - **JupyterLab:** to enable more APIs for users beyond the classic notebook - **JupyterHub:** to manage users and maintain environments for a new population of cloud-friendly users - **Kubernetes:** to manage everything and deploy easily on cloud hardware This talk will focus less on how these libraries work and will instead be a case study of using them together in an operational setting. During the talk we will build up and deploy a running system that the audience can then use to access distributed computing resources. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 2213 PyCon 2018
Allison Kaptur - Love your bugs - PyCon 2018
 
33:18
Speaker: Allison Kaptur Wrestling bugs can be one of the most frustrating parts of programming - but with the right framing, bugs can also be our best allies. I'll tell the tales of two of my favorite bugs, including the time I triggered a DDOS of a logging cluster, and explain why I love them. I'll also give you concrete strategies for approaching tricky bugs and making them easier and more fun. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 892 PyCon 2018
Irina Truong - Adapting from Spark to Dask: what to expect - PyCon 2018
 
27:55
Speaker: Irina Truong Until very recently, Apache Spark has been a de facto standard choice of a framework for batch data processing. For Python developers, diving into Spark is challenging, because it requires learning the Java infrastructure, memory management, configuration management. The multiple layers of indirection also make it harder to debug things, especially when throwing the Pyspark wrapper into the equation. With Dask emerging as a pure Python framework for parallel computing, Python developers might be looking at it with new hope, wondering if it might work for them in place of Spark. In this talk, I’m using a data aggregation example to highlight the important differences between the two frameworks, and make it clear how involved the switch may be. Note: Just in case it's unclear, there's no Java of any kind in this talk. All the code / examples use Python (PySpark). Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1360 PyCon 2018
Using Python to build an AI to play and win SNES StreetFighter II - PyCon 2018
 
30:38
Speakers: Adam Fletcher, Jonathan Mortensen ![ryu-python](http://www.thesimplelogic.com/wordpress/wp-content/uploads/2017/12/ryu-python.png) Hear the story of how we used Python to build an AI that plays Super StreetFighter II on the Super NES. We'll cover how Python provided the key glue between the SNES emulator and AI, and how the AI was built with `gym`, `keras-rl` and `tensorflow`. We'll show examples of game play and training, and talk about which bot beat which bot in the bot-v-bot tournament we ran. After this talk you'll know how easy it is to use Python and Python's machine learning libraries to teach a computer to play games. You'll see a practical example of the same type of machine learning used by AlphaGo, and also get to find out which character in StreetFighter II is best to pick when playing your friends. [1]: https://lh3.googleusercontent.com/Mh9uzCm4JeevMN5w-SWJgzWabrqOClAVMsa4jJtMRm-il1dP6oVTsRstJSQlbgKf4qh3A08yMZ36pwezsITA=w3230-h1786 [2]: http://www.thesimplelogic.com/wordpress/wp-content/uploads/2017/12/ryu-python.png Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1838 PyCon 2018
Mario Corchero - Effortless Logging: A deep dive into the logging module - PyCon 2018
 
30:28
Speaker: Mario Corchero Logs are our best friend, especially on those late nights when we try to troubleshoot a problem in production that was written by a co-worker who is on vacation. Logs are the main way to know what is happening with an application at runtime, but we don’t realize how important they are until we actually need them. Unfortunately, they are usually an under-estimated part of the development process. This talk aims to transmit the need for the logging module, briefly explains how to use it and how it is built, and dives into all the complexity that is hidden to us. This will help attendees not just understand all the magic that allows us to inspect our applications at runtime, but also to avoid mistakes and adapt the module to our needs for more esoteric scenarios. The talk is structured to simplify the understanding of the logging module. Many people have read the documentation, but still struggle to fully understand what is happening under the hood. This talk aims to eliminate that barrier by presenting it in an easier-to-digest manner. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 7518 PyCon 2018
Kevin Markham - Using pandas for Better (and Worse) Data Science - PyCon 2018
 
03:20:43
Speaker: Kevin Markham The pandas library is a powerful tool for multiple phases of the data science workflow, including data cleaning, visualization, and exploratory data analysis. However, proper data science requires careful coding, and pandas will not stop you from creating misleading plots, drawing incorrect conclusions, ignoring relevant data, including misleading data, or executing incorrect calculations. In this tutorial, you'll perform a variety of data science tasks on a handful of real-world datasets using pandas. With each task, you'll learn how to avoid either a pandas pitfall or a data science pitfall. By the end of the tutorial, you'll be more confident that you're using pandas for good rather than evil! Participants should have a working knowledge of pandas and an interest in data science, but are not required to have any experience with the data science workflow. Datasets will be provided by the instructor. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 5628 PyCon 2018
Scott Triglia - Surviving (and thriving!) when you are overloaded - PyCon 2018
 
27:16
Speaker: Scott Triglia Taking on leadership roles always includes new demands on your attention and time. Inevitably, your finite work week will conflict with the sheer amount of tasks you have to do. How can we as leaders keep stepping up to new responsibilities while balancing our pre-existing ones? This talk will focus on strategies for managing a too-large workload without abandoning important tasks or doing a shoddy job. We’ll look at techniques to prioritize what work matters most, identify tasks we should be doing ourselves, and finally delegate the rest to build our team’s skills while reducing our own workload. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1142 PyCon 2018

Annotated bibliography mla example 2014 jeep
Cover letter job references sheet
Cna cover letter examples for resumes
Skyscanner application letters
Heading for apa annotated bibliography