List of videos

Esta charla introducirá a un público no experto rápidamente en el mundo de las simulaciones de dinámica molecular y algunos de sus retos. Se hará especial énfasis en cómo las características y funcionalidades de Python y su ecosistema científico aceleran la investigación en el área, especialmente en los tiempos actuales en donde la aplicación de técnicas de Machine Learning están revolucionando el campo. Lo anterior se demostrará con ejemplos que hacen uso de la herramienta de simulación OpenMM y su sistema de librerías y herramientas (openmmtools, perses, entre otras).

The talk will explain using an Open Policy Agent (OPA) to ensure that governance, compliance, and security controls are implemented in the development process. The domain-agnostic nature of Open Policy Agent makes it well-suited for policy management and evaluation for tasks like that. The Implementation example will be developing a solution for managing SCM (Source Control Management) security at any organization or project's whole CI/CD pipeline. This part of the talk aims to demonstrate how to use Python Open Policy Agent (OPA) Client and build policies to verify the security of SCM (Gitlab or Github) organization/repositories/user accounts. The good practices to automate those Policies to Satisfy Common Concerns will be covered in the presentation.

You will learn about the pluggy Python framework and how it can be used to make your codebase plugin-friendly. As a real-life example, you will also learn about how the 10 year old conda codebase has recently gotten new life injected into it via a plugin API.

In the recent years we saw an explosion of usage of Python in the browser: Pyodide, CPython on WASM, PyScript, etc. All of this is possible thanks to the powerful functionalities of the underlying platform, WebAssembly. In this talk we will examine what is exactly WebAssembly, what are the strong and weak points, what are the limitations and what the future will bring us. We will also see why and how WebAssembly is useful and used outside the browser. This talk is targeted to an intermediate/advanced audience: no prior knowledge of WebAssembly is required, but it is required to have a basic understanding of what is a compiler, an interpreter and the concept of bytecode. The introduction will cover the basics to make sure that the talk is understandable also by people who are completely new to the WebAssembly world, but after that we will dive into the low-level technical details, with a special focus on those who are relevant to the Python world, such WASI vs emscripten, dynamic linking, JIT compilation, interoperability with other languages, etc.

With the tremendous growth of the Python ecosystem, attracting an ever-wider audience of users with a variety of backgrounds and experience levels, it is more critical than ever that its documentation better serve the needs of its diverse array of readers. We formally introduce the Python Docs Community—the self-organized, Python Steering Council-endorsed collective working toward this goal—and provide a look at the major user-facing improvements implemented, underway and coming soon for the core documentation, devguide, PEPs and more. Along the way, we'll share the key insights and lessons learned from our ongoing projects, and how they can help you improve the documentation of your own projects. And if this sounds like something you might want to be a part of, we'll share how you can engage with us and your fellow documentarians through our community platforms and resources.

What is pyproject.toml? What is it good for? The talk will cover the basic format and extensibility of pyproject.toml. It will show how it is extensible by showing how a couple of tools integrate with it. Then the talk will cover how to use pyproject.toml as the source of truth for packaging your Python project with setuptools. Special attention will be given to integration with setuptools plugins.

Tests are great. Except when they’re not. Almost every developer who’s worked with tests has encountered a test suite that caused a lot of pain. Some of them just don’t protect us when we need them, some are flaky, some keep breaking because of unrelated changes, some take hours to debug whenever they fail. And while every company is different, there are definitely patterns. A lot of these problems are the result of some common pitfalls that trap many teams. These pitfalls might be common, but they're not easy to spot - I’ve seen all of them happen in strong, capable, experienced teams. Most of these I fell into myself at least once. In this session, we'll take a look at a selection of problematic testing choices, with examples that show these in the context of common Python frameworks and libraries. We'll discuss how to identify them, what problems they might cause and what alternatives we have so we can save ourselves the pain.

Black, Flake8, isort, and Mypy are useful Python linters but it’s challenging to use them effectively at scale in the case of multiple codebases, in a large codebase, or with many developers. Manually managing consistent linter versions and configurations across codebases requires endless effort. Linter analysis on large codebases is slow. Linters may slow down developers by asking them to fix trivial issues. Running linters in distributed CI jobs makes it hard to understand the overall developer experience. To handle these scale challenges, we developed a reusable linter framework that releases new linter updates automatically, reuses consistent configurations, runs linters on only updated code to speedup runtime, collects logs and metrics to provide observability, and builds auto fixes for common linter issues. Our linter runs are fast and scalable. Every week, they run 10k times on multiple millions of lines of code in over 25 codebases, generating 25k suggestions for more than 200 developers. Its autofixes also save 20 hours of developer time every week. In this talk, we’ll walk you through popular Python linters and configuration recommendations, and we will discuss common issues and solutions when scaling them out. Using linters more effectively will make it much easier for you to apply best practices and more quickly write better code.

Did you know that it only takes 11 pieces of syntax and some special functions to implement all the rest of the syntax of Python 3.8? It turns out you can take something like + and unravel it into Python code, letting you implement what Python does for a certain piece of syntax all on your own! This talk will cover what the minimum bits of Python syntax are needed to implement all the other pieces of syntax that Python supports. We will also cover how various pieces of syntax unravel into code to help you have a better understanding of how Python actually works.