id
stringlengths
31
32
content
stringlengths
466
2.48k
content_type
stringclasses
1 value
meta
dict
id_hash_keys
sequence
score
null
embedding
null
d7be49403931b98bbc3e7a5d4a7ae251
Talks: How we are making CPython faster. Past, present and future. Saturday - April 22nd, 2023 2:30 p.m.-3 p.m. in Presented by: Mark Shannon Experience Level: Some experience Description Many of you will will have heard that Python 3.11 is considerably faster than 3.10. How did we do that? How are we going to make 3.12 and following releases even faster? In this talk, I will present a high level overview of the approach we are taking to speeding up CPython. Starting with a simple overview of some basic principles, I will show how we can apply those to streamline and speedup CPython. I will try to avoid computer science and software engineering terminology, in favor of diagrams, a few simple examples, and some high-school math. Finally, I make some estimates about how much faster the next few releases of CPython will be, and how much faster Python could go..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/73", "_split_id": 0 }
[ "content" ]
null
null
1171b5720aac29bd6fe3229323ae84cd
Tutorials: Data of an Unusual Size: A practical guide to analysis and interactive visualization of massive datasets Wednesday - April 19th, 2023 9 a.m.-12:30 p.m. in Presented by: Pavithra Eswaramoorthy Dharhas Pothina Experience Level: Some experience Description While most folks aren't at the scale of cloud giants or black hole research teams that analyze Petabytes of data every day, you can easily fall into a situation where your laptop doesn't have quite enough power to do the analytics you need. "Big data" refers to any data that is too large to handle comfortably with your current tools and infrastructure. As the leading language for data science, Python has many mature options that allow you to work with datasets that are orders of magnitudes larger than what can fit into a typical laptop's memory. In this hands-on tutorial, you will learn the fundamentals of analyzing massive datasets with real-world examples on actual powerful machines on a public cloud – starting from how the data is stored and read, to how it is processed and visualized. You will understand how large-scale analysis differs from local workflows, the unique challenges associated with scale, and some best practices to work productively with your data. By the end, you will be able to answer: What makes some data formats more efficient at scale? Why, how, and when (and when not) to leverage parallel and distributed computation (primarily with Dask) for your work? How to manage cloud storage, resources, and costs effectively? How interactive visualization can make large and complex data more understandable (primarily with hvPlot)? How to comfortably collaborate on data science projects with your entire team? The tutorial focuses on the reasoning, intuition, and best practices around big data workflows, while covering the practical details of Python libraries like Dask and hvPlot that are great at handling large data. It includes plenty of exercises to help you build a foundational understanding within three hours..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/64", "_split_id": 0 }
[ "content" ]
null
null
66d5d29f45604914358f7e1de36c6294
Talks: Oh no! My regex is causing a Denial of Service! What can I do about it? Saturday - April 22nd, 2023 4:15 p.m.-4:45 p.m. in Presented by: Guillaume Dequenne Quazi Nafiul Islam Experience Level: Some experience Description Every modern programming language supports regular expressions. Python uses a backtracking engine to match developer-defined expressions against a wide range of input. Under certain circumstances, backtracking can lead to performance issues, and in extreme cases a denial of service (ReDoS). We will use descriptive examples to demonstrate the core issue, what to look for to detect problematic expressions, as well as how static analysis can help in this context. We will look at techniques to improve regular expression performance and defend against malicious inputs..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/60", "_split_id": 0 }
[ "content" ]
null
null
71d340af6d3ea35ebbde02a07ce14b7c
Charlas: OCR, Reconocimiento y obtención de información a través de imágenes Friday - April 21st, 2023 12:15 p.m.-12:45 p.m. in Presented by: Alison Orellana Rios Experience Level: Advance experience Description Se verá el área de reconocimiento de patrones y texto en imágenes diversas, el procesamiento que requiere capturar, decodificar y analizar para finalmente obtener texto a partir de imágenes o archivos digitales. A partir de estas premisas, se verá el uso de la librería OpenCV y su complementación con Tesseract, (en conjunto con Python) ya que ambas permiten obtener datos visuales con facilidad, para posteriormente generar información textual que es de gran utilidad para funciones complejas dentro de la industria automotriz, conducción autónoma, registro de actividades, señalización y sensores, robótica entre otros muchos campos de aplicación. La recuperación de texto a partir de imágenes es un pilar fundamental para la ejecución de múltiples categorías de tratamiento de datos, lo cual demuestra su gran importancia como factor base para una gran variedad de aplicaciones. El uso de librerías de Python permite contrastar la facilidad y manejo de información gráfica, su complementación permitirá entender un poco mejor las ramas de aplicación que posee el estudio de las imágenes y la visión artificial..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/55", "_split_id": 0 }
[ "content" ]
null
null
a747672a76180fc77cc9ae7b79aac7d4
Charlas: Cómo Python puede ayudar a monitorear gobiernos Friday - April 21st, 2023 2:30 p.m.-3 p.m. in Presented by: Judite Cypreste Experience Level: Some experience Description Con el riesgo inminente de la caída de las democracias y los constantes ataques a los medios de comunicación, el acceso a la información se ha vuelto cada vez más difícil. Como resultado, la sociedad civil y los periodistas han estado buscando formas de garantizar que la sociedad no se quede en la oscuridad y que el monitoreo del gobierno continúe. Con la popularización de Python en varias áreas profesionales, el lenguaje se volvió cada vez más presente en la lucha por un gobierno más abierto en Brasil, ya sea en la construcción de herramientas de monitoreo o en el análisis de datos de una agencia gubernamental. Las iniciativas provenientes de entidades gubernamentales también están ayudando a hacer posible la transparencia. En esta charla, veremos ejemplos del uso de Python para monitorear al gobierno brasileño y cómo el lenguaje fue fundamental para que la sociedad brasileña no permaneciera en la oscuridad de la desinformación..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/25", "_split_id": 0 }
[ "content" ]
null
null
a09d159c961699e05e5b90c87f9c7a9e
Talks: How Python is Behind the Science of the James Webb Space Telescope Friday - April 21st, 2023 11:30 a.m.-noon in Presented by: Erik Tollerud Experience Level: Just starting out Description The James Webb Space Telescope (JWST) is one of the largest science projects in history. Its aim is to blow the door open on infrared astronomy: it has already found the earliest galaxies, will reveal the birth of stars and planets, and look for planets that could harbor life outside our solar system. Not to mention it has and will produce a lot of spectacular pictures that help us all understand our place in the cosmos in a way never before possible. And while there were many varied programming languages used for development and operation of JWST, the language used for most of the science is Python. In this talk I will walk through some of the early science of JWST and how it has been made possible by Python and the broad and deep open source Python scientific ecosystem..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/122", "_split_id": 0 }
[ "content" ]
null
null
efada6628b8d838caa9c3610252ae902
Talks: Approaches to Fairness and Bias Mitigation in Natural Language Processing Friday - April 21st, 2023 10:45 a.m.-11:15 a.m. in Presented by: Angana Borah Experience Level: Some experience Description With the advent of large pre-trained language models like GPT, BERT, etc., and their usage in almost all natural language understanding and generation applications, it is important that we evaluate the fairness and mitigate biases of these models. Since these models are fed with human-generated data (mostly from the web), they are exposed to human biases. Hence, they carry forward and also amplify these biases in their results. In this talk, we will discuss the motivation for fairness and bias research in NLP and discuss different approaches used to detect and mitigate biases. We will also explore some available tools to include in your models to ensure fairness..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/56", "_split_id": 0 }
[ "content" ]
null
null
8af2c308ec9f93c180142b71144e2fc5
Talks: Pythonic `functional` (`iter`)tools for your data challenges Friday - April 21st, 2023 5 p.m.-5:30 p.m. in Presented by: Valerio Maggio Experience Level: Just starting out Description Nowadays Python is very likely to be the first choice for developing machine learning or data science applications. Reasons for this are manifold, but very likely to be found in the fact that the Python language is amazing (⚠️ opinionated), and the open source community in the PyData ecosystem is absolutely fantastic (💙 that's a fact 1 2 3). In this context, one of the most remarkable features of the Python language is its ability in supporting multiple programming styles (from imperative to OOP and also functional programming). Thanks to this versatility, developers have their freedom to choose whichever programming style they prefer. Functional programming is indeed very fascinating, and it is great for in-demand tasks such as data filtering or data processing. Of course, this doesn't say anything about other paradigms, but sometimes the solution to a data problem could be more naturally expressed using a functional approach. In this talk, we will discuss Python's support to functional programming, understanding the meaning of pure functions (also why mutable function parameters are always a bad idea), and Python classes and modules that would help you in this style, namely itertools, functools, map-reduce data processing pattern. As for reference data challenges, we will discuss functional-style solutions to Advent of Code coding puzzles, to make it fun, and interactive..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/129", "_split_id": 0 }
[ "content" ]
null
null
4beb026dac3740f482d3f54b01da02bd
Talks: How To Keep A Secret Saturday - April 22nd, 2023 3:15 p.m.-3:45 p.m. in Presented by: Glyph Experience Level: Some experience Description API keys, passwords, auth tokens, cryptographic secrets… in the era of cloud-based development, we've all got a bunch of them. But where do you put them? How do you keep them safe? And how can you access them conveniently from your Python code, both in development and production, without putting them at risk? In this talk, I'll review information security best practices for managing secrets as well as Python-specific tips and tricks..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/149", "_split_id": 0 }
[ "content" ]
null
null
5a8e7d7fb0dd435bf44ae9e1682ef8c0
Talks: 10 Ways To Shoot Yourself In The Foot With Tests Saturday - April 22nd, 2023 3:15 p.m.-3:45 p.m. in Presented by: Shai Geva Experience Level: Some experience Description 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..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/89", "_split_id": 0 }
[ "content" ]
null
null
2e4585c666008bbf57e1a5c6f1543aa9
Talks: A pythonic full-text search Sunday - April 23rd, 2023 1:45 p.m.-2:15 p.m. in Presented by: Paolo Melchiorre Experience Level: Some experience Description A full-text search on a website is the best way to make its contents easily accessible to users because it returns better results and is in fact used in online search engines or social networks. The implementation of full-text search can be complex and many adopt the strategy of using dedicated search engines in addition to the database, but in most cases this strategy turns out to be a big problem of architecture and performance. In this talk we'll see a pythonic way to implement full-text search on a website using only Django and PostgreSQL, taking advantage of all the innovations introduced in latest years, and we'll analyze the problems of using additional search engines with examples deriving from my experience on djangoproject.com. Through this talk you can learn how to add a full-text search on your website, if it's based on Django and PostgreSQL, or you can learn how to update the search function of your website if you use other search engines..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/148", "_split_id": 0 }
[ "content" ]
null
null
e62c092b10bfd7949d6b5ef49b766a04
Sponsor Presentations: Python Profiling State of the World (Sponsor: Sentry) Thursday - April 20th, 2023 3:30 p.m.-4:30 p.m. in Presented by: Shana Matthews Indragie Karunaratne Description Most Python devs are familiar with built-in profiling tools like cprofile, but the world of profilers has expanded rapidly. In this hands-on workshop we'll explore different profiling technologies including CPU and memory profilers, sampling and deterministic, as well as different ways of visualizing profile data like flamecharts and flamegraphs..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/153", "_split_id": 0 }
[ "content" ]
null
null
d6429e606b95a35d6e5aa46a0928bf80
Tutorials: Web Development With A Python-backed Frontend: Featuring HTMX and Tailwind Wednesday - April 19th, 2023 9 a.m.-12:30 p.m. in Presented by: Mario Munoz Experience Level: Some experience Description Want to bring hypermedia into your web design workflow, ditching the complexity of JSON-over-HTTP for a more RESTful approach? Create and design your web application with htmx and spark joy in your design process. Splash in a little Tailwind CSS, too. (Ssshh. You're a Full-Stack Developer now.).
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/151", "_split_id": 0 }
[ "content" ]
null
null
7be6579ebfbb97307adee551f8d4bbdf
Sponsor Presentations: Best Practices for Using Python to Power Serverless Applications (Sponsor: Capital One) Thursday - April 20th, 2023 3:30 p.m.-4:30 p.m. in Presented by: Brian McNamara Dan Furman Experience Level: --select-- Description Capital One uses Python to power a large number of serverless applications to improve developer experience and increase customer value. Because Python enables fast development cycles, engineers and data scientists at Capital One have more time to focus on delighting our customers. Our Python development is also more potent on serverless as it eliminates multiple overhead requirements. In this talk, we will cover best practices we've learned along the way for using Python to build serverless solutions to enable a fast, intuitive and iterative developer experience for: API calls Streaming data Machine learning inference Attendees will learn the techniques and tools available when using Python to build a production-grade serverless system complete with observability and development practices baked in without ever provisioning a server. The presentation will feature a demonstration of Python-based AWS Lambda functions-as-a-service..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/152", "_split_id": 0 }
[ "content" ]
null
null
b7ee8478ab558a082b85d64300587c35
Charlas: Salvemos los pingüinos con el green computing Friday - April 21st, 2023 3:15 p.m.-3:45 p.m. in Presented by: Elena Guidi Experience Level: Just starting out Description "Green computing" es un término que nació en 1992 y que busca reducir el impacto ambiental de las actividades digitales. En esta charla vamos a ver que es el green computing (también llamada computación verde) y que estudia esta área de la informática, con algunos ejemplos de mejoras de data centers. También vamos a ver algunas cosas que podemos hacer en nuestro día a día y una introducción al el green programming con python (o codificación ecológica) La tecnología tiene un potencial muy alto de ayudar al medio ambiente, ¡el objetivo de esta charla es que todos lo sepamos! Veremos también que podemos hacer con python para saber cuanto es green nuestro código. (No hay prerequisites, esta charla es para todos los públicos).
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/156", "_split_id": 0 }
[ "content" ]
null
null
7e734afa1d5c4edfb8c921897d6dd114
Talks: Ergonomic codesigning for the Python ecosystem with Sigstore Friday - April 21st, 2023 2:30 p.m.-3 p.m. in Presented by: William Woodruff Experience Level: Some experience Description Code signing is coming to the Python packaging ecosystem, in the form of Sigstore: individual package maintainers and users will be able to sign for and verify the authenticity of their Python packages, respectively, without the historical and technical baggage of PGP. This talk will serve two purposes: (1) as a introduction to Sigstore, and its security model, to Python developers, and (2) as a technical overview of ongoing efforts to integrate Sigstore into Python packaging. Attendees will be introduced to the cryptographic fundamentals of codesigning, how Sigstore accomplishes codesigning without long-term key material (a critical downside to PGP), as well as the guarantees they can derive from strong codesigning in the Python packaging ecosystem. They'll also be introduced to the technical aspects of Sigstore's integration into Python packaging, including a peek behind the scenes at the standardization process and other foundational efforts required to introduce a new codesigning format to one of the world's largest packaging ecosystems..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/19", "_split_id": 0 }
[ "content" ]
null
null
96a571e0848f1b0dc53447a78fb0003d
Talks: Using Python to Help the Unhoused Sunday - April 23rd, 2023 2:30 p.m.-3 p.m. in Presented by: Josh Weissbock Sheila Flood Experience Level: Some experience Description How a group of volunteers from around the globe use Python to help an NGO in Victoria, BC, Canada to help the unhoused. By building a tool to find social media activity on unhoused in the Capitol Region, the NGO can use a dashboard of results to know where to move their limited resources..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/144", "_split_id": 0 }
[ "content" ]
null
null
2baf80c17d8b807253575a2fda95cd7a
Tutorials: How To Troubleshoot and Monitor Production Applications using OpenTelemetry Thursday - April 20th, 2023 1:30 p.m.-5 p.m. in Presented by: Ron Nathaniel Experience Level: Some experience Description OpenTelemetry is a free, open-source Observability Protocol. OpenTelemetry sits at the application layer, and exports Traces, Metrics, and Logs to a backend for observing. It is extremely helpful and beneficial to developers in mean "time-to-detection" and "time-to-resolution" of bugs and issues that occur at the application layer; this ranges from detecting and alerting for errors raised (such as TypeError), to finding that a specific microservice (such as AWS Lambda) ran for twice as long as usual, all the way to seeing the output of a service and comparing it to the expected output to find a bug in the logic of the service. This tutorial is geared towards beginner/intermediate Python developers, who have some experience in Python, its syntax, and very minimal experience in Requests and Flask is needed (extremely popular libraries, with 50k and 60k stars on GitHub, respectively). No OpenTelemetry experience is needed at all. This is a total and complete introduction into OpenTelemetry, consisting instrumenting your first application, viewing your first traces and metrics, and if time-allows then deploying your first Jaeger instance locally (no experience is needed, only Docker desktop), to allow students of this workshop tutorial to build their own in-house observability platform, be-it for their selves or employers. It is important that every developer have at least a solid understanding of Traces, Metrics, and Logs, which we know today as the three pillars of observability. These are the foundational building blocks for monitoring Production environments at the application layer. The extended base workshop is available here and the base slides are available here. Thank you..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/47", "_split_id": 0 }
[ "content" ]
null
null
2eccfa781ef5029dfc97ffe4f8a673f1
Talks: Instrumentation Nightmares: A review of some of our toughest cases Friday - April 21st, 2023 12:15 p.m.-1 p.m. in Presented by: Hannah Stepanek Lalleh Rafeei Timothy Pansino Uma Annamalai Experience Level: Community Presentation Description Ever wonder how companies like New Relic, Data Dog, and Sentry instrument your code? In this talk we will briefly review how to hook into the Python import system in order to instrument code. We'll present some useful design patterns and tricks of the trade. Then, we'll launch straight into real world examples and challenging instrumentation we've done over the years. Take a deep dive with us into some of the most popular Python libraries in use today and learn how they work underneath. We'll talk about proxies, wrapt, async, Python's web server specifications, and more! You will walk away from this talk with an understanding of how instrumentation works under the hood and how to make your own code instrumentation friendly. You'll also learn about various design patterns; some that are gotos for instrumentation and some that make instrumentation nightmarishly difficult. We hope you will join us on this instrumentation journey and come away with an understanding of how it all works to make developer's lives easier..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/82", "_split_id": 0 }
[ "content" ]
null
null
6c2b3589a7d1abdf0e6df4d0f18474dd
Talks: Typing an Existing Codebase: Lessons for Refactoring and Understanding Friday - April 21st, 2023 2:30 p.m.-3 p.m. in Presented by: David Reed Experience Level: Some experience Description Typing is a keystone of modern Python and the foundation of many new and exciting projects in the Python ecosystem, but millions of lines of existing code do not take full advantage of typing capabilities. How can typing add value to those codebases and support the teams working on them? This talk explores how adding type annotations to existing code - with no other changes! - can offer an entry point and a hand up, from helping engineers engage with unfamiliar applications to planning refactors. We'll explore real examples from a production code base, see how typing existing code can be implemented as a practice, and highlight the benefits adopting this mode of engagement can offer an engineering team..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/11", "_split_id": 0 }
[ "content" ]
null
null
38d822b63315271dbd368154864d8b00
Tutorials: Building human-first and machine-friendly CLI applications Thursday - April 20th, 2023 9 a.m.-12:30 p.m. in Presented by: Reka Horvath Experience Level: Some experience Description Command line tools have 2 audiences: humans using it directly other tools, scripts working together with it In this tutorial, you'll learn how to build CLI applications for both of these user groups. We'll get to know the Command Line Interface Guidelines (https://clig.dev/), an open source, language-agnostic collection of principles and guidelines. We'll build an application following those principles in Python, using typer and Rich. Our short-term goal for this workshop is to build a CLI catalogue of past PyCon talks. The long-term goal is to provide tools (incl. code snippets and checklists) that you can use for your own CLI applications..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/125", "_split_id": 0 }
[ "content" ]
null
null
b9bc3106ea79e183d42a5c0bc2869777
Talks: Catching Tensor Shape Errors without Running Your Code Saturday - April 22nd, 2023 11:30 a.m.-noon in Presented by: Pradeep Kumar Srinivasan Experience Level: Some experience Description Machine Learning (ML) is heavily used in industry and research, with millions of lines of critical algorithms written using libraries like Pytorch, TensorFlow, and Numpy. ML developers are often slowed down by errors because of long iteration times for ML models and difficulty in debugging ML code, which can lead to costly production crashes. Tensor shape mismatches are some of the most common errors for both new and experienced ML developers, occurring when an operation is fed a multi-dimensional array (tensor) with the wrong dimensions (shape). We can represent the shape of a tensor using explicit type annotations, called shape types. With the help of a type checker, shape types let us catch Tensor shape mismatches without running the program. We can also see the symbolic shape of any tensor variable right in the IDE for faster development. In this talk, we will introduce shape types, describe how they can catch mismatch errors, and show how the audience can start using shape types in their machine learning projects to boost their productivity..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/83", "_split_id": 0 }
[ "content" ]
null
null
e84244a62b306807388f17d50048a251
Talks: Using Embedded Python - Building Games on BBC micro: bit Friday - April 21st, 2023 5 p.m.-5:30 p.m. in Presented by: Niharika Vadluri Experience Level: Some experience Description Writing code that runs in the terminal or in your web browser is good fun. Writing code that affects the real world, however, can be satisfying on a whole other level. Writing this sort of code is called embedded development, and Python is making it more accessible than ever! Through this talk i would like to share about : What embedded development is and why you would use Python to do it. What your hardware and software options are for running Python on an embedded system. When Python is a good fit for an embedded system and when it’s not. How to write a basic game on the BBC micro: bit with MicroPython.. Table of Contents What Is Embedded Development? Python for Embedded Development Benefits of Using Python Disadvantages of Using Python Things to Watch Out for When New to Embedded Development Hardware Options for Running Embedded Python 6.1. BBC micro:bit 6.2. Raspberry Pi 6.3. pyboard 6.4. Others Software Options for Writing Embedded Python 7.1 MicroPython 7.2. CircuitPython Project: A Simon Says Game on the BBC micro:bit 8.1. Setting Up Your Environment 8.2. Displaying Instructions on the Screen 8.3. Running Your Code 8.4. Optional: Run Your Code on a Physical micro:bit 8.5. Getting Player Input 8.6. Testing Accelerometer Code in the Simulator 8.7. Points and Losing 8.8. Take It a Step Further Other Boards That Run Python Conclusion.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/65", "_split_id": 0 }
[ "content" ]
null
null
ba873f442e80b4bf85b01ea2ed5293c
Talks: Quicksort, Timsort, Powersort - Algorithmic ideas, engineering tricks, and trivia behind CPython's new sorting algorithm Saturday - April 22nd, 2023 3:15 p.m.-3:45 p.m. in Presented by: Sebastian Wild Experience Level: Some experience Description Writing a sorting function is easy - coding a fast and reliable reference implementation less so. In this talk, I tell the story behind CPython's latest updates of the list sort function. Aims: entertain people with twists of history and algorithmic puzzles, which tell a lovely story of how a seemingly useless piece of theory lead to the fastest and most elegant solution of a practical challenge. Target audience: geeks believing in the power of solid algorithmic thinking; programmers interested in engineering performance-critical code; all Python enthusiast curious about what makes (sorting lists in) Python fast. Content: After using Quicksort for a long while, Tim Peters invented Timsort, a clever Mergesort variant, for the CPython reference implementation of Python. Timsort is both effective in Python and a popular export product: it is used in many languages and frameworks, notably OpenJDK, the Android runtime, and the V8 JavaScript engine. Despite this success, algorithms researchers eventually pinpointed two flaws in Timsort's underlying algorithm: The first could lead to a stack overflow in CPython (and Java); although it has meanwhile been fixed, it is curious that 10 years of widespread use didn't bring it to surface. The second flaw is related to performance: the order in which detected sorted segments, the “runs” in the input, are merged, can be 50% more costly than necessary. Based on ideas from the little known puzzle of optimal alphabetic trees, the Powersort merge policy finds nearly optimal merging orders with negligible overhead, and is now (Python 3.11.0) part of the CPython implementation..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/50", "_split_id": 0 }
[ "content" ]
null
null
8a55fdd70bde3dde8d7177d2a4e39644
Charlas: Cooperación internacional en la comunidad de Python Saturday - April 22nd, 2023 10:45 a.m.-11:15 a.m. in Presented by: Débora Azevedo Experience Level: Community Presentation Description Como dice la famosa frase de Brett Cannon, algunas personas “vienen por el lenguage, pero se quedan por la comunidad”. Por lo general, empezamos participando en meetups locales o grupos enfocados como PyLadies, y a veces queremos ayudar, pero no estamos exactamente seguros de cómo hacerlo. Y yendo aún existe la posibilidad de extender nuestro trabajo no solo localmente sino también ayudando a las comunidades de todo el mundo. En esta charla, discutiremos las formas en que podemos cooperar dentro de la comunidad de Python en movimientos que se pueden realizar tanto a nivel local como fuera de nuestro país de forma voluntaria. Para empezar, discutiremos qué es contribuir a la comunidad y las diferentes formas en que puede contribuir. Además, explicaremos un poco sobre Python Software Foundation y sus grupos de trabajo, el papel de estos grupos y cómo proceder si está interesado en ponerse en contacto y ayudar. Destacaremos el trabajo del grupo de Diversidad e Inclusión y también el grupo de trabajo de traducción y su importancia para la comunidad en general. También se presentarán algunos trabajos que están en proceso, como el trabajo masivo de nuestros colegas latinoamericanos con Python en Español, que tiene un grupo de Discord y un grupo de Telegram para estudiar y cooperar juntos. Otro caso de éxito que se presentará es que el encuentro brasileño Python Python Brasil se esforzó durante 2020 y 2021 debido a la cooperación internacional: una mujer brasileña que coopera con EuroPython 2020 nos abrió el camino. Hablaremos de lo importante que es ver a alguien como nosotros, que habla el mismo idioma que nosotros, ocupando estos espacios y llevando nuestras inquietudes a otras mesas de discusión. Y que si no hay alguien que se parezca a nosotros, hay un lugar que podemos ocupar..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/113", "_split_id": 0 }
[ "content" ]
null
null
4d6c0d3d508674726ed4005778d8e3d1
Talks: Skynet 101 How to Keep Your Machine Learning Code From Getting Away From You Sunday - April 23rd, 2023 1 p.m.-1:30 p.m. in Presented by: Elizabeth Johnson Experience Level: Some experience Description Machine learning can feel pretty mysterious at times, but as python developers you have so many of the tools you need to be a part of it! With basic python experience you can use libraries like pandas and tools like Jupyter Notebooks to analyze and manipulate data sets. By apply Test-Driven Development practices to you analysis you can feel confident about what your building. You can build well developed and well tested cleaning scripts and functions using pytest and use these functions in your notebooks and scripts. You can even build simple recommendation engines using libraries such as Scikit Learn! As a part of this talk we will walk through the process of data analysis, data cleaning, feature preparation, and building a simple movie recommendation engine. As we move through those steps, my main focus is to teach engineers how they can incorporate Test-Driven Development into the data cleaning process and the building of our engine. I will also walk through strategies for data analysis and explain at a high level a couple ML concepts that we can use. As participants get the chance to see live examples of how to use Test Driven Development in data analysis and machine learning they can get a handle on some core concepts and learn how to ensure quality in the code that they produce..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/37", "_split_id": 0 }
[ "content" ]
null
null
97908b90ea0922e2ebaef061998251c3
Talks: Reconciling Everything Saturday - April 22nd, 2023 12:15 p.m.-12:45 p.m. in Presented by: Andrew Godwin Experience Level: Some experience Description Queues. The backbone of distributed systems, our old friends that we can rely on, and the cause of a lot of grief and on-call worries as they inevitably back up, overflow, replay, or duplicate items. There is a different (and sometimes better) way to build distributed systems, though - the reconciliation loop, a system where stateless programs talks to a central datastore and try to progress the state in small, incremental actions. We'll take a look at what reconciliation loops are, exactly, how they compare to both queues and other distributed system messaging options, and then dive into their active use as part of the Takahē ActivityPub/Fediverse server - and see the good, the bad, and the strange behaviours that can result..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/106", "_split_id": 0 }
[ "content" ]
null
null
b9d4923957ebe2a04526b48d75aa3c60
Sponsor Presentations: Developing on Google Cloud with Python and DataFrames (Sponsor: Google) Thursday - April 20th, 2023 9:30 a.m.-10:30 a.m. in Presented by: Jason Davenport Description Learn how Google Cloud is creating a better Python experience for developers interested in building applications, pipelines, and analytics. This session will cover how developers can use Python with BigQuery, and what's new for developers for DataFrame support in Google Cloud, and ways you can extend these techniques to make great applications or analyses for business impact..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/161", "_split_id": 0 }
[ "content" ]
null
null
98ba57ab23c6ac83922593b2e864997e
Talks: Reproducible molecular simulations with Python Sunday - April 23rd, 2023 1:45 p.m.-2:15 p.m. in Presented by: Iván Pulido Experience Level: Some experience Description In this talk the audience will be briefly introduced to the field of molecular dynamics simulations and its challenges. Special attention will be given to how the features found in Python and its scientific ecosystem are boosting the research in the area, especially in times where Machine Learning and AI methods are revolutionizing the field. Examples using the OpenMM and its ecosystem (openmmtools, perses, among others) will be featured..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/118", "_split_id": 0 }
[ "content" ]
null
null
38da2befcfd0c0eaf2e4851c5f71622c
Sponsor Presentations: Joyful Django DX with PyCharm (Sponsor: JetBrains) Thursday - April 20th, 2023 3:30 p.m.-4:30 p.m. in Presented by: Paul Everitt Description Django and Python make fullstack and API web projects a breeze. But as Python has matured, significant tooling has risen to improve the development experience (DX). Can you use this tooling, in a modern editor and IDE, to stay in the flow and make your development…joyful? In this session we’ll put PyCharm to work, at helping us work. Navigation, refactoring, autocomplete – the usual suspects. We’ll also see “test-first” development to stay in the IDE, plus how this can apply to frontends. Finally, we’ll follow along with topic’s from Adam Johnson’s book “Boost Your Django DX”, with a surprise at the end..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/157", "_split_id": 0 }
[ "content" ]
null
null
77a3d12ebf91a0a473101dfeb7949e3d
Sponsor Presentations: Accelerate your workflow from local Python prototype to the cloud (Sponsor: Microsoft) Thursday - April 20th, 2023 1:30 p.m.-2:30 p.m. in Presented by: Savannah Ostrowski Description Have you ever struggled taking a Python application from your local machine to the cloud? Had a hard time figuring out what infrastructure you need or how to configure it for your app? Spent too much time researching how to set up your local development environment for cloud development? Learn how to use real-world cloud development application templates via CLI to go from local development environment to the cloud. Scaffold your application, provision resources, deploy code, monitor your application health, and set up a CI/CD pipeline, all in a couple of steps and just a few minutes..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/154", "_split_id": 0 }
[ "content" ]
null
null
432130383f9df3b159a70ccc0918c065
Talks: The magic of Scipy Spatial Data Structures - Think beyond machine learning Friday - April 21st, 2023 1:30 p.m.-2:15 p.m. in Presented by: Deepak K Gupta Experience Level: Advance experience Description Today machine learning algorithms (e.g. KNN et. al) seem to be the obvious choice for any problems related to and manipulation of nearest data points. Even though ML algorithms are appropriately suitable for this purpose, many of the problems can also be solved by using spatial triangulation concepts like Delaunay, Voronoi, etc. These concepts can be implemented as data structures and we have that as part of SciPy spatial library. Using SciPy data structures reduced the complexities associated with using ML algorithms like training, etc, thereby reducing the time it takes to implement the same. It also requires less CPU and Memory Resources to do its work. The lack of awareness about the spatial triangulation concepts and the availability of SciPy libraries for the same, developers, end up using ML algorithms as a one stop solution which may or may not be required. Welcome to this talk on SciPy spatial data structures, where you’ll not only understand the algorithms used in modern day network infrastructure, but will also be able to see them in action online. By the end of this talk, you’ll know enough to make an informed decision about using ML algorithms Vis-a-vis SciPy Spatial Data Structures The presentation as well as the codes will be shared by GitHub Page post session..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/34", "_split_id": 0 }
[ "content" ]
null
null
d6f35ea9d52f10135377bc1a83f265d8
Charlas: Interfaces Low-code con QT y su integración con Python. Saturday - April 22nd, 2023 3:15 p.m.-3:45 p.m. in Presented by: Daniel Hernández Méndez Experience Level: Some experience Description Esta charla tratara de como diseñar interfaces low-code del framework QT de manera visual, por medio de Qt Designer, y como transformar los archivos generados por este programa (.UI) a código Python (.py), sí que existe necesidad de modificar algo a nivel de código, o simplemente integrar estos archivos UI, con el código Python, por medio de un ejemplo de una aplicación control de desempeño empresarial, programada 100% en Python. La charla esta dedicadas a todas esas personas, que como yo necesitamos tener el control de las interfaces totalmente visual, que le dificulta mucho programar a nivel de código dichas interfaces (por tema de control de pixeles, botones, funcionalidades, etc). La charla será, para todo tipo de público, debido a la utilización de poco código, para tener resultados satisfactorios, pero igual se incluirá, modificaciones de esté para usuarios un poco mas avanzados..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/90", "_split_id": 0 }
[ "content" ]
null
null
92215a09d52b4b045ebf205e2d6a03c8
Talks: Inside your web framework: intro to the ASGI spec, middleware and apps Saturday - April 22nd, 2023 10:45 a.m.-11:15 a.m. in Presented by: Adrian Garcia Badaracco Experience Level: Some experience Description What do FastAPI and Django have in common? They both use ASGI under the hood. ASGI, which stands for Asynchronous Server Gateway Interface, is a specification and API for asynchronous, event-driven web applications. The goal of this talk is to peel back the curtain on the internals of this specification and empower you to debug ASGI apps, write custom ASGI middleware, and simplify application lifecycles and serving. We will begin by discussing the basics of the ASGI specification and how it works. Then, we will move on to writing a simple ASGI app using pure, hand-crafted Python, without any frameworks or libraries. After that, we will cover ASGI middleware, which is a powerful tool that allows us to modify the behavior of our ASGI apps without changing the underlying code. We will show how to write custom middleware and how to use it to add features such as authentication or request body processing. Finally, we will discuss the serving of ASGI applications, focusing on how to use Uvicorn programmatically and take control of your event loop..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/5", "_split_id": 0 }
[ "content" ]
null
null
8a69a49974340a11bc571ff44a6998c6
Charlas: Simulaciones moleculares reproducibles con la ayuda de Python Saturday - April 22nd, 2023 5 p.m.-5:30 p.m. in Presented by: Iván Pulido Experience Level: Some experience Description 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)..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/117", "_split_id": 0 }
[ "content" ]
null
null
ac92941aa60eb43440f6afe84a08cc2d
Sponsor Presentations: Modern, typed Python for (multimodal) ML: From training to deployment (Sponsor: Jina.ai) Thursday - April 20th, 2023 9:30 a.m.-10:30 a.m. in Presented by: Johannes Messner Description Typing is at the center of „modern Python“, and tools (mypy, beartype) and libraries (FastAPI, SQLModel, Pydantic, DocArray) based on it are slowly eating the Python world. This talks explores the benefits of Python type hints, and shows how they are infiltrating the next big domain: Machine Learning Target audience: Mainly machine learning practitioners that care about improving their code quality and making use of the ever evolving Python ecosystem. This includes people that focus on model training as well as people that focus on model deployment and serving. The secondary target audience is anyone that likes to know more about Python type hints and how they can be helpful in their code base. Intended takeaways: The audience should leave the talk with three main learnings: - Why Python type hints are useful - Why they are particularly useful in the ML domain - How they can leverage libraries like DocArray in practice Preliminary outline: The talk can be seen as two parts: Part 1: Typing in Python - min 0-5: Introduction - min 5-15: Typing and type hints in Python: Short history, and why is it useful? - min 25-25: Tool landscape: Type checkers (mypy, beartype) and other libraries (Pydantic, FastAPI) Part 2: Python type hints in ML - min 25-40: Why is typing useful in ML? Tensor shapes, multi-modal data, and more - min 40-60: How to get the most out of typing focused tools for ML: jaxtyping and DocArray - How to organize your data using type hints - How to keep track of your tensor shapes using type hints - How to bridge the gap between training and deployment thanks to typing focused libraries.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/131", "_split_id": 0 }
[ "content" ]
null
null
baa935ba669f8994f54cad6a7a364759
Sponsor Presentations: Fixing legacy code, one pull request at a time (Sponsor: Sonar) Thursday - April 20th, 2023 9:30 a.m.-10:30 a.m. in Presented by: Guillaume Dequenne Description Dealing with legacy codebases can be a chore. In this workshop, we talk about modernizing an old Flask application one pull request at a time while incorporating Python best practices. We will talk about how to integrate Code Quality tools in your workflow and in your IDE, so that every pull request is checked to good standards. By the end of this Workshop, we hope everyone can set up a workflow that removes technical debt over time and makes their codebases sustainable..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/139", "_split_id": 0 }
[ "content" ]
null
null
61e3e7c026418c5c002f77c7ef87b657
Tutorials: Feature Engineering is for Everyone! Wednesday - April 19th, 2023 1:30 p.m.-5 p.m. in Presented by: Leah Berg Ray Experience Level: Just starting out Description In Machine Learning, features are the inputs for a machine learning model. Feature Engineering is the process of creating features from raw data and selecting the best features for a model. However, it is not just a tool for Data Scientists - Data Analysts and Developers can use it too. In this tutorial, we will create features that can be used for creating Data Visualizations, Rules Based Automations, and Machine Learning Models. Attendees will learn how to explore, create and select features from various data types such as “discrete/categorical” and “continuous” data. Attendees will learn techniques such as One-hot encodings for categories, text vectorization, date manipulation and more. By the end of this tutorial, attendees will understand how to create features for their projects..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/76", "_split_id": 0 }
[ "content" ]
null
null
dfe147ddcfe11adbe7730fe728e44557
Talks: Into the Logisticverse: Improving Efficiency in Transportation Networks using Python Friday - April 21st, 2023 11:30 a.m.-noon in Presented by: Uzoma Nicholas Muoh Experience Level: Some experience Description When we think about what Python is for, we often think of things like analytics, machine learning, and web apps but python is a workhorse that plays a tremendous and often invisible role in our day-to-day lives, from medicine to finance, and even the transportation of goods from manufacturers to the shelves of our neighborhood stores. Transportation networks are highly dynamic, goods are always moving from point A to point B and money every minute is being gained or lost. Improving efficiency in a transportation network is critical to the survival of a business that provides transportation and distribution services as well as ensuring timely delivery of goods to customers. This talk examines 3 real-world examples of how Python is used to improve the efficiency of transportation networks, particularly we will explore: Finding the optimal match between a driver and a load at the lowest possible cost using pywrapgraph. Generating recommendations for macro level optimizations to a transportation network using networkX. Helping the descision making process by answering the question "Should I accept this work?" using skfuzzy. Key Takeaways: Graph analytics and data science concepts that facilitate getting goods from manufacturers to stores more efficiently and at a lower cost to businesses. An appreciation of the complexity of the logistics industry and the role Python plays in making the life of drivers better..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/61", "_split_id": 0 }
[ "content" ]
null
null
3c0f537fdbe4bff6ed7eba70fbd75e6a
Talks: Python Linters at Scale Saturday - April 22nd, 2023 10:45 a.m.-11:15 a.m. in Presented by: Jimmy Lai Experience Level: Just starting out Description 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..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/101", "_split_id": 0 }
[ "content" ]
null
null
3c8615a3a92428cce2bfc97d852ffaa
Tutorials: Streamlit for Python - How to create beautiful interactive GUIs and web apps Wednesday - April 19th, 2023 1:30 p.m.-5 p.m. in Presented by: Lisa Carpenter Experience Level: Some experience Description In this 3.5 hour tutorial, attendees will learn how to use the streamlit library in Python to create interactive graphical user interfaces (GUIs) for their data science projects. Through a series of hands-on exercises, attendees will gain practical experience using streamlit to build and customize their own interactive GUIs. The tutorial will begin by introducing attendees to the basics of streamlit, including how to install and set up the library, as well as the key concepts and components of streamlit applications. Attendees will then learn how to use streamlit to create simple, yet effective, GUIs for their data science projects, including how to display and interact with data, add text and images, and create custom layouts and widgets. As the tutorial progresses, attendees will have the opportunity to work on more advanced topics, such as using streamlit to create custom interactive plots and charts, and integrating streamlit with other popular libraries such as Pandas and Altair. By the end of the tutorial, attendees will have a solid understanding of how to use streamlit to create effective and engaging interactive GUIs for their own data science projects. The tutorial will be led by an experienced data scientist with a strong background in Python and streamlit, and will include plenty of hands-on exercises to help attendees apply what they learn in a practical setting. Attendees will also have access to detailed tutorial materials and code samples, as well as support from the instructor and other attendees throughout the tutorial..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/45", "_split_id": 0 }
[ "content" ]
null
null
ec0cacdd293956773fd514ef995b136e
Tutorials: Beyond the Basics: Data Visualization in Python Wednesday - April 19th, 2023 1:30 p.m.-5 p.m. in Presented by: Stefanie Molin Experience Level: Some experience Description The human brain excels at finding patterns in visual representations, which is why data visualizations are essential to any analysis. Done right, they bridge the gap between those analyzing the data and those consuming the analysis. However, learning to create impactful, aesthetically-pleasing visualizations can often be challenging. This session will equip you with the skills to make customized visualizations using Python. Section 1: Getting Started With Matplotlib While there are many plotting libraries to choose from, the prolific Matplotlib library is always a great place to start. Since various Python data science libraries utilize Matplotlib under the hood, familiarity with Matplotlib itself gives you the flexibility to fine tune the resulting visualizations (e.g., add annotations, animate, etc.). Moving beyond the default options, we will explore how to customize various aspects of our visualizations. Afterward, you will be able to generate plots using the Matplotlib API directly, as well as customize the plots that other libraries create for you. Section 2: Moving Beyond Static Visualizations While static visualizations are limited in how much information they can show, animations make it possible for our visualizations to tell a story through movement of the plot components (e.g., bars, points, lines), which can encode another dimension of the data. In this section, we will focus on creating animated visualizations before moving on to create interactive visualizations in the next section. Section 3: Building Interactive Visualizations for Data Exploration When exploring our data, interactive visualizations can provide the most value. Without having to create multiple iterations of the same plot, we can use mouse actions (e.g., click, hover, zoom, etc.) to explore different aspects and subsets of the data. In this section, we will learn how to use HoloViz to create interactive visualizations for exploring our data utilizing the Bokeh backend..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/17", "_split_id": 0 }
[ "content" ]
null
null
d83487011c4c74aa43751c885652e619
Talks: Using Python and PyQgis to make cool maps Friday - April 21st, 2023 4:15 p.m.-4:45 p.m. in Presented by: Samweli Mwakisambwe Experience Level: Some experience Description QGIS is a freely downloadable open source GIS software suite that contains a desktop option, mobile, and web component. QGIS is free to download and use, it is released with a GPL v3 license which is a non commercial license allowing users to download and use it without concerns compared to other commercial GIS software. QGIS core support in creating different types of maps, thanks to the recent features updates QGIS version 3.14 was released with a Temporal Controller feature that is responsible for handling all the temporal layers inside QGIS. Temporal support was added in the core part of QGIS hence users can now easily create animation maps from temporal location datasets inside QGIS without any additional plugin. QGIS has scripting support using Python language, it also allows enhancement to its functionality through plugins that are written using Python language. This usage of the Python language in QGIS (PyQgis) is achieved by using SIP and PyQt. Through the bindings QGIS has exposed its core functionality via PyQgis API that can be used to create standalone python applications that can use QGIS features in making maps. The aim of this talk will be to showcase how one could use Python and QGIS to build map animations from temporal location data using the QGIS Temporal Controller Python API. The session will also provide a guide on PyQgis Temporal API, python scripting inside QGIS, how to build standalone python applications and how to create QGIS python plugins that can help in making maps. The talk is aimed at Python geospatial programmers and anyone looking to learn how to use open source tools in analyzing location data. Expecting to raise the participant's awareness and value about the work done and on the open source tools used in the geospatial field..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/96", "_split_id": 0 }
[ "content" ]
null
null
be41df58c5714eaa34893e2c7c10a26d
Talks: Three Musketeers: Sherlock Holmes, Mathematics and Python Sunday - April 23rd, 2023 1 p.m.-1:30 p.m. in Presented by: Gajendra Deshpande Experience Level: Some experience Description Mathematics is a science and one of the most important discoveries of the human race on earth. Math is everywhere and around us. It is in nature, music, sports, economics, engineering, and so on. In our daily life, we use mathematics knowingly and unknowingly. Many of us are unaware that forensic experts use mathematics to solve crime mysteries. In this talk, we will explore how Sherlock Holmes, the famous fictional detective character created by Sir Arthur Conan Doyle uses Mathematics and Python programming language to solve crime mysteries. We will solve simple crime puzzles using mathematics and python scripts. Finally, we will solve a few complex hypothetical crime mysteries using advanced python concepts. The participants will learn how to use the concepts of mathematics such as statistics, probability, trigonometry, and graph theory, and python and its packages such as SciPy, NumPy, and Matplotlib to solve the crime puzzles..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/126", "_split_id": 0 }
[ "content" ]
null
null
4f809cda27eaa777b3c771f87494b299
Talks: How To Monitor and Troubleshoot Applications in Production using OpenTelemetry Friday - April 21st, 2023 10:45 a.m.-11:15 a.m. in Presented by: Ron Nathaniel Experience Level: Just starting out Description OpenTelemetry is a free, open-source Observability Protocol. OpenTelemetry sits at the application layer, and exports Traces, Metrics, and Logs to a backend for observing. It is extremely helpful and beneficial to developers in mean "time-to-detection" and "time-to-resolution" of bugs and issues that occur at the application layer; this ranges from detecting and alerting for errors raised (such as TypeError), to finding that a specific microservice (such as AWS Lambda) ran for twice as long as usual, all the way to seeing the output of a service and comparing it to the expected output to find a bug in the logic of the service. This talk is meant as a great eye-opening introduction into basic Monitoring and Troubleshooting code that may be running in a galaxy far, far away on a Cloud Provider’s computer. This talk is geared towards complete beginners to the Monitoring and Observability world, and to show them just how easy it is to get set up and running. No OpenTelemetry or otherwise experience is needed, just a basic understanding of Python syntax to read and understand the minimal code changes required for OpenTelemetry..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/75", "_split_id": 0 }
[ "content" ]
null
null
1f89e55038b4911b0d322fe63c57e9f0
Charlas: Introducción a FastAPI Friday - April 21st, 2023 4:15 p.m.-4:45 p.m. in Presented by: Sebastián Ramírez Experience Level: Just starting out Description (English version below) Aprende a hacer una API lista para producción en muy poco tiempo usando FastAPI... explicado con memes. Con documentación y validación de datos automáticas, basada en estándares, alto desempeño y otras ventajas. Además, puedes escribir todo el código con autocompletado y chequeos de errores de tipos, incluso para tus propios datos. En esta charla verás de qué se trata FastAPI, qué beneficios te da y por qué sería útil para ti. También verás cómo declarar datos para recibir en cada request (cada mensaje HTTP), usando tipos de Python estándar. Incluyendo parámetros en el path, en queries, y en cuerpos (body) de mensajes. También verás cómo declarar cuerpos de mensajes complejos con datos muy anidados. Y así, aún con código muy simple, tener documentación para todo tu API, serialización (conversión de datos) y validación, todo siguiendo estándares, y todo automáticamente. Learn how to create an API ready for production in very little time using FastAPI... explained with memes. Your API will have automatic validation, documentation based on standards, high performance, and several other features. All this, having editor support including autocompletion everywhere. In this talk you will learn what FastAPI can do, and how it could benefit you. You will see how to declare the data you want to receive in each request using standard Python type annotations. Including path parameters, query parameters, body payloads with JSON, etc. You will also see how to use simple, standard, Python type annotations to declare complex JSON body payloads with deeply nested structures, and get automatic data validation, serialization, and documentation..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/18", "_split_id": 0 }
[ "content" ]
null
null
3997705ca45de7990f62a5eabe267ac9
Tutorials: Introduction to Decorators: Power Up Your Python Code Thursday - April 20th, 2023 1:30 p.m.-5 p.m. in Presented by: Geir Arne Hjelle Experience Level: Some experience Description You can use decorators in your Python code to change the behavior of one or several functions. Many popular libraries are based on decorators. For example, you can use decorators to register functions as web endpoints, mark functions for JIT compilation, or profile your functions. Using decorators makes your code simpler and more readable. However, to unlock the full capability of decorators, you should also be comfortable writing your own. In this tutorial, you'll learn how decorators work under the hood, and you'll get plenty of practice writing your own decorators. You'll be introduced to necessary background information about how functions are first-class objects in Python and how you can define inner functions. You'll learn how to unwrap the @decorator syntactic sugar and how to write solid decorators that you can use in your code. Being comfortable with using and creating decorators will make you a more efficient Python programmer..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/121", "_split_id": 0 }
[ "content" ]
null
null
1f585af06e2ce6e5526ccda991692448
Tutorials: Comprehending comprehensions Wednesday - April 19th, 2023 1:30 p.m.-5 p.m. in Presented by: Reuven M. Lerner Experience Level: Just starting out Description Comprehensions are one of the most important — and misunderstood — parts of Python. In this tutorial, I'll walk you through comprehensions, including how to write them, and why you would want to do so. By the time you finish this tutorial, you'll fully understand list, set and dict comprehensions, as well as nested comprehensions and generator expressions. You'll understand the differences between regular "for" loops and comprehensions, and where to use them..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/38", "_split_id": 0 }
[ "content" ]
null
null
17697fb4cf68b2ae93fd2b7763029918
Tutorials: Writing Serverless Python Web Apps with PyScript Wednesday - April 19th, 2023 1:30 p.m.-5 p.m. in Presented by: Ted Patrick Experience Level: Some experience Description Python web applications running in the browser or mobile without a Server? What seemed to be a dream just a few months ago is not possible thanks to PyScript. It is now possible to write websites, apps, and games running entirely on the browser. This Tutorial is an introduction to PyScript and will walk you through learning about basic concepts, how to set up your project and create amazing applications. More specifically: - Create your project configuration - Define a python environment with all the dependencies to run your code - Loading and manipulating with user data - Writing your python code - Accessing the DOM and other browser features - Using Javascript libraries from your Python application - Optimizing your application - Look at what’s different between “standard” python vs. Python on the browser - Have a lot of fun and hack together on your ideas!.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/102", "_split_id": 0 }
[ "content" ]
null
null
e7df53834d26ced59e82ff5bd231e861
Talks: What's old is new again: using Python's import machinery to handle API deprecations Sunday - April 23rd, 2023 1 p.m.-1:30 p.m. in Presented by: Ludovico Bianchi Experience Level: Some experience Description For any software project with an established user base, introducing breaking changes in its API can be daunting. To minimize disruptions for users, projects are incentivized to plan these transitions carefully, which may include API deprecations, where messages warning users of upcoming changes are added to the affected APIs while they’re still functional. However, this imposes extra workload for the project’s maintainers, as both old and new versions of the API must be kept functional throughout the transition period. As a maintainer of a software project undergoing preparations for a major version release, I recently found myself in a similar situation: our goal was to provide backward compatibility with the previous version for as long as possible, without impacting the development of new features. Practically, this included dealing with a radical restructuring of the Python codebase, resulting in hundreds of modules being relocated, split, or removed. Was there any way to ensure that the deprecated import paths could still be used without errors, without having to maintain two separate versions of the package? Fortunately, the answer to “can you do that in Python?” is more often than not “yes!”; for this particular case, the path to success turned out to be through the importlib package of the standard library. For something so close to Python’s internals, importlib is both accessible and extensible, allowing ordinary code to customize almost completely how and what modules can be imported---including modules that are not there anymore! This intermediate-level talk will present a complete solution based on Python’s importlib machinery that allows to redirect modules or module attributes with deprecations in a simple, robust, and scalable way. While the context of the solution is especially relevant for project maintainers, the focus is on importlib techniques that are generally applicable..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/128", "_split_id": 0 }
[ "content" ]
null
null
89f0e23f973662e74f5d54180ddfc6a8
Tutorials: Intro to Hugging Face: Fine-tuning BERT for NLP tasks Wednesday - April 19th, 2023 9 a.m.-12:30 p.m. in Presented by: Juhi Chandalia Dana Engebretson Experience Level: Advance experience Description You’ve heard about ChatGPT’s conversational ability and how DALL-E can create images from a simple phrase. Now, you want to get your hands dirty training some state of the art (SOTA) deep learning models. We will use Jupyter notebooks to fine-tune an NLP model based on BERT to do sentiment analysis. In this hands-on tutorial, we will learn about using HuggingFace models from pre-trained open-source checkpoints and adapting these models to our own specific tasks. We will see that using SOTA NLP and computer vision models has been made easier with a combination of HuggingFace and PyTorch. At the end of this session, you will know how to fine-tune a large public pre-trained model to a particular task and have more confidence navigating the deep learning open source landscape..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/103", "_split_id": 0 }
[ "content" ]
null
null
e573137cef30ca2b00f52f5f1382dfc3
Sponsor Presentations: Python & Bloomberg: An Open Source Duo (Sponsor: Bloomberg) Thursday - April 20th, 2023 11:30 a.m.-12:30 p.m. in Presented by: Pradyun Gedam Bernat Gabor Laszlo Kiss Kollar Mario Corchero Description Join this talk where we will briefly introduce Bloomberg and have some of our engineers discuss their engagement in the Python Open Source ecosystem. We will also present some exciting troubleshooting tools that are widely used at Bloomberg that we are publishing as open source. You will leave this talk having learned about the technical details and new features related to these open source tools, which you might use daily in the future!.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/132", "_split_id": 0 }
[ "content" ]
null
null
ff16a7949c5a214a82912d58e9469cd5
Talks: How memory profilers work Saturday - April 22nd, 2023 1:45 p.m.-2:15 p.m. in Presented by: Pablo Galindo Salgado Experience Level: Some experience Description These days, it is very easy for applications to run out of memory due to the vast amounts of data they need to process. While Python makes it very easy to get something up and running, the highly dynamic nature of the language abstracts memory management away from us and makes it very difficult to understand what is going on when we run out of memory or when we have memory leaks. This is where memory profilers come into play. Memory profilers are tools that allow us to understand how our applications are using memory. Not only can they help us diagnose why our programs are using so much memory, but also they can also help us optimize our code to be faster by using smarter allocation patterns. Being able to understand how to use memory profilers effectively is an essential skill for any Python developer, especially those working on programs that involve the transformation of large amounts of data, large-scale applications, or long-running processes. This talk will cover the basics of memory profilers, how they work, and how to use them effectively. We will cover the different types of memory profilers, the different kinds of allocations a Python program can perform, and how to use memory profilers effectively to understand what is going on in our programs..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/91", "_split_id": 0 }
[ "content" ]
null
null
c8404b48dc68f9a3fc61438e95589df7
Tutorials: Publishing your Python project, the conda way Thursday - April 20th, 2023 9 a.m.-12:30 p.m. in Presented by: Dave Clements Mahe Iram Khan Valerio Maggio Experience Level: Some experience Description Conda is an open source, language agnostic package and environment management system for Linux, macOS, and Windows. The conda ecosystem, including the conda-forge package repository, is widely used to install, run and update packages and their dependencies. In this tutorial you will learn how to create a full-fledged and easy to install Python software package using conda. We will start by introducing software packaging and packaging concepts (package dependencies, open source licensing, ...), and an introduction to the conda ecosystem and how conda implements software packaging. Most of our time will be spent doing a hands-on walk through of how to prepare a Python software package for conda, and then how to submit that package to the conda-forge, a widely used community driven package repository. The workshop is a hands-on workshop, where participants use their own laptops to prepare a full-fledged Python software package that is submission-ready for the conda-forge package repository. Participants need to bring a WiFi enabled laptop with a web browser, a command line interface, a text editor program, and git and/or a GitHub client already installed. Workshop participants will gain a basic understanding of software packaging, and how to prepare and publish their packages in the conda ecosystem..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/94", "_split_id": 0 }
[ "content" ]
null
null
7debf27fa1ac4177c8691670b88db525
Charlas: XGBoost para clasificación: construyendo modelos precisos y eficientes Saturday - April 22nd, 2023 1:45 p.m.-2:15 p.m. in Presented by: Laura Funderburk Experience Level: Some experience Description En esta charla, nos centraremos en el uso de XGBoost para problemas de clasificación. Comenzaremos explicando los conceptos básicos de la clasificación y cómo difiere de la regresión. Luego, demostraremos cómo usar XGBoost para construir y evaluar modelos de clasificación, y discutiremos algunas de las características y ventajas clave de XGBoost para tareas de clasificación. Al final de la charla, los asistentes tendrán una comprensión sólida de cómo usar XGBoost para construir modelos de clasificación precisos y eficientes..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/44", "_split_id": 0 }
[ "content" ]
null
null
a44ebe694a416f1e1a20e5bb0e9019db
Charlas: Jaguares y serpientes Saturday - April 22nd, 2023 12:15 p.m.-12:45 p.m. in Presented by: Nicole Franco Leon Experience Level: Just starting out Description ¿Es posible juntar la necesidad de conservar al jaguar y usar Python como herramienta para lograrlo? Sí, gracias a los procesos de telemetría, nos podemos permitir hacer el seguimiento de individuos a distancia brindando información imposible de recopilar en primera persona, tales como geoposición, velocidad, frecuencia cardiaca, temperatura corporal y altitud, entre otras. Pero te preguntarás en donde entra Python en todo esto, es por ello, que en esta charla aprenderemos a como condensar, categorizar, y cuestionar los diferentes datos del dominio ambiental a un modelo entendible para los humanos y que sea capaz de ser procesado por Python. Usaremos ArcPy (Paquete de Python para ejecutar funciones de índole geográfico dentro de ArcGis Pro) para procesar los datos obtenidos mediante la telemetría y realizar análisis geográficos que nos permitirán entender el comportamiento del jaguar y si es posible su conservación. Si lo tuyo son los animales, Python y un poco de conservación, esta charla es un buen punto de inicio..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/116", "_split_id": 0 }
[ "content" ]
null
null
3b8a068a8a86bb81f0d9f63aa06500e6
Charlas: Orcha 🐳: Procesamiento Masivo Paralelo (MPP) y diseño de APIs Saturday - April 22nd, 2023 11:30 a.m.-noon in Presented by: Javier Alonso Miguel Robledo Experience Level: Advance experience Description El CI es fundamental en el desarrollo de productos hoy en día y uno de sus pilares básicos es la ejecución de tests. Sin embargo, a medida que el producto madura la cantidad de tests aumenta y con ello el tiempo que tardan en completarse. Para tener feedback lo antes posible, ¿cómo se maquetan las pruebas de forma eficiente? El problema es aún más acusado cuando se cuenta con multitud de dispositivos y versiones en desarrollo. En particular, con dos servidores distriubyéndose carga de tests, el tiempo total de ejecución alcanzaba las 15 horas probando únicamente dos versiones. Es imperativo contar con una herramienta que permita paralelizar las pruebas de forma masiva, aprovechando al máximo los recursos disponibles. Además, es necesario que dicha herramienta sea lo suficientemente flexible como para soportar la infraestructura actual y permita expandir el tipo de infraestrucuras de tests. En esta charla vamos a explorar el diseño de Orcha (la herramienta de orquestración), la API para extender su funcionalidad y la necesidad de tener un usuario dedicado. La charla está orientada a usuarios intermedio-avanzados con familiaridad con el módulo multiprocessing..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/23", "_split_id": 0 }
[ "content" ]
null
null
c57f030b28d5d9a1f173f64a046cd7e2
Tutorials: You CAN teach an old doc new tricks: Automate your project documentation using Sphinx & GitHub Actions Thursday - April 20th, 2023 1:30 p.m.-5 p.m. in Presented by: Olga Matoula Aya Elsayed Experience Level: Some experience Description You've built an awesome API; time to give it some exposure! But, how do you keep a documentation website up-to-date as your code evolves? This tutorial will teach you how to write, generate, host, automate and version your documentation easily so it becomes part of your software development life cycle..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/62", "_split_id": 0 }
[ "content" ]
null
null
eaa40a9cf447abff60d7f2381b3a37f3
Talks: Getting Around the GIL: Parallelizing Python for Better Performance Sunday - April 23rd, 2023 1 p.m.-1:30 p.m. in Presented by: Alireza Farhidzadeh Experience Level: Some experience Description One of the ever-present banes of a data scientist’s life is the constant wait for the data processing code to finish executing. Slow code affects almost every step of a typical data pipeline: data collection, data pre-processing/parsing, feature engineering, etc. Many times, the lengthy execution times force data scientists to work with only a subset of data, depriving him/her of the insights and performance improvements that could be obtained with a larger dataset. One of the tools that can mitigate this problem and speed up data science pipelines (and CPU-bound programs) is parallelization. Parallelization is a useful way to work around the limitations of the Global Interpreter Lock (GIL), a key feature of Python that prevents code from fully utilizing multiple processor cores and can impact performance. In this session, we’ll walk through several ways to parallelize Python code, depending on the specific needs of your program and the type of parallelism you want to achieve..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/147", "_split_id": 0 }
[ "content" ]
null
null
b6b06d5a9876b58403e878fdbe9560ff
Sponsor Presentations: From Closed to Open: The Journey of Enabling Next Scale Development using Python and Open Source at Ansys (Sponsor: Ansys) Thursday - April 20th, 2023 11:30 a.m.-12:30 p.m. in Presented by: Alexander Kaszynski Description Four years ago, our company embarked on a journey to expose APIs from our products. After evaluating two strategies, we chose the open source and managed decentralized approach, which has now grown into a company-scale project. In this talk, we will discuss our journey of transitioning from a monolithic and centralized development approach to a decentralized development process using common tools, including a common documentation theme, GitHub actions, styling and automation. We will also delve into how we balance developer autonomy with guardrails such as pre-commit, auto-code formatting, and flake8. At the heart of this journey, we learned that the fundamental problem is never the technology; it's the culture. By embracing open source and decentralization, we were able to unlock new levels of collaboration, productivity, and innovation within our company. Join us for a thought-provoking presentation on how you can integrate Python and open source into your closed source company and reap the benefits of a more collaborative and productive development process..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/135", "_split_id": 0 }
[ "content" ]
null
null
eeb56b42b74580ee22f03ffbeceeaba0
Talks: Python Meets UX: Enhancing User Experience with Code Saturday - April 22nd, 2023 11:30 a.m.-noon in Presented by: Neeraj Pandey Aashka Dhebar Experience Level: Just starting out Description The intersection of UX and Python programming is a powerful combination for building great products and enhancing user experience. Python is a versatile and popular programming language that is widely used for a variety of tasks, including web development, data analysis, and machine learning. UX, or user experience, is the process of designing products that provide a seamless and intuitive experience for users. Learn about this powerful intersection of UX design and Python programming by understanding how Python can be used to enhance the user experience and provide practical examples on how UX designers can automate tasks, gather and analyze data, develop personalized experiences, and continually improve their own skills and processes..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/109", "_split_id": 0 }
[ "content" ]
null
null
7e25f6bbbcb018a8d5ce7527e0004f71
Talks: Plug life into your codebase: Making an established Python codebase pluggable Saturday - April 22nd, 2023 11:30 a.m.-noon in Presented by: Bianca Henderson Experience Level: Some experience Description 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. DETAILED ABSTRACT What is a plugin? A “plugin” is a customization or extra feature that is compatible with and discoverable by a particular piece of software. It is not part of the default codebase nor is it necessarily distributed as a default part of the software itself. What is pluggy and how can it be used? The pluggy Python framework (used by other projects such as pytest, tox, and devpi) is a great tool for incorporating a new plugin system. It provides both developers and software users with the ability to extend or modify the behavior of a Python program by enabling function hooking so that you can build pluggable systems with minimal fuss. A real world example: Conda How did conda incorporate a new plugin system for new features and refactors? Because of how pluggy works, the conda team’s developers created plugins simply by defining “hooks” and registering the custom plugins under the “conda” entry point namespace. Conclusion: What other exciting things can be created with plugins? Functionalities such as: - Authentication and authorization - Different storage backends (e.g., S3 buckets, etc.) - Development environment integrations (e.g., different shells) - Programming language support - Code editor integrations …and more are all possible to implement via a plugin system!.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/66", "_split_id": 0 }
[ "content" ]
null
null
af445089ad6c9b1f858339dcb24ddb91
Talks: A Per-Interpreter GIL: Concurrency and Parallelism with Subinterpreters Friday - April 21st, 2023 3:15 p.m.-3:45 p.m. in Presented by: Eric Snow Experience Level: Some experience Description We live in a world of concurrent code and multi-core computing, so come learn about a new solution for both in Python 3.12. We'll quickly explain the new feature (and an old one), and then show you how to take advantage of it, for simpler concurrency and faster code..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/54", "_split_id": 0 }
[ "content" ]
null
null
7477bb005f923def85f0370982323ec
Tutorials: The How and Why of Object-oriented Programming in Python Thursday - April 20th, 2023 9 a.m.-12:30 p.m. in Presented by: Mike Müller Experience Level: Some experience Description Python supports multiple programming paradigms. You can write procedural programs, use functional programming features, or use the full power object-oriented programming. In this tutorial you will learn how to get the most out of object-oriented programming. After this tutorial you will able to: design you own objects take advantage of inheritance for code re-use implement special methods for pythonic objects convert programs from a procedural to a object-oriented approach This tutorial is based on a small but comprehensive example. Starting from a procedural solution with lists and dictionaries, the tutorial gradually introduces how to create own objects to solve the same problem. The next steps introduce the concepts of inheritance and special methods to take full advantage of object-oriented programming..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/69", "_split_id": 0 }
[ "content" ]
null
null
d9475e16423d1d43f970074705990295
Charlas: Biohacking con Python: cómo convertirse en el señor Burns fluorescente Saturday - April 22nd, 2023 4:15 p.m.-4:45 p.m. in Presented by: Marina Moro López Experience Level: Just starting out Description La charla abrirá con una breve introducción al biohacking, seguida por una mini clase (súper leve, lo prometo) de teoría genética con el propósito de entender perfectamente la metodología del caso práctico. Éste es el verdadero centro de la charla y consistirá en editar nuestro propio ADN con CRISPR (una herramienta de corte y empalme biológico) y un script de Python (que diseñará las secuencias genéticas necesarias para el experimento) para biohackearnos ciertos genes y convertirnos en el señor Burns fluorescente. Todo esto nos servirá para ver el tremendo potencial de la sinergia entre la ingeniería genética y Python, no sólo en ejemplos cómicos como el ya mencionado, sino también en el ámbito sanitario como tratamiento de enfermedades..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/14", "_split_id": 0 }
[ "content" ]
null
null
8aef9f2fbfa20894b5939bb30ab1ef0e
Tutorials: Exploring Eco topics with Python Thursday - April 20th, 2023 9 a.m.-12:30 p.m. in Presented by: Mx Chiin-Rui Tan Experience Level: Some experience Description From Deforestation to Illegal Wildlife Trade to Carbon Footprints, learn how to use Python to explore current Eco topics! As Earth's sustainability edges ever closer to tipping point, it has never been more important for us inhabitants to be aware of the impact we have on the environment, and the deteriorating state of our planet. This tutorial will democratize access to practical Python skills for the relevant sciences, applying these skills to pressing Eco issues, and ultimately empower non-subject experts with working proficiency of some open-source tools for discovering more facts about our natural world, at a time when disinformation is rife. Key Python takeaways: intro to and application of numpy, pandas, matplotlib, networkx, geopandas. Format: interactive computer lab, with attendees working hands-on through pre-prepared Jupyter Notebook content at a group pace led by the instructor. Audience: no prior Eco/Scientific domain knowledge or experience with the Python packages being taught required, but attendees must have basic Python programming proficiency and ability to set-up access to JupyterLab with the required mainstream dependencies (as per instructions provided in advance).
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/3", "_split_id": 0 }
[ "content" ]
null
null
e97377c8d5df8ff5cd8bc168b8b3ec5d
Talks: Argument Clinic: What Healthy Professional Conflict Looks Like Friday - April 21st, 2023 5 p.m.-5:30 p.m. in Presented by: Sumana Harihareswara Jacob Kaplan-Moss Experience Level: Community Presentation Description What does healthy disagreement look like? Many of us have never experienced healthy conflict at work, and so assume our only options are to either avoid conflict or have a nasty fight. But it doesn't have to be that way: professional disagreement can be direct without being nasty. We want to show what that looks like. In this model argument, presented as a play, watch two engineering managers disagree about something. How do they work through their disagreement -- politely and effectively? Watch our the characters figure out what they're really clashing about, learn about each other's perspectives, and come to a better decision than either could alone..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/10", "_split_id": 0 }
[ "content" ]
null
null
6ab742fbf4c6ccf9e3792d0b1afb5c42
Tutorials: Build a production ready GraphQL API using Python Wednesday - April 19th, 2023 9 a.m.-12:30 p.m. in Presented by: Patrick Arminio Experience Level: Some experience Description This workshop will teach you how to create a production ready GraphQL API using Python and Strawberry. We will be using using Django as our framework of choice, but most of the concept will be applicable to other frameworks too. We'll learn how GraphQL works under the hood, and how we can leverage type hints to create end to end type safe GraphQL queries. We'll also learn how to authenticate users when using GraphQL and how to make sure our APIs are performant. If we have enough time we'll take a look at doing realtime APIs using GraphQL subscriptions and how to use GraphQL with frontend frameworks such as React..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/70", "_split_id": 0 }
[ "content" ]
null
null
5c01b1a1ba24c0101374f2ff74983917
Talks: Consistency and isolation for Python programmers Friday - April 21st, 2023 12:15 p.m.-12:45 p.m. in Presented by: A. Jesse Jiryu Davis Experience Level: Some experience Description When you use a SQL database like Postgres, you have to understand the subtleties of isolation levels from "read committed" to "serializable". And distributed databases like MongoDB offer a range of consistency levels, from "eventually consistent" to "linearizable" and many options in between. Plus, non-experts usually confuse "isolation" with "consistency"! If we don't understand these concepts we risk losing data, or money, or worse. So what's the bottom line? Isolation: in a simple world, your database runs on one machine and executes each request one-at-a-time. In reality, databases execute requests in parallel, leading to weird phenomena called "anomalies". To see why anomalies happen, we'll look at Python code that simulates how a database executes operations. The various isolation levels make different tradeoffs between the anomalies they allow, versus the parallelism they can achieve. Consistency: distributed databases keep copies of your data on several machines, but these copies go out of sync. This leads to new anomalies: weird phenomena that reveal the out-of-sync data, and make your application feel like it's in a time warp. The various consistency levels make tradeoffs between anomalies versus latency. It depends how long you're willing to wait for your data changes to be synced across all the machines. Again, we'll look at a Python simulation to understand these anomalies. You don't need to know all the names and details of every consistency and isolation level. You can refer to this handy chart. And you don't need to read all the academic papers, but I'll name four or five that are worth your time. Now, make informed decisions about consistency and isolation, and use your database with confidence!.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/26", "_split_id": 0 }
[ "content" ]
null
null
3af3f190a68528c2238c9a9ddfb2e885
Talks: Trying No GIL on Scientific Programming Friday - April 21st, 2023 5 p.m.-5:30 p.m. in Presented by: Cheuk Ting Ho Experience Level: Some experience Description Last year, Sam Gross, the author of nogil fork on Python 3.9, demonstrates the GIL can be removed. For scientific programs which use heavy CPU-bound processes, it could be a huge performance improvement. In this talk, we will see if this is true and compare the nogil version to the original. In this talk, we will have a look at what is no-gil Python and how it may improve the performance of some scientific calculations. First of all, we will touch upon the background knowledge of the Python GIL, what is it and why it is needed. On the contrary, why it is stopping multi-threaded CPU processes to take advantage of multi-core machines. After that, we will have a look at no-gil Python, a folk of CPython 3.9 by Same Gross. How it provides an alternative to using Python with no GIL and demonstrates it could be the future of the newer versions of Python. With that, we will try out this version of Python in some popular yet calculation-heavy algorithms in scientific programming and data sciences e.g. PCA, clustering, categorization and data manipulation with Scikit-learn and Pandas. We will compare the performance of this no-gil version with the original standard CPython distribution. This talk is for Pythonistas who have intermediate knowledge of Python and are interested in using Python for scientific programming or data science. It may shine some light on having a more efficient way of using Python in their tasks and interest in trying the no-gil version of Python..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/31", "_split_id": 0 }
[ "content" ]
null
null
6427d085b8ae882c6f903fe856065525
Talks: Robyn: An async Python web framework with a Rust runtime Sunday - April 23rd, 2023 1:45 p.m.-2:15 p.m. in Presented by: Sanskar Jethi Experience Level: Some experience Description With the rise of Rust bindings being used in the Python ecosystem, we know that throughput efficiency is one of the top priority items in the Python ecosystem. Inspired by the extensibility and ease of use of the Python Web ecosystem and the increase of performance by using Rust as a core, Robyn was created. Robyn is one of the fastest Python web frameworks in the current Python web ecosystem. With a runtime written in Rust, Robyn achieves near-native rust performance while still having the ease of writing Python code. This talk will focus on the increased involvement of Rust in the Python ecosystem. It will also demonstrate why Robyn was created, the technical decisions behind Robyn, the increased performance by using the Rust runtime, how to use Robyn to develop web apps, and most importantly, how the community is helping Robyn grow! I will briefly demonstrate my experience and challenges of building a community around the project and how it allowed Robyn to ensure a smooth sail even in turbulent situations. I shall also share my future plans for Robyn..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/67", "_split_id": 0 }
[ "content" ]
null
null
dc4a00b460bc775387f3ef58a5f16feb
Talks: Inside CPython 3.11's new specializing, adaptive interpreter. Friday - April 21st, 2023 11:30 a.m.-noon in Presented by: Brandt Bucher Experience Level: Advance experience Description Python 3.11 was released on October 24th, bringing with it a new "specializing, adaptive interpreter". As one of the engineers who works on this ambitious project, my goal is to introduce you to the fascinating way that your code now optimizes itself as it's running, and to explore the different techniques employed under-the-hood to make your programs 25% faster on average. Along the way, we'll also cover many of the challenges faced when optimizing dynamic programming languages, some of the tools you can use to observe the new interpreter in action, and what we're already doing to further improve performance in Python 3.12 and beyond..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/6", "_split_id": 0 }
[ "content" ]
null
null
9d08d2e30e764c08e691270334dba1c
Talks: The CPU in your browser: WebAssembly demystified Saturday - April 22nd, 2023 12:15 p.m.-12:45 p.m. in Presented by: Antonio Cuni Experience Level: Some experience Description 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..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/93", "_split_id": 0 }
[ "content" ]
null
null
cc66d351f5b8e3bd936c9489d447b348
Talks: Vectorize all the things! Using linear algebra and NumPy to make your Python code lightning fast. Saturday - April 22nd, 2023 4:15 p.m.-4:45 p.m. in Presented by: Jodie Burchell Experience Level: Some experience Description Have you found that your code works beautifully on a few dozen examples, but leaves you wondering how to spend the next couple of hours after you start looping through all of your data? Are you only familiar with Python, and wish there was a way to speed things up without subjecting yourself to learning C? In this talk, you'll see some simple tricks, borrowed from linear algebra, which can give you significant performance gains in your Python code, and how you can implement these in NumPy. We'll start exploring an inefficient implementation of an algorithm that relies heavily on loops and lists. Throughout the talk, we'll iteratively replace bottlenecks with NumPy vectorized operations. At each stage, you'll learn the linear algebra behind why these operations are more efficient so that you'll be able to utilize these concepts in your own code. You'll see how straightforward it can be to make your code many times faster, all without losing readability or needing to understand complex coding concepts..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/140", "_split_id": 0 }
[ "content" ]
null
null
6acae4b97654042bc1c0f5bc58b2b1e5
Tutorials: Data analysis with SQLite and Python Wednesday - April 19th, 2023 1:30 p.m.-5 p.m. in Presented by: Simon Willison Experience Level: Some experience Description SQLite is the world's most widely used database and has been a part of the Python standard library since 2006. It continues to evolve and offer more capabilities every year. This tutorial will transform you into a SQLite power-user. You'll learn to use SQLite with Python, level up your SQL skills and take advantage of libraries such as sqlite-utils and tools such as Datasette to explore and analyze data in all kinds of shapes and sizes. This hands-on tutorial will cover: The sqlite3 module in the Python standard library A review of SQL basics, plus advanced SQL features available in SQLite Using sqlite-utils for advanced manipulation of SQLite databases Datasette as a tool for exploring, analyzing and publishing data Applying the Baked Data architectural pattern to build a data application using Datasette and deploy it to the cloud This tutorial is aimed at beginner-to-intermediate Python users with some previous exposure to basic SQL. Attendees will leave this workshop with a powerful new set of tools for productively exploring, analyzing and publishing data..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/120", "_split_id": 0 }
[ "content" ]
null
null
53188f2457bc69ecaa2b508fd6c5ab8a
Talks: Pyscript for Education Saturday - April 22nd, 2023 10:45 a.m.-11:15 a.m. in Presented by: Blake Rayfield Experience Level: Some experience Description Python is one of the more accessible programming languages and has been adopted by a broad community of users. For educators of all levels, Python has become a go-to programming language. However, while there are ways to distribute creations in Python, they tend to be notoriously complex, unreliable, or require additional services like web hosting. With the creation of Pyscript, Python projects can be distributed with little to no web hosting or even internet connectivity. This change can potentially bring previously inaccessible topics or tools to a broader community while increasing the popularity of Python. This talk will describe and demonstrate Python and Pyscript's potential opportunities in the education space. We will talk about what makes these tools different than those previously available and how the future development of Pyscript can drive additional education changes in the near future..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/57", "_split_id": 0 }
[ "content" ]
null
null
ffeb01898b2a7ebf4e695397f38261ad
Tutorials: Power up your work with compiling and profiling Thursday - April 20th, 2023 9 a.m.-12:30 p.m. in Presented by: Cheuk Ting Ho Experience Level: Some experience Description Have you been troubled by Python code that took too long to run? Do you want to know why and how to improve? In this workshop, we will introduce Numba - a JIT compiler that is designed to speed up numerical calculations. Most people found all of it is like a mystery - It sounds like magic, but how does it work? Under what conditions does it work? And because of it, new users found it hard to start using it and it requires a steep learning curve to get the hang of it. This workshop will provide all the knowledge that you need to make Numba works for you. This workshop is for Data scientists or developers who have math-heavy code that would like to speed up with the benefit of Numpy and Numba..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/71", "_split_id": 0 }
[ "content" ]
null
null
cbd4cd8adc22f76895ec0b68720a417a
Talks: Supercharging Pipeline Efficiency with ML Performance Prediction Sunday - April 23rd, 2023 1:45 p.m.-2:15 p.m. in Presented by: Boaz Wiesner Keren Meron Experience Level: Some experience Description To process our customers' data, Singular's pipeline runs hundreds of thousands of daily tasks, each with a different processing time and resource requirements. We deal with this scale by using Celery and Kubernetes as our tasks infrastructure, letting us allocate dedicated workers and queues to each type of task based on its requirements. Originally, this was configured manually. As our customer base grew, we noticed that heavier and longer tasks were grabbing all the resources and causing unacceptable queues in our pipeline. Moreover, some of the heavier tasks required significantly more memory, leading to OOM kills and infrastructure issues. If we could classify tasks by their expected duration and memory requirements, we could have segregated tasks in Celery based on these properties and thus minimized interruptions to the rest of the pipeline. However, the variance in the size and granularity of the fetched data made it impossible to classify if a task was about to take one minute or one hour. Our challenge was: how do we categorize these tasks, accurately and automatically? To solve the issue we implemented a machine-learning model that could predict the expected duration and memory usage of a given task. Using Celery’s advanced task routing capabilities, we could then dynamically configure different task queues based on the model's prediction. This raised another challenge - how could we use the classified queues in the best way? Configuring workers statically for each queue would be inadequate at scale. We utilized Kubernetes’ vertical and horizontal autoscaling capabilities to dynamically allocate workers for each classified queue based on its length. This improved our ability to respond to pipeline load automatically, increasing performance and availability. Additionally, we were able to deploy shorter-lived workers on AWS Spot instances, giving us higher performance while lowering cloud costs.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/1", "_split_id": 0 }
[ "content" ]
null
null
e0f5430a87d309534b2573bfe7d6ec84
Talks: PyScript and the magic of Python in the browser Saturday - April 22nd, 2023 1:30 p.m.-2:15 p.m. in Presented by: Fabio Pliger Experience Level: Some experience Description A year after its announcement, PyScript is a very different project. From major performance improvements to great plugins, PyScript applications allow a new way to create fun and educational opportunities that were not possible until now. This talk summarizes the work done over the past year, and what you might expect in the future. In this talk I will: Give a quick overview of what PyScript is Talk about features and changes introduced this year: Support for the blazing fast MicroPython interpreter Powerful Plugins System (support for Python and Javascript) Much improved Pythonic Dom interface Improved support for data Execution in web workers Many amazing plugins! Much more… Show how to create PyScript applications [running on the browser] and leverage the new possibilities that the web and the browser provide to the Python ecosystem Live demo amazing [PyScript] web applications running Python on the browser Give you a sneak-preview of some upcoming features What should you expect? Fun! Yes, I promise we’ll make it fun :) To walk away with a good understanding of how to write a PyScript application To have an understanding of what parts of Python on the browser are different then “regular Python” See snippets and examples that you can use to build your own PyScript apps Why should you care? Python on the browser is the new frontier of Python. You’ll have the chance to learn more about it, how to create your own Python apps on the browser, and see what’s coming..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/77", "_split_id": 0 }
[ "content" ]
null
null
b9d3b7ceae4e82332aed6510816cfba2
Talks: Testing Spacecraft with Pytest Friday - April 21st, 2023 4:15 p.m.-4:45 p.m. in Presented by: Dan Craig Experience Level: Some experience Description Much of the industry discussion around software testing over the last couple of decades has been focused on web services, but there are lots of different types of software systems that have different testing needs. This talk will first explore the differences and similarities between testing web services and testing safety- and mission-critical software systems, such as those used on spacecraft. We will then consider a rubric for thinking about the verification needs of different types of software based on attributes of the software and the environments in which it runs. Finally, we will examine a real-world example of using pytest to test Varda Space Industries' spacecraft software, showcasing many of pytest's power features, such as its fixtures and extensive hook system, as well as Python language features such as generators, context managers, and threading, that enable easy-to-use tools for testing against real-time telemetry streams and generating rich test report output..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/40", "_split_id": 0 }
[ "content" ]
null
null
41e8193214f1f874273762beecb0f76c
Sponsor Presentations: The complex web of events, speakers, and attendees (Sponsor: neo4j) Thursday - April 20th, 2023 1:30 p.m.-2:30 p.m. in Presented by: Jason Koo Description As we gain access to more data, being able to organize and analyze this thickening web of information gets harder to untangle. In this talk, we’ll explore the intricate relationships between events, speakers, and attendees. We’ll also demonstrate how graph databases empower apps to traverse and extract valuable information from these complex connections. We’ll jump into the basics of graph databases, why they’re advantageous for handling such interconnected data, how to model data for graphs, and show how to connect and query them from Python applications. Whether you’re new to graph databases or have been wondering how to use one, this talk will leave you wondering why you didn’t try them earlier!.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/143", "_split_id": 0 }
[ "content" ]
null
null
92288dbb6e2339a92597c0dc28779e58
Talks: What framework should I use for web testing? Saturday - April 22nd, 2023 3:15 p.m.-3:45 p.m. in Presented by: Pandy Knight Experience Level: Some experience Description Web apps these days are bigger than ever! With added complexity comes higher risk for bugs and poor user experience. One of the best ways to improve quality during development is to build feedback loops with automated test suites that run continuously. These days, there are three major open source test frameworks for automating web UI tests: Selenium, the old-school browser automation tool Cypress, the darling framework for frontend developers Playwright, the dark horse rising in popularity These three can test any kind of web app, including ones developed in Python, but which one is best? In this talk, I’ll give a brief overview of each one, including example code for a basic search engine test. We will compare and contrast their features head-to-head so that you can make the right decision for your team..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/36", "_split_id": 0 }
[ "content" ]
null
null
3976322d9e23c9b1a59968de54d1e859
Tutorials: Creating a Full Fledged Event Driven System in Python using Apache Kafka Thursday - April 20th, 2023 9 a.m.-12:30 p.m. in Presented by: Deepak K Gupta Experience Level: Advance experience Description Today every enterprise is powered by and with data. They need to capture, analyse, manipulate, notify and log pretty much everything to be able to create a successful product, service, or a system. To achieve this, enterprises require to have an efficient big data storage as well as an event driven data streaming system to avoid the obvious complexity of sending and receiving large chunks of data without duplicating and securing it in all the places. It’s possible for enterprises to create their own proprietary solution for event streaming platforms, however using well known and widely used frameworks like Apache Kafka has its own benefits. Once can start immediately or it fits into the most, if not all of the obvious use cases. Welcome to this tutorial on Apache Kafka and how to create a high performance event streaming system in python programming language. You’ll not only learn about the basics of the event streaming platform and Apache Kafka, but will also learn how to use various constructs of Python Programming Language to create a full fledged, highly scalable and performant system. This tutorial will have classroom exercises as well as post class homework and complimentary readings. All the presentation, code, exercises as well as solutions will be shared after the tutoria..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/32", "_split_id": 0 }
[ "content" ]
null
null
4de4be684e0622c6455b54e509ded504
Sponsor Presentations: How to build stunning Data Science Web applications in Python (Sponsor: Taipy) Thursday - April 20th, 2023 11:30 a.m.-12:30 p.m. in Presented by: Florian Jacta Description This workshop presents Taipy, a new low-code Python package that allows you to create complete Data Science applications, including graphical visualization and managing algorithms, pipelines, and scenarios. It is composed of two main independent components: Taipy Core Taipy GUI. In this workshop, participants will learn how to use: Taipy Core to create scenarios, use models, retrieve metrics easily, version control their application configuration, Taipy GUI to create an interactive and powerful user interface in a few lines of code. Taipy Studio, a brand-new pipeline graphical editor inside VS Code that facilitates the creation of scenarios and pipelines. They will be used to build a complete interactive AI application where the end user can explore data and execute pipelines (make predictions) from within the application. With Taipy, the Python developer can transform simple pilots into production-ready end-user applications. Taipy GUI goes way beyond the capabilities of the standard graphical stack: Gradio, Streamlit, Dash, etc. Similarly, Taipy Core is simpler yet more powerful than the standard Python back-end stack..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/134", "_split_id": 0 }
[ "content" ]
null
null
6d37a795fd20d5de8b02f2337d398bca
Tutorials: Intro to Python for Brand New Programmers Wednesday - April 19th, 2023 9 a.m.-12:30 p.m. in Presented by: Trey Hunner Experience Level: Just starting out Description Brand new to programming and want to get some hands-on Python experience? Let's learn some Python together! During this tutorial we will work through a number of programming exercises together. We'll be doing a lot of asking questions, taking guesses, trying things out, and seeking out help from others. In this tutorial we'll cover: Types of things in Python: strings, numbers, lists Conditionally executing code Repeating code with loops Getting user input This tutorial is intended to ease you into Python. Each exercise section is careful not to assume prior programming knowledge. I expect you to have experience typing on computers and to have rudimentary math skills (just arithmetic). I am not expecting you to have experience with programming. We will define new terms as we use them You'll leave this tutorial, having written a couple small programs Python yourself. Hopefully you'll also leave with a bit of excitement about what Python can do and curiosity to keep diving deeper..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/53", "_split_id": 0 }
[ "content" ]
null
null
d78d58755ada953fffa6151223b058d2
Talks: Subclassing, Composition, Python, and You Saturday - April 22nd, 2023 12:15 p.m.-1 p.m. in Presented by: Hynek Schlawack Experience Level: Some experience Description Ever seen a code base where understanding a simple method meant jumping through tangled class hierarchies? We all have! And while "Favor composition over inheritance!" is almost as old as object-oriented programming, strictly avoiding all types of subclassing leads to verbose, un-Pythonic code. So, what to do? The discussion on composition vs. inheritance is so frustrating because far-reaching design decisions like this can only be made with the ecosystem in mind – and because there's more than one type of subclassing! Let's take a dogma-free stroll through the types of subclassing through a Pythonic lens and untangle some patterns and trade-offs together. By the end, you'll be more confident in deciding when subclassing will make your code more Pythonic and when composition will improve its clarity..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/7", "_split_id": 0 }
[ "content" ]
null
null
f419051e7ce1ed1f8967b73685ca33b3
Charlas: Unit Testing con Pytest Friday - April 21st, 2023 5 p.m.-5:30 p.m. in Presented by: Sofía Denner Experience Level: Some experience Description Spanish: ¿Y esto cómo lo testeo? Al momento de escribir tests, no siempre es simple saber qué cosas hay que testear o cómo hacerlo. En esta charla voy a hablar de mocks, de buenas prácticas, voy a dar algunos tips y voy a mostrar ejemplos de todo esto usando pytest. La charla se va a dividir en tres partes: - ¿Por qué (y para quién) testeamos? - ¿Cómo escribir tests? Ejemplos de tests y cómo escribir código preparado para pruebas unitarias. - ¿Cómo le sacamos el jugo a pytest?: Ejemplos de fixtures, parametrizaciones, etc. English: So, how do I test this? When writing tests, is not always easy to know what to test and how to do it. I’m going to talk about mocks, good practices, a few tips, and I’m going to show some examples using pytest. The talk is splitted in three parts: - Why (and for whom) do we write tests? - How to write unit tests? (Some test examples, and how to write code ready to be tested). - How to take advantage of pytest main features? (Examples of fixtures, parametrize, etc.)..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/15", "_split_id": 0 }
[ "content" ]
null
null
1b8ab2bc54a1c718c22fa17d64cbe84c
Talks: MQTT: A Pythonic introduction to the protocol for connected devices Friday - April 21st, 2023 10:45 a.m.-11:15 a.m. in Presented by: Jonas Neubert Experience Level: Some experience Description MQTT is to connected devices what HTTP is to web applications. It is a publish-subscribe protocol specifically designed for devices with limited bandwidth and CPU. MQTT is widely used in home automation, industrial automation, remote monitoring, and everywhere else where machines talk to each other or to a server. This talk is an introduction to MQTT for Pythonistas. I’ll start with a brief overview of basic concepts of the protocol. The rest of the presentation will be a sequence of code examples in CPython and Micropython/CircuitPython, building up to a demo with several devices publishing data to each other. Along the way, you will see a few of the most common tools for debugging MQTT communications. After attending this talk you will have a high level idea of Python use cases in automation, seen some examples of coding Python for microcontrollers, and know a whole lot more about four letters that look like an acronym but aren’t actually one. No prior experience with automation or microcontrollers is assumed..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/29", "_split_id": 0 }
[ "content" ]
null
null
d0c55b2dbeea8d0de321f1528be256bc
Tutorials: Introduction to Property-Based Testing Thursday - April 20th, 2023 1:30 p.m.-5 p.m. in Presented by: Zac Hatfield-Dodds Ryan Soklaski Experience Level: Advance experience Description Has testing got you down? Ever spent a day writing tests, only to discover that you missed a bug because of some edge case you didn’t know about? Does it ever feel like writing tests is just a formality - that you already know your test cases will pass? Property-based testing might be just what you need! After this introduction to property-based testing, you’ll be comfortable with Hypothesis, a friendly but powerful property-based testing library. You’ll also known how to check and enforce robust properties in your code, and will have hands-on experience finding real bugs. Where traditional example-based tests require you to write out each exact scenario to check - for example, assert divide(3, 4) == 0.75 - property-based tests are generalised and assisted. You describe what kinds of inputs are allowed, write a test that should pass for any of them, and Hypothesis does the rest! from hypothesis import given, strategies as st @given(a=st.integers(), b=st.integers()) def test_divide(a, b): result = a / b assert a == b * result There’s the obvious ZeroDivisionError, fixable with b = st.integers().filter(lambda b: b != 0), but there’s another bug lurking. Can you see it? Hypothesis can! Audience: This tutorial is for anybody who regularly writes tests in Python, and would like an easier and more effective way to do so. We assume that you are comfortable with traditional unit tests - reading, running, and writing; as well as familar with ideas like assertions. Most attendees will have heard "given, when, then" and "arrange, act, assert". You may or may not have heard of pre- and post-conditions - we will explain what "property-based" means without reference to Haskell or anything algebraic..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/84", "_split_id": 0 }
[ "content" ]
null
null
bc9b2b8f6afa7e7bb7d2020a8001438c
Talks: Rethinking Objects Saturday - April 22nd, 2023 2:30 p.m.-3 p.m. in Presented by: Bruce Eckel Experience Level: Some experience Description This presentation revisits two core concepts of Object-Oriented programming: encapsulation and code reuse. Using a series of examples, we'll ask whether these concepts have satisfied their promises, and how functional approaches can do a better job. We'll also see that objects still have value in making library use easy..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/46", "_split_id": 0 }
[ "content" ]
null
null
2695441f084ae007c82cea207b88c73f
Talks: so much depends upon... your python app's dependencies Saturday - April 22nd, 2023 5 p.m.-5:30 p.m. in Presented by: Mario Munoz Experience Level: Some experience Description How do you keep track of your project's building blocks? Is it enough just pinning your dependencies in a requirements.txt file? Or is there any reason to learn one (or any) in a myriad of dependency management tools? It depends. Untangling the complexity of this topic might not be worth it for certain small projects. But there are a lot of reasons why learning about (and using) a dependency management tool will help you in the future. Find out why embracing proper dependency management can help your project's predictability, sustainability, security, and yes, even simplicity. Learn how you can use a tool like pdm to help accomplish these goals..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/123", "_split_id": 0 }
[ "content" ]
null
null
11b0f31114e2d189d6a263a946bd846c
Talks: Create interactive games using MicroPython and electronics Friday - April 21st, 2023 3:15 p.m.-3:45 p.m. in Presented by: Juliana Karoline de Sousa Experience Level: Just starting out Description Do you want to have fun and learn Python? Let's learn how to use electronics and programming to create games using MicroPython and a micro:bit board. In this talk you'll learn how the micro:bit board works with MicroPython and how you can use push buttons, an accelerometer sensor and a LED display to create interactive games. The game examples will be Chase the Dot, Genius and Car Crash. For each game we'll see how the game works, the source code and a demonstration..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/142", "_split_id": 0 }
[ "content" ]
null
null
7ef07cc69e9673ba60f71e0fcfdac818
Talks: Cross-Server Data Joins on Slow Networks with Python Friday - April 21st, 2023 11:30 a.m.-noon in Presented by: Bert Wagner Experience Level: Some experience Description While working from home has its perks, you've found one thing missing in your remote work life: speed of network data transfer. It doesn't matter if you can write the most efficient Python data transformation code when your jobs are bottlenecked by slow data movement happening between your local laptop and remote servers. In this talk we will address techniques for querying and joining data across distant machines efficiently with Python. We will also discuss how to handle scenarios where you need to join datasets that won't fit in your laptop's memory, including several techniques and packages for making cross server joins. This session won't stop you from getting angry when your ISP throttles your home internet connection, but it will teach you ways to work with local and remote datasets as efficiently as possible..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/72", "_split_id": 0 }
[ "content" ]
null
null
a4ad9f864d0def678167aa9462c72589
Talks: The Lost Art of Diagrams: Making Complex Ideas Easy to See with Python Saturday - April 22nd, 2023 5 p.m.-5:30 p.m. in Presented by: Tadeh Hakopian Experience Level: Some experience Description This talk is about communicating with visuals to make complex ideas simple to understand. Over the years I have produced diagrams, charts, illustrations and other graphics to help people understand sophisticated project concepts. This includes project architecture, standard operating procedures, coding concepts, sprints and roadmaps. You will be guided through ways of how to make stylized examples of your project code and workflows in easy to follow examples. By using common software for illustrations along with some simple guidelines you too can make easy to follow visual content for your next project. Key Takeaways: Learn methods to visually communicate with your team including with color, shapes, images, gifs and even memes to help get a point across Understand how to make your technical documentation into visual graphics with diagram design style guides See examples of how to take technical documentation and create an intuitive diagram of it to share Come away with an ability to execute a simple (or sophisticated) graphic with essential steps and key requirements.
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/63", "_split_id": 0 }
[ "content" ]
null
null
94b785a8d65b1b92f4046088f838c092
Talks: Building NumPy Arrays from CSV Files, Faster than Pandas Friday - April 21st, 2023 12:15 p.m.-12:45 p.m. in Presented by: Christopher Ariza Experience Level: Some experience Description Twenty years ago, in 2003, Python 2.3 was released with csv.reader(), a function that provided support for parsing CSV files. The C implementation, proposed in PEP 305, defines a core tokenizer that has been a reference for many subsequent projects. Two commonly needed features, however, were not addressed in csv.reader(): determining type per column, and converting strings to those types (or columns to arrays). Pandas read_csv() implements automatic type conversion and realization of columns as NumPy arrays (delivered in a DataFrame), with performance good enough to be widely regarded as a benchmark. Pandas implementation, however, does not support all NumPy dtypes. While NumPy offers loadtxt() and genfromtxt() for similar purposes, the former (recently re-implemented in C) does not implement automatic type discovery, while the latter (implemented in Python) suffers poor performance at scale. To support reading delimited files in StaticFrame (a DataFrame library built on an immutable data model), I needed something different: the full configuration options of Python's csv.reader(); optional type discovery for one or more columns; support for all NumPy dtypes; and performance competitive with Pandas read_csv(). Following the twenty-year tradition of extending csv.reader(), I implemented delimited_to_arrays() as a C extension to meet these needs. Using a family of C functions and structs, Unicode code points are collected per column (with optional type discovery), converted to C-types, and written into NumPy arrays, all with minimal PyObject creation or reference counting. Incorporated in StaticFrame, performance tests across a range of DataFrame shapes and type heterogeneity show significant performance advantages over Pandas. Independent of usage in StaticFrame, delimited_to_arrays() provides a powerful new resource for converting CSV files to NumPy arrays. This presentation will review the background, architecture, and performance characteristics of this new implementation..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/8", "_split_id": 0 }
[ "content" ]
null
null
7356dbda608759df6aa25688649fda34
Talks: An Overview of the Python Code Tool Landscape 2023 Friday - April 21st, 2023 10:45 a.m.-11:15 a.m. in Presented by: Al Sweigart Experience Level: Some experience Description Linters, type checkers, style formatters, package linters, security analysis, dead code removers, docstring formatters, code complexity analyzers: There is a wealth of static code analysis tools in the Python ecosystem. It's intimidating to start looking at them and easy to get lost. What's the difference between Pyflakes, flake8, and autoflake? Or between autopep8 and pep8-naming? This overview explains the different kinds of static code analysis tools, what tools are out there (as of 2023), and how beginners can get started using these tools to write code like pros. This talk also provides a beginner's introduction to type hints in Python and the type checker tools available. There are too many tools to describe in detail, but this talk does introduce the promising newcomer Ruff, an extremely fast Python linter written in Rust..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/110", "_split_id": 0 }
[ "content" ]
null
null
c8f0f5e85b731b3c136d80c6070fcdbc
Sponsor Presentations: Flagging in the Backend - Shipping API's with Flask and LaunchDarkly (Sponsor: LaunchDarkly) Thursday - April 20th, 2023 11:30 a.m.-12:30 p.m. in Presented by: Cody De Arkland Description Everyone acts like the party is in the Frontend, but the Backend is what keeps your platforms running. Python has a number of options for building backend API's but the most common are Flask and Django. API's are the backbone of most applications, and shipping new ones is often risky - but they don't have to be. In this session, Cody will take you through where he started his coding journey with Python and Flask, go hands on with examples of backend API's, and show how you can ship faster and safer using feature flags..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/138", "_split_id": 0 }
[ "content" ]
null
null
9c71356a1799d7312f98e0d40baf8031
Talks: Build Yourself a PyScript Friday - April 21st, 2023 12:15 p.m.-1 p.m. in Presented by: Paul Everitt Nicholas H.Tollervey Experience Level: Some experience Description PyScript and Pyodide have gained a lot of attention, as Python in the browser presents interesting opportunities. And architectural questions as well. What does it mean to write an extensible, friendly web platform targeting Python? In this talk, learn how PyScript works and watch a treatment of key technical issues for writing web apps with the WebAssembly version of Python. What does “file” mean? How do you install something? What are web workers and how do they impact your architecture? PyScript itself is constantly evolving on these topics. Come for a spirited discussion with a fast-paced format..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/27", "_split_id": 0 }
[ "content" ]
null
null
e0ab80b61fcb98659ee5070fb653eefa
Talks: Python on Android Sunday - April 23rd, 2023 2:30 p.m.-3 p.m. in Presented by: Malcolm Smith Experience Level: Some experience Description By many measures, Android is the most widely-used operating system in the world. But Python development on the platform remains quite rare. Fortunately there are several active projects working to improve this. In this talk, you'll learn about: Why Android support is important for the future of Python. How Android compares to other platforms, and the unique challenges it presents. What's needed to make mobile Python development practical, including build tools, GUI libraries, and binary package support. The available options for running Python on Android, and how to choose which one is best for you..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/145", "_split_id": 0 }
[ "content" ]
null
null
b28684d7904d807ac41599b27770082b
Talks: Improving debuggability of complex asyncio applications Friday - April 21st, 2023 1:45 p.m.-2:15 p.m. in Presented by: Joongi Kim Experience Level: Some experience Description The key of debugging is observability and reproducibility. Despite a series of the asyncio stdlib improvements for the last few years, it is still challenging to see what’s happening in complex real-world asyncio applications. Particularly, when multiple asyncio libraries and your codes are composed together, it is hard to track down silently swallowed cancellations and resource-hogging floods of tasks triggered by internals of 3rd-party callbacks. Moreoever, such misbehaviors are often observed only in production environments where the app faces the actual workloads and I/O patterns, making it even harder to reproduce. In this talk, I present an improved version of aiomonitor, called aiomonitor-ng (next generation). The original aiomonitor provides a live access to a running asyncio process using a telnet socket and a basic REPL to inspect the list of tasks and their current stacks. After getting several times of assistance in production debugging with it, I have added more features to help tracking the above issues of asyncio apps running in production: task creation tracker and termination tracker. These trackers keeps the stack traces whenever a new task is created or terminated, and provides a holistic view of chained stack traces when the tasks are nested with arbitrary depths. aiomonitor-ng also demonstrates a rich async TUI (terminal UI) based on prompt toolkit and Click, with auto-completion of commands and arguments, far enhancing the original version’s simple REPL. With the improved aiomonitor-ng, I could successfully debug several production bugs. I hope this talk would help our fellow asyncio developers to make more complex yet stable applications at scale..
text
{ "url": "https://us.pycon.org/2023/schedule/presentation/13", "_split_id": 0 }
[ "content" ]
null
null