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: 32443 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: 16638 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: 19080 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: 38971 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: 12510 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: 11319 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: 10314 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: 5070 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: 6567 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: 10096 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: 9495 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: 3556 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: 13591 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: 13414 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: 30184 PyCon 2018
Dan Callahan - Keynote - PyCon 2018
 
30:10
Speaker: Dan Callahan
Views: 6441 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: 2839 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: 2751 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: 8352 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: 4440 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: 4895 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: 6715 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: 5925 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: 24530 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: 6101 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: 8959 PyCon 2018
Lilly Ryan - Don't Look Back in Anger: Wildman Whitehouse and the Great Failure of 1858 - PyCon 2018
 
30:13
Speaker: Lilly Ryan In the 1850s, Edward Orange Wildman Whitehouse was appointed the lead engineer of the first attempt to build a trans-Atlantic telegraph cable. With the entire population of two continents waiting for his go-live, their handlebar moustaches aquiver, he demonstrated in fine form just how spectacularly a big project can be a bigger disaster. This is a tale of long-winded rants, spectacular sideburns, and gentlemen scientists behaving badly. It is also a lesson about the importance of honest reflection in technical teamwork. Lilly outlines some of the mistakes made during one of the biggest tech delivery projects in history, and how a constructive view of failure helped to turn it all around. Through the public meltdowns of Wildman Whitehouse you will learn the importance of feedback, how to handle complex tasks gracefully, and the best way to recover from having your pipeline eaten by a whale. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 669 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: 2534 PyCon 2018
Steven Sklar - The Hare Wins the Race: Getting the most out of RabbitMQ in distributed applications
 
28:57
Speaker: Steven Sklar As web apps grow increasingly complex, distributing asynchronous work across multiple background workers is often a basic requirement of a performant app. While there are a variety of tools that exist to solve this issue, one common feature among them is the need for a robust messaging platform. [RabbitMQ][1] is a stable, full-featured, and mature solution that is usually found in the Python ecosystem backing [Celery][2] implementations. While Celery's utilization of RabbitMQ works just fine out of the gate, users with complex workflows, unique constraints, or tight budgets can take advantage of the flexibility of RabbitMQ to streamline their data pipelines and get the most out of their infrastructure. This talk will provide an overview of RabbitMQ, review its varied message-routing capabilities, and demonstrate some of the ways in which these features can be utilized in Python applications to solve common yet difficult use-cases. [1]: https://www.rabbitmq.com/ [2]: http://www.celeryproject.org/ Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1558 PyCon 2018
Zekun Li - There and Back Again: Disable and re-enable garbage collector at Instagram - PyCon 2018
 
24:12
Speaker: Zekun Li Python's cyclic garbage collector wonderfully hides the complexity of memory management from the programmer. But we pay the price in performance. Ever wondered how that works? In this talk, you'll learn how garbage collection is designed in Python, what the tradeoffs are and how Instagram battled copy-on-write memory issues by disabling the garbage collector entirely. You'll also learn why that isn't such a great idea after all and how we ended up extending the garbage collector API which allowed us to (mostly) re-enable garbage collection. We'll discuss our upstream contributions to the garbage collector that landed in Python 3.6 and 3.7. This is an in-depth talk about memory management but no prior experience with CPython internals is necessary to follow it. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 1394 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: 7639 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: 3949 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: 4656 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: 1797 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: 2373 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: 18293 PyCon 2018
Andrew Knight - Behavior-Driven Python - PyCon 2018
 
28:31
Speaker: Andrew Knight Behavior-Driven Development (BDD) is gaining popularity as an improved way to collaborate over product features and tests. In Python, **behave** is one of the leading BDD test frameworks. Using **behave**, teams write Gherkin behavior scenarios (e.g., tests) in plain language, and then programmers write Python code to automate the steps. BDD testing is great because tests are self-documenting and steps abide by the DRY principle. An example test could be: - Given the DuckDuckGo home page is displayed - When the user searches the phrase "Python" - Then search results for "Python" are shown This talk will teach how to use **behave** to develop well-designed test scenarios and a robust automation framework. It will focus on the layers of the behave framework: feature files, step definitions, support classes, and config files. A full example project will be hosted on GitHub for audience members to reference after the talk. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 3197 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: 5246 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: 3369 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: 2913 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: 3073 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: 3436 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: 1435 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: 5076 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: 11132 PyCon 2018
Greg Price - Clearer Code at Scale: Static Types at Zulip and Dropbox - PyCon 2018
 
29:51
Speaker: Greg Price Python now offers static types! Companies like Dropbox and Facebook, and open-source projects like Zulip, use static types (with [PEP 484](https://www.python.org/dev/peps/pep-0484/) and [mypy](https://github.com/python/mypy)) to make Python more productive and fun to work with — in existing codebases from 40k lines to 4 million, in Python 2 and 3, and while preserving the conciseness and flexibility that make Python a great language in the first place. I’ll describe how. Reading and understanding code is a huge part of what we do as software developers. If we make it easier to understand our codebases, we make everyone more productive, help each other write fewer bugs, and lower barriers for new contributors. That's why Python now features optional static types, and why Dropbox, [Facebook](https://engineering.instagram.com/let-your-code-type-hint-itself-introducing-open-source-monkeytype-a855c7284881), and [Zulip](https://blog.zulip.org/2016/10/13/static-types-in-python-oh-mypy/) use them on part or all of their Python code. In this talk, I’ll share lessons from Zulip’s and Dropbox’s experience — having led the mypy team at Dropbox and working now on the Zulip core team — for how you can start using static types in your own codebases, large or small. We’ll discuss how to make it a seamless part of your project’s tooling; what order to approach things in; and powerful new tools that make it even easier today to add static types to your Python codebase than ever before. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 3010 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: 1374 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: 9754 PyCon 2018
Allen Downey - Introduction to Digital Signal Processing - PyCon 2018
 
03:05:24
Speaker: Allen Downey Spectral analysis is an important and useful technique in many areas of science and engineering, and the Fast Fourier Transform is one of the most important algorithms, but the fundamental ideas of signal processing are not as widely known as they should be. Fortunately, Python provides an accessible and enjoyable way to get started. In this tutorial, I present material from my book, *Think DSP*, and from a class I teach at Olin College. We will work with audio signals, including music and other recorded sounds, and visualize their spectrums and spectrograms. We will synthesize simple sounds and learn about harmonic structure, chirps, filtering, and convolution. Slides can be found at: https://speakerdeck.com/pycon2018 and https://github.com/PyCon/2018-slides
Views: 7432 PyCon 2018
Trey Hunner - Using List Comprehensions and Generator Expressions For Data Processing - PyCon 2018
 
03:21:44
Speaker: Trey Hunner Creating one list out of another list is a very common thing to do in Python, so common that Python includes a special construct just for this purpose: list comprehensions. We'll get hands-on experience using list comprehensions, set comprehensions, and dictionary comprehensions during this tutorial. We'll also learn how and when we can slightly tweak our comprehensions to turn them into more performant generator expressions. We will learn some tricks for figuring out which of our "for" loops can be rewritten as comprehensions and which cannot. We will focus heavily on code readability and code clarity and we'll discuss when comprehensions help readability and when they hurt. All new skills will be acquired through practice. We'll work through many exercises both individually and as a group. All students will also receive a cheat sheet which can be used for guidance during future comprehension-writing journeys. A laptop with Python installed is required for this workshop.
Views: 10729 PyCon 2018

Licensing specialists and microsoft
Best free perl for windows
Partitie uitbreiden windows vista
Rooting windows rt
Barski cell 2007 microsoft