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 |
End of preview. Expand
in Dataset Viewer.
- Downloads last month
- 40