<?xml version='1.0' encoding='utf-8' ?>
<!-- Made with love by pretalx v2026.1.1. -->
<schedule>
    <generator name="pretalx" version="2026.1.1" />
    <version>0.25</version>
    <conference>
        <title>EuroPython 2023</title>
        <acronym>europython-2023</acronym>
        <start>2023-07-17</start>
        <end>2023-07-23</end>
        <days>7</days>
        <timeslot_duration>00:05</timeslot_duration>
        <base_url>https://programme.europython.eu</base_url>
        <logo>https://programme.europython.eu/media/europython-2023/img/epslogo_2rBf6vZ.png</logo>
        <time_zone_name>Europe/Prague</time_zone_name>
        
        
        <track name="Arts, Crafts Culture &amp; Demos (2023)" slug="3544-arts-crafts-culture-demos-2023"  color="#000000" />
        
        <track name="Infrastructure: Cloud &amp; Hardware (2023)" slug="3559-infrastructure-cloud-hardware-2023"  color="#000000" />
        
        <track name="Makers, Microcontrollers and IoT (2023)" slug="3560-makers-microcontrollers-and-iot-2023"  color="#000000" />
        
        <track name="Testing (2023)" slug="3572-testing-2023"  color="#000000" />
        
        <track name="PyData: Machine Learning, Stats (2023)" slug="3564-pydata-machine-learning-stats-2023"  color="#000000" />
        
        <track name="PyData: Data Engineering (2023)" slug="3561-pydata-data-engineering-2023"  color="#000000" />
        
        <track name="Web (2023)" slug="3573-web-2023"  color="#000000" />
        
        <track name="PyData: Deep Learning, NLP, CV (2023)" slug="3562-pydata-deep-learning-nlp-cv-2023"  color="#000000" />
        
        <track name="~ None of these topics (2023)" slug="3574-none-of-these-topics-2023"  color="#000000" />
        
        <track name="PyData: Ethics in AI (2023)" slug="3563-pydata-ethics-in-ai-2023"  color="#000000" />
        
        <track name="PyData: Software Packages &amp; Jupyter (2023)" slug="3565-pydata-software-packages-jupyter-2023"  color="#000000" />
        
        <track name="Ethics, Philosophy &amp; Politics (2023)" slug="3569-ethics-philosophy-politics-2023"  color="#000000" />
        
        <track name="Community &amp; Diversity (2023)" slug="3556-community-diversity-2023"  color="#000000" />
        
        <track name="Python Libraries (2023)" slug="3567-python-libraries-2023"  color="#000000" />
        
        <track name="DevOps (2023)" slug="3557-devops-2023"  color="#000000" />
        
        <track name="TBD - Multiple Tracks (2023)" slug="3683-tbd-multiple-tracks-2023"  color="#ff0000" />
        
        <track name="Software Engineering &amp; Architecture (2023)" slug="3570-software-engineering-architecture-2023"  color="#000000" />
        
        <track name="Security (2023)" slug="3571-security-2023"  color="#000000" />
        
        <track name="Career, Life, Health (2023)" slug="3555-career-life-health-2023"  color="#000000" />
        
        <track name="Python Friends (2023)" slug="3566-python-friends-2023"  color="#000000" />
        
        <track name="Python Internals &amp; Ecosystem (2023)" slug="3568-python-internals-ecosystem-2023"  color="#000000" />
        
        <track name="Education, Teaching &amp; Training (2023)" slug="3558-education-teaching-training-2023"  color="#000000" />
        
    </conference>
    <day index='1' date='2023-07-17' start='2023-07-17T04:00:00+02:00' end='2023-07-18T03:59:00+02:00'>
        <room name='Club A' guid='53d942d8-41c6-5ce2-9e68-e27dbe1581dd'>
            <event guid='20530159-f8f3-58a9-a69c-421ceb0d0cc8' id='35573' code='3HURZQ'>
                <room>Club A</room>
                <title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-17T08:30:00+02:00</date>
                <start>08:30</start>
                <duration>01:00</duration>
                <abstract>Welcome to EuroPython 2023! You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!

Queues will be sorted by your **first name** on your ticket. Your ticket can be located via your order confirmation email (from support@pretix.eu with the Subject: Your order: XXXX). If you ordered your ticket after we&apos;ve sent badges for printing (after 10 July), go directly to the Info Desk (also referred as Debugging Desk) and a volunteer will help!</abstract>
                <slug>europython-2023-35573-registration-welcome-forum-hall-foyer-1st-floor</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3HURZQ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3HURZQ/feedback/</feedback_url>
            </event>
            <event guid='7e4d6e58-660d-53cc-be1f-33600da29548' id='29567' code='8XKCB8'>
                <room>Club A</room>
                <title>Asyncio without Asyncio</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>This tutorial aims to demystify asyncio builtin module by implementing it from scratch without any dependencies other than the Python Standard Library. We will go through the problem of blocking IO and how it is possible to solve it without single &quot;async&quot; and &quot;await&quot; statement using native Python concepts. Then, we will demystify async/await syntax and see how it is implemented. We will also build our own scheduler which will have a similar API as asyncio, which will be able to run async functions the same way asyncio does. And finally we will build real asynchronous http proxy using our own asyncio implementation. Why reinvent the wheel? - &quot;I hear and I forget. I see and I remember. I do and I understand.&quot;.</abstract>
                <slug>europython-2023-29567-0-asyncio-without-asyncio</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34012'>Yan Yanchii</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/8XKCB8/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/8XKCB8/feedback/</feedback_url>
            </event>
            <event guid='d95b2f1c-28d3-50cb-b954-3ac7ed13ad2c' id='29567' code='8XKCB8'>
                <room>Club A</room>
                <title>Asyncio without Asyncio</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>This tutorial aims to demystify asyncio builtin module by implementing it from scratch without any dependencies other than the Python Standard Library. We will go through the problem of blocking IO and how it is possible to solve it without single &quot;async&quot; and &quot;await&quot; statement using native Python concepts. Then, we will demystify async/await syntax and see how it is implemented. We will also build our own scheduler which will have a similar API as asyncio, which will be able to run async functions the same way asyncio does. And finally we will build real asynchronous http proxy using our own asyncio implementation. Why reinvent the wheel? - &quot;I hear and I forget. I see and I remember. I do and I understand.&quot;.</abstract>
                <slug>europython-2023-29567-1-asyncio-without-asyncio</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34012'>Yan Yanchii</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/8XKCB8/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/8XKCB8/feedback/</feedback_url>
            </event>
            <event guid='f11b32a9-ee97-5110-8de6-f91b1e07b151' id='29501' code='3HDWUZ'>
                <room>Club A</room>
                <title>Geospatial Data Processing in Python: A Comprehensive Tutorial</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>In this tutorial, you will learn about the various Python modules for processing geospatial data, including GDAL, Rasterio, Pyproj, Shapely, Folium, Fiona, OSMnx, Libpysal, Geopandas, Pydeck, Whitebox, ESDA, and Leaflet. You will gain hands-on experience working with real-world geospatial data and learn how to perform tasks such as reading and writing spatial data, reprojecting data, performing spatial analyses, and creating interactive maps. This tutorial is suitable for beginners as well as intermediate Python users who want to expand their knowledge in the field of geospatial data processing.</abstract>
                <slug>europython-2023-29501-0-geospatial-data-processing-in-python-a-comprehensive-tutorial</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33956'>Martin Christen</person>
                </persons>
                <language>en</language>
                <description>Geospatial data, which refers to data that has a geographic component, is a crucial part of many fields, including geography, geography, urban planning, and environmental science. In this tutorial, you will learn about the various Python modules that are available for working with geospatial data.

We will start by introducing the **GDAL** (Geospatial Data Abstraction Library) and **Rasterio** modules, which are used for reading and writing raster data (data stored in a grid of cells, where each cell has a value). You will learn how to read and write common raster formats such as GeoTIFF and ESRI ASCII, as well as how to perform common raster operations such as resampling and reprojecting.

Next, we will cover the **Pyproj** module, which is used for performing coordinate system transformations. You will learn how to convert between different coordinate systems and how to perform common tasks such as converting latitude and longitude coordinates to UTM (Universal Transverse Mercator) coordinates.

After that, we will introduce the **Shapely** module, which is used for working with geometric objects in Python. You will learn how to create and manipulate points, lines, and polygons, as well as how to perform spatial operations such as intersection and union.

Then, we will cover the **Folium** module, which is used for creating interactive maps in Python. You will learn how to create simple maps, add markers and popups, and customize the appearance of your maps.

Next, we will introduce the **Fiona** module, which is used for reading and writing vector data (data stored as individual features, each with its own geometry and attributes). You will learn how to read and write common vector formats such as ESRI Shapefile and GeoJSON, as well as how to access and manipulate the attributes of vector features.

After that, we will cover the **OSMnx** module, which is used for working with OpenStreetMap data in Python. You will learn how to download and manipulate street networks, buildings, and other geospatial data.

Next, we will introduce the **Libpysal** module, which is used for performing spatial statistics and econometrics in Python. You will learn how to calculate spatial weights, perform spatial autocorrelation tests, and estimate spatial econometric models.

Then, we will cover the **Geopandas** module, which is used for working with geospatial data in a Pandas DataFrame. You will learn how to load and manipulate vector data, perform sp</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3HDWUZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3HDWUZ/feedback/</feedback_url>
            </event>
            <event guid='1ae20717-2045-5476-90b3-605621532bd9' id='29501' code='3HDWUZ'>
                <room>Club A</room>
                <title>Geospatial Data Processing in Python: A Comprehensive Tutorial</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>In this tutorial, you will learn about the various Python modules for processing geospatial data, including GDAL, Rasterio, Pyproj, Shapely, Folium, Fiona, OSMnx, Libpysal, Geopandas, Pydeck, Whitebox, ESDA, and Leaflet. You will gain hands-on experience working with real-world geospatial data and learn how to perform tasks such as reading and writing spatial data, reprojecting data, performing spatial analyses, and creating interactive maps. This tutorial is suitable for beginners as well as intermediate Python users who want to expand their knowledge in the field of geospatial data processing.</abstract>
                <slug>europython-2023-29501-1-geospatial-data-processing-in-python-a-comprehensive-tutorial</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33956'>Martin Christen</person>
                </persons>
                <language>en</language>
                <description>Geospatial data, which refers to data that has a geographic component, is a crucial part of many fields, including geography, geography, urban planning, and environmental science. In this tutorial, you will learn about the various Python modules that are available for working with geospatial data.

We will start by introducing the **GDAL** (Geospatial Data Abstraction Library) and **Rasterio** modules, which are used for reading and writing raster data (data stored in a grid of cells, where each cell has a value). You will learn how to read and write common raster formats such as GeoTIFF and ESRI ASCII, as well as how to perform common raster operations such as resampling and reprojecting.

Next, we will cover the **Pyproj** module, which is used for performing coordinate system transformations. You will learn how to convert between different coordinate systems and how to perform common tasks such as converting latitude and longitude coordinates to UTM (Universal Transverse Mercator) coordinates.

After that, we will introduce the **Shapely** module, which is used for working with geometric objects in Python. You will learn how to create and manipulate points, lines, and polygons, as well as how to perform spatial operations such as intersection and union.

Then, we will cover the **Folium** module, which is used for creating interactive maps in Python. You will learn how to create simple maps, add markers and popups, and customize the appearance of your maps.

Next, we will introduce the **Fiona** module, which is used for reading and writing vector data (data stored as individual features, each with its own geometry and attributes). You will learn how to read and write common vector formats such as ESRI Shapefile and GeoJSON, as well as how to access and manipulate the attributes of vector features.

After that, we will cover the **OSMnx** module, which is used for working with OpenStreetMap data in Python. You will learn how to download and manipulate street networks, buildings, and other geospatial data.

Next, we will introduce the **Libpysal** module, which is used for performing spatial statistics and econometrics in Python. You will learn how to calculate spatial weights, perform spatial autocorrelation tests, and estimate spatial econometric models.

Then, we will cover the **Geopandas** module, which is used for working with geospatial data in a Pandas DataFrame. You will learn how to load and manipulate vector data, perform sp</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3HDWUZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3HDWUZ/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club E' guid='fbf44aaf-fa84-51fb-90c7-f426cd0cfe7a'>
            <event guid='5e83e942-339d-589c-bd07-511466cd854d' id='30023' code='PNYMHE'>
                <room>Club E</room>
                <title>How to MLOps: Experiment tracking &amp; deployment &#128202;</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>What&apos;s this thing called **MLOps**? You may have heard about it by now, but never really understood what all the fuzz is about. Let&apos;s find out together!

In this tutorial, you will learn about MLOps and take your first steps in a hands-on way. To do so, we will be using **Open Source** tooling. We will be taking a simple example of Machine Learning use case and will gradually make it more ready for production &#128640;.

We start with a simple time-series model in Python using scikit-learn and first add logging steps to make the performance of the model measurable. Don&apos;t worry: we will go through it step-by-step, so you won&apos;t be overwhelmed. Then, we will log our ML model and load it back into an inference step. Lastly, we will learn about deploying these actual models by Dockerizing our application &#128591;.</abstract>
                <slug>europython-2023-30023-0-how-to-mlops-experiment-tracking-deployment</slug>
                <track>PyData: Machine Learning, Stats (2023)</track>
                
                <persons>
                    <person id='34477'>Jeroen Overschie</person><person id='38511'>Yke Rusticus</person>
                </persons>
                <language>en</language>
                <description>Welcome! You will be learning about MLOps in a hands-on way. So get ready to get your hands dirty and code along! &#128079;&#127995;

Join us if you &#129781;:
- Are working with Machine Learning / Data Science
- Have some experience with Python
- Are interested in MLOps and want to get some hands-on experience
- Are interested in taking your Machine Learning model to production

### Contents of the tutorial &#128204;:
1. [15 min] MLOps: what&apos;s the fuzz about?
2. [15 min] Why Experiment tracking? &#128202;
3. [15 min] Hands-on: Logging metrics with MLFlow
4. [10 min] Hands-on: Comparing experiments in the MLFlow interface
5. [15 min] Hands-on: Saving a trained model with MLFlow
6. [20 min] Hands-on: Loading a model with MLFlow and running inference
7. [15 min] How to deploy our application? &#128640;
8. [30 min] Hands-on: Dockerizing our application
9. [30 min] Hands-on: Deploying our application

### &#127969; What you will take home
At the end of the tutorial, you will be taking home the following:
- What MLOps is
- When it&apos;s applicable, and why it is important
- How you can track your Machine Learning experiments and build better models because of it
- Separate model training from model inference
- Know how you could deploy your ML model to production

### &#10084;&#65039; Open Source Software
Many of the used tooling is Open Source. Open software for all!

### &#127890; Pre-requisites
Some Python knowledge is required, as well as some general Data Science knowledge: model- training and inference as well as cross-validation. We will not go into details on the Data Science part, but it is good to have a rough understanding about it &#128077;&#127995;.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PNYMHE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PNYMHE/feedback/</feedback_url>
            </event>
            <event guid='b996f8b1-5770-51da-82c8-c5eb37d762e4' id='30023' code='PNYMHE'>
                <room>Club E</room>
                <title>How to MLOps: Experiment tracking &amp; deployment &#128202;</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>What&apos;s this thing called **MLOps**? You may have heard about it by now, but never really understood what all the fuzz is about. Let&apos;s find out together!

In this tutorial, you will learn about MLOps and take your first steps in a hands-on way. To do so, we will be using **Open Source** tooling. We will be taking a simple example of Machine Learning use case and will gradually make it more ready for production &#128640;.

We start with a simple time-series model in Python using scikit-learn and first add logging steps to make the performance of the model measurable. Don&apos;t worry: we will go through it step-by-step, so you won&apos;t be overwhelmed. Then, we will log our ML model and load it back into an inference step. Lastly, we will learn about deploying these actual models by Dockerizing our application &#128591;.</abstract>
                <slug>europython-2023-30023-1-how-to-mlops-experiment-tracking-deployment</slug>
                <track>PyData: Machine Learning, Stats (2023)</track>
                
                <persons>
                    <person id='34477'>Jeroen Overschie</person><person id='38511'>Yke Rusticus</person>
                </persons>
                <language>en</language>
                <description>Welcome! You will be learning about MLOps in a hands-on way. So get ready to get your hands dirty and code along! &#128079;&#127995;

Join us if you &#129781;:
- Are working with Machine Learning / Data Science
- Have some experience with Python
- Are interested in MLOps and want to get some hands-on experience
- Are interested in taking your Machine Learning model to production

### Contents of the tutorial &#128204;:
1. [15 min] MLOps: what&apos;s the fuzz about?
2. [15 min] Why Experiment tracking? &#128202;
3. [15 min] Hands-on: Logging metrics with MLFlow
4. [10 min] Hands-on: Comparing experiments in the MLFlow interface
5. [15 min] Hands-on: Saving a trained model with MLFlow
6. [20 min] Hands-on: Loading a model with MLFlow and running inference
7. [15 min] How to deploy our application? &#128640;
8. [30 min] Hands-on: Dockerizing our application
9. [30 min] Hands-on: Deploying our application

### &#127969; What you will take home
At the end of the tutorial, you will be taking home the following:
- What MLOps is
- When it&apos;s applicable, and why it is important
- How you can track your Machine Learning experiments and build better models because of it
- Separate model training from model inference
- Know how you could deploy your ML model to production

### &#10084;&#65039; Open Source Software
Many of the used tooling is Open Source. Open software for all!

### &#127890; Pre-requisites
Some Python knowledge is required, as well as some general Data Science knowledge: model- training and inference as well as cross-validation. We will not go into details on the Data Science part, but it is good to have a rough understanding about it &#128077;&#127995;.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PNYMHE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PNYMHE/feedback/</feedback_url>
            </event>
            <event guid='7252a403-e1e2-51df-b043-e4aedca184b1' id='29463' code='SEBRJA'>
                <room>Club E</room>
                <title>Build, Serve, and Deploy a Fast, Production-Ready API with Python and Robyn</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>Join our hands-on workshop and discover how to build fast, production-ready APIs using Robyn, a developer-friendly web framework for Python. We&apos;ll guide you through key features like GraphQL, WebSockets, and data validation, as well as essential topics like app structure, database modeling, and code splitting. With our workshop, you&apos;ll gain practical experience and valuable insights into Robyn&apos;s simple and extensible API, middleware, and deployment process.</abstract>
                <slug>europython-2023-29463-0-build-serve-and-deploy-a-fast-production-ready-api-with-python-and-robyn</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33932'>Sanskar Jethi</person>
                </persons>
                <language>en</language>
                <description>Are you looking to build a fast, scalable, and production-ready API using Python? Look no further than Robyn - one of the fastest and most developer-friendly web frameworks on the market! In this hands-on workshop, you&apos;ll learn how to use Robyn to build a robust API that can handle a high volume of requests.

We will walk you through the key features of Robyn. You&apos;ll also learn how to take advantage of Robyn&apos;s easy deployment process, fast shipping process, and middleware functionality to customize your app&apos;s behavior.

We&apos;ll cover essential topics like app structure, database modeling, and code splitting using views so that you can organize your code in a modular and reusable way. Additionally, we&apos;ll explore Robyn&apos;s simple and extensible API, which makes it easy to create a custom API that meets your unique requirements.

Throughout the workshop, you&apos;ll have ample opportunity to practice your skills and ask questions. We&apos;ll provide a fully-functional codebase that you can use as a starting point for your own API, and our instructors will be on hand to help you troubleshoot any issues you encounter.

By the end of the workshop, you&apos;ll have the confidence and expertise to build a fast, production-ready API using Python and Robyn. Whether you&apos;re building a web app, mobile app, or IoT device, this workshop is a must-attend event for anyone looking to take their API development skills to the next level. Sign up today and get ready to supercharge your API development workflow!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SEBRJA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SEBRJA/feedback/</feedback_url>
            </event>
            <event guid='a308ef1b-f619-5627-80d2-cd33e7ca0d37' id='29463' code='SEBRJA'>
                <room>Club E</room>
                <title>Build, Serve, and Deploy a Fast, Production-Ready API with Python and Robyn</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>Join our hands-on workshop and discover how to build fast, production-ready APIs using Robyn, a developer-friendly web framework for Python. We&apos;ll guide you through key features like GraphQL, WebSockets, and data validation, as well as essential topics like app structure, database modeling, and code splitting. With our workshop, you&apos;ll gain practical experience and valuable insights into Robyn&apos;s simple and extensible API, middleware, and deployment process.</abstract>
                <slug>europython-2023-29463-1-build-serve-and-deploy-a-fast-production-ready-api-with-python-and-robyn</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33932'>Sanskar Jethi</person>
                </persons>
                <language>en</language>
                <description>Are you looking to build a fast, scalable, and production-ready API using Python? Look no further than Robyn - one of the fastest and most developer-friendly web frameworks on the market! In this hands-on workshop, you&apos;ll learn how to use Robyn to build a robust API that can handle a high volume of requests.

We will walk you through the key features of Robyn. You&apos;ll also learn how to take advantage of Robyn&apos;s easy deployment process, fast shipping process, and middleware functionality to customize your app&apos;s behavior.

We&apos;ll cover essential topics like app structure, database modeling, and code splitting using views so that you can organize your code in a modular and reusable way. Additionally, we&apos;ll explore Robyn&apos;s simple and extensible API, which makes it easy to create a custom API that meets your unique requirements.

Throughout the workshop, you&apos;ll have ample opportunity to practice your skills and ask questions. We&apos;ll provide a fully-functional codebase that you can use as a starting point for your own API, and our instructors will be on hand to help you troubleshoot any issues you encounter.

By the end of the workshop, you&apos;ll have the confidence and expertise to build a fast, production-ready API using Python and Robyn. Whether you&apos;re building a web app, mobile app, or IoT device, this workshop is a must-attend event for anyone looking to take their API development skills to the next level. Sign up today and get ready to supercharge your API development workflow!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SEBRJA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SEBRJA/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club H' guid='6941bc28-5e5b-53eb-b15c-1285139e1f61'>
            <event guid='148873fe-fcaa-5eed-8023-38e9bc48a2ca' id='29384' code='BGEYP7'>
                <room>Club H</room>
                <title>Decorators - A Deep Dive</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>Python offers decorator to implement re-usable code for cross-cutting task.
The support the separation of cross-cutting concerns such as logging, caching,
or checking of permissions.
This can improve code modularity and maintainability.

This tutorial is an in-depth introduction to decorators.
It covers the usage of decorators and how to implement simple and more advanced
decorators.
Use cases demonstrate how to work with decorators.
In addition to showing how functions can use closures to create decorators,
the tutorial introduces callable class instance as alternative.
Class decorators can solve problems that use be to be tasks for metaclasses.
The tutorial provides uses cases for class decorators.

While the focus is on best practices and practical applications, the tutorial
also provides deeper insight into how Python works behind the scene.
After the tutorial participants will feel comfortable with functions that take
functions and return new functions.</abstract>
                <slug>europython-2023-29384-0-decorators-a-deep-dive</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33881'>Mike M&#252;ller</person>
                </persons>
                <language>en</language>
                <description>## Audience

This tutorial is for intermediate Python programmers who want to dive deeper.
Solid working knowledge of functions and classes basics is required.

## Format

The tutorial will be hands on.
I will start with a blank Notebook for each topic and develop the content
step-by-step.
The participants are encouraged to type along.
My typing speed is usually appropriate and allows participants to follow.
The students will receive a comprehensive PDF with all course content as well
Python source code files for all use cases and large code blocks I use.
I will load these files in my Notebook.
The students can do the same or open the files in their preferred editor or IDE.

I also explicitly ask for feedback if I am too fast or things are unclear.
I encourage questions at any time.
In fact, questions and my answers are often an important part of my teaching,
making the learning experience much more lively and typically more useful.

So the participants will be active throughout the whole tutorial.
There will be two exercises that each participant has to do on its own
(or in breakout rooms if the tutorials should be remote) during the tutorial.
We will look at the solutions during the tutorial.
I also supply a solutions PDF after the tutorial.


## Outline

* Examples of using decorators
  * from the standard library
  * from third-party packages
* Closures for decorators
* Write a simple decorator
* Best Practice
* Use case: Caching
* Use case: Logging
* Parameterizing decorators
* Chaining decorators
* Callable instances instead of functions
* Use case: Argument Checking
* Use case: Registration
* Class decorators
* Wrap-up and questions</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BGEYP7/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BGEYP7/feedback/</feedback_url>
            </event>
            <event guid='22fded8e-f50d-5add-8f61-0d8a1b29f7e9' id='29384' code='BGEYP7'>
                <room>Club H</room>
                <title>Decorators - A Deep Dive</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>Python offers decorator to implement re-usable code for cross-cutting task.
The support the separation of cross-cutting concerns such as logging, caching,
or checking of permissions.
This can improve code modularity and maintainability.

This tutorial is an in-depth introduction to decorators.
It covers the usage of decorators and how to implement simple and more advanced
decorators.
Use cases demonstrate how to work with decorators.
In addition to showing how functions can use closures to create decorators,
the tutorial introduces callable class instance as alternative.
Class decorators can solve problems that use be to be tasks for metaclasses.
The tutorial provides uses cases for class decorators.

While the focus is on best practices and practical applications, the tutorial
also provides deeper insight into how Python works behind the scene.
After the tutorial participants will feel comfortable with functions that take
functions and return new functions.</abstract>
                <slug>europython-2023-29384-1-decorators-a-deep-dive</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33881'>Mike M&#252;ller</person>
                </persons>
                <language>en</language>
                <description>## Audience

This tutorial is for intermediate Python programmers who want to dive deeper.
Solid working knowledge of functions and classes basics is required.

## Format

The tutorial will be hands on.
I will start with a blank Notebook for each topic and develop the content
step-by-step.
The participants are encouraged to type along.
My typing speed is usually appropriate and allows participants to follow.
The students will receive a comprehensive PDF with all course content as well
Python source code files for all use cases and large code blocks I use.
I will load these files in my Notebook.
The students can do the same or open the files in their preferred editor or IDE.

I also explicitly ask for feedback if I am too fast or things are unclear.
I encourage questions at any time.
In fact, questions and my answers are often an important part of my teaching,
making the learning experience much more lively and typically more useful.

So the participants will be active throughout the whole tutorial.
There will be two exercises that each participant has to do on its own
(or in breakout rooms if the tutorials should be remote) during the tutorial.
We will look at the solutions during the tutorial.
I also supply a solutions PDF after the tutorial.


## Outline

* Examples of using decorators
  * from the standard library
  * from third-party packages
* Closures for decorators
* Write a simple decorator
* Best Practice
* Use case: Caching
* Use case: Logging
* Parameterizing decorators
* Chaining decorators
* Callable instances instead of functions
* Use case: Argument Checking
* Use case: Registration
* Class decorators
* Wrap-up and questions</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BGEYP7/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BGEYP7/feedback/</feedback_url>
            </event>
            <event guid='0228d42a-16cd-55eb-a04d-a28b96d30ea8' id='29196' code='C7AZ33'>
                <room>Club H</room>
                <title>Build a terminal TODO app with Textual</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>Learn how to build powerful terminal-based user interfaces (TUIs) with ease using Textual - an open-source Python framework.

Throughout this tutorial, you&apos;ll learn how to use Textual&apos;s built-in widgets, reactive features, and message-passing system to create a dynamic and user-friendly TODO app that&apos;s perfect for managing your daily tasks.

From creating and displaying tasks to editing and deleting them, you&apos;ll cover all the essential features needed to make a functional TODO app.

You&apos;ll also learn how to use Textual CSS to style your TUI for a polished and elegant look, together with some tips and tricks to make it even easier to develop your TUIs in Textual.

This tutorial provides everything you need to get started with building TUIs in Python. By the end of the tutorial, you&apos;ll have a fully functional and stylish TODO app that showcases Textual&apos;s versatility and useful features.</abstract>
                <slug>europython-2023-29196-0-build-a-terminal-todo-app-with-textual</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33700'>Rodrigo Gir&#227;o Serr&#227;o</person>
                </persons>
                <language>en</language>
                <description>[Instructions below!]

During this tutorial, we will build a terminal-user interface for a TODO app.
This will showcase all the essential features that make Textual a very interesting Python framework to build terminal user interfaces.

Topics covered in this tutorial include:

 - the vast built-in widget gallery;
 - reactive attributes;
 - handling messages;
 - key bindings and action methods;
 - Textual CSS;
 - the Textual developer console; and
 - creation of custom widgets.

Attendees are not expected to have prior Textual experience but they are expected to have a working knowledge of classes, methods, and attributes.

If you want to attend the workshop, please follow the instructions in [this GitHub repo](https://github.com/Textualize/TODO-tutorial): https://github.com/Textualize/TODO-tutorial.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/C7AZ33/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/C7AZ33/feedback/</feedback_url>
            </event>
            <event guid='46d89171-66fd-5082-aa5d-141de7d3d525' id='29196' code='C7AZ33'>
                <room>Club H</room>
                <title>Build a terminal TODO app with Textual</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>Learn how to build powerful terminal-based user interfaces (TUIs) with ease using Textual - an open-source Python framework.

Throughout this tutorial, you&apos;ll learn how to use Textual&apos;s built-in widgets, reactive features, and message-passing system to create a dynamic and user-friendly TODO app that&apos;s perfect for managing your daily tasks.

From creating and displaying tasks to editing and deleting them, you&apos;ll cover all the essential features needed to make a functional TODO app.

You&apos;ll also learn how to use Textual CSS to style your TUI for a polished and elegant look, together with some tips and tricks to make it even easier to develop your TUIs in Textual.

This tutorial provides everything you need to get started with building TUIs in Python. By the end of the tutorial, you&apos;ll have a fully functional and stylish TODO app that showcases Textual&apos;s versatility and useful features.</abstract>
                <slug>europython-2023-29196-1-build-a-terminal-todo-app-with-textual</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33700'>Rodrigo Gir&#227;o Serr&#227;o</person>
                </persons>
                <language>en</language>
                <description>[Instructions below!]

During this tutorial, we will build a terminal-user interface for a TODO app.
This will showcase all the essential features that make Textual a very interesting Python framework to build terminal user interfaces.

Topics covered in this tutorial include:

 - the vast built-in widget gallery;
 - reactive attributes;
 - handling messages;
 - key bindings and action methods;
 - Textual CSS;
 - the Textual developer console; and
 - creation of custom widgets.

Attendees are not expected to have prior Textual experience but they are expected to have a working knowledge of classes, methods, and attributes.

If you want to attend the workshop, please follow the instructions in [this GitHub repo](https://github.com/Textualize/TODO-tutorial): https://github.com/Textualize/TODO-tutorial.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/C7AZ33/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/C7AZ33/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club B' guid='adf8e14a-7784-5378-ba65-a3621e64826e'>
            <event guid='a9325f6c-e4f3-5c7b-9ba5-2bbd1d4f5f82' id='29642' code='CRTSNK'>
                <room>Club B</room>
                <title>sktime - python toolbox for time series</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>This tutorial presents sktime - a unified, open source framework for machine learning with time series in python. sktime provides interfaces to algorithms of various types, and modular tools for pipelining, composition, and tuning. You will learn how identify your learning task, and how to build, use, and evaluate different algorithms on real-world data sets.

All tutorial notebooks are available in this repository and runnable from the cloud:
https://github.com/sktime/sktime-tutorial-europython-2023</abstract>
                <slug>europython-2023-29642-0-sktime-python-toolbox-for-time-series</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='34064'>Franz Kiraly</person><person id='38401'>Sagar Mishra</person><person id='39519'>Kiril Ralinovski</person>
                </persons>
                <language>en</language>
                <description>Time series are ubiquitous in real-world applications, but often add considerable complications to data science workflows. 

In this tutorial, we will present sktime - a unified framework for machine learning with time series. sktime covers multiple time series learning problems, including time series transformation, classification and forecasting, among others. In addition, sktime allows you to easily apply an algorithm for one task to solve another (e.g. a scikit-learn regressor to solve a forecasting problem). In the tutorial, you will learn about how you can identify these problems, what their key differences are and how they are related.

To solve these problems, sktime provides various time series algorithms and modular tools for pipelining, composition and tuning. In addition, sktime is interoperable with common libraries in the data science stack, including scikit-learn, statsmodels and prophet.

You will learn how to use, combine, tune and evaluate different algorithms on real-world data sets. We&apos;ll work through all of this step by step using Jupyter Notebooks. 

sktime is an openly governed open source community where everyone can join or become a leader. We encourage contributions and provide mentoring opportunities.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/CRTSNK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/CRTSNK/feedback/</feedback_url>
            </event>
            <event guid='5db11823-a1a1-5689-8ee6-65bd785aa6d1' id='29642' code='CRTSNK'>
                <room>Club B</room>
                <title>sktime - python toolbox for time series</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>This tutorial presents sktime - a unified, open source framework for machine learning with time series in python. sktime provides interfaces to algorithms of various types, and modular tools for pipelining, composition, and tuning. You will learn how identify your learning task, and how to build, use, and evaluate different algorithms on real-world data sets.

All tutorial notebooks are available in this repository and runnable from the cloud:
https://github.com/sktime/sktime-tutorial-europython-2023</abstract>
                <slug>europython-2023-29642-1-sktime-python-toolbox-for-time-series</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='34064'>Franz Kiraly</person><person id='38401'>Sagar Mishra</person><person id='39519'>Kiril Ralinovski</person>
                </persons>
                <language>en</language>
                <description>Time series are ubiquitous in real-world applications, but often add considerable complications to data science workflows. 

In this tutorial, we will present sktime - a unified framework for machine learning with time series. sktime covers multiple time series learning problems, including time series transformation, classification and forecasting, among others. In addition, sktime allows you to easily apply an algorithm for one task to solve another (e.g. a scikit-learn regressor to solve a forecasting problem). In the tutorial, you will learn about how you can identify these problems, what their key differences are and how they are related.

To solve these problems, sktime provides various time series algorithms and modular tools for pipelining, composition and tuning. In addition, sktime is interoperable with common libraries in the data science stack, including scikit-learn, statsmodels and prophet.

You will learn how to use, combine, tune and evaluate different algorithms on real-world data sets. We&apos;ll work through all of this step by step using Jupyter Notebooks. 

sktime is an openly governed open source community where everyone can join or become a leader. We encourage contributions and provide mentoring opportunities.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/CRTSNK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/CRTSNK/feedback/</feedback_url>
            </event>
            <event guid='8b650ba7-e9e9-5464-869c-35335980dbe7' id='28791' code='Z7HAUH'>
                <room>Club B</room>
                <title>Food For Rabbits: Celery From Zero to Hero</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>In a world, full of Micro-Services, distributing tasks is a constant challenge, and there&apos;s only one tool that can rule them all.

In this workshop, we&apos;ll introduce Celery - a tool for distributing tasks in an easy, fast, and flexible manner, and take you from zero to hero!
- We&apos;re going to understand why we need a distributed task system, and why to choose Celery.
- We&apos;ll write our first Celery task.
- Understand how to configure and run Celery.
- Familiarize ourselves with Celery&apos;s fundamental concepts.
- Dive into celery customizable options.
- Finally, we&apos;ll see a real-life example of how we used Celery in our production system and how we customized it to fit our needs, and discuss how you can do the same.</abstract>
                <slug>europython-2023-28791-0-food-for-rabbits-celery-from-zero-to-hero</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='33323'>Roy M Mezan</person>
                </persons>
                <language>en</language>
                <description>**Outline:**
- Setup [5 min]
- What is Celery? When to use it and why.  [5 min]
- Let&apos;s write our first Celery Task.  [5 min + 10 min Exercise]
- Getting statuses and results.  [5 min + 15 min Exercise]
- The Celery Worker.  [5 min]
- Go configure - the Celery Config.  [5 min]
- Customize it &amp; Retry [10 min + 15 min Exercise]
- Break - [15min]
- Celery Workflows and Signature.  [10 min + 25 min Exercise]
- How we use Celery to solve complex problems &amp; Production use-case [10 min]
- Final Excercise [40 min]
- Recap [5 min]

---
## [link to the workshop materials](https://gitlab.com/88roy88/celery_workshop)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/Z7HAUH/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/Z7HAUH/feedback/</feedback_url>
            </event>
            <event guid='c1745d0b-a249-53fc-b9c1-6bf3f84c674e' id='28791' code='Z7HAUH'>
                <room>Club B</room>
                <title>Food For Rabbits: Celery From Zero to Hero</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-17T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>In a world, full of Micro-Services, distributing tasks is a constant challenge, and there&apos;s only one tool that can rule them all.

In this workshop, we&apos;ll introduce Celery - a tool for distributing tasks in an easy, fast, and flexible manner, and take you from zero to hero!
- We&apos;re going to understand why we need a distributed task system, and why to choose Celery.
- We&apos;ll write our first Celery task.
- Understand how to configure and run Celery.
- Familiarize ourselves with Celery&apos;s fundamental concepts.
- Dive into celery customizable options.
- Finally, we&apos;ll see a real-life example of how we used Celery in our production system and how we customized it to fit our needs, and discuss how you can do the same.</abstract>
                <slug>europython-2023-28791-1-food-for-rabbits-celery-from-zero-to-hero</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='33323'>Roy M Mezan</person>
                </persons>
                <language>en</language>
                <description>**Outline:**
- Setup [5 min]
- What is Celery? When to use it and why.  [5 min]
- Let&apos;s write our first Celery Task.  [5 min + 10 min Exercise]
- Getting statuses and results.  [5 min + 15 min Exercise]
- The Celery Worker.  [5 min]
- Go configure - the Celery Config.  [5 min]
- Customize it &amp; Retry [10 min + 15 min Exercise]
- Break - [15min]
- Celery Workflows and Signature.  [10 min + 25 min Exercise]
- How we use Celery to solve complex problems &amp; Production use-case [10 min]
- Final Excercise [40 min]
- Recap [5 min]

---
## [link to the workshop materials](https://gitlab.com/88roy88/celery_workshop)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/Z7HAUH/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/Z7HAUH/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club C' guid='de67a498-3720-5e81-836e-c6857397d92d'>
            <event guid='2bba52d6-6b77-5a69-a7fd-482abf0054cf' id='33697' code='BABLES'>
                <room>Club C</room>
                <title>Humble Data</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-17T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>Are you a complete beginner to coding, but would love to learn how to get started? Have you been curious about data science, but feel overwhelmed with all the talk of AI? Many people working in data science were once in the same position and know how hard it is to take those first steps.

However, fear not! It&#8217;s easier than you think to get started, and to help make this transition easier we&#8217;re hosting a workshop to teach beginners how to get started in Python and data science. We&#8217;ll start with Python basics, and show you how you can use this knowledge to easily read and transform data using Pandas, Python&#8217;s powerful data analysis library. You&#8217;ll also see how you can create beautiful, customized visualizations in Python using packages such as Matplotlib and Seaborn. You&#8217;ll also learn how to use a core data science tool, Jupyter notebooks, to run and check the output of your code. See more details on the workshop here: https://ep2023.europython.eu/humble-data</abstract>
                <slug>europython-2023-33697-0-humble-data</slug>
                <track></track>
                
                <persons>
                    <person id='33458'>Jodie Burchell</person><person id='38297'>Lais Carvalho</person>
                </persons>
                <language>en</language>
                <description>This workshop is aimed at both those with no programming experience, and those with some experience in Python who want to get started in data science, and who want to learn in a supportive, relaxed and empathic environment. 

As part of the workshop, participants will work through a series of approachable tutorials with the help of a mentor. For 3 hours (breaks included) we will have teams that will work together with mentors to do plenty of exercises, quizzes and games, to go from Zero to Hero in Python data science. All that participants will need to bring is a tablet or a laptop with internet access - we will help them get started with the rest!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BABLES/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BABLES/feedback/</feedback_url>
            </event>
            <event guid='e37c3609-30e0-5993-b8b1-649b2b781a6d' id='33697' code='BABLES'>
                <room>Club C</room>
                <title>Humble Data</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-17T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>Are you a complete beginner to coding, but would love to learn how to get started? Have you been curious about data science, but feel overwhelmed with all the talk of AI? Many people working in data science were once in the same position and know how hard it is to take those first steps.

However, fear not! It&#8217;s easier than you think to get started, and to help make this transition easier we&#8217;re hosting a workshop to teach beginners how to get started in Python and data science. We&#8217;ll start with Python basics, and show you how you can use this knowledge to easily read and transform data using Pandas, Python&#8217;s powerful data analysis library. You&#8217;ll also see how you can create beautiful, customized visualizations in Python using packages such as Matplotlib and Seaborn. You&#8217;ll also learn how to use a core data science tool, Jupyter notebooks, to run and check the output of your code. See more details on the workshop here: https://ep2023.europython.eu/humble-data</abstract>
                <slug>europython-2023-33697-1-humble-data</slug>
                <track></track>
                
                <persons>
                    <person id='33458'>Jodie Burchell</person><person id='38297'>Lais Carvalho</person>
                </persons>
                <language>en</language>
                <description>This workshop is aimed at both those with no programming experience, and those with some experience in Python who want to get started in data science, and who want to learn in a supportive, relaxed and empathic environment. 

As part of the workshop, participants will work through a series of approachable tutorials with the help of a mentor. For 3 hours (breaks included) we will have teams that will work together with mentors to do plenty of exercises, quizzes and games, to go from Zero to Hero in Python data science. All that participants will need to bring is a tablet or a laptop with internet access - we will help them get started with the rest!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BABLES/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BABLES/feedback/</feedback_url>
            </event>
            <event guid='53ed8327-2ffa-5093-95bd-c22306dd9814' id='33699' code='73TAHG'>
                <room>Club C</room>
                <title>Women in AI Workshop</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-17T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33699-0-women-in-ai-workshop</slug>
                <track></track>
                
                <persons>
                    <person id='33583'>Nabanita Roy</person><person id='39648'>Liliya Akhtyamova</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/73TAHG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/73TAHG/feedback/</feedback_url>
            </event>
            <event guid='e469344c-f46b-599b-ab20-27ac4bad0d25' id='33699' code='73TAHG'>
                <room>Club C</room>
                <title>Women in AI Workshop</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-17T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33699-1-women-in-ai-workshop</slug>
                <track></track>
                
                <persons>
                    <person id='33583'>Nabanita Roy</person><person id='39648'>Liliya Akhtyamova</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/73TAHG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/73TAHG/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club D' guid='7fcee5c4-5365-5ed6-87e8-a96ceb2e915b'>
            <event guid='477ab783-8cd2-5fdb-8208-33eb2a860392' id='33698' code='JWTGPG'>
                <room>Club D</room>
                <title>Beginners&apos; Day - PyLadies Snake Workshop</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-17T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33698-0-beginners-day-pyladies-snake-workshop</slug>
                <track></track>
                
                <persons>
                    <person id='38267'>Petr Viktorin</person><person id='33911'>Mia Baji&#263;</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/JWTGPG/feedback/</feedback_url>
            </event>
            <event guid='aa989e3b-4bd3-5251-8859-be9b4e50294e' id='33698' code='JWTGPG'>
                <room>Club D</room>
                <title>Beginners&apos; Day - PyLadies Snake Workshop</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-17T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33698-1-beginners-day-pyladies-snake-workshop</slug>
                <track></track>
                
                <persons>
                    <person id='38267'>Petr Viktorin</person><person id='33911'>Mia Baji&#263;</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/JWTGPG/feedback/</feedback_url>
            </event>
            <event guid='ae552a3e-3eda-52d0-914c-177b9d9336a4' id='33698' code='JWTGPG'>
                <room>Club D</room>
                <title>Beginners&apos; Day - PyLadies Snake Workshop</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-17T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33698-2-beginners-day-pyladies-snake-workshop</slug>
                <track></track>
                
                <persons>
                    <person id='38267'>Petr Viktorin</person><person id='33911'>Mia Baji&#263;</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/JWTGPG/feedback/</feedback_url>
            </event>
            <event guid='3d5e54d3-81e6-5191-8753-f7770e2c8a8d' id='33698' code='JWTGPG'>
                <room>Club D</room>
                <title>Beginners&apos; Day - PyLadies Snake Workshop</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-17T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33698-3-beginners-day-pyladies-snake-workshop</slug>
                <track></track>
                
                <persons>
                    <person id='38267'>Petr Viktorin</person><person id='33911'>Mia Baji&#263;</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/JWTGPG/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='2' date='2023-07-18' start='2023-07-18T04:00:00+02:00' end='2023-07-19T03:59:00+02:00'>
        <room name='Club A' guid='53d942d8-41c6-5ce2-9e68-e27dbe1581dd'>
            <event guid='9db153cc-edab-5faa-8c93-401eb4e4cc17' id='35574' code='3KTQQW'>
                <room>Club A</room>
                <title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-18T08:30:00+02:00</date>
                <start>08:30</start>
                <duration>01:00</duration>
                <abstract>Welcome to EuroPython 2023! You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!

Queues will be sorted by your **first name** on your ticket. Your ticket can be located via your order confirmation email (from support@pretix.eu with the Subject: Your order: XXXX). If you ordered your ticket after we&apos;ve sent badges for printing (after 10 July), go directly to the Info Desk (also referred as Debugging Desk) and a volunteer will help!</abstract>
                <slug>europython-2023-35574-registration-welcome-forum-hall-foyer-1st-floor</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3KTQQW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3KTQQW/feedback/</feedback_url>
            </event>
            <event guid='d5405d83-cf61-5959-b5e2-03e46272a100' id='29497' code='FGWHPW'>
                <room>Club A</room>
                <title>Gathering data from the web using Python</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>Information is abundant and readily available on the internet. However, the sheer amount of data can be overwhelming and time-consuming to navigate through. That&apos;s where web scraping comes in - a powerful tool used to extract data from websites and turn it into a usable format.

In this tutorial, we will explore the basics of web scraping and how to implement it using Scrapy (a Python framework). Whether you are a data analyst, programmer, or researcher, this tutorial will equip you with the fundamental skills needed to create your own web scraper and extract valuable information from websites.</abstract>
                <slug>europython-2023-29497-0-gathering-data-from-the-web-using-python</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33952'>Renne Rocha</person>
                </persons>
                <language>en</language>
                <description>During the tutorial, we will learn concepts of web scraping doing some exercises against a fake website with challenges that are very similar to the ones we will find in real websites using Scrapy, a Python framework designed for web scraping tasks.

**To better follow the tutorial, it would be good to install Scrapy in your machine**. More information at https://github.com/rennerocha/europython-2023-gathering-data-tutorial#before-the-tutorial

1. (presentation) Web scraping fundamentals
   - What is web scraping, why we want to do web scraping and real use cases for web scraping

2. (presentation) Scrapy basic concepts
   - What is Scrapy, what its advantages over other tools, its basic classes (Spider, Request, Response, parses) and how to create a very simple web crawler

3. (presentation + exercise) Scraping a basic HTML page 
   - Gathering data from http://quotes.toscrape.com/, a plain well-structure HTML page

4. (presentation  exercise) Scraping Javascript generated content (external API)
   - Gathering data from http://quotes.toscrape.com/scroll, where the data is gathered from an API call

5. (presentation + exercise) Scraping Javascript generated content (data into HTML)
   - Gathering data from http://quotes.toscrape.com/js/, where the data to be gathered is located inside the HTML code, but processed by Javascript
   
6. (presentation + exercise) Scraping page with forms and ViewState
  - Gathering data from http://quotes.toscrape.com/search.aspx, where we need to handle forms submission and ViewStates
 
7. (presentation) Proxies and headless browsers
   - When simple requests are not enough, what other tools we have to proceed

8. (presentation) Being polite and not gathering data you shouldn&apos;t gather
   - How to avoid interfering in your target website and some restrictions about what data you can and you can&apos;t gather</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://github.com/rennerocha/europython-2023-gathering-data-tutorial">Slides and Code Samples of the Tutorial</link>
                </links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/FGWHPW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/FGWHPW/feedback/</feedback_url>
            </event>
            <event guid='3789c285-14e8-58db-894e-d3591004143b' id='29497' code='FGWHPW'>
                <room>Club A</room>
                <title>Gathering data from the web using Python</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>Information is abundant and readily available on the internet. However, the sheer amount of data can be overwhelming and time-consuming to navigate through. That&apos;s where web scraping comes in - a powerful tool used to extract data from websites and turn it into a usable format.

In this tutorial, we will explore the basics of web scraping and how to implement it using Scrapy (a Python framework). Whether you are a data analyst, programmer, or researcher, this tutorial will equip you with the fundamental skills needed to create your own web scraper and extract valuable information from websites.</abstract>
                <slug>europython-2023-29497-1-gathering-data-from-the-web-using-python</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33952'>Renne Rocha</person>
                </persons>
                <language>en</language>
                <description>During the tutorial, we will learn concepts of web scraping doing some exercises against a fake website with challenges that are very similar to the ones we will find in real websites using Scrapy, a Python framework designed for web scraping tasks.

**To better follow the tutorial, it would be good to install Scrapy in your machine**. More information at https://github.com/rennerocha/europython-2023-gathering-data-tutorial#before-the-tutorial

1. (presentation) Web scraping fundamentals
   - What is web scraping, why we want to do web scraping and real use cases for web scraping

2. (presentation) Scrapy basic concepts
   - What is Scrapy, what its advantages over other tools, its basic classes (Spider, Request, Response, parses) and how to create a very simple web crawler

3. (presentation + exercise) Scraping a basic HTML page 
   - Gathering data from http://quotes.toscrape.com/, a plain well-structure HTML page

4. (presentation  exercise) Scraping Javascript generated content (external API)
   - Gathering data from http://quotes.toscrape.com/scroll, where the data is gathered from an API call

5. (presentation + exercise) Scraping Javascript generated content (data into HTML)
   - Gathering data from http://quotes.toscrape.com/js/, where the data to be gathered is located inside the HTML code, but processed by Javascript
   
6. (presentation + exercise) Scraping page with forms and ViewState
  - Gathering data from http://quotes.toscrape.com/search.aspx, where we need to handle forms submission and ViewStates
 
7. (presentation) Proxies and headless browsers
   - When simple requests are not enough, what other tools we have to proceed

8. (presentation) Being polite and not gathering data you shouldn&apos;t gather
   - How to avoid interfering in your target website and some restrictions about what data you can and you can&apos;t gather</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://github.com/rennerocha/europython-2023-gathering-data-tutorial">Slides and Code Samples of the Tutorial</link>
                </links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/FGWHPW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/FGWHPW/feedback/</feedback_url>
            </event>
            <event guid='28c691ff-8186-59ea-b222-10ba9923d710' id='29261' code='WB7ALT'>
                <room>Club A</room>
                <title>Kubernetes &lt;3 Python - Deploy Python apps &amp; extend Kubernetes with Python</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>You don&apos;t have to be an Ops expert to make Kubernetes useful! In this workshop, you will learn how to overcome complexity, and love Kubernetes as a Platform to deploy a Python web application or your data science and machine learning pipelines. You will learn how and when to use basic elements of Kubernetes like Deployments and Stateful Sets.

Once you understand these basic elements, you will learn how to extend Kubernetes using Python.
You will learn how to define custom resources and controllers to automate all things related to your applications&apos; life cycle, from ETL through sending email for password reset to where your imagination stops.

In the end of this workshop, you will have deployed a python web application and successfully extend Kubernetes with so-called operators to manage the complete life-cycle of your application.</abstract>
                <slug>europython-2023-29261-0-kubernetes-3-python-deploy-python-apps-extend-kubernetes-with-python</slug>
                <track>Infrastructure: Cloud &amp; Hardware (2023)</track>
                
                <persons>
                    <person id='33820'>Oz Tiram</person>
                </persons>
                <language>en</language>
                <description>Why you need this workshop?

Kubernetes is a platform for running applications on one or more computer. It provides a command line and a set of APIs to provision applications, virtual machines and even a complete cloud infrastructure.
In this workshop, you will learn why Kubernetes is a great platform to host your applications or run your data pipeline consistently - whether you run on a single Raspberry Pi or tens of Virtual machines in the public cloud.

What will you do in this workshop?

1. You will see that deploying Kubernetes isn&apos;t hard. You can use a single node or a cluster. Furthermore, you will learn the differences and trade-off between managed Kubernetes and DIY approach.

2. After a basic introduction to Kubernetes, you will learn to deploy and run a web application written in Python using a Kubernetes deployment and store data in a data using a Stateful Set. You will learn how to define these resources using YAML manifests and learn to use a pure Python alternative to create these manifests.

3. Finally, you will learn how you can extend Kubernetes to more than just serving a web application to almost anything you want, using so-called Kubernetes Operators. To do this, you will create a Kubernetes &quot;extension&quot;. You first learn how to store your own data inside Kubernetes, using Custom Resources. Once you define your own custom definitions, you will learn how to create a controller that interacts with this data and other objects in your Kubernetes.

The ultimate goal of this training:

By the end of this workshop, you will know how to deploy a Python application, and you will be able to extend Kubernetes using operators written also in Python.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/WB7ALT/resources/K8s_Workshop_Europython_erv3Kr9.pdf">Workshop notes</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/WB7ALT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/WB7ALT/feedback/</feedback_url>
            </event>
            <event guid='56f4f562-abe7-5647-a399-06d6a2646c33' id='29261' code='WB7ALT'>
                <room>Club A</room>
                <title>Kubernetes &lt;3 Python - Deploy Python apps &amp; extend Kubernetes with Python</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>You don&apos;t have to be an Ops expert to make Kubernetes useful! In this workshop, you will learn how to overcome complexity, and love Kubernetes as a Platform to deploy a Python web application or your data science and machine learning pipelines. You will learn how and when to use basic elements of Kubernetes like Deployments and Stateful Sets.

Once you understand these basic elements, you will learn how to extend Kubernetes using Python.
You will learn how to define custom resources and controllers to automate all things related to your applications&apos; life cycle, from ETL through sending email for password reset to where your imagination stops.

In the end of this workshop, you will have deployed a python web application and successfully extend Kubernetes with so-called operators to manage the complete life-cycle of your application.</abstract>
                <slug>europython-2023-29261-1-kubernetes-3-python-deploy-python-apps-extend-kubernetes-with-python</slug>
                <track>Infrastructure: Cloud &amp; Hardware (2023)</track>
                
                <persons>
                    <person id='33820'>Oz Tiram</person>
                </persons>
                <language>en</language>
                <description>Why you need this workshop?

Kubernetes is a platform for running applications on one or more computer. It provides a command line and a set of APIs to provision applications, virtual machines and even a complete cloud infrastructure.
In this workshop, you will learn why Kubernetes is a great platform to host your applications or run your data pipeline consistently - whether you run on a single Raspberry Pi or tens of Virtual machines in the public cloud.

What will you do in this workshop?

1. You will see that deploying Kubernetes isn&apos;t hard. You can use a single node or a cluster. Furthermore, you will learn the differences and trade-off between managed Kubernetes and DIY approach.

2. After a basic introduction to Kubernetes, you will learn to deploy and run a web application written in Python using a Kubernetes deployment and store data in a data using a Stateful Set. You will learn how to define these resources using YAML manifests and learn to use a pure Python alternative to create these manifests.

3. Finally, you will learn how you can extend Kubernetes to more than just serving a web application to almost anything you want, using so-called Kubernetes Operators. To do this, you will create a Kubernetes &quot;extension&quot;. You first learn how to store your own data inside Kubernetes, using Custom Resources. Once you define your own custom definitions, you will learn how to create a controller that interacts with this data and other objects in your Kubernetes.

The ultimate goal of this training:

By the end of this workshop, you will know how to deploy a Python application, and you will be able to extend Kubernetes using operators written also in Python.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/WB7ALT/resources/K8s_Workshop_Europython_erv3Kr9.pdf">Workshop notes</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/WB7ALT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/WB7ALT/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club E' guid='fbf44aaf-fa84-51fb-90c7-f426cd0cfe7a'>
            <event guid='eb348d30-a140-58fb-86ba-a21a831a7404' id='29891' code='3HR8HZ'>
                <room>Club E</room>
                <title>Practical tools for documentation at scale</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>In a hands-on workshop I&apos;ll introduce some of the tools and methods I have developed to improve documentation consistently and effectively, at scale - by a thousand people or more, working on a hundred or so software products and other projects.</abstract>
                <slug>europython-2023-29891-0-practical-tools-for-documentation-at-scale</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33507'>Daniele Procida</person>
                </persons>
                <language>en</language>
                <description>At Canonical, I lead documentation practice - the way we, as an organisation, do documentation. That means establishing a shared understanding of standards, and how to reach them. 

To help do this I have developed a number of tools and methods to help all of us understand our progress and achieve it faster.

In this hands-on workshop I will introduce some of them, and help you start to adapt them to your own needs.

I hope that this workshop will be of value to anyone working in an engineering organisation where documentation discipline and success seems harder to obtain than it should be.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3HR8HZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3HR8HZ/feedback/</feedback_url>
            </event>
            <event guid='d7bee122-1bc4-593f-b031-f2d303a559be' id='29891' code='3HR8HZ'>
                <room>Club E</room>
                <title>Practical tools for documentation at scale</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>In a hands-on workshop I&apos;ll introduce some of the tools and methods I have developed to improve documentation consistently and effectively, at scale - by a thousand people or more, working on a hundred or so software products and other projects.</abstract>
                <slug>europython-2023-29891-1-practical-tools-for-documentation-at-scale</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33507'>Daniele Procida</person>
                </persons>
                <language>en</language>
                <description>At Canonical, I lead documentation practice - the way we, as an organisation, do documentation. That means establishing a shared understanding of standards, and how to reach them. 

To help do this I have developed a number of tools and methods to help all of us understand our progress and achieve it faster.

In this hands-on workshop I will introduce some of them, and help you start to adapt them to your own needs.

I hope that this workshop will be of value to anyone working in an engineering organisation where documentation discipline and success seems harder to obtain than it should be.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3HR8HZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3HR8HZ/feedback/</feedback_url>
            </event>
            <event guid='5374aaac-4c0f-5d95-86fc-8a0a0e4d033b' id='29310' code='TGRMDT'>
                <room>Club E</room>
                <title>pytest tips and tricks for a better testsuite</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>pytest lets you write simple tests fast - but also scales to very complex scenarios: Beyond the basics of no-boilerplate test functions, this training will show various intermediate/advanced features, as well as gems and tricks.

To attend this training, you should already be familiar with the pytest basics (e.g. writing test functions, parametrize, or what a fixture is) and want to learn how to take the next step to improve your test suites.

If you&apos;re already familiar with things like fixture caching scopes, autouse, or using the built-in tmp_path/monkeypatch/... fixtures: There will probably be some slides about concepts you already know, but there are also various little hidden tricks and gems I&apos;ll be showing.</abstract>
                <slug>europython-2023-29310-0-pytest-tips-and-tricks-for-a-better-testsuite</slug>
                <track>Testing (2023)</track>
                
                <persons>
                    <person id='33822'>Freya Bruhin</person>
                </persons>
                <language>en</language>
                <description>We&apos;ll cover things like:

- Recommended pytest settings for more strictness
- What&apos;s xfail and why is it useful?
- How to mark an entire test file or single parameters
- Ways to deal with parametrize IDs and syntax
- Useful built-in pytest fixtures
- Caching for fixtures
- Using fixtures implicitly
- Advanced fixture and parametrization topics
- How to customize fixtures behavior based on markers or custom CLI arguments
- Patching, mocking, and alternatives
- Various useful plugins, and how to write your own
- Short intro to property-based testing with Hypothesis</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TGRMDT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TGRMDT/feedback/</feedback_url>
            </event>
            <event guid='f813cb04-b2e8-55d8-85da-85147edb187e' id='29310' code='TGRMDT'>
                <room>Club E</room>
                <title>pytest tips and tricks for a better testsuite</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>pytest lets you write simple tests fast - but also scales to very complex scenarios: Beyond the basics of no-boilerplate test functions, this training will show various intermediate/advanced features, as well as gems and tricks.

To attend this training, you should already be familiar with the pytest basics (e.g. writing test functions, parametrize, or what a fixture is) and want to learn how to take the next step to improve your test suites.

If you&apos;re already familiar with things like fixture caching scopes, autouse, or using the built-in tmp_path/monkeypatch/... fixtures: There will probably be some slides about concepts you already know, but there are also various little hidden tricks and gems I&apos;ll be showing.</abstract>
                <slug>europython-2023-29310-1-pytest-tips-and-tricks-for-a-better-testsuite</slug>
                <track>Testing (2023)</track>
                
                <persons>
                    <person id='33822'>Freya Bruhin</person>
                </persons>
                <language>en</language>
                <description>We&apos;ll cover things like:

- Recommended pytest settings for more strictness
- What&apos;s xfail and why is it useful?
- How to mark an entire test file or single parameters
- Ways to deal with parametrize IDs and syntax
- Useful built-in pytest fixtures
- Caching for fixtures
- Using fixtures implicitly
- Advanced fixture and parametrization topics
- How to customize fixtures behavior based on markers or custom CLI arguments
- Patching, mocking, and alternatives
- Various useful plugins, and how to write your own
- Short intro to property-based testing with Hypothesis</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TGRMDT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TGRMDT/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club H' guid='6941bc28-5e5b-53eb-b15c-1285139e1f61'>
            <event guid='67476a07-8791-5085-9b66-a10dcd17fe3f' id='29607' code='PZQHFU'>
                <room>Club H</room>
                <title>Develop your Python cloud applications offline with LocalStack</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>This tutorial provides a hands-on introduction to LocalStack - the leading platform to develop and test cloud applications entirely on your local machine!

LocalStack provides a set of 70+ AWS services, running in a local Docker container. The hugely popular open source project (46k+ Github stars, 130+ million downloads) is today considered a &#8220;must-have&#8221; in the toolbox of every AWS cloud developer around the globe.

Outline:
(1) Intro to AWS cloud development with Python
(2) Developing Python cloud apps with LocalStack
(3) Advanced integrations for IaC and CI/CD pipelines
(4) Python internals &amp; advanced features in LocalStack
(5) Summary and wrap-up

This interactive session covers live coding to showcase common use cases, settings for local debugging of Lambdas and containerized apps, as well as advanced features that can radically improve team collaboration. We&apos;ll also glance over the large ecosystem of tools &amp; integrations - including Terraform, Pulumi, CDK, Serverless.</abstract>
                <slug>europython-2023-29607-0-develop-your-python-cloud-applications-offline-with-localstack</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='34040'>Waldemar Hummer</person><person id='34006'>Thomas Rausch</person><person id='36807'>Alex Rashed</person>
                </persons>
                <language>en</language>
                <description>In this tutorial, we provide a hands-on introduction to LocalStack - the leading community platform that allows you to develop and test cloud&amp;serverless applications entirely on your local machine, without ever having to connect to the real cloud!

LocalStack is the leading AWS cloud emulator that provides a set of 70+ AWS services, running in a Docker container entirely on your local machine. Being a hugely popular open source project, LocalStack is among the top ~150 all-time repositories ranked on Github (46k+ stars), has been downloaded over 130+ million times, and is today considered a &#8220;must-have&#8221; in the toolbox of every AWS cloud developer around the globe.

This tutorial is designed to follow along on participants&#8217; own laptops. There are no special requirements - literally the only prerequisite is having Python 3.x and Docker installed on the local machine. We are going to develop AWS applications, but since LocalStack runs entirely on the local machine without ever talking to the real cloud, *no* cloud access credentials are required to follow the tutorial.

The tutorial is structured as follows:
(1) Intro to AWS cloud development with Python (0:00-0:30h)
(2) Developing Python cloud apps with LocalStack (0:30-1:30h)
(3) Advanced integrations for IaC and CI/CD pipelines (1:30-2:15h)
(4) Python internals and advanced team collaboration features in LocalStack (2:15-2:45h)
(5) Summary and wrap-up (2:45-3:00h)

The session covers interactive live coding to showcase common scenarios and use cases, different settings for local debugging of Lambdas and containerized apps (e.g., ECS/EKS), as well as some advanced new features that can radically improve productivity and team collaboration patterns. We will also glance over the large ecosystem of tools that LocalStack natively integrates with - from IaC frameworks like Terraform or Pulumi, to application frameworks like Serverless, to a whole suite of tools in the AWS ecosystem, including CDK, SAM, Copilot, Chalice, etc.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PZQHFU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PZQHFU/feedback/</feedback_url>
            </event>
            <event guid='c0e6f346-abc9-5fb4-95a9-b7f6bca5d3b3' id='29607' code='PZQHFU'>
                <room>Club H</room>
                <title>Develop your Python cloud applications offline with LocalStack</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>This tutorial provides a hands-on introduction to LocalStack - the leading platform to develop and test cloud applications entirely on your local machine!

LocalStack provides a set of 70+ AWS services, running in a local Docker container. The hugely popular open source project (46k+ Github stars, 130+ million downloads) is today considered a &#8220;must-have&#8221; in the toolbox of every AWS cloud developer around the globe.

Outline:
(1) Intro to AWS cloud development with Python
(2) Developing Python cloud apps with LocalStack
(3) Advanced integrations for IaC and CI/CD pipelines
(4) Python internals &amp; advanced features in LocalStack
(5) Summary and wrap-up

This interactive session covers live coding to showcase common use cases, settings for local debugging of Lambdas and containerized apps, as well as advanced features that can radically improve team collaboration. We&apos;ll also glance over the large ecosystem of tools &amp; integrations - including Terraform, Pulumi, CDK, Serverless.</abstract>
                <slug>europython-2023-29607-1-develop-your-python-cloud-applications-offline-with-localstack</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='34040'>Waldemar Hummer</person><person id='34006'>Thomas Rausch</person><person id='36807'>Alex Rashed</person>
                </persons>
                <language>en</language>
                <description>In this tutorial, we provide a hands-on introduction to LocalStack - the leading community platform that allows you to develop and test cloud&amp;serverless applications entirely on your local machine, without ever having to connect to the real cloud!

LocalStack is the leading AWS cloud emulator that provides a set of 70+ AWS services, running in a Docker container entirely on your local machine. Being a hugely popular open source project, LocalStack is among the top ~150 all-time repositories ranked on Github (46k+ stars), has been downloaded over 130+ million times, and is today considered a &#8220;must-have&#8221; in the toolbox of every AWS cloud developer around the globe.

This tutorial is designed to follow along on participants&#8217; own laptops. There are no special requirements - literally the only prerequisite is having Python 3.x and Docker installed on the local machine. We are going to develop AWS applications, but since LocalStack runs entirely on the local machine without ever talking to the real cloud, *no* cloud access credentials are required to follow the tutorial.

The tutorial is structured as follows:
(1) Intro to AWS cloud development with Python (0:00-0:30h)
(2) Developing Python cloud apps with LocalStack (0:30-1:30h)
(3) Advanced integrations for IaC and CI/CD pipelines (1:30-2:15h)
(4) Python internals and advanced team collaboration features in LocalStack (2:15-2:45h)
(5) Summary and wrap-up (2:45-3:00h)

The session covers interactive live coding to showcase common scenarios and use cases, different settings for local debugging of Lambdas and containerized apps (e.g., ECS/EKS), as well as some advanced new features that can radically improve productivity and team collaboration patterns. We will also glance over the large ecosystem of tools that LocalStack natively integrates with - from IaC frameworks like Terraform or Pulumi, to application frameworks like Serverless, to a whole suite of tools in the AWS ecosystem, including CDK, SAM, Copilot, Chalice, etc.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PZQHFU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PZQHFU/feedback/</feedback_url>
            </event>
            <event guid='65a029e3-9876-5a58-bf77-a3a65d3797b5' id='35393' code='AEAPDB'>
                <room>Club H</room>
                <title>Robust Data Transformation with Pandas: Typing, Validation, Testing</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>We will explore possibilities for making our data analyses and transformations in Pandas robust and production ready. We will see how advanced group-by, resample or rolling aggregations work on large time series weather data. (As a bonus, you will learn about Prague climate.) We will use type annotations and schema validations with the Pandera library to make our code more readable and robust. We will also show the potential of property-based testing using the Hypothesis package, with strategies generated from Pandera schemas. We will show how to avoid issues with time zones when working with time series data. By the end of the tutorial, you will have a deeper understanding of advanced Pandas aggregations and be able to write robust, production ready Pandas code.</abstract>
                <slug>europython-2023-35393-0-robust-data-transformation-with-pandas-typing-validation-testing</slug>
                <track></track>
                
                <persons>
                    <person id='39229'>Jakub Urban</person><person id='39267'>Jan Pipek</person>
                </persons>
                <language>en</language>
                <description>## Instructions

Before attending the workshop, it&apos;s important to prepare your environment by following the **instructions in the repository located at https://github.com/coobas/robust-pandas-workshop**. This will ensure that you have all the necessary tools and dependencies installed to participate in the workshop.

Please note that we will be continuously updating the repository leading up to the workshop, so it&apos;s important to **pull the latest changes on the day of the workshop** to ensure that you have the most up-to-date materials.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/AEAPDB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/AEAPDB/feedback/</feedback_url>
            </event>
            <event guid='4b611c94-b773-5c26-aedf-444ae5da0f81' id='35393' code='AEAPDB'>
                <room>Club H</room>
                <title>Robust Data Transformation with Pandas: Typing, Validation, Testing</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>We will explore possibilities for making our data analyses and transformations in Pandas robust and production ready. We will see how advanced group-by, resample or rolling aggregations work on large time series weather data. (As a bonus, you will learn about Prague climate.) We will use type annotations and schema validations with the Pandera library to make our code more readable and robust. We will also show the potential of property-based testing using the Hypothesis package, with strategies generated from Pandera schemas. We will show how to avoid issues with time zones when working with time series data. By the end of the tutorial, you will have a deeper understanding of advanced Pandas aggregations and be able to write robust, production ready Pandas code.</abstract>
                <slug>europython-2023-35393-1-robust-data-transformation-with-pandas-typing-validation-testing</slug>
                <track></track>
                
                <persons>
                    <person id='39229'>Jakub Urban</person><person id='39267'>Jan Pipek</person>
                </persons>
                <language>en</language>
                <description>## Instructions

Before attending the workshop, it&apos;s important to prepare your environment by following the **instructions in the repository located at https://github.com/coobas/robust-pandas-workshop**. This will ensure that you have all the necessary tools and dependencies installed to participate in the workshop.

Please note that we will be continuously updating the repository leading up to the workshop, so it&apos;s important to **pull the latest changes on the day of the workshop** to ensure that you have the most up-to-date materials.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/AEAPDB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/AEAPDB/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club B' guid='adf8e14a-7784-5378-ba65-a3621e64826e'>
            <event guid='279b17e1-1599-51c7-8d93-7f6850e67415' id='33701' code='ZSCRBC'>
                <room>Club B</room>
                <title>Write your first web API with Rust!</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>with Jeremy</abstract>
                <slug>europython-2023-33701-0-write-your-first-web-api-with-rust</slug>
                <track></track>
                
                <persons>
                    <person id='37791'>Jeremy Lempereur</person>
                </persons>
                <language>en</language>
                <description>In this 180 minutes tutorial, we will take a hands on approach to Rust, and write our first web API!

We will only focus on the parts you&apos;ll need to know to start building APIs, so you can learn while you build!

No need to know Rust as long as you&apos;re curious about the language.
If you&apos;ve already built web APIs in python, you should be good to go!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZSCRBC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZSCRBC/feedback/</feedback_url>
            </event>
            <event guid='12ce6801-19a2-550d-af31-86336e39061c' id='33701' code='ZSCRBC'>
                <room>Club B</room>
                <title>Write your first web API with Rust!</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>with Jeremy</abstract>
                <slug>europython-2023-33701-1-write-your-first-web-api-with-rust</slug>
                <track></track>
                
                <persons>
                    <person id='37791'>Jeremy Lempereur</person>
                </persons>
                <language>en</language>
                <description>In this 180 minutes tutorial, we will take a hands on approach to Rust, and write our first web API!

We will only focus on the parts you&apos;ll need to know to start building APIs, so you can learn while you build!

No need to know Rust as long as you&apos;re curious about the language.
If you&apos;ve already built web APIs in python, you should be good to go!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZSCRBC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZSCRBC/feedback/</feedback_url>
            </event>
            <event guid='62225ad8-a9e4-5ecc-92df-6bff21e95c68' id='35672' code='ADBP8B'>
                <room>Club B</room>
                <title>Build your first GraphQL API using Python &#127827;</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>This workshop will teach you how to create your first GraphQL API using Python and Strawberry. We will be using using Fastapi as our framework of choice, but most of the concept will be applicable to other frameworks too.

We&apos;ll learn how GraphQL works under the hood, and how we can leverage type hints to create end to end type safe GraphQL queries.

To run this workshop you need to have at least python 3.8 and have followed the installation guide here: https://github.com/patrick91/strawberry-tiny-workshop</abstract>
                <slug>europython-2023-35672-build-your-first-graphql-api-using-python</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34511'>Patrick Arminio</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ADBP8B/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ADBP8B/feedback/</feedback_url>
            </event>
            <event guid='8352a92c-4cc8-56ed-9c90-646caf44ced3' id='35732' code='SXEJWS'>
                <room>Club B</room>
                <title>Practical introduction to descriptors</title>
                <subtitle></subtitle>
                <type>Tutorial</type>
                <date>2023-07-18T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>Descriptors are not black magic and this practical tutorial will show you that.
In fact, you use descriptors every day and you don&apos;t even know it!

Through a series of practical, hands-on exercises, you will learn

 - how to create a descriptor;
 - how to use the dunder methods `__get__`, `__set__`, and `__set_name__`;
 - what the descriptor protocol is; and
 - where descriptors show up in day-to-day Python code.</abstract>
                <slug>europython-2023-35732-practical-introduction-to-descriptors</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33700'>Rodrigo Gir&#227;o Serr&#227;o</person>
                </persons>
                <language>en</language>
                <description>The expected Python level for participants is &#8220;intermediate&#8221;.
In practice, if you are comfortable with using the built-in `property` and if you have used [dunder methods](https://mathspp.com/blog/pydonts/dunder-methods) before, you should be fine.

This tutorial is based off of [an article I wrote about descriptors](https://mathspp.com/blog/pydonts/describing-descriptors).

All materials can be accessed from [this GH repo](https://github.com/mathspp/talks).</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SXEJWS/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SXEJWS/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club C' guid='de67a498-3720-5e81-836e-c6857397d92d'>
            <event guid='d6953b54-e949-5c04-b236-feacf89d2979' id='33700' code='MQRJXF'>
                <room>Club C</room>
                <title>WASM Summit</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-18T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>This summit aims to bring together maintainers and users of the Python with WebAssembly, to discuss the state of this ecosystem, existing challenges and ongoing work.

Find out more, including how to sign up, here: [https://ep2023.europython.eu/wasm](https://ep2023.europython.eu/wasm)</abstract>
                <slug>europython-2023-33700-0-wasm-summit</slug>
                <track></track>
                
                <persons>
                    <person id='34079'>Roman Yurchak</person><person id='33291'>Nicholas Tollervey</person>
                </persons>
                <language>en</language>
                <description>Agenda:
   
* 9:00: Meet and greet (many of us won&#8217;t know each other) + unconference-y post-it based organisation.
* 9:30: Presentations (30mins each)
* 11:00: Coffee
* 11:20: Presentations
* 13:00: Lunch at the PCC (included)
* 14:00: Unconference-y activities (discussions, hacks, ad hoc tutorials etc&#8230;)
* 16:00: Round-up / plenary session for feedback and organising next steps.
* 18:30: Dinner</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MQRJXF/feedback/</feedback_url>
            </event>
            <event guid='078cd942-c65c-50c9-bebf-fbe6f4931a4e' id='33700' code='MQRJXF'>
                <room>Club C</room>
                <title>WASM Summit</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-18T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>This summit aims to bring together maintainers and users of the Python with WebAssembly, to discuss the state of this ecosystem, existing challenges and ongoing work.

Find out more, including how to sign up, here: [https://ep2023.europython.eu/wasm](https://ep2023.europython.eu/wasm)</abstract>
                <slug>europython-2023-33700-1-wasm-summit</slug>
                <track></track>
                
                <persons>
                    <person id='34079'>Roman Yurchak</person><person id='33291'>Nicholas Tollervey</person>
                </persons>
                <language>en</language>
                <description>Agenda:
   
* 9:00: Meet and greet (many of us won&#8217;t know each other) + unconference-y post-it based organisation.
* 9:30: Presentations (30mins each)
* 11:00: Coffee
* 11:20: Presentations
* 13:00: Lunch at the PCC (included)
* 14:00: Unconference-y activities (discussions, hacks, ad hoc tutorials etc&#8230;)
* 16:00: Round-up / plenary session for feedback and organising next steps.
* 18:30: Dinner</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MQRJXF/feedback/</feedback_url>
            </event>
            <event guid='fd5f981d-71c9-5187-9494-517eb7264451' id='33700' code='MQRJXF'>
                <room>Club C</room>
                <title>WASM Summit</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-18T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>This summit aims to bring together maintainers and users of the Python with WebAssembly, to discuss the state of this ecosystem, existing challenges and ongoing work.

Find out more, including how to sign up, here: [https://ep2023.europython.eu/wasm](https://ep2023.europython.eu/wasm)</abstract>
                <slug>europython-2023-33700-2-wasm-summit</slug>
                <track></track>
                
                <persons>
                    <person id='34079'>Roman Yurchak</person><person id='33291'>Nicholas Tollervey</person>
                </persons>
                <language>en</language>
                <description>Agenda:
   
* 9:00: Meet and greet (many of us won&#8217;t know each other) + unconference-y post-it based organisation.
* 9:30: Presentations (30mins each)
* 11:00: Coffee
* 11:20: Presentations
* 13:00: Lunch at the PCC (included)
* 14:00: Unconference-y activities (discussions, hacks, ad hoc tutorials etc&#8230;)
* 16:00: Round-up / plenary session for feedback and organising next steps.
* 18:30: Dinner</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MQRJXF/feedback/</feedback_url>
            </event>
            <event guid='827ab2e0-5386-54e9-aef7-2310dac2830a' id='33700' code='MQRJXF'>
                <room>Club C</room>
                <title>WASM Summit</title>
                <subtitle></subtitle>
                <type>Conference Workshop</type>
                <date>2023-07-18T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>This summit aims to bring together maintainers and users of the Python with WebAssembly, to discuss the state of this ecosystem, existing challenges and ongoing work.

Find out more, including how to sign up, here: [https://ep2023.europython.eu/wasm](https://ep2023.europython.eu/wasm)</abstract>
                <slug>europython-2023-33700-3-wasm-summit</slug>
                <track></track>
                
                <persons>
                    <person id='34079'>Roman Yurchak</person><person id='33291'>Nicholas Tollervey</person>
                </persons>
                <language>en</language>
                <description>Agenda:
   
* 9:00: Meet and greet (many of us won&#8217;t know each other) + unconference-y post-it based organisation.
* 9:30: Presentations (30mins each)
* 11:00: Coffee
* 11:20: Presentations
* 13:00: Lunch at the PCC (included)
* 14:00: Unconference-y activities (discussions, hacks, ad hoc tutorials etc&#8230;)
* 16:00: Round-up / plenary session for feedback and organising next steps.
* 18:30: Dinner</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MQRJXF/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Club D' guid='7fcee5c4-5365-5ed6-87e8-a96ceb2e915b'>
            <event guid='475e692d-dee4-5a87-9a17-269f3bd52802' id='33696' code='P77JBK'>
                <room>Club D</room>
                <title>Trans*Code</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-18T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>01:30</duration>
                <abstract>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate. FInd more details including how to sign up here: https://ep2023.europython.eu/trans_code</abstract>
                <slug>europython-2023-33696-0-trans-code</slug>
                <track></track>
                
                <persons>
                    <person id='38193'>Naomi Ceder</person>
                </persons>
                <language>en</language>
                <description>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Trans\*Code events are informal hackdays where participants can explore their ideas in collaboration with like-minded people. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate.

Trans*Code events are similar to hackathons, but with some key differences:

* Events are only one day long. So you don&#8217;t need to take off an entire weekend;
* Events are not competitive. At Trans\*Code events, we&#8217;re all pulling for each other. While we do have final presentations, they are made in the spirit of sharing, not in the spirit of competition;
* Events encourage following your interests. Want to work on that project? Fine, do it. Want to spend the morning with this one, and the afternoon with that one? The choice is yours. Trans*Code subscribes to the Un-Conference philosophy - whatever happens is exactly what should happen.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/P77JBK/feedback/</feedback_url>
            </event>
            <event guid='561ea18a-be8c-512c-b0a1-d8f0454ffc85' id='33696' code='P77JBK'>
                <room>Club D</room>
                <title>Trans*Code</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-18T11:15:00+02:00</date>
                <start>11:15</start>
                <duration>01:30</duration>
                <abstract>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate. FInd more details including how to sign up here: https://ep2023.europython.eu/trans_code</abstract>
                <slug>europython-2023-33696-1-trans-code</slug>
                <track></track>
                
                <persons>
                    <person id='38193'>Naomi Ceder</person>
                </persons>
                <language>en</language>
                <description>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Trans\*Code events are informal hackdays where participants can explore their ideas in collaboration with like-minded people. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate.

Trans*Code events are similar to hackathons, but with some key differences:

* Events are only one day long. So you don&#8217;t need to take off an entire weekend;
* Events are not competitive. At Trans\*Code events, we&#8217;re all pulling for each other. While we do have final presentations, they are made in the spirit of sharing, not in the spirit of competition;
* Events encourage following your interests. Want to work on that project? Fine, do it. Want to spend the morning with this one, and the afternoon with that one? The choice is yours. Trans*Code subscribes to the Un-Conference philosophy - whatever happens is exactly what should happen.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/P77JBK/feedback/</feedback_url>
            </event>
            <event guid='574a62c0-cff9-50e2-b427-0a2cfcf7ba9a' id='33696' code='P77JBK'>
                <room>Club D</room>
                <title>Trans*Code</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-18T13:45:00+02:00</date>
                <start>13:45</start>
                <duration>01:30</duration>
                <abstract>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate. FInd more details including how to sign up here: https://ep2023.europython.eu/trans_code</abstract>
                <slug>europython-2023-33696-2-trans-code</slug>
                <track></track>
                
                <persons>
                    <person id='38193'>Naomi Ceder</person>
                </persons>
                <language>en</language>
                <description>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Trans\*Code events are informal hackdays where participants can explore their ideas in collaboration with like-minded people. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate.

Trans*Code events are similar to hackathons, but with some key differences:

* Events are only one day long. So you don&#8217;t need to take off an entire weekend;
* Events are not competitive. At Trans\*Code events, we&#8217;re all pulling for each other. While we do have final presentations, they are made in the spirit of sharing, not in the spirit of competition;
* Events encourage following your interests. Want to work on that project? Fine, do it. Want to spend the morning with this one, and the afternoon with that one? The choice is yours. Trans*Code subscribes to the Un-Conference philosophy - whatever happens is exactly what should happen.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/P77JBK/feedback/</feedback_url>
            </event>
            <event guid='84420b33-5c36-5618-82cc-a685b87bd25d' id='33696' code='P77JBK'>
                <room>Club D</room>
                <title>Trans*Code</title>
                <subtitle></subtitle>
                <type>Free Workshop</type>
                <date>2023-07-18T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate. FInd more details including how to sign up here: https://ep2023.europython.eu/trans_code</abstract>
                <slug>europython-2023-33696-3-trans-code</slug>
                <track></track>
                
                <persons>
                    <person id='38193'>Naomi Ceder</person>
                </persons>
                <language>en</language>
                <description>Trans\*Code is an international hack event series focused on building connections and community while exploring the tech side of transgender issues and opportunities. Trans\*Code events are informal hackdays where participants can explore their ideas in collaboration with like-minded people. Coders, designers, activists, visionaries of all sorts, and community members not currently working in technology are all welcome and encouraged to participate.

Trans*Code events are similar to hackathons, but with some key differences:

* Events are only one day long. So you don&#8217;t need to take off an entire weekend;
* Events are not competitive. At Trans\*Code events, we&#8217;re all pulling for each other. While we do have final presentations, they are made in the spirit of sharing, not in the spirit of competition;
* Events encourage following your interests. Want to work on that project? Fine, do it. Want to spend the morning with this one, and the afternoon with that one? The choice is yours. Trans*Code subscribes to the Un-Conference philosophy - whatever happens is exactly what should happen.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/P77JBK/feedback/</feedback_url>
            </event>
            <event guid='be2f88fd-3826-5dc7-878b-7e7d688d762f' id='34099' code='GRDPPX'>
                <room>Club D</room>
                <title>Beginner Conference Orientation</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-18T16:10:00+02:00</date>
                <start>16:10</start>
                <duration>00:50</duration>
                <abstract>Are you new to EuroPython or any Python conference? You must have a lot of questions like: 

- What is a Lightning Talk? 
- What is an Open Space? 
- Besides going to talk, what else can I do? 
- Why everyone seems to know each other, how can I join in conversations?

Don&apos;t worry, we are here to help you get the most out of your first EuroPython experience. Come to join us in this Beginner Conference Orientation that is tailer made for you.</abstract>
                <slug>europython-2023-34099-beginner-conference-orientation</slug>
                <track></track>
                
                <persons>
                    <person id='33929'>Cheuk Ting Ho</person>
                </persons>
                <language>en</language>
                <description>In this orientation, we will break into 2 parts

**1) Suggestions about what you can do as a first-time attendee at the conference (30 mins)**

We will give you many tips on how you can get the most out of your experience here at EuroPython. We will also tell you what you can expect at the conference and how to make new connections at the conference. 

**2) No questions are stupid questions, ask away Q &amp;A session (20 mins)**

Since we are here to help we would like to let you ask us questions. We love your questions! Please ask us anything, we are happy to answer and no questions are stupid questions.

Slides can be found here: https://drive.google.com/file/d/1Sga1kbrMkmj1rHWpjBispQ-PnTOx0KOi/view?usp=sharing</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/GRDPPX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/GRDPPX/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='3' date='2023-07-19' start='2023-07-19T04:00:00+02:00' end='2023-07-20T03:59:00+02:00'>
        <room name='PyCharm (Forum Hall)' guid='bde7cec6-20ad-5a61-8c4f-43220b09f87c'>
            <event guid='68e641fe-9235-55de-92a0-932f8ab1d87d' id='35610' code='ZPN8UC'>
                <room>PyCharm (Forum Hall)</room>
                <title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-19T08:00:00+02:00</date>
                <start>08:00</start>
                <duration>01:00</duration>
                <abstract>Welcome to EuroPython 2023! You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!

Queues will be sorted by your **first name** on your ticket. Your ticket can be located via your order confirmation email (from support@pretix.eu with the Subject: Your order: XXXX). If you ordered your ticket after we&apos;ve sent badges for printing (after 10 July), go directly to the Info Desk (also referred as Debugging Desk) and a volunteer will help!</abstract>
                <slug>europython-2023-35610-registration-welcome-forum-hall-foyer-1st-floor</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZPN8UC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZPN8UC/feedback/</feedback_url>
            </event>
            <event guid='a030423a-e76a-541f-a277-db867c31925c' id='34200' code='QUQSZH'>
                <room>PyCharm (Forum Hall)</room>
                <title>Opening Session</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-19T09:00:00+02:00</date>
                <start>09:00</start>
                <duration>00:30</duration>
                <abstract></abstract>
                <slug>europython-2023-34200-opening-session</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/QUQSZH/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/QUQSZH/feedback/</feedback_url>
            </event>
            <event guid='f161a616-393d-59f9-916d-07513e3c5571' id='33369' code='C7SMXT'>
                <room>PyCharm (Forum Hall)</room>
                <title>Kindnesses &amp; Promises</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-07-19T09:30:00+02:00</date>
                <start>09:30</start>
                <duration>00:45</duration>
                <abstract>The more applications you build, the more libraries you share, the more they become an excuse to meet people and have fun together.

What makes it fun? And how do we keep it fun?</abstract>
                <slug>europython-2023-33369-kindnesses-promises</slug>
                <track></track>
                
                <persons>
                    <person id='37648'>Petr Viktorin</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/C7SMXT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/C7SMXT/feedback/</feedback_url>
            </event>
            <event guid='3582e22e-8257-5063-a015-f27f34ec6153' id='29666' code='C3GDXY'>
                <room>PyCharm (Forum Hall)</room>
                <title>How we are making CPython faster. Past, present and future</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T10:45:00+02:00</date>
                <start>10:45</start>
                <duration>00:30</duration>
                <abstract>Python 3.11 is considerably faster than 3.10. 
How did we do that? And 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.</abstract>
                <slug>europython-2023-29666-how-we-are-making-cpython-faster-past-present-and-future</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='34086'>Mark Shannon</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/C3GDXY/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/C3GDXY/feedback/</feedback_url>
            </event>
            <event guid='92d4d471-62c2-5bb9-8e07-d7deccfcd241' id='29848' code='BCDBBR'>
                <room>PyCharm (Forum Hall)</room>
                <title>f&quot;yeah!&quot; - How we are supercharging f-strings in Python 3.12</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T11:35:00+02:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>Everybody loves f-strings in Python. But what if they could be even better? Thanks to PEP 701, Python 3.12 will ship with an improved version of f-strings that will once and for all fix the little remaining problems that f-strings have had, while also supercharging them with new cool powers.  In this talk, you will discover the dark little secrets of how f-strings were being processed before Python 3.12 and the many things that didn&apos;t work and you didn&apos;t know about. You will learn how we changed thousands of lines of manually written C code without anybody noticing, how we changed the oldest part of CPython so quotes behave like parentheses, and how we taught the PEG parser to understand f-strings. Plus, you&apos;ll gain an understanding of how these new and improved capabilities will provide several advantages for both end-users and library developers, while also reducing the maintenance cost of the CPython implementation.</abstract>
                <slug>europython-2023-29848-f-yeah-how-we-are-supercharging-f-strings-in-python-3-12</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='35139'>Pablo Galindo Salgado</person><person id='37300'>Marta Gomez</person>
                </persons>
                <language>en</language>
                <description>In this talk, we will cover one of the primary syntactic changes of Python 3.12: PEP 701 &#8211; Syntactic formalisation of f-strings.  Here is the structure of the talk:  - How f-strings were originally introduced - Problems with f-strings * Backslashes cannot be used within the expression part of f-strings * It is impossible to use the quote character delimiting the f-string within the expression portion * Comments are forbidden, even in multi-line f-strings * Arbitrary nesting of expressions without expansion of escape sequences is impossible * There is no referential transparency - How f-strings are currently parsed: The two-pass process - How PEP 701 formalises a grammar for f-strings - How we changed the tokeniser and parser to understand f-strings - Syntactic and semantic consequences of the new grammar - Implementation challenges  Attendees will not only learn the (normally unknown) problems that f-strings previously had, but also will learn through the journey of how the PEP was implemented several techniques and approaches to changing big codebases such as CPython in an efficient way, while minimising user impact. Attendees will also learn how changes to the CPython grammar that also require lexer changes are implemented, which is quite a unique situation, as most changes to the Python Grammar do not require lexer changes.  No matter whether someone is new to Python or an advanced developer that enjoys hacking with the interpreter, there is something in this talk for them.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BCDBBR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BCDBBR/feedback/</feedback_url>
            </event>
            <event guid='9b4ac39b-a514-5aa4-820f-ab3d2813d65d' id='28908' code='NVW8EF'>
                <room>PyCharm (Forum Hall)</room>
                <title>HPy: The Future of Python Native Extensions</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T12:10:00+02:00</date>
                <start>12:10</start>
                <duration>00:30</duration>
                <abstract>Updating Python versions often forces us to update native extensions at the
same time. But what if you need to update Python because of a security issue,
but cannot (yet) move to a newer version of a dependency? Or you are running a
proprietary binary extension that cannot easily be recompiled?

The HPy project provides a better C extension API for Python. It compiles to
binaries that work across all versions of CPython, PyPy, GraalPy. HPy makes
porting from the existing C API easy and its design ensures that the binaries
we produce today stay binary compatible with future Python versions.

NumPy is the single largest direct user of the CPython C API we know of. After
over 2 years of work and more than 30k lines of code ported, we can demonstrate
NumPy running its tests and benchmarks with HPy. We will show the same NumPy
binary run on multiple CPython versions and GraalPy. And we will discuss
performance characteristics of this port across CPython, GraalPy, and PyPy.</abstract>
                <slug>europython-2023-28908-hpy-the-future-of-python-native-extensions</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33455'>&#352;t&#283;p&#225;n &#352;indel&#225;&#345;</person><person id='33681'>Florian Angerer</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/NVW8EF/resources/EuroPython2023_HPy_dLwxQ4i.pdf">Slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/NVW8EF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/NVW8EF/feedback/</feedback_url>
            </event>
            <event guid='680861e9-a488-5c70-9d83-9abb50e70274' id='33374' code='AAJLRW'>
                <room>PyCharm (Forum Hall)</room>
                <title>CPython Core Developer Panel</title>
                <subtitle></subtitle>
                <type>Panel</type>
                <date>2023-07-19T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>01:00</duration>
                <abstract>Come meet the folks who make the Python programming language!

A panel discussion of core Python developers will take place on Wednesday at 2pm. Hear what&apos;s on their mind, what they&apos;re working on, and what the future holds for Python.

The panel will include:
* sitting Steering Council member Pablo Galindo Salgado;
* cybersecurity expert and aspiring core developer Marta G&#243;mez Mac&#237;as who made f-strings much better in 3.12;
* CPython&apos;s Windows expert Steve Dower;
* Red Hat veteran and emeritus Steering Council member Petr Viktorin;
* and the tech lead of Microsoft&apos;s &quot;Faster Python&quot; team Dr. Mark &quot;HotPy&quot; Shannon. 

The panel will be chaired by &#321;ukasz &quot;Any-color-you-like-as-long-as-it&apos;s-black&quot; Langa.</abstract>
                <slug>europython-2023-33374-cpython-core-developer-panel</slug>
                <track></track>
                
                <persons>
                    <person id='34015'>&#321;ukasz Langa</person><person id='38267'>Petr Viktorin</person><person id='35139'>Pablo Galindo Salgado</person><person id='34086'>Mark Shannon</person><person id='39142'>Steve Dower</person><person id='37300'>Marta Gomez</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/AAJLRW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/AAJLRW/feedback/</feedback_url>
            </event>
            <event guid='63328c9e-fcec-5c7f-81df-2b9c52d8d7f6' id='30039' code='9GJFZZ'>
                <room>PyCharm (Forum Hall)</room>
                <title>Dynamically generated methods with a non-generic signature</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>In other words, Descriptors + PEP-362 (function signature object) and a seasoning of PEP-487 (simpler customization of class creation via `__init_subclass__`).

There are different ways to have generated methods and attributes attached to all classes in a library, and this talk presents the way we&#8217;re doing it in scikit-learn. Here you&#8217;ll understand the use-case, and see the details and challenges presented by it, and how we approached them.</abstract>
                <slug>europython-2023-30039-dynamically-generated-methods-with-a-non-generic-signature</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='34479'>Adrin Jalali</person>
                </persons>
                <language>en</language>
                <description>Title:
Dynamically generated methods with a non-generic signature

Abstract:
In other words, Descriptors + PEP-362 (function signature object) and a seasoning of PEP-487 (simpler customization of class creation via `__init_subclass__`).

There are different ways to have generated methods and attributes attached to all classes in a library, and this talk presents the way we&#8217;re doing it in scikit-learn. Here you&#8217;ll understand the use-case, and see the details and challenges presented by it, and how we approached them.

Long:
The use-case we study here goes as: we would like to add methods to all `Estimator`s, which are all subclasses of the `BaseEstimator`. The signature of the methods generated depends on the signature of other methods existing in those subclasses, but we also want to give the option of modifying generated methods without having to change the existing methods.

The solution we present involves a few concepts which we&#8217;ll explain during the talk:
Investigate the existing methods&#8217; signature using `inspect`
Manually traverse MRO (method resolution order) and inspect class attributes allowing for modifications on what the `inspect` has concluded
Use a descriptor to generate methods accordingly
Use PEP-362 to attach a signature object to the generated methods
Dynamically generate docstrings for those methods
Use PEP-487, aka `__init_subclass__`, to attach those methods to child classes when appropriate

This is a hands-on talk, explaining each concept in isolation and then showing how they fit together, and we&#8217;ll be presenting and testing code during the talk.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/9GJFZZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/9GJFZZ/feedback/</feedback_url>
            </event>
            <event guid='4d98a931-7820-5603-a98a-475499d2d449' id='28769' code='XW8RB3'>
                <room>PyCharm (Forum Hall)</room>
                <title>Writing a Python interpreter from scratch, in half an hour.</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>You use the Python interpreter every single day. It does a lot of things for you: checks that your code has valid syntax and is properly indented, imports modules from various locations, and runs your code instruction-by-instruction.

But if you&apos;ve ever wondered how exactly it happens, this talk will teach you the entire process, by building a working python interpreter from scratch.</abstract>
                <slug>europython-2023-28769-writing-a-python-interpreter-from-scratch-in-half-an-hour</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='34089'>Tushar Sadhwani</person>
                </persons>
                <language>en</language>
                <description>The plan is to write a really simple, but working Python interpreter that can run Python code, from scratch.

The topics we&apos;ll be going through to build this interpreter:
- Lexing an indentation based language
  - Why `Indent` and `Dedent` need to be tokens
- Writing a Recursive Descent parser
  - Parsing literals: ints, strings, lists, dictionaries
  - Parsing expressions
  - Parsing function calls - `print(&quot;Hello world!&quot;)`
- Semantic analysis: removing invalid code
- A tree-walk interpreter
  - Interpreting `print()` statements
  - Running `import` statements
  - File I/O: implementing `open()` calls
- Running `json.loads()` and `json.dumps()` from scratch</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XW8RB3/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XW8RB3/feedback/</feedback_url>
            </event>
            <event guid='b91a3c56-ca0a-5836-8981-cda80a1b4f31' id='33372' code='LJZBKW'>
                <room>PyCharm (Forum Hall)</room>
                <title>Large Language Models: From Prototype to Production</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-07-19T17:00:00+02:00</date>
                <start>17:00</start>
                <duration>00:45</duration>
                <abstract>Large Language Models (LLMs) have shown some impressive capabilities and their impact is the topic of the moment. What will the future look like? Are we going to only talk to bots? Will prompting replace programming? Or are we just hyping up unreliable parrots and burning money? In this talk, I&apos;ll present visions for NLP in the age of LLMs and a pragmatic, practical approach for how to use Large Language Models to ship more successful NLP projects from prototype to production today.</abstract>
                <slug>europython-2023-33372-large-language-models-from-prototype-to-production</slug>
                <track></track>
                
                <persons>
                    <person id='37651'>Ines Montani</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/LJZBKW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/LJZBKW/feedback/</feedback_url>
            </event>
            <event guid='322c030d-671c-5838-b6d0-5df177f094e1' id='34203' code='938SAD'>
                <room>PyCharm (Forum Hall)</room>
                <title>Lightning Talks Wednesday</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T17:50:00+02:00</date>
                <start>17:50</start>
                <duration>00:45</duration>
                <abstract>Enjoy Wednesday&apos;s lightning talks, hosted by La&#237;s Carvalho &#11015;&#65039;

  - **Pyvo Meetup @ EuroPython** &#8212; Mia Baji&#263;
  - **AI Game Tournament** &#8212; Neil Vaytet
  - **How Government Policy Can Affect Open Source** &#8212; Cheuk Ting Ho
  - **AWS Lambda &#10084;&#65039; Python 3.11** &#8212; Jonas Weissensel
  - **Brings Llamas Closer** &#8212; Vaibhav (VB) Srivastav 
  - **Adding Arrow Function to Python Grammar** &#8212; Oguz Albayrak 
  - **A Curious Bug that Happened with List Comprehensions** &#8212; Jouni Sepp&#228;nen  
  - **Spy** &#8212; Antonio Cuni
  - **Learning Python Through Blocks** &#8212; Joshua Lowe  
  - **25 Years of Open Source Software** &#8212; Radomir Dopieralski</abstract>
                <slug>europython-2023-34203-lightning-talks-wednesday</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/938SAD/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/938SAD/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='South Hall 2A' guid='b4aa8885-f330-5bc6-b7b3-d64f56d62691'>
            <event guid='6181c044-f0c9-5bfd-b141-0b56850f3436' id='30022' code='UVUXFQ'>
                <room>South Hall 2A</room>
                <title>Adding zero-downtime migrations strategy in a SaaS project</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T10:45:00+02:00</date>
                <start>10:45</start>
                <duration>00:30</duration>
                <abstract>Zero-downtime migration is a technique for running database migrations without stopping the web app. As clients&apos; databases grow larger, applying necessary updates to the database can become time-consuming or potentially break the database schema. This talk will describe problematic operation types and provide a strategy for writing and running migrations to release new software versions without downtime.</abstract>
                <slug>europython-2023-30022-adding-zero-downtime-migrations-strategy-in-a-saas-project</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34475'>Iga Karbowiak</person>
                </persons>
                <language>en</language>
                <description>When running a web-based SaaS application, it is important to provide software updates without causing downtime for users. However, these updates often require changing the database schema with migrations. In this talk, we will discuss a solution that allows the software to remain life and able to handle incoming traffic while performing migrations.
To ensure zero downtime during this process, the old code must be compatible with the new database schema. Although this may seem easy, it often isn&apos;t. In this talk, we will cover problematic operations such as:
- renaming tables or columns,
- deleting tables or columns,
- adding new columns,
- updating all records in a table with a large amount of data.

We will discuss potential problems that may arise due to certain changes and provide corresponding solutions. Additionally, I will describe the challenges we encountered when introducing this approach to Saleor, an open-source e-commerce platform powered by Django.

While the topic and examples are from the Django project, the issue is general and can be faced by any database-related project.

The structure of the talk:
1. Background of the problem
2. Examples of operations causing the downtime
3. Introducing the zero-downtime strategy
    a) Writing migrations that follow a zero downtime approach
    b) Proceeding the software update without any downtime</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/UVUXFQ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/UVUXFQ/feedback/</feedback_url>
            </event>
            <event guid='ee889328-056c-5578-962e-a0d7298b5865' id='29402' code='PMNVR3'>
                <room>South Hall 2A</room>
                <title>A quick guide to logging for Django developers</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T11:35:00+02:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>The python `logging` module is a really powerful tool for troubleshooting with a lot of potential to save us hours of debugging.

The aim for the talk is to provide an overview how the logging module in python works, how Django uses it and how to improve our logging to make it better for our web project.</abstract>
                <slug>europython-2023-29402-a-quick-guide-to-logging-for-django-developers</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33899'>Ivaylo Donchev</person>
                </persons>
                <language>en</language>
                <description>As Django developers, we implictly use the python `logging` module daily in our work - for HTTP requests, for SQL queries, for custom logs, etc.

The aim of this talk is to provide useful information for Django developers on:
1. How does logging in python works?
2. How to setup a logging configuration based on our needs?
3. How to configure logging in our Django app?
4. Tips and tricks for custom logging in Django app</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PMNVR3/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PMNVR3/feedback/</feedback_url>
            </event>
            <event guid='69f7958c-f328-5379-9ea8-e68fb00ac25c' id='29482' code='VPWTYU'>
                <room>South Hall 2A</room>
                <title>Stop using print! Understanding and using the &quot;logging&quot; module</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T12:10:00+02:00</date>
                <start>12:10</start>
                <duration>00:30</duration>
                <abstract>If you&apos;re like me, then you&apos;ve long known about Python&apos;s &quot;logging&quot; module, but you&apos;ve ignored it because it seemed too complex. In this talk, I&apos;ll show you that &quot;logging&quot; is easy to learn and use, giving you far more flexibility than you can get from inserting calls to &quot;print&quot; all over your code. I&apos;ll show you how you can start to use &quot;logging&quot; right away -- but also how you can use it to create a sophisticated logging system that sends different types of output to different destinations. After this talk, you&apos;ll know how to use &quot;logging&quot;, and you&apos;ll be less likely to use &quot;print&quot; in your applications.</abstract>
                <slug>europython-2023-29482-stop-using-print-understanding-and-using-the-logging-module</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33842'>Reuven M. Lerner</person>
                </persons>
                <language>en</language>
                <description>You don&apos;t need to be a Python expert to use the &quot;logging&quot; module! In this talk, I&apos;ll show how you can take advantage of it almost right away, with the basic configuration. We&apos;ll then go into more complex parts of the module, looking at different handler types (and using multiple handlers), formatters, and filters. We&apos;ll look at different ways you can configure your logging system, and what some of the best practices are for including logging in your programs. 

I&apos;m aiming this talk at beginners because it took me far too long to recognize the usefulness of the &quot;logging&quot; module, and I&apos;m hoping to help others start using it much earlier in their Python journey.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/VPWTYU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/VPWTYU/feedback/</feedback_url>
            </event>
            <event guid='6b110801-5565-55a0-b99a-198308625779' id='29927' code='CUEWG8'>
                <room>South Hall 2A</room>
                <title>Pydantic: Making life easier with data validation</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>Abstract:
Data validation is a critical component of any software application, ensuring that the data processed by the application is accurate and consistent. However, data validation can often be a tedious and error-prone process, especially when dealing with complex data structures. Pydantic, a powerful and flexible data validation library for Python, simplifies the process of data validation by providing a declarative syntax that is easy to read and write.</abstract>
                <slug>europython-2023-29927-pydantic-making-life-easier-with-data-validation</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='34397'>Bojan Miletic</person>
                </persons>
                <language>en</language>
                <description>In this talk, we will introduce Pydantic and discuss how it can be used to make data validation easy in Python. We will cover the following topics:

- What is Pydantic and how does it work?
- How to define data models using Pydantic
- Validating and converting data using Pydantic
- Working with complex data structures using Pydantic
- Integrating Pydantic with other Python libraries

We will also provide real-world examples of how Pydantic has been used to simplify data validation in production applications. By the end of this talk, attendees will have a solid understanding of Pydantic and how it can be used to make data validation easy in their Python applications.

Target Audience:
This talk is aimed at Python developers of all levels who are interested in simplifying the process of data validation in their applications. No prior knowledge of Pydantic is required, but a basic understanding of Python is recommended.

Conclusion:
In this talk, attendees will learn how to use Pydantic to simplify data validation in their Python applications. Whether you are building a small script or a large-scale application, Pydantic can be an invaluable tool for data validation</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/CUEWG8/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/CUEWG8/feedback/</feedback_url>
            </event>
            <event guid='2eb204b9-020b-5a62-8fa9-278fa69363dd' id='29170' code='MEXBJ7'>
                <room>South Hall 2A</room>
                <title>CLI application development made easier with typer</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>Do you feel like digging through github code to learn how to use it is painful? Also think simply packaging and publishing your library to the world on pypi sometimes isn&apos;t enough to help others use what you are working on? Then come join me, as this talks is definitely for you!

In this presentation, I&apos;d like to present you typer, and why it&apos;s probably the easiest and most affordable way to create command line applications (in 2023) that your users will love to use.
We&apos;ll discuss it&apos;s key strong points, how to structure your CLI application, and make it ready to be packaged and published with no hussle.</abstract>
                <slug>europython-2023-29170-cli-application-development-made-easier-with-typer</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33671'>Vin&#237;cius Gubiani Ferreira</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MEXBJ7/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MEXBJ7/feedback/</feedback_url>
            </event>
            <event guid='43a56845-435a-5769-b3a1-2189285d3ed5' id='29456' code='NLZZBQ'>
                <room>South Hall 2A</room>
                <title>Polars vs Pandas - what&apos;s the difference?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Have you heard about Polars? What are the differences? Is Polars replacing Pandas? In this talk, we are going to demystify these questions about Polars. Compares the differences between Polars and Pandas, and explains the pros and cons of both of them.</abstract>
                <slug>europython-2023-29456-polars-vs-pandas-what-s-the-difference</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33929'>Cheuk Ting Ho</person>
                </persons>
                <language>en</language>
                <description>In this talk, we will explore what is Polars, a new tabular data management package that is written in Rust and used Arrow. Many people compare it to Pandas, the goto package for tabular data management for years. However, there is still some confusion regarding what Polars really is, whether or not it is more efficient than Pandas and if you can just replace Pandas with Polars. Hopefully, by the end of the talk, all of these questions will be answered and for people new to Polars, they will feel encouraged to try it out and more confident to make the switch.

## Goal

This talk is for data scientists who have been using Pandas and have only heard of the name Polars to understand more about the difference and similarities between the two libraries and can make a better decision of which one to use when they start their next project.

## Outline

- Introduction: why I am talking about this (5 mins)
- Polars is not Pandas 2.0 (5 mins)
- If you do this in Pandas, do that in Polars (10 mins)
- Performance comparison (5 mins)
- Which one should I use? (5 mins)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/NLZZBQ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/NLZZBQ/feedback/</feedback_url>
            </event>
            <event guid='28978d4e-45c6-582b-98aa-7946cc50e2d1' id='29438' code='EATNFR'>
                <room>South Hall 2A</room>
                <title>The State of Production Machine Learning in 2023</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>As the number of production machine learning use-cases increase, we find ourselves facing new and bigger challenges where more is at stake. Because of this, it&apos;s critical to identify the key areas to focus our efforts, so we can ensure our machine learning pipelines are reliable and scalable. In this talk we dive into the state of production machine learning, and we will cover the concepts that make production machine learning so challenging, as well as some of the recommended tools available to tackle these challenges.</abstract>
                <slug>europython-2023-29438-the-state-of-production-machine-learning-in-2023</slug>
                <track>PyData: Machine Learning, Stats (2023)</track>
                
                <persons>
                    <person id='33921'>Alejandro Saucedo</person>
                </persons>
                <language>en</language>
                <description>As the number of production machine learning use-cases increase, we find ourselves facing new and bigger challenges where more is at stake. Because of this, it&apos;s critical to identify the key areas to focus our efforts, so we can ensure our machine learning pipelines are reliable and scalable. In this talk we dive into the state of production machine learning, and we will cover the concepts that make production machine learning so challenging, as well as some of the recommended tools available to tackle these challenges.

This talk will cover key principles, patterns and frameworks around the open source frameworks powering single or multiple phases of the end-to-end MLOps lifecycle, incluing model training, deploying, monitoring, etc. We will be covering a high level overview of the production ML ecosystem and dive into best practices that have been abstracted from production use-cases of machine learning operations at scale, as well as how to leverage tools to that will allow us to deploy, explain, secure, monitor and scale production machine learning systems.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/EATNFR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/EATNFR/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='South Hall 2B' guid='eca0a8bd-c83c-5ce2-b5c8-78da7df606c8'>
            <event guid='df914c42-864d-595e-a659-aa3fec3fc072' id='29606' code='D88LXE'>
                <room>South Hall 2B</room>
                <title>Building native Rust modules for Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T10:45:00+02:00</date>
                <start>10:45</start>
                <duration>00:30</duration>
                <abstract>We&apos;ll cover the basics of Rust and demonstrate how to create a Rust module that can be imported and used within Python. Discover the advantages of using Rust in Python, especially regarding improved performance.</abstract>
                <slug>europython-2023-29606-building-native-rust-modules-for-python</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='34039'>Arthur Pastel</person>
                </persons>
                <language>en</language>
                <description>As Python developers, we love our favorite language&apos;s ease of use and flexibility. However, performance becomes increasingly important as projects grow in size and complexity. That&apos;s where Rust can come in.

In this session, we&apos;ll explore the basics of Rust and demonstrate how to build native Rust modules for Python. We&apos;ll cover the advantages of using Rust in Python, including improved performance and memory safety, and how to leverage existing Rust libraries within our Python projects.

Detailed plan:
- Why Rust?
- Introduction to Rust for Python developers
- Rust tooling for Python module development
- Building a simple Python extension module in Rust
- Writing tests to ensure proper integration with Python
- Performance comparisons between the Rust and Python implementation
- Real-world examples of successful Rust and Python integration

Whether you&apos;re a Python developer looking to improve the performance of your projects or just curious about Rust, this session will provide valuable insights and practical guidance on building native Rust modules for Python.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/D88LXE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/D88LXE/feedback/</feedback_url>
            </event>
            <event guid='f1b5c206-0dc5-5ffa-986b-2b0aebdc6f7c' id='28774' code='H3TBAP'>
                <room>South Hall 2B</room>
                <title>Rust for Python data engineers</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T11:35:00+02:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>Python is a popular language for data engineering but has some limitations in performance, concurrency, and production deployments. The Rust programming language offers powerful alternatives with strong compile-time and memory safety guarantees. In this talk, I&apos;ll explore how data engineers can leverage Rust to build high-performance data pipelines and processing systems. I&apos;ll cover the Rust ecosystem for data work, including frameworks and libraries for working with data formats, databases, streaming systems, and scientific computing. By combining Rust and Python, data engineers can harness the benefits of both languages and build robust end-to-end data systems that scale to meet demanding production needs.</abstract>
                <slug>europython-2023-28774-rust-for-python-data-engineers</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33305'>Karim Jedda</person>
                </persons>
                <language>en</language>
                <description>After using Python for almost a decade now, mostly for data engineering, I thought I&apos;d give Rust a try to solve some of the problems I face daily as a data engineer. What I learned doing so is that Rust can be a great and valid additional tool for any data engineer, especially in combination with Python.

I&apos;ll elaborate on:
- How the Python ecosystem can benefit from integrating Rust in data engineering workflows 
- How Rust can be interfaced with Python
- The strengths of each programming language 

Further reading material: 

- [Blog post](https://karimjedda.com/carefully-exploring-rust/) 
- [HN discussion](https://news.ycombinator.com/item?id=33581901)
- [LinkedIn post](https://www.linkedin.com/feed/update/urn:li:activity:7035701103337828352/)
- [Website](https://datawithrust.com/)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/H3TBAP/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/H3TBAP/feedback/</feedback_url>
            </event>
            <event guid='7b1bf20f-9ce4-5114-a8e9-23619c8c8c4d' id='29385' code='AXWQBB'>
                <room>South Hall 2B</room>
                <title>Would Rust make you a better Pythonista?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T12:10:00+02:00</date>
                <start>12:10</start>
                <duration>00:45</duration>
                <abstract>What would a Pythonista gain from becoming a Rustacean other than semicolons and brackets?

In this talk I&apos;ll share the learnings and achievements I got by adding the Rust programming language into my Python life. Illustrating a real story now in production at scale, I&apos;ll walk you through all the pains and joys of this unexpected journey which changed me more than I anticipated.

Proposed agenda:
- Project introduction
- Motivations of selecting this project to learn Rust
- Tales of a Pythonista learning Rust
- Results, numbers and production graphs
- How Rust influences my daily Python
- Was it worth it? Should you do it too?</abstract>
                <slug>europython-2023-29385-would-rust-make-you-a-better-pythonista</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33882'>Alexys Jacob</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/AXWQBB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/AXWQBB/feedback/</feedback_url>
            </event>
            <event guid='2cdbf3f2-ec67-54e0-a616-6afd87e264d9' id='29542' code='DQBDJE'>
                <room>South Hall 2B</room>
                <title>Continue Thinking Small: Next level machine learning with TinyML</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>The Internet of Things has been flourishing for many years, and Python has been playing an important role on the &#8220;easy to automate&#8221; topic for many devices. One of the challenges for the next generation ML is to think small, you read that right &#8220;thinking small&#8221;. It&#8217;s time to start being able to have mechanisms with super well-trained ML models in small-devices: ML on Microcontrollers. We are going to dive into TinyML and evaluate different setups to interact with sensors on microcontrollers. We will discuss the different hardware options and frameworks to start with, while checking different use cases that TinyML can solve, like: agriculture, conservation, health issues detection, ecology monitoring etc. In this talk, you will learn about Tiny Machine Learning (TinyML), which is an approach that explores machine learning to be deployed in embedded systems that enable run ML on microcontrollers. Lastly, we will discuss real use-cases and a practical case that could be implemented at home</abstract>
                <slug>europython-2023-29542-continue-thinking-small-next-level-machine-learning-with-tinyml</slug>
                <track>Makers, Microcontrollers and IoT (2023)</track>
                
                <persons>
                    <person id='33990'>Maria Jose Molina Contreras</person>
                </persons>
                <language>en</language>
                <description>We usually associate the future of computing as large clusters being able to perform tasks in a fraction of a second, but is it really the only scenario on how computational hardware will evolve?

Machine learning has become an important component in our societies, we see how people, communities, and global companies are focusing their resources into improving their technological stack, and being the leader into the next generation of AI.
At the same time that we see clusters getting larger, GPUs more powerful, and our phones are practically computers being capable of doing almost everything, we do see that some of the smart devices are becoming smaller.

The Internet of Things has been flourishing for many years, and Python has been playing an important role on the &#8220;easy to automate&#8221; topic for many devices, but can Python help us in all scenarios? One of the challenges for the next generation ML is to think small, you read that right &#8220;thinking small&#8221;.

It&#8217;s time to start being able to have mechanisms with super well-trained ML models in small-devices: ML on Microcontrollers.

We are going to dive into TinyML and evaluate different setups to interact with sensors on microcontrollers. We will discuss the different hardware options and frameworks to start with, while checking different use cases that TinyML can solve, like: agriculture, conservation, health issues detection, ecology monitoring, autonomous vehicles, etc.

In this talk, you will learn about Tiny Machine Learning (TinyML), which is an approach that explores machine learning to be deployed in embedded systems that enable run ML on microcontrollers. 
Lastly, we will discuss a real use-case that you will be able to implement at home.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/DQBDJE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/DQBDJE/feedback/</feedback_url>
            </event>
            <event guid='e8ce7f3f-9ddc-50ef-a044-ae8851bbdcd8' id='29210' code='NZ8J7S'>
                <room>South Hall 2B</room>
                <title>Async Robots</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>Interactive control of robots can be a challenge, as it requires a lot of things to happen in parallel while at the same time reacting to data from sensors and control signals. Using python&apos;s async facilities may greatly simplify this task, allowing us to write code that is similar to the non-parallel version, but that is at the same time easy to compose into bigger program doing many things at once. I will talk about my own experiences programming the Fluffbug robot with CircuitPython, point out the problems and the solutions I found.</abstract>
                <slug>europython-2023-29210-async-robots</slug>
                <track>Makers, Microcontrollers and IoT (2023)</track>
                
                <persons>
                    <person id='33715'>Radomir Dopieralski</person>
                </persons>
                <language>en</language>
                <description>Fluffbug is a small, affordable walking robot programmed with CircuitPython. The way it moves and reacts to sensors and control signals requires code that seemingly does a lot of things all at once, but we don&apos;t have direct access to mechanisms like threads or interrupts. What we use instead is Python&apos;s async syntax and the minimal version of asyncio library available in CircuitPython. This makes an interesting use case for asynchronous programming that is different from the usual web servers and API frontends. The resulting code is much shorter and easier to maintain than similar code written in a traditional, linear way.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/NZ8J7S/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/NZ8J7S/feedback/</feedback_url>
            </event>
            <event guid='43a67412-3249-5e93-86e3-514826dd110b' id='29480' code='T3JFHR'>
                <room>South Hall 2B</room>
                <title>Bulletproof Python &#8211; Writing fewer tests with a typed code base</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>A fully typed code base requires less test code to achieve the same level of confidence in its correctness. We&apos;ll analyze specific code examples and see how dependent types and exhaustiveness checking make certain classes of tests obsolete.</abstract>
                <slug>europython-2023-29480-bulletproof-python-writing-fewer-tests-with-a-typed-code-base</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33942'>Michael Seifert</person>
                </persons>
                <language>en</language>
                <description>A type system forms a set of rules that is imposed on a programming language with the goal to avoid invalid operations. Type checking Python code is particularly interesting, because it happens before running the code or the test code. This allows software engineers to perform checks on the source code that otherwise would have to be performed at runtime.

The typing module in the Python standard library provides powerful concepts to provide hints to the type checker. Specifically, we&apos;ll look at use cases for NewType, dependent functions, and exhaustiveness checking.

Audience members are expected to be able to read and understand Python code and have a basic understanding of unit testing.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/T3JFHR/resources/slides_ehPQjUs.pdf">Slides</attachment>
                
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/T3JFHR/resources/slides-with-notes_lVUvfRb.pdf">Annotated slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/T3JFHR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/T3JFHR/feedback/</feedback_url>
            </event>
            <event guid='e2eeccb3-b6cd-5087-b524-1082bb015022' id='29107' code='FNLQH7'>
                <room>South Hall 2B</room>
                <title>BDD - how to make it work?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>Behaviour-driven development promises evergreen documentation or human-readable executable specification - sounds great. However, adopting it takes much more than simply installing behave or pytest-bdd and writing Gherkin. This talk will show what.</abstract>
                <slug>europython-2023-29107-bdd-how-to-make-it-work</slug>
                <track>Testing (2023)</track>
                
                <persons>
                    <person id='33613'>Sebastian Buczy&#324;ski</person>
                </persons>
                <language>en</language>
                <description>This talk discusses common issues with BDD specifications, such as:
- lengthy, hard to maintain &amp; read specifications
- intertwined order of given-when-then steps
- technical details leaking to specifications.

Then it shows how to deal with them:
- how to write good specifications,
- what do modularization and DDD have to do with focused scenarios,
- building automation layer to have reusable blocks for Gherkin scenarios.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/FNLQH7/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/FNLQH7/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='North Hall' guid='a05be9db-82c0-57ef-b134-93cda35ef695'>
            <event guid='ef82973a-1800-50a0-bb48-e74c79c767ea' id='29712' code='HSPJMX'>
                <room>North Hall</room>
                <title>Apache Arrow and Substrait, the secret foundations of Data Engineering</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T10:45:00+02:00</date>
                <start>10:45</start>
                <duration>00:45</duration>
                <abstract>Apache Arrow, and its Python library PyArrow are becoming the standard de facto for transfering data and interoperability between libraries and languages. As more compute engines, storages and databases start to speak arrow, you might be relying on it without even knowing.
The same transformation is happening with Substrait, that is on track to be the standard representation of query plans themselves. Allowing queries to be routed to different engines as far as they speak substrait, or even decomposed and forwarded to different engines.
This talk we will provide a quick introduction to the Arrow ecosystem, showing to Python developers how libraries like Pandas, Polars and PyArrow itself leverage Arrow and how compute engines like Velox, Datafusion and Acero are embracing Arrow and Substrait.
The talk will also show how a basic database system based on Arrow and Substrait can be built with a minimum amount of code thanks to all the foundations they provide.</abstract>
                <slug>europython-2023-29712-apache-arrow-and-substrait-the-secret-foundations-of-data-engineering</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='34154'>Alessandro Molina</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/HSPJMX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/HSPJMX/feedback/</feedback_url>
            </event>
            <event guid='9e0ef95b-4358-5de0-9ce4-0102e7f7ec4e' id='33364' code='RAXZVW'>
                <room>North Hall</room>
                <title>Temporal Python &#8211; A Durable, Distributed Asyncio Event Loop</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-19T11:35:00+02:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>This talk discusses asyncio, an essential tool for asynchronous, non-blocking code in Python, and its limitations, such as non-durability and inability to distribute across multiple machines. Temporal.io, an open-source microservice orchestration platform, is introduced as a robust solution capable of using event sourcing for durability, scalability, and resilience, effectively managing system failures. Temporal based asyncio event loop implementation adds seamless durability to Python code. The complete state of the program, including local variables and await calls, is fully preserved across process and other infra failures. We highlight real-world applications and conclude by emphasizing how Temporal transforms the design and implementation of distributed fault-tolerant systems.</abstract>
                <slug>europython-2023-33364-temporal-python-a-durable-distributed-asyncio-event-loop</slug>
                <track></track>
                
                <persons>
                    <person id='37792'>Maxim Fateev</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://github.com/temporalio/sdk-python">Temporal Python SDK</link>
                
                    <link href="https://temporal.io/blog/durable-distributed-asyncio-event-loop">Blog Post: Temporal Python 1.0.0 &#8211; A Durable, Distributed Asyncio Event Loop</link>
                </links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/RAXZVW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/RAXZVW/feedback/</feedback_url>
            </event>
            <event guid='9f936f45-ef5d-53fd-b081-b6d44a9f8eee' id='29564' code='EWHVWK'>
                <room>North Hall</room>
                <title>Apache Spark vs cloud-native SQL engines</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T12:10:00+02:00</date>
                <start>12:10</start>
                <duration>00:30</duration>
                <abstract>Currently, SQL and Cloud Data Warehouses (DWH) are extremely popular for good reason. They are great for dashboarding and business intelligence (BI) use cases due to their ease-of-use. However, their combination might not be the best choice for every problem. More precisely, business-critical data pipelines with high complexity might be better suited for frameworks such as Apache Spark which greatly benefit from the tight integration with general purpose languages like Python (e.g., PySpark). 

Expect an opinionated comparison between Apache Spark and seemingly easier-to-use cloud native SQL engines. By the end of this talk, you will be challenged to think about why they are complementary and when each has its justification.</abstract>
                <slug>europython-2023-29564-apache-spark-vs-cloud-native-sql-engines</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='34008'>Franz W&#246;llert</person>
                </persons>
                <language>en</language>
                <description>This talk is intended for data engineers, solution architects and alike who deal with distributed computation engines for analytical batch workloads in their day to day work.

While SQL is the lingua franca for data analysis, it might not be the best choice for every problem. Business-critical data pipelines with high complexity demand for appropriate abstractions, proper testability and enhanced debugging tooling that is hard to achieve with SQL and surrounding frameworks. In contrast, using the power of Python in conjunction with frameworks like Apache Spark is a promising solution for the following reasons:

- Apache Spark&#8217;s DataFrame API is embedded in a general purpose programming language like Python which allows to leverage software engineering concepts such as inheritance, composition, introspection and higher order functions. This provides data engineers a toolbox of abstractions to properly handle complexity. More precisely, it allows to structure, modularize, reuse, and dynamically generate building blocks of data pipelines.
- To ensure semantic correctness, data engineers can develop unit tests on individual transformations or integration tests on entire pipelines in classical software development tradition which is hardly possible with cloud-native SQL engines.
- Apache Spark&apos;s future-proof is ensured due to its wide adoption, runtime flexibility and vendor independence.

The talk will guide you through each of the claims stated above using a real world IoT use case while comparing the strengths and weaknesses of both Apache Spark and cloud-native SQL engines.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/EWHVWK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/EWHVWK/feedback/</feedback_url>
            </event>
            <event guid='04f38cf0-59da-5aa8-be9b-b63a91832b9a' id='29231' code='3AD79Q'>
                <room>North Hall</room>
                <title>Serverless billion-scale vector search for AI applications</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>From recommendation systems to LLM-based applications, vector search is a critical component of the modern AI workflow. Existing vector solutions are complicated to use, hard to maintain, and cost too much. LanceDB is a free open-source vector store that can perform low latency vector search on billion-scale vector datasets on a single node.</abstract>
                <slug>europython-2023-29231-serverless-billion-scale-vector-search-for-ai-applications</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33743'>Chang She</person>
                </persons>
                <language>en</language>
                <description>LanceDB is powered by Lance format, a modern columnar data format for machine learning and data science. Compatible with pandas/polars/duckdb, Lance format supports vector index, predicate pushdown, and random access performance 2000x faster than parquet.

This talk will:
1. Introduce LanceDB and show some example workflows
2. Outline Lance format design and what makes it so fast
3. Review the Lance roadmap and ecosystem integrations

You can find Lance here: https://github.com/eto-ai/lance</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3AD79Q/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3AD79Q/feedback/</feedback_url>
            </event>
            <event guid='781e2d4e-ac55-5e97-bf16-e20f355e708f' id='29655' code='BBZVUP'>
                <room>North Hall</room>
                <title>The needle and the haystack: visualizing single datapoints out of billions</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>Python tools like Bokeh and Dash let you build custom Web-based interactive visualization apps and dashboards.  While these solutions work well to visualize megabyte-sized datasets, web technologies struggle to render gigabyte or larger datasets efficiently, because they transfer all the data into the client browser. Pre-rendering the data on the server using a tool like Datashader can visualize such large datasets efficiently, but the resulting static renderings make exploring individual datapoints difficult.

This talk demonstrates how the HoloViz ecosystem of tools (holoviz.org) allows you to run exploratory notebooks and build dashboards that do server-side rendering of billions of data points without losing the ability to interactively inspect and annotate individual samples in the browser.</abstract>
                <slug>europython-2023-29655-the-needle-and-the-haystack-visualizing-single-datapoints-out-of-billions</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33997'>Jean-Luc Stevens</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BBZVUP/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BBZVUP/feedback/</feedback_url>
            </event>
            <event guid='61ab0e85-f723-5c6c-bbf2-91812aac78c6' id='29751' code='AG7JR9'>
                <room>North Hall</room>
                <title>From Algorithms to Agendas: A Beginner&apos;s Guide to Integer Programming</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>This talk will provide an introduction to Integer Programming and demonstrate how it can be used for conference scheduling. We will explore the basics of Integer Programming and how it can be applied to optimize the allocation of talks to time slots and rooms in a conference program. By the end of the talk, attendees will have a better understanding of how this powerful tool can help to create an efficient and effective conference schedule that maximizes attendee satisfaction. Whether you&apos;re a conference organizer or simply interested in learning more about optimization algorithms, this talk is for you!</abstract>
                <slug>europython-2023-29751-from-algorithms-to-agendas-a-beginner-s-guide-to-integer-programming</slug>
                <track>PyData: Machine Learning, Stats (2023)</track>
                
                <persons>
                    <person id='34190'>Florian Wilhelm</person>
                </persons>
                <language>en</language>
                <description>### Introduction

* Overview of the challenges of conference scheduling and the potential benefits of using optimization algorithms
* Explanation of the basics of Integer Programming and its role in conference scheduling

### Key Concepts

* The importance of defining clear objectives and constraints for a conference program
* The different types of variables used in Integer Programming models for conference scheduling (e.g. binary, integer, continuous)
* An overview of popular optimization algorithms and their application to conference scheduling (e.g. branch-and-bound, cutting plane methods, column generation)
* A step-by-step guide to constructing an Integer Programming model for conference scheduling, including how to formulate objectives and constraints

### PyConDE / PyData 2023 Berlin Example:

* A real-world conference scheduling problem, that is for the PyConDE / PyData 2023,  and how we used  Integer Programming

### Conclusion

* Recap of the key concepts and takeaways from the talk
* Q&amp;A session to answer any remaining questions from the audience

Overall, this talk aims to provide attendees with a beginner-friendly introduction to Integer Programming and its applications in conference scheduling. By the end of the talk, attendees will have a better understanding of how to use optimization algorithms to create an efficient and effective conference schedule that maximizes attendee satisfaction.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/AG7JR9/resources/MIP_Introduction_fwilhelm_AnOFZ7w.pdf">Slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/AG7JR9/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/AG7JR9/feedback/</feedback_url>
            </event>
            <event guid='aec1f596-72b5-5b9e-97a7-9030c87e89ed' id='29367' code='3Y3BJN'>
                <room>North Hall</room>
                <title>Solving Multi-Objective Constrained Optimisation Problems using Pymoo</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Pymoo is an open source python framework with state-of-the-art optimisation and post performance analysis capabilities. It provides an object oriented interface to solve constrained Single/Multi-Objective optimisation problems with a catalog of algorithms, customisations and post-optimisation evaluation functionalities. With additional features like Visualisation of optimal pareto-fronts, decision making, parallelization and customised sampling, Pymoo promises to be highly valuable for scalable optimisation solutions.</abstract>
                <slug>europython-2023-29367-solving-multi-objective-constrained-optimisation-problems-using-pymoo</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='33366'>Pranjal Biyani</person>
                </persons>
                <language>en</language>
                <description>I will share a github repository with jupyter notebooks and datasets with the attendees, before the talk and have multiple hands on segments during the talk. The talk will take the users step-by-step through the sections mentioned below - 

1. What is an optimisation problem ? 
2. Core components of an optimisation problem ? 
3. Finding the right type of solution ? 
4. Identifying constraints, bounds and objectives
5. Pymoo API - Object Oriented Interface, Parallelization, Visulization
6. Hands on Example :  a ML Model as an objective function, to find optimal input variables for a desired output variable
7. Customisations using Pymoo : Termination, Crossover, Mutation etc
8. A one-stop solution for Optimisation Problems</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3Y3BJN/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3Y3BJN/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Terrace 2A' guid='ab4602e3-05dd-5b83-a1c0-aebd23a49cdc'>
            <event guid='9d637dc9-6965-55d2-926f-10886e9512f4' id='29785' code='HMJU9J'>
                <room>Terrace 2A</room>
                <title>An unbiased evaluation of environment management and packaging tools</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T10:45:00+02:00</date>
                <start>10:45</start>
                <duration>00:45</duration>
                <abstract>Python packaging is quickly evolving and new tools pop up on a regular basis. Lots of talks and posts on packaging exist but none of them give a structured, unbiased overview of the available tools.

This talk will shed light on the jungle of packaging and environment management tools, comparing them on a basis of predefined features.</abstract>
                <slug>europython-2023-29785-an-unbiased-evaluation-of-environment-management-and-packaging-tools</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='34237'>Anna-Lena Popkes</person>
                </persons>
                <language>en</language>
                <description>Python packaging has come a long way in the last years. The landscape is evolving quickly and new tools pop up on a regular basis. Lots of talks and posts on packaging exist but none of them give a structured, unbiased overview of the available tools.

This talk will shed light on the jungle of packaging and environment management tools, comparing them on a basis of predefined features.

We will categorize tools using the following categories:
- Python version management
- Environment management
- Package management
- Package building
- Package publishing

A lot of tools exist, including: pyenv, pip, poetry, hatch, flit, and many more. We will categorize all of them and discuss some in more detail.

Most importantly, we will evaluate the tools on the basis of features that are important for developers like:
- Does the tool manage dependencies?
- Can it manage Python installations?
- Does it have a clean build/publish flow?
- Does it allow for plugins?
- Does it support important PEPs, e.g. PEP 660, PEP 621, PEP 582?

This talk is intended for developers who
- Have used packaging and want to get to know new tools
- Want to have an overview of existing tools and their capabilities</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/HMJU9J/resources/slides_euro_python_2023_aeLoKB9.pdf">PDF of slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/HMJU9J/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/HMJU9J/feedback/</feedback_url>
            </event>
            <event guid='917b2631-6344-5966-9426-ba5509cb1fb9' id='29828' code='LLHGKF'>
                <room>Terrace 2A</room>
                <title>The Python package repository accelerating software development at CERN</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T11:35:00+02:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>Python&#8217;s expressive syntax, ease of use, and powerful ecosystem of third-party packages are all major contributing factors to its thriving use for accelerator controls at CERN. Providing access to this rich ecosystem in a protected environment, whilst also allowing developers to augment this with internally developed packages is a key enabling service. Existing open-source solutions didn&#8217;t meet our needs, and the evolving Package index standardisation, as well as exposure to dependency confusion attacks, left us searching for a more modular and flexible approach.  


In this presentation we will demonstrate the Python package upload, index, and browsing services developed at CERN. We will discuss the gradual transition from our existing repository service (based on Nexus), and demonstrate - with the help of recent packaging PEPs - the flexibility that modularising the services has brought, helping us to meet our needs for local specialisation and enhanced security measures.</abstract>
                <slug>europython-2023-29828-the-python-package-repository-accelerating-software-development-at-cern</slug>
                <track>DevOps (2023)</track>
                
                <persons>
                    <person id='34294'>Phil Elson</person><person id='36060'>Ivan Sinkarenko</person>
                </persons>
                <language>en</language>
                <description>CERN, the European Organization for Nuclear Research, operates the largest particle physics laboratory in the world, including the 27km long Large Hadron Collider (LHC). Python is increasingly at the heart of CERN&#8217;s accelerator control software, with hundreds of domain specialists using Python on a daily basis to research, engineer and operate this world-leading facility. 

Python&#8217;s expressive syntax, ease of use, and powerful ecosystem of third-party packages are all major contributing factors to its success. Providing access to this rich ecosystem in a protected environment, whilst also allowing developers to augment this with internally developed packages is a key enabling service. Existing open-source solutions didn&#8217;t meet our needs, and the evolving Package index standardisation as well as exposure to dependency confusion attacks, left us wishing for a more modular and flexible approach.  

In this presentation we will demonstrate the Python package upload, index, and browsing services developed at CERN, and will show that modularising the service gives greater opportunities for local specialisation and enhanced security approaches, as well as offering easy evaluation and adoption of PEP-standardised packaging enhancements. Starting from an existing package repository setup (based on Nexus), we will present the steps taken to gradually introduce this modular infrastructure using specific packaging PEPs to demonstrate the existing challenges and motivation. 

We will look at code snippets that we are able to inject into the package index definition, and get into fine detail about recent packaging PEPs (e.g., PEP-658) in order to build the case that modularity is essential to build package index services that can evolve with the standards, and which can be adapted to the specific needs of an organisation such as CERN (e.g., specific authentication methods, resource ownership, network segregation). 

Finally, we will demonstrate our package browsing service, which is a FastAPI-based web service offering a browser on a &#8220;Simple Index&#8221; (PEP-503) package repository which mimics the look-and-feel of PyPI.org.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/LLHGKF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/LLHGKF/feedback/</feedback_url>
            </event>
            <event guid='0fd4c818-e240-5a91-aec3-69c12e783565' id='28949' code='RRJAZA'>
                <room>Terrace 2A</room>
                <title>From Jupyter Notebooks to a Python Package: The Best of Both Worlds</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T12:10:00+02:00</date>
                <start>12:10</start>
                <duration>00:30</duration>
                <abstract>A Jupyter notebook is quite handy for rapid REPL (Read-Eval-Print-Loop) style tasks
such as exploratory data analysis and data science. However, we would feel
deficiencies in proper SW engineering supports at some point as the notebook grows
to have larger and more complicated code. It is because the Jupyter notebook lacks
several important features including code sharing, refactoring support,
version control and advanced editing. Fortunately, traditional full-fledged IDEs,
such as *VS Code* or *PyCharm*, are available at hand and they support
these lacking features very well.
Then, why don&#8217;t we take advantage of the best of both worlds?

In this beginner-level hands-on talk, I will demonstrate how to
transform Jupyter notebook workflows to a proper Python package using *VS Code*.
I will also introduce several basic but essential refactoring recommendations.
By doing so, you can use the package for several notebooks
and even share with your colleagues and friends.</abstract>
                <slug>europython-2023-28949-from-jupyter-notebooks-to-a-python-package-the-best-of-both-worlds</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33471'>Sin-seok SEO</person>
                </persons>
                <language>en</language>
                <description>Notebooks, code and slides are available in [this repo](https://github.com/sesise0307/europython2023-package).

## Introduction

- Jupyter Notebook
  - Provides ideal workflows for data science
  - Pros: REPL, interactivity, integration of code / output / documentation,
    visualization, rapid prototyping, result sharing, etc.
  - Cons: lacks of debugging, code sharing, refactoring, version control,
    advanced editing, etc.
- Full-fledged IDEs
  - Designed to maximize programmer productivity
  - One iteration might take a long journey
- We can benefit from the best of both worlds
  by using a Python package

## Jupyter Notebook Data Science Workflow

- Data Loading
- Preprocessing
- Exploratory Data Analysis (EDA)
- Prediction

## To (Your Own) Python Package

- What is a package and why do we want to use it?
- How to create a (minimal) package
- How to import and use
- Live refactoring examples

## Wrap up / Some tips

- Publish your awesome package
- PyScaffold
- VS Code</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://github.com/sesise0307/europython2023-package">GitHub repo</link>
                </links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/RRJAZA/resources/slides_JE8Oe8x.pdf">Slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/RRJAZA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/RRJAZA/feedback/</feedback_url>
            </event>
            <event guid='5d4d8bd0-6829-50b4-8bdd-325ae1f5add5' id='29633' code='WAZGKA'>
                <room>Terrace 2A</room>
                <title>From Dataset to Features: A Python-Based Evolutionary Approach</title>
                <subtitle></subtitle>
                <type>Poster</type>
                <date>2023-07-19T13:00:00+02:00</date>
                <start>13:00</start>
                <duration>01:00</duration>
                <abstract>Multilabel classification is a machine learning task in which each instance is assigned to a group of labels. It has gained widespread use in various applications in recent years. Preprocessing, such as feature selection, is an important step in any machine learning or data mining task. It helps to improve the performance of an algorithm and reduce computational time by eliminating highly correlated, irrelevant, and noisy features. A new algorithm called Black Hole, inspired by the phenomenon of black holes, has recently been developed to tackle multi-label classification problems. In this talk, we present a modified version of the Black Hole algorithm that combines it with two genetic algorithm operators: crossover and mutation. The combination of Black Hole and genetic algorithms has the potential to solve multi-label classification problems across a range of domains.</abstract>
                <slug>europython-2023-29633-from-dataset-to-features-a-python-based-evolutionary-approach</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='34059'>Neeraj Pandey</person><person id='34186'>Hitesh Khandelwal</person>
                </persons>
                <language>en</language>
                <description>Multilabel classification is a machine learning task where each instance in a dataset is assigned to multiple labels. This is in contrast to traditional classification, where each instance is assigned to a single label. Multilabel classification has gained popularity in recent years due to its expanding use in a variety of applications across domains.

One of the key challenges in multilabel classification is the high dimensionality of the data, which can make it difficult for machine learning algorithms to learn effectively. This is where feature selection comes in. Feature selection is the process of identifying and selecting a subset of relevant and non-redundant features from a larger set of features. It is a critical preprocessing step that can improve the performance and efficiency of machine learning algorithms.

One of the recent developments in feature selection is the Black Hole algorithm, which is inspired by the phenomenon of black holes in space. The Black Hole algorithm is a metaheuristic that iteratively removes the least relevant features from a dataset, based on a relevance measure such as mutual information. In this talk, we present a modified standalone Black Hole algorithm that incorporates genetic algorithm operators, such as crossover and mutation, to improve its performance in solving multilabel classification problems. The hybridization of Black Hole and Genetic Algorithms has shown to be effective in solving multilabel classification problems in different domains.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/WAZGKA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/WAZGKA/feedback/</feedback_url>
            </event>
            <event guid='bd1c543c-928a-58be-bf4e-ffa3f68f2013' id='30077' code='VATHTK'>
                <room>Terrace 2A</room>
                <title>Lessons from Prague</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>Our EuroPython takes place in Prague - a city with some lessons for us, about programming, software and technology. More than 100 years ago Prague produced buildings that hint at how far our ideas in software might take us, and writers and artists who imagined challenges that have lately become real.</abstract>
                <slug>europython-2023-30077-lessons-from-prague</slug>
                <track>Ethics, Philosophy &amp; Politics (2023)</track>
                
                <persons>
                    <person id='33507'>Daniele Procida</person>
                </persons>
                <language>en</language>
                <description>Cities, electronic circuits and software all have *architectures*; they are machines that process signals and messages, balance forces and respond to demands, strongly analogous ways. Cities are much older than circuits and software. They are full of lessons about systems - I think some of these lessons van apply directly to our work in software, and I think that Prague, our host city, has some special ones. Some of the lessons are built literally into its buildings: Prague has the most intense concentration of Cubist architecture in the world.

Architecture springs from ideas - this talk will discuss those ideas, and the people who had them, and what we can think about our software when we think about them. I&apos;ll discuss, amongst other things, Karel &#268;apek, the Czech writer who gave us the word &quot;robot&quot; in 1920, and who also offers us ways of thinking about how artificial intelligence might occupy a space in our life and civilisation, and the Czech movement from Cubism to functionalism in architecture, and the connection between them, and more besides.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/VATHTK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/VATHTK/feedback/</feedback_url>
            </event>
            <event guid='de999b5d-3ef9-51d5-a43f-0522100c5f60' id='29376' code='RQCYKG'>
                <room>Terrace 2A</room>
                <title>Spiral Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>Most introductory Python books and online resources like w3schools.com try to be complete when a new concept is explained. This does not always work well for beginners. E.g. if you have just grasped how a while-loop  works, it may cause too much cognitive load to also understand the break and continue options, let alone the else clause.
The learning psychologist Jerome Bruner introduced the term &quot;spiral learning&quot;. The idea is that you don&apos;t teach all aspects of a new concept, but just enough to use it. At a later stage a teacher can revisit the subject and explain more details, when a student needs this to take the next step.
Spiral Python is a road map of subjects that can be found in any introductory book or online resource about Python, but absolutely original in the sense that it takes into account how people learn in a natural way. You do not need to know the whole language before you can use it. Spiral Python also contains exercises (to practice) and challenges (to motivate).</abstract>
                <slug>europython-2023-29376-spiral-python</slug>
                <track>Education, Teaching &amp; Training (2023)</track>
                
                <persons>
                    <person id='33632'>Jan Kroon</person>
                </persons>
                <language>en</language>
                <description>The idea of Spiral Python comes from the original Meccano construction kits. In Kit #1 you found building materials, some simple tools and a booklet with ideas what to build. It was possible, however, to build much cooler contraptions than those in the booklet. Meccano enabled children to be creative. Soon a kid needed Kit #2 to realise his or her ideas.

In a workshop, I can first summarise what cognitive psychology understands about learning (e.g. from &quot;How We Learn&quot;, Dehaene 2020). Subsequently I can share our experience at Rotterdam University on what beginner programmers find difficult or misunderstand when they learn programming. In general the problem is that there is too much cognitive load, too much new ideas at once (&quot;The Programmer&apos;s Brain&quot;, Hermans 2021). Finally I will sketch the Spiral Python approach, in which new concepts build on prior experience of students (e.g. the Python List is related to shopping lists and to-do lists) and gradually explained. At each stage of Spiral Python, students don&apos;t make just standard exercises but are challenged to be creative and follow their own passion in building software-driven products. We use libraries (turtle, opencv) and hardware (microbit, raspberry pi with sense hat) to make the software products more interesting.
Students that take the Spiral Python approach get used to extending and adapting the mental models they have made of the Python programming language, computers, networking and computing. This makes them more flexible and independent thinkers, who hopefully enjoy lifelong learning.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/RQCYKG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/RQCYKG/feedback/</feedback_url>
            </event>
            <event guid='63f97743-07f6-594f-96c2-6e6354ef447e' id='29109' code='JHY3ZK'>
                <room>Terrace 2A</room>
                <title>Using NLP to Detect Knots in Protein Structures</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Proteins are essential components of our bodies, with their function often dependent on their 3D structure. However, uncovering the 3D structure has for a long time been redeemed by months of hard work in the lab. Recent advances in Machine learning and Natural language processing have made it possible to build models (eg. AlphaFold) capable of predicting the protein&apos;s 3D structure with the same precision as experimental methods.

In this talk, I will explore an even more specific application of language models for proteins - the detection of a knot in a protein&apos;s 3D structure solely from the protein amino acid sequence. Knotting in proteins is a phenomenon that can affect their function and stability. Thanks to NLP and interpretation techniques we can try to uncover why and how proteins tie themself into a knot. In this research, we rely on many Python-based tools starting from Biopython to Pymol and Hugging Face transformer library.</abstract>
                <slug>europython-2023-29109-using-nlp-to-detect-knots-in-protein-structures</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33615'>Eva Klimentov&#225;</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/JHY3ZK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/JHY3ZK/feedback/</feedback_url>
            </event>
            <event guid='a6dd4279-68ff-507c-9292-46b81df152a3' id='29428' code='VCNMWZ'>
                <room>Terrace 2A</room>
                <title>Robot Holmes and The MLington Murder Mysteries</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>We will follow master detective Robot Holmes on his way to solve one of his hardest cases so far - a series of mysterious murders in the city of MLington. The traces lead him to the Vision-Language part of town, which has been a quiet and tranquil place with few incidents until lately. For a few months the neighbourhood has been growing extensively and careless benchmark leaders are dropping dead at an alarming rate.

Robot Holmes sets out to find the cause for this new development and will gather intel on some of the most notorious of the new citizens of the Vision-Language neighbourhood and find out what makes them tick.</abstract>
                <slug>europython-2023-29428-robot-holmes-and-the-mlington-murder-mysteries</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='35131'>Johannes Kolbe</person>
                </persons>
                <language>en</language>
                <description>Join the detective Robot Holmes on an adventure through the streets of the vibrant city of MLington. Together, we will find out who is behind a series of mysterious murders in the bustling neighbourhood of Vision-Language Village (ViLaVi).

ViLaVi has seen a steady influx of new posh Vision-Language models, which are not only rapidly expanding the size of the district but also the quality of services that are offered in these streets.

On his journey Robot Holmes will compile an overview of the tasks these new models excel in and find out what makes them so good at it. Additionally he will gather details on some of the most successful of the Vision-Language models and eventually find out who or what is behind the series of murders.

By the end of our journey you will have a better overview of the rapidly expanding Vision-Language neighbourhood and will have knowledge of the most important inner workings of Vision-Language models like CLIP, OWL-ViT, and BLIP. You will also know how to run them yourself in a few lines of code with the transformers library by Hugging Face.

The talk is for everyone interested in the topic of Vision-Language models and who wants to gain some first insights into their ways of working. People who already have a profound knowledge of Vision-Language models are welcome as well, as they probably have never seen it presented as a crime story in a strangely familiar city.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/VCNMWZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/VCNMWZ/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Terrace 2B' guid='3fcaeaa9-6c50-5e80-9387-b6a42febf14b'>
            <event guid='996ff733-00ec-5281-aae2-120064d36942' id='29624' code='FFTHXB'>
                <room>Terrace 2B</room>
                <title>Python Linters at Scale</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T10:45:00+02:00</date>
                <start>10:45</start>
                <duration>00:30</duration>
                <abstract>Black, Flake8, isort, and Mypy are useful Python linters but it&#8217;s challenging to use them effectively at scale in the case of multiple codebases, in a large codebase, or with many developers. 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.

In this talk, we&apos;ll walk you through solving those scaling problems using 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.</abstract>
                <slug>europython-2023-29624-python-linters-at-scale</slug>
                <track>DevOps (2023)</track>
                
                <persons>
                    <person id='34055'>Jimmy Lai</person>
                </persons>
                <language>en</language>
                <description>Popular Python linters overview and configuration recommendation (6 mins)
- Black, Flake8, isort, mypy
Common practice: linter versions and config files managed by version control (1.5 mins)
- dependency management
- cached dependencies in CI jobs

Scaling Challenges: (5 mins)
 - Multiple codebases 
   1. Inconsistent linter version and configuration
   2. Endless effort on upgrading linters and configs
 - Large codebases (1 min): Linters run slow on analyzing million lines of code
 - Many developers (2 mins): Linter suggestions of trivial issues slow down developers

Solutions for the challenges: (12.5 mins in total)
 - The solution for inconsistent version and configuration (2.5 mins)
    - Tradeoff between consistent version and flexible versions
    - All codebases use the same version and configurations of linters
    - Need to fix existing linter errors while upgrading linters
    - Reusable workflow
 - The solution for slow linter run: (2.5 mins)
    - Avoid repeated analysis by caching linter results
    - Only run linters on updated files
 - The solution for lake of developer experience overview (2.5 mins)
    - Collect linter suggestions from CI jobs
    - Detect linter errors that are merged to the main branch and find the breaking change easily
    - Understand frequent linter suggestions
 - The solution for slowing down developers (2.5 mins)
   - Build autofixes for frequent linter suggestions: Black and isort formatting, Flake8 unused import, and Mypy missing return type.
 - The solution for providing guidance on more best practices (2.5 minutes)
   - Build custom linters for best practices using PyGithub and LibCST

Effective linter strategies: (3 mins)
- Use linters to guide developers on best practices
   - Convention over configuration
   - With linters, developer don&#8217;t need to remember too many things
- Use autofix to help developer on fixing issues
   - DRY: don&#8217;t repeat yourself
   - Wth autofixes, developers move fast to focus on developing products

Results and Recap: (2 mins)
 - scaled out our linters to run 10k times on 25 codebases for 200 developers and provide 25k suggestions on a weekly basis
 - recap the solutions for scaling out linters</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/FFTHXB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/FFTHXB/feedback/</feedback_url>
            </event>
            <event guid='7310ae86-a45c-5997-a13c-011655cf919d' id='29105' code='PNVM3S'>
                <room>Terrace 2B</room>
                <title>Optimizing Your CI Pipelines</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T11:35:00+02:00</date>
                <start>11:35</start>
                <duration>00:30</duration>
                <abstract>Take your Continuous Integration to the next level! Learn how to optimize your pipelines for faster and more efficient builds through parallelization, caching, failing early, conditional runs, and more.</abstract>
                <slug>europython-2023-29105-optimizing-your-ci-pipelines</slug>
                <track>DevOps (2023)</track>
                
                <persons>
                    <person id='33612'>Sebastian Witowski</person>
                </persons>
                <language>en</language>
                <description>This talk aims to show you some ideas on how to improve your CI pipelines. I assume that you already know what CI is, you chose one of many tools available on the market and wrote some kind of a CI setup for your project. Great! Now, let&#8217;s take it one step forward and see how we can make it even better.

I will talk mainly about improving the speed of your CI pipelines (which in many cases will correspond to also lowering costs if you use a paid service) through:

-   Making more things run at the same time - parallelization
-   Making things start faster - caching, smaller containers
-   Making things finish faster - failing early, splitting tests, running CI conditionally, etc.

I will use Gitlab CI to show concrete examples, but I will also try to make this talk as generic as possible to make it useful for people using different CI tools.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PNVM3S/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PNVM3S/feedback/</feedback_url>
            </event>
            <event guid='1a16cf59-4861-5395-9199-ddec79880f8c' id='30125' code='F3KLX7'>
                <room>Terrace 2B</room>
                <title>Zero downtime deployments: Is it worth the effort?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T12:10:00+02:00</date>
                <start>12:10</start>
                <duration>00:30</duration>
                <abstract>Learn about the advantages and disadvantages of zero downtime deployment strategy, as well as best practices for implementing it in your organization. Learn how to make changes to production systems while keeping users up to date. Don&apos;t pass up this chance to optimize your software deployments.</abstract>
                <slug>europython-2023-30125-zero-downtime-deployments-is-it-worth-the-effort</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34552'>Rafa&#322; Nowicki</person>
                </persons>
                <language>en</language>
                <description>Minimizing downtime during deployments is critical in the world of software development for maintaining high-availability applications and ensuring users have continuous access to applications. In this presentation, we will look at the advantages, disadvantages, and best practices of zero-downtime deployments. 

We will go over the technical aspects of achieving zero downtime, such as blue-green deployments, canary releases, feature toggles, and so on. We&apos;ll also talk about how to balance the benefits of zero-downtime deployments with the effort required to put them in place. You will discover the significance of testing, monitoring, and automation in achieving successful zero-downtime deployments.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/F3KLX7/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/F3KLX7/feedback/</feedback_url>
            </event>
            <event guid='c7026672-9d24-544f-a303-9befe416c77f' id='29650' code='YRM7GF'>
                <room>Terrace 2B</room>
                <title>Serve notebook as a Web App with Mercury framework</title>
                <subtitle></subtitle>
                <type>Poster</type>
                <date>2023-07-19T13:00:00+02:00</date>
                <start>13:00</start>
                <duration>01:00</duration>
                <abstract>Make your coding meaningful to non-technical recipients! Write your code in Jupyter Notebook, add widgets with the Mercury framework, and easily turn your notebook into an interactive web app. Or.. create a dashboard, a report, and DEPLOY it.</abstract>
                <slug>europython-2023-29650-serve-notebook-as-a-web-app-with-mercury-framework</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='34063'>Aleksandra Plonska</person><person id='34071'>Piotr P&#322;o&#324;ski</person>
                </persons>
                <language>en</language>
                <description>Problem: sharing coding work, notebooks with stakeholders, non-technical people without any basic knowledge of coding. 
Solution: 1. Write code in Jupyter Notebook. 2. Install Mercury 3. Choose widgets and decide how to present it. 3. Deploy.
The poster will show how, with a few steps transform, a notebook into an interactive website, report, and dashboard easily. Using the Mercury framework doesn&apos;t require frontend technologies knowledge, only python. With this open-source solution, you can decide to restrict access to the created web app by adding authentication. What is more, you can set up notifications, show or hide code, serve multiple apps without the user&apos;s limit, users can easily export the executed notebook as a PDF or HTML. It doesn&apos;t require rewriting your code. In the end, you can decide if you want to self-host it or deploy it with Mercury Cloud.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/YRM7GF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/YRM7GF/feedback/</feedback_url>
            </event>
            <event guid='f5ab8438-bbd0-5659-8f67-29337f4d7d10' id='29948' code='YPKPWV'>
                <room>Terrace 2B</room>
                <title>The Power of Spec-Based Testing:Adding Functional Requirements to Unit Test</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>Testing is a crucial part of the software development process. But, with so many testing techniques available, it can be challenging to know which one to use. While unit testing is a popular technique, it&apos;s not always the most effective or efficient way to ensure software quality. In this talk, we&#8217;ll explore spec-based testing, a technique that focuses on verifying that the software behaves in accordance with its specifications or requirements.</abstract>
                <slug>europython-2023-29948-the-power-of-spec-based-testing-adding-functional-requirements-to-unit-test</slug>
                <track>Testing (2023)</track>
                
                <persons>
                    <person id='34415'>Anupama Tiruvaipati</person>
                </persons>
                <language>en</language>
                <description>Our focus in this talk will be on the benefits of spec-based testing, including:
1. Problems with unit testing: How spec-based testing can bridge this gap.
2. Improved test coverage: Spec-based testing will ensure all the requirements or specifications are covered by the test, thereby helping to attain better overall software quality.
3. Reducing maintenance work: Since they are based on the software&#8217;s intended behaviour and not implementation details, spec-based tests are less likely to break due to changes in the code. This can lead to fewer tests needing to be maintained over time.
4. Better alignment: Spec-based testing ensures that software meets its intended purpose as defined by the requirements or specifications.

Key takeaways:
1. Benefits of spec-based testing
2. How to boost your testing strategy with spec-based testing
3. How to get started with spec-based testing in your own project development
4. Learn how to identify functional requirements or specifications and create effective test cases</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/YPKPWV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/YPKPWV/feedback/</feedback_url>
            </event>
            <event guid='85b9d4f5-0bbe-522e-ba61-8301e9bee420' id='34742' code='M93HCV'>
                <room>Terrace 2B</room>
                <title>Q&amp;A panel for data science newbies</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>Are you just getting started in the world of data science and feeling overwhelmed by the abundance of information on various packages, models, and techniques? Perhaps you&apos;re finding it challenging to decide which visualization package to use or which tools to begin with. Maybe you&apos;re puzzled by the distinctions between pip and Conda, or you&apos;re feeling bombarded by all the news about AI and large language models.

Worry no more! Join us for this Q&amp;A session, where a panel of data science experts will be there to address all of your pressing questions. This session is designed to create a relaxed and welcoming environment for complete beginners in the field, offering guidance on topics that might be causing confusion.</abstract>
                <slug>europython-2023-34742-q-a-panel-for-data-science-newbies</slug>
                <track></track>
                
                <persons>
                    <person id='33929'>Cheuk Ting Ho</person><person id='33290'>Vaibhav Srivastav</person><person id='33458'>Jodie Burchell</person><person id='34082'>Valerio Maggio</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/M93HCV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/M93HCV/feedback/</feedback_url>
            </event>
            <event guid='d36fb328-fc04-5adb-9d1c-d43f484c6337' id='29337' code='LQZ7BP'>
                <room>Terrace 2B</room>
                <title>Interactive, animated reports and dashboards in Streamlit with ipyvizzu.</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>It&apos;s great when you can share the results of your analysis not only as a presentation but as something that non-data scientists can explore on their own, looking for insights and applying their business expertise to understand the significance of what they find.

With its accessibility for both creators and viewers, Streamlit offers a brilliant platform for data scientists to build and deploy data apps. Now, with the integration of [ipyvizzu](https://ipyvizzu.vizzuhq.com/latest/) - a new, open-source data visualization tool focusing on animation and storytelling - you can quickly create and publish interactive, animated reports and dashboards on top of static or dynamic data sets and your models.</abstract>
                <slug>europython-2023-29337-interactive-animated-reports-and-dashboards-in-streamlit-with-ipyvizzu</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33839'>Peter Vidos</person>
                </persons>
                <language>en</language>
                <description>The ability to build Streamlit apps that enable business users to explore data on their own is an excellent way to support data-driven decision-making in any organization. Pair this up with the animated transitions between the charts provided by the new, open-source library, ipyvizzu, and you have a self-service, interactive report or dashboard that makes it much easier for non-experts to make sense of complex data sets.

In this talk, one of the creators of ipyvizzu shows how their technology works within Streamlit and the advantages of using animation in self-service data exploration to help business stakeholders feel smarter and do a better job.

We&apos;ll cover the following topics within the talk:
- Introduction to Vizzu, the open-source C++/JavaScript library behind ipyvizzu
- Benefits of animated charts for storytelling and data exploration
- Basic logic and options of ipyvizzu
- Quick walkthrough of building an interactive report within Streamlit
- Live examples to showcase the benefits and the opportunities</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/LQZ7BP/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/LQZ7BP/feedback/</feedback_url>
            </event>
            <event guid='f2e8617d-54b3-54d7-8856-4b9bd67efc20' id='28844' code='BXZD9Z'>
                <room>Terrace 2B</room>
                <title>DuckDB: Bringing analytical SQL directly to your Python shell</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-19T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>In this talk, we will present DuckDB. DuckDB is a novel data management system that executes analytical SQL queries without requiring a server. DuckDB has a unique, in-depth integration with the existing PyData ecosystem. This integration allows DuckDB to query and output data from and to other Python libraries without copying it. This makes DuckDB an essential tool for the data scientist. In a live demo, we will showcase how DuckDB performs and integrates with the most used Python data-wrangling tool, Pandas. 
Besides learning about DuckDB&apos;s main charactestics, users will also experience a live demo of DuckDB and Pandas in a typical data science scenario, focusing on comparing their performance and usability while showcasing their cooperation. The demo is most interesting for an audience familiar with Python, the Pandas API, and SQL.</abstract>
                <slug>europython-2023-28844-duckdb-bringing-analytical-sql-directly-to-your-python-shell</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33373'>Pedro Holanda</person>
                </persons>
                <language>en</language>
                <description>The talk is catered primarily towards data scientists and data engineers. The talk aims to familiarize users with the design differences between Pandas and DuckDB and how to combine them to solve their data-science needs. We will have an overview about five main characteristics of DuckDB. 1) Vectorized Execution Engine, 2) End-to-end Query Optimization, 3) Automatic Parallelism, 4) Beyond Memory Execution, and 5) Data Compression.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BXZD9Z/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BXZD9Z/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='4' date='2023-07-20' start='2023-07-20T04:00:00+02:00' end='2023-07-21T03:59:00+02:00'>
        <room name='PyCharm (Forum Hall)' guid='bde7cec6-20ad-5a61-8c4f-43220b09f87c'>
            <event guid='90894652-32af-576e-aeae-a5d92a37868e' id='35608' code='XPARN3'>
                <room>PyCharm (Forum Hall)</room>
                <title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-20T08:00:00+02:00</date>
                <start>08:00</start>
                <duration>01:00</duration>
                <abstract></abstract>
                <slug>europython-2023-35608-registration-welcome-forum-hall-foyer-1st-floor</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                <description>Welcome to EuroPython 2023! You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!

Queues will be sorted by your **first name** on your ticket. Your ticket can be located via your order confirmation email (from support@pretix.eu with the Subject: Your order: XXXX). If you ordered your ticket after we&apos;ve sent badges for printing (after 10 July), go directly to the Info Desk (also referred as Debugging Desk) and a volunteer will help!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XPARN3/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XPARN3/feedback/</feedback_url>
            </event>
            <event guid='8e9854d7-993a-507a-8f08-0b32967247f0' id='34202' code='CHSAUC'>
                <room>PyCharm (Forum Hall)</room>
                <title>Morning Announcement</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-20T09:00:00+02:00</date>
                <start>09:00</start>
                <duration>00:15</duration>
                <abstract></abstract>
                <slug>europython-2023-34202-morning-announcement</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/CHSAUC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/CHSAUC/feedback/</feedback_url>
            </event>
            <event guid='782cadb9-19a2-5ce4-b40c-66861e09b50b' id='33371' code='ZJRTGW'>
                <room>PyCharm (Forum Hall)</room>
                <title>The Future of Microprocessors</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-07-20T09:15:00+02:00</date>
                <start>09:15</start>
                <duration>00:45</duration>
                <abstract>The Future of Microprocessors - a talk about the history of microprocessors, how we got here and what might happen next. There will be two laws, one equation, some graphs and a particle beam weapon out of Star Trek.</abstract>
                <slug>europython-2023-33371-the-future-of-microprocessors</slug>
                <track></track>
                
                <persons>
                    <person id='37652'>Sophie Wilson</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZJRTGW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZJRTGW/feedback/</feedback_url>
            </event>
            <event guid='0f78480e-a1cb-5c77-b479-1746276df62a' id='29609' code='ZUSHKU'>
                <room>PyCharm (Forum Hall)</room>
                <title>PyScript and the magic of Python in the browser</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:45</duration>
                <abstract>Python running on the browser is the new frontier to creating true client-side web and mobile applications. Today we can many incredible things that were not possible just a few months ago before WASM, Pyodide and PyScript.

The talk will cover what&apos;s possible today, cover the major features offered by PyScript and walk through creating amazing applications and games with Python, on the browser, without the need for Python server-side logic.</abstract>
                <slug>europython-2023-29609-pyscript-and-the-magic-of-python-in-the-browser</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33291'>Nicholas Tollervey</person><person id='34041'>Fabio Pliger</person>
                </persons>
                <language>en</language>
                <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&#8230;
* 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 of 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&#8217;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 than &#8220;regular Python&#8221; 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&#8217;ll have the chance to learn more about it, how to create your own Python apps on the browser, and see what&#8217;s coming.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://ntoll.org/static/presentations/2023-pyscript-magic/index.html">Web based slides (press &quot;S&quot; for speaker notes and allow popups from the site)</link>
                </links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZUSHKU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZUSHKU/feedback/</feedback_url>
            </event>
            <event guid='7467b7c5-9888-5dae-8911-0e9ded9bf3b8' id='29656' code='XLLSWL'>
                <room>PyCharm (Forum Hall)</room>
                <title>Running Python packages in the browser with Pyodide</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Pyodide is a port of CPython to WebAssembly/Emscripten enabling Python packages to run directly in the browser or Node.js. We will provide an overview of Pyodide&apos;s architecture, capabilities, and potential use cases before looking into building, running, and testing Python packages for the browser.

We will also discuss how browser-specific optimizations, such as code splitting, tree shaking, and lazy loading could be adapted to Python to reduce package size and load time.

Finally, we will mention some of the common restrictions of the browser runtime and how they can be overcome in Python packages.</abstract>
                <slug>europython-2023-29656-running-python-packages-in-the-browser-with-pyodide</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34079'>Roman Yurchak</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XLLSWL/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XLLSWL/feedback/</feedback_url>
            </event>
            <event guid='8b6f8de5-09ff-5948-992a-84f8c0e78807' id='28768' code='HL8XCC'>
                <room>PyCharm (Forum Hall)</room>
                <title>The CPU in your browser: WebAssembly demystified</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>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, which is essentially a virtual CPU
inside the browser.</abstract>
                <slug>europython-2023-28768-the-cpu-in-your-browser-webassembly-demystified</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33297'>Antonio Cuni</person>
                </persons>
                <language>en</language>
                <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.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/HL8XCC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/HL8XCC/feedback/</feedback_url>
            </event>
            <event guid='c1712f48-b91e-59ee-8aed-488970559564' id='28781' code='B7WYKQ'>
                <room>PyCharm (Forum Hall)</room>
                <title>Packaging Python Apps with Briefcase</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Python has proven itself to be a powerful tool for data science, and for web servers. However, one area where it hasn&apos;t historically been popular is in building applications for end users.

In this talk, you&apos;ll discover how you can use Briefcase to distribute an app to users on desktop, mobile, and the web - all from a single Python codebase.</abstract>
                <slug>europython-2023-28781-packaging-python-apps-with-briefcase</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33316'>Russell Keith-Magee</person>
                </persons>
                <language>en</language>
                <description>Once you&apos;re written your amazing new application using Python, the next problem you&apos;ll face is how to get that application into the hands of users. If your users are familiar with `pip` and and `venv`, you can put `pip install` into a README, and leave it at that. But what if your audience aren&apos;t Python programmers? What if your app needs to be used by people who don&apos;t write Python at all? How do you distribute your code so that others can use it?

In this talk, you&apos;ll learn about **Briefcase**, a tool that can convert a Python project into platform-native installers on macOS, Windows, Linux - and can also target iOS, Android, and the web. You&apos;ll learn how to use Briefcase to start a new project, or convert an existing project for distribution. You&apos;ll learn about the features of Briefcase that can support you while you develop your application. Finally, you&apos;l learn how to generate installers and standalone applications for multiple platforms from a single Python codebase.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/B7WYKQ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/B7WYKQ/feedback/</feedback_url>
            </event>
            <event guid='a74ee6ec-0f2b-5b57-a184-3381883cc03b' id='33482' code='F9UBUW'>
                <room>PyCharm (Forum Hall)</room>
                <title>Cyber Resilience Act Panel</title>
                <subtitle></subtitle>
                <type>Panel</type>
                <date>2023-07-20T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>01:00</duration>
                <abstract>The [EU Cyber Resilience Act (CRA)](https://digital-strategy.ec.europa.eu/en/library/cyber-resilience-act) may have a huge impact on the open-source community. There are concerns about how this framework would be applied to the open-source software contribution and distribution. If you would like to know more and voice out your concerns, join our sessions with leaders in the Python community and experts in the field.</abstract>
                <slug>europython-2023-33482-0-cyber-resilience-act-panel</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                <description>## Agenda

- 2:00 pm - 2:40 pm - CRA panel
- 2:40 pm - 3:00 pm - CRA panel Q&amp;A
- 3:00 pm - 3:30 pm - Coffee break
- 3:30 pm - 4:30 pm - CRA Unconference Discussion (at Open Space)

---

## CRA Panel

We have invited leaders in the Python community and domain experts to discuss the current state of CRA, related regulations and the potential effect to open-source, especially in the Python community. Confirmed Panelists are:

- Deb Nicholson - Executive Director at the Python Software Foundation
- Jannis Leidel - Founder of the Python Packaging Authority and the PSF Board of Directors
- Ciar&#225;n O&apos;Riordan - Senior Policy Advisor of OpenForum Europe

## CRA panel Q&amp;A

After the panel, it is your turn to ask questions and voice out your concern regarding the CRA. Are you a contributor to open-source software and wonder who will be held accountable for the software that you contributed? Are you working for a company that publishes open-source software and wonder if that will affect the business model of your company? Are you using open-source software and wonder if the open-source ecosystem would be the same after the CRA has been put into action? Join us to discuss all these.

## CRA Unconference Discussion

If you would like to discuss further about CRA and the related PLD (Product Liability Directive), and their potential effect in the open source community. We reserved a 1-hour session in the open space for unconference discussion.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/F9UBUW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/F9UBUW/feedback/</feedback_url>
            </event>
            <event guid='408c8a39-0cb6-5650-9696-e823839d2580' id='29748' code='CRPQGK'>
                <room>PyCharm (Forum Hall)</room>
                <title>Music information retrieval with Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>The advancements of artificial intelligence in computer vision and natural language processing often make the headlines, but the subspace of musical AI is developing just as rapidly. Let&#8217;s take a dive into the research area of music information retrieval and see how Python enables some of its proudest achievements. You&#8217;ll learn about common MIR tasks and get ideas on how you can analyze, generate and interact with music using code, so you can start exploring right away! 
No music theory knowledge nor prior experience with MIR is expected.</abstract>
                <slug>europython-2023-29748-music-information-retrieval-with-python</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='34192'>Mateusz Modrzejewski</person>
                </persons>
                <language>en</language>
                <description>The talk gives an overview of the music information retrieval (MIR) research area. The area encompasses music analysis, generation, processing and recommendation. Python is one of the main tools used in MIR, with many dedicated libraries and more and more pre-trained AI models available for Pythonistas. Both the research area of MIR and the contents of this talk are highly interdisciplinary - MIR has something for you regardless whether you&apos;re a music lover, an active musician, deep learning researcher or web app builder!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/CRPQGK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/CRPQGK/feedback/</feedback_url>
            </event>
            <event guid='dc05ce29-274e-5316-90a6-35c47e953ad9' id='29572' code='KYAWCJ'>
                <room>PyCharm (Forum Hall)</room>
                <title>Games of Life: generative art in Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>We&apos;re entering the age of machine-generated art. Many of the new systems are shockingly impressive but impossible to replicate by individuals because they rely on complex machine learning techniques with huge datasets that aren&apos;t feasible to do in a home environment. Fortunately, there&apos;s an entire group of clever approaches to generate graphics that look cohesive, unique, and deliberate... and that you can easily do on your own computer.

In this short talk we&apos;ll go through a few of those algorithms like Clifford attractors, slime mold simulation, and reduction of source imagery to geometric primitives. We&apos;ll generate images and animations, we&apos;ll dabble in 2D and 3D. You&apos;ll leave the talk with your own ideas how to create attractive visualizations out of thin air. The talk assumes familiarity with Python and high-school math.</abstract>
                <slug>europython-2023-29572-games-of-life-generative-art-in-python</slug>
                <track>Arts, Crafts Culture &amp; Demos (2023)</track>
                
                <persons>
                    <person id='34015'>&#321;ukasz Langa</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/KYAWCJ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/KYAWCJ/feedback/</feedback_url>
            </event>
            <event guid='66c3d4b5-8b33-5bba-9af7-3f67d6a3434b' id='33370' code='RMHLRA'>
                <room>PyCharm (Forum Hall)</room>
                <title>Welcome to Your World</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-07-20T16:55:00+02:00</date>
                <start>16:55</start>
                <duration>00:45</duration>
                <abstract>In 2018 the author, journalist and broadcaster Andrew Smith realized that although computer code now mediated almost everything he did, he understood next to nothing about it. The only way to participate in the growing debates around what our code should and should not do, he reasoned, would be to enter the world of the people writing it, by learning to code himself. Nice idea! In a near thirty year writing career, Smith had flown to the edge of space, slept under Spearfish torpedoes aboard a nuclear hunter-killer submarine, roamed the vast Victorian sewer system under London, spent six months on the road with Bianca Jagger, toured with artists including Radiohead and The Prodigy, and been perhaps the only person ever to shake Fidel Castro&apos;s hand by accident. None of which prepared him for the challenge of learning to code. After a miserable false start with JavaScript, a kindly C++ programmer pointed him in the direction of Python and he fell in love not just with the language, but with the remarkable community behind it. In this unusual keynote, Andrew, with help from his great friend and Python stalwart Nicholas Tollervey, will describe what he found&#8212;explaining the joys, frustrations and surprises, while touching on his experiences in Silicon Valley and the intriguing historical discoveries he made during his research. Smith&apos;s meditation on code&apos;s relationship to the wider world, Devil in the Stack: Searching for the Soul of the New Machine, will be published next March. This is his chance to share a preview of his reflections with the community that did so much to make them possible, of which he is grateful to consider himself a part.</abstract>
                <slug>europython-2023-33370-welcome-to-your-world</slug>
                <track></track>
                
                <persons>
                    <person id='37654'>Andrew Smith</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/RMHLRA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/RMHLRA/feedback/</feedback_url>
            </event>
            <event guid='5211a097-153f-59bd-8c1f-adefc456b26c' id='34204' code='YWGAUU'>
                <room>PyCharm (Forum Hall)</room>
                <title>Lightning Talks Thursday</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T17:45:00+02:00</date>
                <start>17:45</start>
                <duration>00:45</duration>
                <abstract>Enjoy Thursday&apos;s lightning talks, hosted by Omotola Omotayo &#11015;&#65039;
  
  - **Being Nice** &#8212; Daniele Procida 
  - **I am Biased** &#8212;  Filipa Andrade 
  - **What APL Taught Me about Python** &#8212; Rodrigo Gir&#227;o Serr&#227;o 
  - **All You Need to Know About Federated Learning in 2 Minutes** &#8212; Sarah Diot-Girard 
  - **A Different (Travel) Program** &#8212; Riccardo Polli
  - **fstring.help Or: How I Bought Yet Another Domain** &#8212; Florian Bruhin 
  - **Community Conference / Events Announcements &amp; Celebration!** 
  - **Pick a Side: Planet or Profit?** &#8212; Chiin-Rui Tan
  - **Isolated Python Functions** &#8212; Meder Kamalov  
  - **Gambatte Terminal** &#8212; Vincent Michel</abstract>
                <slug>europython-2023-34204-lightning-talks-thursday</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/YWGAUU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/YWGAUU/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='South Hall 2A' guid='b4aa8885-f330-5bc6-b7b3-d64f56d62691'>
            <event guid='43d95f8c-3989-5ac6-ba8a-fc28b1667f8e' id='29804' code='SDEUCB'>
                <room>South Hall 2A</room>
                <title>Poisoned pickles make you ill</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>Don&#8217;t you love pickles? In the data science space, the pickle module has become one of the most popular ways to serialise and distribute machine learning models - yet, pickles introduce a wide range of problems. For starters, it is incredibly easy to poison a pickle. Once this happens, a poisoned pickle can be used by an attacker to inject any arbitrary code into your ML pipelines. And what&#8217;s even worse: it&#8217;s incredibly hard to detect if a pickle has been poisoned!

Good news? Help is on the way! You now have access to an increasing number of tools to help you generate higher-quality pickles. And when those are not enough, you can always draw inspiration from the DevOps movement and their trust-or-discard processes.

This talk will show you how widespread pickles are and how easy it is to poison models serialised with pickle, but also how easy it is to start protecting them from attacks.</abstract>
                <slug>europython-2023-29804-poisoned-pickles-make-you-ill</slug>
                <track>PyData: Machine Learning, Stats (2023)</track>
                
                <persons>
                    <person id='34265'>Adrian Gonzalez-Martin</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://github.com/adriangonz/sigstore-talk">Notebooks &amp; Code</link>
                </links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/SDEUCB/resources/EuroPython_2023_Poisoned_pickles_make_you_i_g3TMZgG.pdf">Slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SDEUCB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SDEUCB/feedback/</feedback_url>
            </event>
            <event guid='37636395-5587-5f01-baf9-c30a66138f07' id='33361' code='B3MU99'>
                <room>South Hall 2A</room>
                <title>Unlocking the Power of What-If Analysis for BI, Data, and AI with Taipy</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-20T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>What-if analysis is the key to exploring datasets and assessing outcomes by gradually varying input parameters. It is a vital tool for users in the realm of data analysis and decision-making. However, implementing what-if analysis can be challenging. Join this captivating talk as we delve into the practical implementation of what-if analysis using Taipy.</abstract>
                <slug>europython-2023-33361-unlocking-the-power-of-what-if-analysis-for-bi-data-and-ai-with-taipy</slug>
                <track></track>
                
                <persons>
                    <person id='33930'>Jean-Baptiste Braun</person>
                </persons>
                <language>en</language>
                <description>This session will delve into a real-world industry case study highlighting the profound benefits of what-if analysis. While the focus is on Business Intelligence (BI), the concepts discussed are equally applicable to AI and data analysis in general.

Agenda:

    Understanding the limitations of data exploration without what-if analysis
    Discovering why your users will fall in love with what-if analysis
    Demystifying the possibility of implementing what-if analysis with popular tools like PowerBI and Looker
    Introducing Taipy: The Ultimate What-If Analysis Toolkit
    Unveiling the killer features of Taipy that empower data professionals
    A glimpse into the future of Taipy and what to expect
    Live demo showcasing Taipy&apos;s powerful scenario feature

This session will ignite your enthusiasm as we explore the game-changing potential of designing front-ends in Python. With Python skills already prevalent among data analysts, the possibilities are endless.

Join this exciting journey as we unlock the full potential of what-if analysis with Taipy.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/B3MU99/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/B3MU99/feedback/</feedback_url>
            </event>
            <event guid='daff4b7b-d7a8-5bcc-8d3b-ca6347529e9b' id='29425' code='ZPH9PC'>
                <room>South Hall 2A</room>
                <title>High Volume PDF Text Extraction using Python Open-Source Tools</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>All major companies have huge amounts of (mostly PDF) documents that contain important - even critically important - information, that does no longer exist anywhere else in their data stores.

Reports, once generated for shareholders and legal or financial authorities, may still be useful for developing longterm forecasts or triggering company management decisions.

By definition, documents are intended for human perception, and as such contain unstructured data from an information technology perspective.

Therefore, tools to extract PDF text content (mostly, but not only text) from millions of pages have become important vehicles to recreate structured information.

This presentation talks about extraction &quot;need for speed&quot; in this Big Data scenario, the need for integration with OCR capabilities and presents an open-source toolset which combines both, top-of-the-class performance and maximum extraction detail.</abstract>
                <slug>europython-2023-29425-high-volume-pdf-text-extraction-using-python-open-source-tools</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33909'>Harald Lieder</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZPH9PC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZPH9PC/feedback/</feedback_url>
            </event>
            <event guid='c6f78c4d-3396-5be7-a0d5-283d23b2a370' id='35781' code='D9HP7Z'>
                <room>South Hall 2A</room>
                <title>How dunder methods rule Python under the hood</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>[Python dunder methods](https://mathspp.com/blog/pydonts/dunder-methods) &#8211; like `__init__` &#8211; are sometimes referred to as &#8220;magic methods&#8221; but they are not!

They are just regular methods!

Functions that are associated with objects and that you can call with arguments.

The only thing is... Python also calls those functions behind the scenes in certain situations!

So, let us learn what that is all about.</abstract>
                <slug>europython-2023-35781-how-dunder-methods-rule-python-under-the-hood</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33700'>Rodrigo Gir&#227;o Serr&#227;o</person>
                </persons>
                <language>en</language>
                <description>In this talk aimed at beginners, we will see what &#8220;dunder methods&#8221; are and how they govern Python behind the scenes.

We will understand, for example, why the funny-looking method `__init__` looks so funny and what its real purpose is.

Then, we will understand that all of the Python syntax really is governed by dunder methods, and thus, if you want your own classes and objects to interact with the Python syntax, all you need to do is implement the appropriate dunder methods.

For example, we will see how to use dunder methods to enable you to create a good string representation of your class, or how to define `len` on your own objects.

Although the talk is aimed at beginners, the audience is expected to know how to use the keyword `class` to create their own classes.

All materials can be accessed from [this GH repo](https://github.com/mathspp/talks).</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/D9HP7Z/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/D9HP7Z/feedback/</feedback_url>
            </event>
            <event guid='a48a632d-a4cd-5443-839d-a073f7cf4f0a' id='29432' code='XEQPYB'>
                <room>South Hall 2A</room>
                <title>pip install malware</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>pip install malware: it&#8217;s that easy. Almost all projects depend on external packages, but did you know how easy it can be to install something nasty instead of the dependency you want? I&apos;ll be showing this live, as I make malware and install it from PyPI onto my own computer during the talk!</abstract>
                <slug>europython-2023-29432-pip-install-malware</slug>
                <track>Security (2023)</track>
                
                <persons>
                    <person id='33915'>Max Kahan</person>
                </persons>
                <language>en</language>
                <description>You might remember classic typosquatting examples like goggle.com, but it&#8217;s now common to see malicious code hidden in spoofed or otherwise fraudulent PyPI packages or nested dependencies. Malware developers can also use techniques like starjacking to appear legitimate, so these unpleasant packages become even more difficult to spot. It&#8217;s estimated that over 3% of packages on PyPI could be using this technique.

By the end of this talk, you&#8217;ll know how to protect yourself when installing and updating dependencies and you&#8217;ll leave with a checklist to follow to help you stay safe in future.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XEQPYB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XEQPYB/feedback/</feedback_url>
            </event>
            <event guid='659c66b0-cae6-52ca-8088-0aad6dc885aa' id='29395' code='ETSMPK'>
                <room>South Hall 2A</room>
                <title>PEP 458 a solution not only for PyPI</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>[PEP 458](https://peps.python.org/pep-0458/) uses cryptographic signing on [PyPI](https://pypi.org) to protect Python packages against attackers. The implementation of the PEP inspired the [Repository Service for TUF (RSTUF)](http://repository-service-tuf.readthedocs.io/), a project [accepted into the OpenSSF sandbox](https://github.com/ossf/tac/pull/137). We identified that the design could benefit other organizations and repositories looking to secure their software supply chains.
In this talk we would answer the following questions: 
- How did the PEP 458 design help to start the Repository Service for TUF (RSTUF)?
- How could RSTUF be used for PyPI with its millions of packages?
- How can RSTUF be deployed by any organization at any scale without requiring TUF expertise?

Additionally, in this talk, we would give an overview of PEP 458, how it works, and give a high-level overview of TUF.</abstract>
                <slug>europython-2023-29395-pep-458-a-solution-not-only-for-pypi</slug>
                <track>Security (2023)</track>
                
                <persons>
                    <person id='33891'>Kairo de Araujo</person><person id='34073'>Martin Vrachev</person>
                </persons>
                <language>en</language>
                <description>[PEP 458](https://peps.python.org/pep-0458/) was designed to protect [PyPI](https://pypi.org) against various possible attacks on PyPIs own content distribution network and its mirrors while giving administrators a mechanism to recover from a compromise if it happens using [The Update Framework (TUF)](http://theupdateframework.io/).
Using [Repository Service for TUF (RSTUF)](http://repository-service-tuf.readthedocs.io/) is actually deploying TUF as a service based on PEP 458 design to solve a lot of common problems for repositories. It will help PyPI maintainers to integrate TUF using simple REST API calls without adding a large amount of code in the PyPI/Warehouse code base. 
In this talk, we will recap PEP 458 and TUF, and what they are good for. We will show how RSTUF works and demonstrate the integration with Warehouse. Additionally, we will share how other organizations could use RSTUF to protect their clients.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ETSMPK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ETSMPK/feedback/</feedback_url>
            </event>
            <event guid='55d1ccc2-5ee6-517c-92ed-f4ae176ff4dd' id='29569' code='BHXSQU'>
                <room>South Hall 2A</room>
                <title>Don&#8217;t Panic! A Developer&#8217;s Guide to Security</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>As a developer, you play a crucial role in the security of your projects. At the same time, it can be difficult to know if what you&#8217;re doing is enough. Luckily, you don&#8217;t have to be a security expert to contribute to the security of your projects. Instead, you can use industry standards as a guide for your approach to security.

In this talk, I will introduce you to a framework that is especially accessible to developers, the [OWASP DevSecOps Maturity Model](https://owasp.org/www-project-devsecops-maturity-model/), and help you get started with a systematic approach to improving the security of your projects.</abstract>
                <slug>europython-2023-29569-don-t-panic-a-developer-s-guide-to-security</slug>
                <track>Security (2023)</track>
                
                <persons>
                    <person id='34013'>Sebastiaan Zeeff</person>
                </persons>
                <language>en</language>
                <description>One of the leading security principles today is that you should embrace security practices throughout your entire Software Development Lifecycle (SDLC), from design to deployment and maintenance. This means that you, as a developer, have a crucial part to play in keeping your projects secure.

In my talk, I will show you how to do that by introducing you to the [OWASP DevSecOps Maturity Model (DSOMM)](https://owasp.org/www-project-devsecops-maturity-model/). This model, which is very accessible to anyone familiar with DevOps, allows you to evaluate and improve your security practices. As the model describes the entire Software Development Lifecycle, it also serves as a nice reference framework for industry-standard security practices.

I will start by giving you a high-level overview of the model and the principles behind it. I will also compare the DevSecOps Maturity Model with its older sibling, the [OWASP Software Assurance Maturity Model (SAMM)](https://owasp.org/www-project-samm/). Since it&#8217;s important, I will end the first part by going into the difference between having a good security culture and [checkbox compliance](https://en.wiktionary.org/wiki/checkbox_compliance).

Next, I will take you through the dimensions of the DevSecOps Maturity Model, with a focus on those dimensions that are especially relevant to developers. I will illustrate each dimension with concrete examples of security practices that you can implement yourself today.

Finally, I will talk about the best way to start implementing these practices. This is crucial: For instance, if you suddenly introduce all the tools you can find, chances are that the only thing you&#8217;ll learn from the plethora of alerts you&#8217;ll get is how to ignore these tools. Since some of us also have to deal with corporate policies and a limited sphere of influence within an organization, I will end with some pointers on how to advocate good security practices from the bottom up.

And, if this all feels a bit overwhelming, remember the big friendly letters in the title: [**Don&#8217;t Panic!**](https://en.wikipedia.org/wiki/The_Hitchhiker%27s_Guide_to_the_Galaxy)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BHXSQU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BHXSQU/feedback/</feedback_url>
            </event>
            <event guid='5bacc759-c96f-56d3-b254-d19a049ac0b0' id='33368' code='XYLWJH'>
                <room>South Hall 2A</room>
                <title>Sponsor Highlight &amp; Recruitment Fair</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-20T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>Many of our sponsors are looking to hire talented people and EuroPython is the perfect place to reach out to them!

In this session, our sponsors will each give a short presentation about their company and what they do with Python. You will meet and hear the exciting opportunities from JetBrains. Kraken Technologies, Microsoft, Optiver, Sentry, Temporal Technologies, Google Cloud, Numberly and Arm. Afterwards, you can approach them directly in their sponsor booth to carry on the conversation!</abstract>
                <slug>europython-2023-33368-sponsor-highlight-recruitment-fair</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XYLWJH/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XYLWJH/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='South Hall 2B' guid='eca0a8bd-c83c-5ce2-b5c8-78da7df606c8'>
            <event guid='2d60964f-e175-5d1d-bcd6-df6c6174fd2c' id='29585' code='ZCXMQK'>
                <room>South Hall 2B</room>
                <title>Understanding Neural Network Architectures with Attention and Diffusion</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>Neural networks have revolutionized AI, enabling machines to learn from data and make intelligent decisions. In this talk, we&apos;ll explore two popular architectures: Attention models and Diffusion models.

First up, we&apos;ll discuss Attention models and how they&apos;ve contributed to the success of large language models like ChatGPT. We&apos;ll explore how the Attention mechanism helps GPT focus on specific parts of a text sequence and how this mechanism has been applied to different tasks in natural language processing.

Next, we&apos;ll dive into Diffusion models, a class of generative models that have shown remarkable performance in image synthesis. We&apos;ll explain how they work and their potential applications in the creative industry.

This is a good talk for visual learners. I prepared schematic diagrams, which present main features of the nerual network architectures. By necessity, the diagrams are oversimplified, but I believe they will allow you to gain some insight into Transformers and Latent Diffusion models.</abstract>
                <slug>europython-2023-29585-understanding-neural-network-architectures-with-attention-and-diffusion</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='35000'>Micha&#322; Karzy&#324;ski</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZCXMQK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZCXMQK/feedback/</feedback_url>
            </event>
            <event guid='77a8507a-a36a-5735-8ecb-6ea7fd49a875' id='29499' code='RGRQVQ'>
                <room>South Hall 2B</room>
                <title>Story Generation using Stable Diffusion in Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Recently, most works focus on synthesizing independent images; While for
real-world applications, it is common and necessary to generate a series of coherent images for story-telling. In this work, we mainly focus on story visualization and continuation tasks and propose AR-LDM, a latent diffusion model auto-regressively conditioned on history captions and generated images. To my best knowledge, this is the first work successfully leveraging diffusion models for coherent visual story synthesizing.</abstract>
                <slug>europython-2023-29499-story-generation-using-stable-diffusion-in-python</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33955'>Nilesh Arnaiya</person>
                </persons>
                <language>en</language>
                <description>In this talk, we will explore the use of stable diffusion and diffusion models in Python for generating original stories. We will first introduce the concept of stable diffusion and how it can be used to model the spread of information or ideas. We will then discuss how this can be applied to the task of story generation, and demonstrate how to use Python libraries such as Markovify and OpenAI ChatGPT API.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/RGRQVQ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/RGRQVQ/feedback/</feedback_url>
            </event>
            <event guid='17cb3b2b-c874-57bd-9d9e-1ace57836a69' id='29670' code='SG3NQB'>
                <room>South Hall 2B</room>
                <title>Word Wranglers &amp; News Navigators: Taming GPT-3 Beast for Media Monitoring</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>The emergence of ChatGPT has led to an exponential growth of prospects and implementations in the field of Natural Language Processing (NLP). Various teams were struck with FOMO (Fear of Missing Out) and hastened to incorporate Large Language Models (LLMs) into their products. By using OpenAI models (text-curie-001, davinci, gpt-3.5-turbo), we successfully integrated them into our production on March 2, granting our users the ability to receive text summaries in their email reports and comprehend the essence of any article within our application. Three weeks later, we trained our own large language model for the same purpose. This talk will delve into our journey, exploring the lessons and insights gleaned from our hands-on experience with these cutting-edge tools.</abstract>
                <slug>europython-2023-29670-word-wranglers-news-navigators-taming-gpt-3-beast-for-media-monitoring</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='34110'>Petr &#352;ime&#269;ek</person>
                </persons>
                <language>en</language>
                <description>While heaps of research focus on English texts, this talk will zoom in on using LLMs for smaller languages like Czech or Slovak. I&apos;ll share some hair-raising examples from our early days after deployment (trust me, when the LLM starts hallucinating about a local politician&apos;s resignation, your client won&apos;t be thrilled) and how we managed to tackle those challenges. I&apos;ll also chat about the quirks that come with non-English languages (more tokens, bigger models, ...) and dish about our experiments with other LLMs like OPT, BLOOM, and LLaMA. I will show how to fine-tune the general LLM to the Czech instruction set and demonstrate the danger of injecting false information. Finally, I will discuss possibilities of putting LLM to production.

Established in 2015, Monitora Media burst onto the scene and rapidly rose to prominence in the realm of media analysis and monitoring across Central Europe. We&apos;ve been shaking things up with innovations like real-time media monitoring and scrollable print titles, even scoring a spot on Deloitte&apos;s Technology Fast 50 for Central Europe in the past two years. We keep an eye on print and online publications, as well as TV and radio broadcasts, and podcast transcripts &#8211; we&apos;re talking over 350 programs, 9,000 websites, and 2,500 print titles! Python and Django hold a special place in our hearts.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SG3NQB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SG3NQB/feedback/</feedback_url>
            </event>
            <event guid='1854378d-7ef6-5e0f-a7d6-012ef19c253f' id='29546' code='YNHRBS'>
                <room>South Hall 2B</room>
                <title>Generative AI: Beyond technicalities &#8211; an ethical perspective</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Machines have become smarter than ever before. Recently, we have started using computers for solving problems beyond computations, and it might not be wrong to call them electronic creators. The future laptop might have a prompt based word application, replacing the current Word, where one has to type their thoughts and formulate an entire document from  scratch. Similarly, we might see a prompt based Paint application, instead of the typical Paint program, that generates the paintings for us. In my opinion, AI-based applications are not in fiction anymore, and we may soon be using them on our computers. However, there is a possibilty that the Generative AI can be potentially harmful for society. We need to explore the ethical concerns, and how the AI can impact our society. In this talk, we will try to understand how Generative AI is becoming a part of our future and how we can use it in a responsible and ethical manner.</abstract>
                <slug>europython-2023-29546-generative-ai-beyond-technicalities-an-ethical-perspective</slug>
                <track>PyData: Ethics in AI (2023)</track>
                
                <persons>
                    <person id='33994'>Bhawna Singh</person>
                </persons>
                <language>en</language>
                <description>In the current rat race of building AI, the hype is being created to show that AI can take over the world and it can perform better in some aspects than humans. People are scared that they will not have their jobs anymore as they might get automated by GPT. There&apos;s also a belief that AI might develop sentience after ingesting so much data. This talk aims at addressing such issues. As a Researcher, I want to discuss the ground truth and share what&apos;s possible and what&apos;s not. Ultimately, the talk will leave the audience with an understanding of the architectures of AI and why we should adopt an ethical approach in developing and deploying these models.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/YNHRBS/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/YNHRBS/feedback/</feedback_url>
            </event>
            <event guid='a8d5593b-a73e-5d70-b4a9-65950c1eb2e4' id='29033' code='DT9HXE'>
                <room>South Hall 2B</room>
                <title>Solving Data Problems in Management Accounting</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>Controllers deal with numbers all day long. They have to check a lot of data from different sources. Often the reports contain erroneous or missing data. Identifying outliers and suspicious data is time-consuming. 

This presentation will introduce a Small Data Problem-End2End workflow using statistical tools and machine learning to make controllers&apos; jobs easier and help them be more productive.

We will demonstrate how we used amongst others, 
- [scipy](https://scipy.org/)
- [pandera](https://pandera.readthedocs.io/en/stable/)
- [dirty cat](https://dirty-cat.github.io/stable/)
- [nltk](https://www.nltk.org/)
- [fastnumbers](https://pypi.org/project/fastnumbers/)
to create a self-improving system to automate the screening of reports and report outliers in advance so that they can be eliminated more quickly.</abstract>
                <slug>europython-2023-29033-solving-data-problems-in-management-accounting</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33549'>Alexander CS Hendorf</person><person id='36044'>Lucas-Raphael M&#252;ller</person>
                </persons>
                <language>en</language>
                <description>Controllers deal with numbers all day long. They have to check a lot of data from different sources. Often the reports contain erroneous or missing data. Identifying outliers and suspicious data is time-consuming. 

This presentation will introduce a Small Data Problem-End2End workflow using statistical tools and machine learning to make controllers&apos; jobs easier and help them be more productive.

It is a common business problem that the data provided is incorrect due to misunderstandings, manual input, cultural differences, typos, etc. and these errors can often be weeded out in short order. 

This talk will show how heuristic data validation can help to facilitate - in our specific use case controller - automated detection of inaccuracies, outliers or input errors. 

In our use case we have to deal with a lot of reports. Some of the reports contain hundreds of columns and are very individually structured. Defining data types and expectations for each individual report for each column would be too time-consuming. 
We are dealing with a technically manageable number of data sets, but too many to leave to human visual control alone.

In our talk we will present strategies on how we have solved small data problems using heuristic and statistical methods.

Questions to tackle:
* Are None values ok or not, and if  - why?
* Is a value an outlier or a typo?
* How much deviation is ok, or not?
* How can historical data help and to what extent?
* Which other external information can help to validate data?

We will demonstrate how we used amongst others, 
- [scipy](https://scipy.org/)
- [pandera](https://pandera.readthedocs.io/en/stable/)
- [dirty cat](https://dirty-cat.github.io/stable/)
- [nltk](https://www.nltk.org/)
- [fastnumbers](https://pypi.org/project/fastnumbers/)
to create a self-improving system to automate the screening of reports and report outliers in advance so that they can be eliminated more quickly.

Audience:
This presentation is intended for anyone interested in data quality management without heavy lifting. Especially small data problems.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/DT9HXE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/DT9HXE/feedback/</feedback_url>
            </event>
            <event guid='ced6321e-499d-549e-8b7c-6ba12994410c' id='29903' code='XRGTRX'>
                <room>South Hall 2B</room>
                <title>Give your program Appeal!</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>This talk presents Appeal, a new library for command-line parsing in Python. Appeal avoids the cumbersome APIs and repetition endemic to the currently prevalent libraries in this space by leveraging Python&apos;s own function call interface. This talk will familiarize the audience with Appeal, its motivation, its approach, and its expressive power, and show them how to use Appeal in their own programs.</abstract>
                <slug>europython-2023-29903-give-your-program-appeal</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='34379'>Larry Hastings</person>
                </persons>
                <language>en</language>
                <description>Appeal is a new and different command-line parsing library. It leverages Python&apos;s powerful function call interface to define your command-line, thus avoiding the clumsy, wordy APIs and endless repetition associated with other libraries. With Appeal, you just write Python functions, and it does the rest! This talk will show you how to use Appeal, how it works internally, and will leave you ready to use Appeal with your own programs.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XRGTRX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XRGTRX/feedback/</feedback_url>
            </event>
            <event guid='ca9aa360-65f7-5463-979f-e662d03942b7' id='29427' code='VHWTVF'>
                <room>South Hall 2B</room>
                <title>The Standard Library Tour</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Are you tired of writing complicated code only to discover that Python has tools in its standard library that could have made your life easier? Join us for a tour of the standard library where we&apos;ll dive into less-known modules that do well-known things and well-known modules that do less-known things. This talk is tailored to beginners or anyone who wants to learn more about Python&apos;s standard library.</abstract>
                <slug>europython-2023-29427-the-standard-library-tour</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33911'>Mia Baji&#263;</person>
                </persons>
                <language>en</language>
                <description>The Standard Library Tour is designed to provide attendees with an understanding of Python&apos;s standard library less known features. Have you ever found yourself writing complex code only to discover that Python has tools available within its library that could have made your job easier? Then this talk is for you!

The outline of the talk:
* Basic information about the library 
* Well-known modules which do less-known things
  * `functools` less-known features: `@singledispatch`, `partial()`, `@cache`
  * `itertools` less-known features: `product()`, `filterfalse()`, `zip_longest()`
  * `collections` less-known features: `ChainMap`,  `defaultdict`
* Less-known modules which do well-known things
  * `doctest` for testing: `testmod()` 
  * `Difflib` &amp; `Filecmp` for comparison: `Difflib.SequenceMatcher`, `Filecmp.cmpfiles()`
  * `contextlib` for tasks involving the `with` statement: `@contextmanager`, `@asynccontextmanager`

By attending this session, you&apos;ll gain a deeper understanding of Python&apos;s standard library and you&apos;ll discover the &quot;unknown unknowns&quot; - tools that you may not even know exist within Python&apos;s standard library. By becoming familiar with the library and all of its capabilities, you&apos;ll be better equipped to solve problems and build applications more efficiently, without reinventing the wheel. You&apos;ll also receive recommendations on where to find additional resources and information so you can continue learning and exploring Python&apos;s tools after the conference has ended.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/VHWTVF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/VHWTVF/feedback/</feedback_url>
            </event>
            <event guid='80e2da60-9d77-551e-8df9-f9fc89866b95' id='29678' code='ZFB73A'>
                <room>South Hall 2B</room>
                <title>The coding conventions that makes our lives easier</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Discover how coding conventions can enhance code quality, readability, maintainability, and reduce errors. Join us as we discuss the creation and implementation of coding conventions, and how to use linters for maintenance.</abstract>
                <slug>europython-2023-29678-the-coding-conventions-that-makes-our-lives-easier</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='34097'>&#199;a&#287;&#305;l Ulu&#351;ahin S&#246;nmez</person>
                </persons>
                <language>en</language>
                <description>Engineers review code as often as they write it and use a lot of tools to improve this process, such as linters and auto-formatters. One tool that is also very useful is coding conventions. It is a collection of references that can be used during code reviews while also serving as a valuable day-to-day reference and guide for the entire team.

This talk will explore several different conventions from the open-source conventions repository, offering an in-depth exploration of how they improve the quality of the codebase and serve as a tool for knowledge transfer among engineering teams.

The structure of the talk will follow:

* What are coding conventions, and why do we use them?

* How to establish your own coding conventions?

* Examples of some of the most useful coding conventions and how they enhance code quality.

* How to uphold your coding conventions with the help of linters?

Attendees will leave with a comprehensive understanding of the concept of coding conventions and how to implement them within their own team.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZFB73A/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZFB73A/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='North Hall' guid='a05be9db-82c0-57ef-b134-93cda35ef695'>
            <event guid='d81babf9-664e-5dc5-a6ed-6f7d4cd71602' id='29537' code='WUPCGU'>
                <room>North Hall</room>
                <title>Unlocking the Power of Raft Consensus with rqlite using Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>Distributed databases are widely used in modern applications for their high availability and scalability. Have you ever wondered how data integrity is maintained with the data across multiple nodes? One of the key components of achieving this is distributed consensus. Raft is a widely used consensus algorithm that provides a fault-tolerant and highly available system. In this talk, we will explore how to implement Raft consensus using the rqlite distributed database in python.</abstract>
                <slug>europython-2023-29537-unlocking-the-power-of-raft-consensus-with-rqlite-using-python</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='33988'>Tanya Sneh</person>
                </persons>
                <language>en</language>
                <description>Consensus is a fundamental problem in distributed systems, and it is critical for maintaining data consistency and availability in applications. In this talk, we will explore how to implement Raft consensus using rqlite, a distributed database that uses SQLite as its storage engine.

We will begin with an overview of distributed databases and the need for consensus algorithms, followed by a deep dive into the key concepts of the Raft consensus algorithm. We will discuss how Raft ensures consistency and availability in a distributed system and explore its strengths and weaknesses compared to other consensus algorithms.

We will then focus on rqlite, a powerful tool for building distributed databases with Raft consensus. We will cover its key features, including its SQL interface, fault tolerance, and scalability. We will also demonstrate how to use rqlite in Python applications to build fault-tolerant and highly available distributed systems.

Attendees will gain a deeper understanding of the key concepts of distributed consensus, the benefits of using the Raft algorithm, and how to implement it using rqlite in python. No prior knowledge of consensus algorithms, Raft, and rqlite is required, but some familiarity with databases would be helpful. This talk is suitable for developers, database enthusiasts, and anyone interested in distributed systems and database design.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/WUPCGU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/WUPCGU/feedback/</feedback_url>
            </event>
            <event guid='81e2319f-0e4b-5280-8ec3-0288b8c03f65' id='35631' code='TYTBKX'>
                <room>North Hall</room>
                <title>What polars does for you.</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Ritchie Vink is the Author of the new Polars DataFrame library. The library that is built for modern hardware. 

Polars is a query engine written in Rust that focusses on the DataFrame front-end. It is written from scratch in Rust designed to be fast, parallel and memory efficient. This talk we&apos;ll go through in the design of Polars and some of its design decisions.</abstract>
                <slug>europython-2023-35631-what-polars-does-for-you</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='39464'>Ritchie Vink</person>
                </persons>
                <language>en</language>
                <description>Ritchie Vink is the Author of the new Polars DataFrame library. The library that is built for modern hardware. 

Polars is a query engine written in Rust that focusses on the DataFrame front-end. It is written from scratch in Rust designed to be fast, parallel and memory efficient. This talk we&apos;ll dive deeper the design of Polars.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TYTBKX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TYTBKX/feedback/</feedback_url>
            </event>
            <event guid='918f398f-4a0e-5140-bbbd-00aea247a227' id='29258' code='W8J9MF'>
                <room>North Hall</room>
                <title>Learning the ropes: understanding Python generics</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>What if you don&apos;t want a Cat to be an Animal? What is the Liskov Substitution Principle? And what on earth is contravariance?

Discover the answers to these questions and more, as we explore the foundations of generic types in Python. And by the end, you might even understand the weirder errors that Mypy sometimes throws your way.</abstract>
                <slug>europython-2023-29258-learning-the-ropes-understanding-python-generics</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33765'>David Seddon</person>
                </persons>
                <language>en</language>
                <description>Do you run a static type checker, such as Mypy, on your Python code? And have you ever been confused by the error messages?

In Learning the Ropes, we&apos;ll explore how the Python&apos;s support for generics can unlock new patterns in your code. Along the way, we&apos;ll learn about some foundations of type theory which will give you a firmer understanding of what type safety really means. Suddenly those Mypy errors will make sense. Be prepared to think hard and learn fancy new terms with which you can dazzle your friends and relations!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/W8J9MF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/W8J9MF/feedback/</feedback_url>
            </event>
            <event guid='1ad0ad94-a1f1-5137-ade1-4e62490a19f0' id='29387' code='8S3VD9'>
                <room>North Hall</room>
                <title>Designing a Human-Friendly CLI for API-Driven Infrastructure</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>As Bloomberg&#8217;s infrastructure grows and evolves, the tools we use to manage it are becoming increasingly important. To streamline infrastructure management, our team set out to design a REST API and constituent CLI (Command Line Interface) that would comprise a single interface for both programmatic and human interaction with our infrastructure. Traditionally, building a CLI that is tightly coupled to an API requires maintaining a separate codebase, which is tedious and error-prone. Instead, we designed a CLI that dynamically generates commands based on the OpenAPI JSON documentation. However, since APIs are designed for computer interaction, we designed our API to include the information needed to implement a human-friendly CLI. Leveraging Python, FastAPI, and numerous other open source projects, we built a stable, extensible tool that greatly improves how we interact with our infrastructure.</abstract>
                <slug>europython-2023-29387-designing-a-human-friendly-cli-for-api-driven-infrastructure</slug>
                <track>Infrastructure: Cloud &amp; Hardware (2023)</track>
                
                <persons>
                    <person id='33874'>Oliver Rew</person>
                </persons>
                <language>en</language>
                <description>In this talk, we will share our experience designing a resilient infrastructure API with a human-friendly CLI that does not need continued development, even as the API evolves.

We will discuss some of the specific approaches we used to build a dynamically-updated CLI with human-friendly features:
- Extending OpenAPI to communicate CLI intent
- Using templating languages (Jinja) to convert the API&#8217;s response JSON into human readable output
- Defining CLI command aliases to abstract long, verbose API endpoints
- Embedding CLI help text in the API to generate well-documented commands
- Other small enhancements and strategies that improve the CLI user&#8217;s quality-of-life.

Furthermore, we will also discuss how we leveraged several open source projects and standards to accomplish our goals, including Python, FastAPI, OpenAPI, Jinja, OAuth2, Pydantic, prompt_toolkit, and more.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/8S3VD9/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/8S3VD9/feedback/</feedback_url>
            </event>
            <event guid='76022327-b28b-536d-b8e4-9389d1858132' id='29478' code='9CUAPR'>
                <room>North Hall</room>
                <title>Zero-Copy Zen: Boost Performance with Memory View</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>Are you tired of struggling with memory management in Python? Do you want to take your skills to the next level and achieve maximum performance while minimising memory usage? Look no further, here is Zero-Copy in Python!
Zero-copy is a technique in computer programming that allows data to be transferred between different parts of a program without being copied to intermediate buffers. In Python, this technique can be achieved using the memory view object, which provides a view into the memory of other objects. Learn how to efficiently manipulate large datasets and optimise your code with the help of this powerful tool. Whether you&apos;re working with sockets, objects or memory profiling, memory view is your key to faster and more efficient Python programming.</abstract>
                <slug>europython-2023-29478-zero-copy-zen-boost-performance-with-memory-view</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='33940'>Kesia Mary Joies</person><person id='33992'>Aby M Joseph</person>
                </persons>
                <language>en</language>
                <description>In today&apos;s data-driven world, efficient memory management is critical for achieving optimal performance in Python. Memory view and byte array provide a powerful combination of tools for managing bytes and memory in Python, enabling zero-copy interactions that can significantly improve performance and reduce memory usage. 

Memory view is a built-in Python class that provides a zero-copy interface to the memory of an object, allowing efficient manipulation of large data sets. Memory view objects can be used to share memory between different parts of a program without creating intermediate copies of the data, which can significantly improve the performance of Python code. This feature is particularly useful when working with large arrays, binary data, or network programming using sockets. Memory view can also be used in conjunction with the buffer protocol to work with objects in a zero-copy manner. 

Overall, memory view is a powerful tool for Python developers looking to optimise their code and improve performance. This talk will explore the technical aspects of memory view and byte array, providing real-world examples of how these tools can be used to achieve zero-copy interactions with bytes. Attendees will learn how to optimise their code by leveraging these tools, with a focus on achieving maximum performance while minimising memory usage.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/9CUAPR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/9CUAPR/feedback/</feedback_url>
            </event>
            <event guid='2be49834-84a6-54ff-8379-f601d7b1476c' id='33362' code='3GWJCA'>
                <room>North Hall</room>
                <title>Cultivating a Performance Mindset</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-20T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>As developers, we learn early on that it&#8217;s important to focus on getting our code to work without unnecessarily pre-optimizing, but how do we learn to eventually optimize our code? What do we look for? How do you know when something is slow? How do you **do** something about it?

In this talk, we&#8217;ll discuss why your application performance matters, how you can learn to identify what matters most to you, and how Sentry has you in mind so you can effectively spend time improving the performance of critical user flows in your application.</abstract>
                <slug>europython-2023-33362-cultivating-a-performance-mindset</slug>
                <track></track>
                
                <persons>
                    <person id='38033'>Nar Saynorath</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/3GWJCA/resources/Cultivating_a_Performance_Mindset_h41ZvIA.pptx">Powerpoint Slides</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3GWJCA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3GWJCA/feedback/</feedback_url>
            </event>
            <event guid='875d8275-f557-5ddd-b771-d019fc77cb7b' id='29534' code='U3SEG8'>
                <room>North Hall</room>
                <title>Dive into codebase like a pro</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>How to get familiar with codebase you need to maintain with minimum suffering? How to leave codebase easier to deal with for your colleagues so they don&#8217;t have to suffer like you did?

If you are experienced developer or a junior just starting your journey, inheriting codebase can be a very challenging task. Especially if the codebase is not quite up to your standards, or it&#8217;s just huge and complex beast.

I will convey my experience and tips and tricks on inheriting code I acquired during 12 years of software development on new and old projects.

The talk will provide guidelines to ease taking over code from somebody else, as well as remind developers of the importance that planning, preparation and documentation have in facilitating code change and project growth.</abstract>
                <slug>europython-2023-29534-dive-into-codebase-like-a-pro</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33984'>Luka Raljevi&#263;</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/U3SEG8/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/U3SEG8/feedback/</feedback_url>
            </event>
            <event guid='dc12d727-8e50-51ca-8d54-015aca0ea7bf' id='30057' code='XYHXYP'>
                <room>North Hall</room>
                <title>From idea to production</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>In this talk we will take you through a complete journey a website takes - from conception to running in production, the right way.

What is the best setup for local development, how to then move to testing and production? An opinionated talk from two veterans.</abstract>
                <slug>europython-2023-30057-from-idea-to-production</slug>
                <track>DevOps (2023)</track>
                
                <persons>
                    <person id='34504'>Flavio Percoco</person><person id='34501'>Honza Kr&#225;l</person>
                </persons>
                <language>en</language>
                <description>We start with choosing the proper architecture, show you what is a good setup for local development, and finally we will deploy our code to production.

The aim is to demystify the devops buzzword as well as show some practical examples that can be used by beginners as well as experienced developers.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XYHXYP/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XYHXYP/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Terrace 2A' guid='ab4602e3-05dd-5b83-a1c0-aebd23a49cdc'>
            <event guid='0ffd5001-ffd5-51c6-917e-41fdb3de2bc3' id='29360' code='7KAKAG'>
                <room>Terrace 2A</room>
                <title>Python on Arm architecture</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:45</duration>
                <abstract>Arm is everywhere technology matters: 250+ billion chips in everything from sensors to smartphones to servers. Due to its simplicity, versatility, and growth in popularity over the past decade Python is the most used language in the world.

In this presentation I will show you what the status of Python is on Arm architecture on all major operating systems and how you could help to improve it further.</abstract>
                <slug>europython-2023-29360-python-on-arm-architecture</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33850'>Diego Russo</person>
                </persons>
                <language>en</language>
                <description>I&apos;ve recently joined the RCVM (runtimes, compilers and virtual machines) team in the Open Source Software group at Arm for a secondment of 6 months, looking at the status of Python and its ecosystem on Arm architecture. I engage with Arm&apos;s internal teams, external partners and the upstream community looking at potential gaps and how these can be fixed. During the presentation I will introduce the Arm architecture and explain the status of Python and its ecosystem on it. I will share my findings about potential gaps to be fixed and how we (as company, partners and community) can fix them to have a flawless Python experience on Arm.

The high-level agenda for this talk is:

* Introduction to Arm architecture and why this matters to you (5 min)
* What it has been done to enable Python on Arm architecture (10 min)
    * This will likely involve activities from Arm, its partners and the upstream community
    * I&apos;ll try to cover all major operating systems
* What gaps do we have today?  (10 min)
    * This will be likely the result of my secondment
* What&apos;s next?  (5 min)
    * How you can help to get Python and its ecosystem even better on Arm architecture
* Final remarks (5 min)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/7KAKAG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/7KAKAG/feedback/</feedback_url>
            </event>
            <event guid='9be083d3-1496-57db-872e-4d201896ab9f' id='29849' code='S3LKMH'>
                <room>Terrace 2A</room>
                <title>Instrumenting CPython with eBPF</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>eBPF is a amazing technology that can run sandboxed programs in a privileged context such as the operating system kernel. But are eBPF programs limited to the operating system kernel? eBPF programs have fast access to resources like memory. These programs can access the memory of running Python applications very faster, allowing you to instrument Python processes with low overhead!

In my presentation, I will show how Python&apos;s internal structure supports instrumentation through the use of eBPF. Following that, we&apos;ll experiment with eBPF and other modern techniques to instrumenting the Python applications. I&apos;ll explain explain why eBPF is more appropriate and efficient technology for instrumentation. By the end of the session, we will have developed an eBPF-based simple tracing tool for instrumenting Python applications.

After this presentation, you will better understand how eBPF can help you in the instrumentation of Python applications.</abstract>
                <slug>europython-2023-29849-instrumenting-cpython-with-ebpf</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='34317'>Furkan Taha &#214;NDER</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/S3LKMH/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/S3LKMH/feedback/</feedback_url>
            </event>
            <event guid='9c1d940c-8a17-5568-8125-b16696c6abe0' id='33365' code='TN3EXR'>
                <room>Terrace 2A</room>
                <title>Python, Visual Studio Code, Copilot - Revolutionizing the way you do data science</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-20T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>Come join this session to check out how Visual Studio Code along with GitHub, Codespaces, and Copilot can significantly improve the data science workflow and take your productivity to the next level. In this talk we will walk through several common Python data science scenarios, showcasing all the productive tooling VS Code has to offer along the way. As a sneak peek, we will be demoing a best-in-class Jupyter Notebooks experience with VS Code Notebooks, a revolutionary new data cleaning / preparation experience with Data Wrangler in VS Code, Copilot that helps you write code and fix issues faster, and more!</abstract>
                <slug>europython-2023-33365-python-visual-studio-code-copilot-revolutionizing-the-way-you-do-data-science</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='37841'>Steve Dower</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TN3EXR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TN3EXR/feedback/</feedback_url>
            </event>
            <event guid='94fb14d4-e665-58ad-90c1-0c364b77320b' id='29069' code='FRZHZG'>
                <room>Terrace 2A</room>
                <title>Quantify Self</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Want to learn something new about yourself? This talk will showcase some approaches to get the best from behavioral tracking as well as silent wearables tracking. Where and how to get data with my experience regarding the quality (expectation management), what to do with the raw data (IDA + some knowledge needed), how to convert insights into actions.</abstract>
                <slug>europython-2023-29069-quantify-self</slug>
                <track>Career, Life, Health (2023)</track>
                
                <persons>
                    <person id='33568'>Alisa Dammer</person>
                </persons>
                <language>en</language>
                <description>This talk present my summed up experience in self-tracking of many years. I will show what can be detected using modern wearable devices (rings, watches, EEG helms, etc.), what should you be searching in your data (if searching for specific answer at all), what interesting findings can present themselves and what you can do about them to make your life better.
My personal questions as a use-case would be:
- Focus and Productivity
- Nutrition (general health concerns like energy levels, resilience)
- Happiness (mood, stress)
- Overall health (energy levels, sleep, stress)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/FRZHZG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/FRZHZG/feedback/</feedback_url>
            </event>
            <event guid='7696b480-5f2c-5853-bdd0-d509a80c8b8b' id='35141' code='SWSLHC'>
                <room>Terrace 2A</room>
                <title>You DON&apos;T know comprehensions &#129335;</title>
                <subtitle></subtitle>
                <type>Poster</type>
                <date>2023-07-20T13:00:00+02:00</date>
                <start>13:00</start>
                <duration>01:00</duration>
                <abstract>You _**don&apos;t**_ know comprehensions!

Why are list comprehensions good?
Because they are fast?

Wrong!

Because they are short?

Wrong!

This poster session will show why list comprehensions are an excellent Python tool.

The poster session will:
 - teach you to convert loops to list comprehensions;
 - show how to write list comprehensions from scratch; and
 - give 10+ actionable tips and tricks for list comprehensions.

The poster will also show the similarities between list comprehensions and:
 - set comprehensions;
 - dict comprehensions; and
 - generator expressions.</abstract>
                <slug>europython-2023-35141-you-don-t-know-comprehensions</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33700'>Rodrigo Gir&#227;o Serr&#227;o</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SWSLHC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SWSLHC/feedback/</feedback_url>
            </event>
            <event guid='5f3716f7-7725-5316-9099-79a125ceb0dd' id='33367' code='JHSMMJ'>
                <room>Terrace 2A</room>
                <title>The challenges of doing Infra-As-Code without &quot;the cloud&quot;</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-20T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>How do you implement Infrastructure-as-Code (IaC) in a non-cloud environment?</abstract>
                <slug>europython-2023-33367-the-challenges-of-doing-infra-as-code-without-the-cloud</slug>
                <track>Infrastructure: Cloud &amp; Hardware (2023)</track>
                
                <persons>
                    <person id='37855'>Nicolas Demarchi</person>
                </persons>
                <language>en</language>
                <description>Optiver, a key player on major financial exchanges around the world, tackles this complex question head-on. As traditional trading floors have evolved into expansive data centres characterised by low-latency networks and high computing power, building and maintaining infrastructure in this environment presents challenges that can&#8217;t be solved with off-the-shelf tools.
In this talk, you&#8217;ll discover more about the unique strategies and bespoke solutions that Optiver deploys to overcome these exciting challenges.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/JHSMMJ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/JHSMMJ/feedback/</feedback_url>
            </event>
            <event guid='84d87acb-34e2-5c3e-ab43-52396de9c166' id='29529' code='KT8QPL'>
                <room>Terrace 2A</room>
                <title>Vector data cubes as a bridge between raster and vector worlds</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>This talk introduces the concept of vector data cubes - multi-dimensional arrays where at least one dimension is composed of vector geometries - and its implementation in Python within a new library Xvec, built on top of Xarray, Shapely 2.0 and GeoPandas.</abstract>
                <slug>europython-2023-29529-vector-data-cubes-as-a-bridge-between-raster-and-vector-worlds</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33982'>Martin Fleischmann</person>
                </persons>
                <language>en</language>
                <description>Vector geospatial data, such as points, lines and polygons, are primarily stored in one-dimensional arrays; in Python, typically as a GeoPandas&apos; GeoSeries column within a data frame. At the same time, raster data representing, among others, satellite imagery or digital terrain models (DTM) are multi-dimensional arrays with a number of dimensions being anywhere from 2 (e.g. DTM) to N (e.g. multi-spectral time series from Sentinel 2), in Python mostly captured as Xarray objects. The two, raster and vector, rarely meet, and if so, we either transform one to the other using rasterisation or vectorisation or link vector geometries to a raster index via a unique identifier. However, there is a space in between that would benefit from multi-dimensional arrays with support for vector geometry.

This talk presents a concept of vector data cubes - multi-dimensional arrays where at least one dimension is composed of vector geometries - and its implementation in Python using Xarray, Shapely 2.0 and GeoPandas under the hood. Using the new Xvec package extending Xarray&apos;s abilities, we can assign an array of vector geometries as dimension coordinates and use the geospatial capabilities within the Xarray object. A typical use case can be a time series of a land cover proportion per region, where one dimension is composed of vector region boundaries, other as land use classes and a third one capturing time. While the same can be stored as a long-form data frame, it is not an efficient format due to a large amount of data replication. Using the vector data cube instead brings both efficiency and convenience as the included vector dimension can be directly used for indexing, plotting, and other operations that depend on the vector data and for which we would need to switch between Xarray and GeoPandas.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/KT8QPL/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/KT8QPL/feedback/</feedback_url>
            </event>
            <event guid='c9d0acf4-5a09-52a8-9181-b42c1bac429b' id='29313' code='3MDSQN'>
                <room>Terrace 2A</room>
                <title>Private Data Anonymization with Python, Fundamentals</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>How to bring large legal document repositories into the public domain without releasing private data? The fundamental concepts behind document anonymization are entity recognition, masking type, and pseudoanonymization. Using python language and a collection of libraries such as spacy, pytorch, and others we can achieve good scores of anonymization. How is this applied within a flow containing AI models for NER? Once anonymized how to improve the result by doing more text mining with python based apps and human in the loop. Although it was approved in 2016, the application of the GDPR at the European level remains a challenge in banking, legal, and other contexts. This talk covers the process of transforming pdf and docx documents into xml, processing them using regexp and spacy/torch models, and how to parse these results using AntConc and Textacy. All the ideas will be supported with the real experience of the MAPA project a European project for anonymization finished in 2022.</abstract>
                <slug>europython-2023-29313-private-data-anonymization-with-python-fundamentals</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33824'>Abel Meneses Abad</person><person id='36681'>Oscar L. Garcell</person>
                </persons>
                <language>en</language>
                <description>Based on the experience of more than 3 years anonymizing documents in different domains, the idea is to present the necessary steps in the anonymization process and how python tools are essential for it.

It will include the presentation of a European project in the field of anonymization completed in 2022 whose data is available to the entire community and which is known as MAP (https://www.elrc-share.eu/repository/search/? q=MAP)

The talk will focus its objectives on the importance of AI models to scale anonymization in environments with high volumes of documents, and how python technologies make possible a better performance of the solution and also of the team that develops it.

The following frameworks will be mentioned in the presentation: Spacy, Pytorch, FastAPI, Textacy, Pytest and other base libraries.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3MDSQN/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3MDSQN/feedback/</feedback_url>
            </event>
            <event guid='13aa54a4-9a7d-5d2f-bbc2-4eaf5abe82dd' id='29495' code='HUC9XE'>
                <room>Terrace 2A</room>
                <title>Unlocking Healthcare data: the power of Open Formats in Python Data Science</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:45</duration>
                <abstract>Are you a data scientist or developer working in healthcare? Are you tired of dealing with proprietary data formats for biological and vital sign information? It&apos;s time to unlock the power of open data and make your research more impactful.

In this talk, we&apos;ll explore how you can leverage Python analytics to manipulate and analyze complex datasets of patient information, including blood work, ECG, EEG, echocardiography, radiography, and more.

We&apos;ll also dive into the world of open data formats, and show you how using these formats can make it easier to anonymize, convert, and collaborate on research.

Don&apos;t miss this opportunity to learn how Python analytics and open data formats can help you unlock the insights hidden in your data and improve patient outcomes.</abstract>
                <slug>europython-2023-29495-unlocking-healthcare-data-the-power-of-open-formats-in-python-data-science</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='33947'>Stefano Cotta Ramusino</person>
                </persons>
                <language>en</language>
                <description>In this talk, we&apos;ll explore the power of open data formats for healthcare and how Python analytics, like NumPy, SciPy, Pandas and Matplotlib, can be used to analyze and unlock the insights hidden in biomedical datasets. We&apos;ll dive into the world of open data formats, including EDF for ECG and EEG, ISHNE for Holter, FASTA, FASTQ and SAM for biological sequence data, DICOM for radiology, and more.

We&apos;ll also discuss the importance of adhering to open data format standards and avoiding proprietary extensions, which can limit collaboration and hinder progress in healthcare research. To help ensure compliance with these standards, we&apos;ll introduce a variety of Python libraries, like Biopython, MNE-Python, pydicom, EDFlib-Python and ISHNEHolterLib, that can be used to test output files and ensure they meet the required standard.

Whether you&apos;re a data scientist, developer, or healthcare professional, this talk is for you. By leveraging the power of open data formats and Python analytics, we can improve patient outcomes and advance the field of healthcare research. Join us as we explore the exciting possibilities of open data formats and Python analytics in healthcare.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/HUC9XE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/HUC9XE/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Terrace 2B' guid='3fcaeaa9-6c50-5e80-9387-b6a42febf14b'>
            <event guid='0c8917ad-420d-5794-a3b7-31ebc5f7b052' id='29211' code='U9SNQ7'>
                <room>Terrace 2B</room>
                <title>How to land your new Python Developer job: a Recruiter&apos;s perspective</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>Looking for a job is already a job. How can you make sure that you are successful in the role of a Python Developer job-seeker? Join this talk to learn directly from an insider the tips &amp; tricks about what technologies are in-demand, how to look for your next role, how to display your experience (or lack of) in your CV, how to prepare for interviews, and much more.</abstract>
                <slug>europython-2023-29211-how-to-land-your-new-python-developer-job-a-recruiter-s-perspective</slug>
                <track>Career, Life, Health (2023)</track>
                
                <persons>
                    <person id='33718'>Giordano Tuvo</person>
                </persons>
                <language>en</language>
                <description>Being a job-seeker is one of the most extenuating jobs ever. Everyone knows this, Recruiters included. This is why, after several years of experience working as a Recruiter and facing challenging times, it would be my pleasure to share my knowledge with the community. Together, we are going to tackle the steps and skills that are needed to secure a role in today&apos;s job market, with a focus on landing a job in the Python field. Come and then share your knowledge with other job seekers, we are in this all together!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/U9SNQ7/resources/GiordanoTuvo_EuroPython23_SpeakerSession_yKNGRmV.pdf">GiordanoTuvo_EuroPython2023</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/U9SNQ7/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/U9SNQ7/feedback/</feedback_url>
            </event>
            <event guid='6427b2d6-775b-53cf-96eb-67ffde1740f6' id='28934' code='BMYYTX'>
                <room>Terrace 2B</room>
                <title>Career Building Through Open Source &amp; Community Participation</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Open source has widely grown to allow different tech career paths to enhance projects with their skills &amp; provide jobs for those interested in working with open source. Open source contribution programs provide &amp; build interested persons&apos; capacity to become professionals.

Active community participation helps enhance career growth. 

Outreachy is a paid and remote internship OS program that empowers, grows talents, and prepares them for career growth. Outreachy provides internships to people subject to systemic bias and impacted by underrepresentation in the technical industry where they are living. 
 
At the end of this session, beginners and persons on the intermediate level will have enough knowledge of how they can build a career in open source; experts will also get more insights on how they can contribute to the advancement of open source contribution by giving back to the community as a mentor helping new contributors understand the open source ecosystem and contribution.</abstract>
                <slug>europython-2023-28934-career-building-through-open-source-community-participation</slug>
                <track>Community &amp; Diversity (2023)</track>
                
                <persons>
                    <person id='33449'>Omotola Eunice Omotayo</person>
                </persons>
                <language>en</language>
                <description>This session aims to empower attendees with different ways to contribute to open source and how the community behind open source can be a tool for their career development and growth. 

Community participation is the secret sauce to career growth. I will highlight how to use the community effectively, the skills members can gain, and how to best position oneself for professional career growth in a community. 

Open source contribution is one of the easiest ways to build and gain relevant skills needed to make a career. I will give insights on the what, why, and steps to achieve this.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BMYYTX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BMYYTX/feedback/</feedback_url>
            </event>
            <event guid='6c449ac9-5fbd-581f-8934-6bdd682317a1' id='29565' code='EAPRY9'>
                <room>Terrace 2B</room>
                <title>Breaking the Stereotype: Evolution &amp; Persistence of Gender Bias in Tech</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>Did you know that originally programming was a female-heavy field? 
How did we get to the stereotype of the antisocial programmer (and therefore male)? 

How the concept that good programmers appeared to have been &#8220;born, not made&#8221; is still affecting our tech industry and society.</abstract>
                <slug>europython-2023-29565-breaking-the-stereotype-evolution-persistence-of-gender-bias-in-tech</slug>
                <track>Community &amp; Diversity (2023)</track>
                
                <persons>
                    <person id='34010'>Ester Beltrami</person>
                </persons>
                <language>en</language>
                <description>I will explore the early days of computing when **women were actually the dominant sex in programming**. Can you believe it??
**How did we get from this to the stereotype of the nerdy programmer obsessed with programming?**
We will find out how this has changed and how gender bias has influenced the development of the tech industry as we know it today.

I will also dig into the consequences of gender bias in the tech industry, including the negative impacts on innovation, profitability, and the overall well-being of the industry. The talk will conclude with practical steps and solutions that companies can take to create a more inclusive and diverse tech industry.

The gender gap it&#8217;s an important issue that affects all of us. By taking action to address these biases, we can create a better future for everyone in the industry.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/EAPRY9/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/EAPRY9/feedback/</feedback_url>
            </event>
            <event guid='49a8ec1f-a70c-51a1-8cf9-40a7ed58086a' id='29350' code='S8H88E'>
                <room>Terrace 2B</room>
                <title>All about djangoproject.com</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>The [djangoproject.com](https://www.djangoproject.com) website is the _showcase_ of the **Django** project and is the result of **contributions** from many _people_. In this talk, we&apos;ll update you on its **development** and _learn_ how to contribute to it.</abstract>
                <slug>europython-2023-29350-all-about-djangoproject-com</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33752'>Paolo Melchiorre</person>
                </persons>
                <language>en</language>
                <description>The [djangoproject.com](https://www.djangoproject.com) website is the _showcase_ of the **Django** project and _developers_ and _users_ have always looked for _updates_ on the project, _documentation_, and information from the **DSF** _(Django Software Foundation)_.

As with its _source code_, the Django project website is also the result of **contributions** from many _people_ who voluntarily help to keep it updated and _improve_ it.

This talk will show all the latest **updates**, ongoing **improvements**, and upcoming **developments** of the Django project website.

Participants will be able to **learn** more about the Django project site, how it is maintained, and above all understand how to **help** improve it.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/S8H88E/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/S8H88E/feedback/</feedback_url>
            </event>
            <event guid='ab16e3a8-b189-543c-9fff-d0cd020ddecf' id='29260' code='QRBSUK'>
                <room>Terrace 2B</room>
                <title>What are you yield from?</title>
                <subtitle></subtitle>
                <type>Poster</type>
                <date>2023-07-20T13:00:00+02:00</date>
                <start>13:00</start>
                <duration>01:00</duration>
                <abstract>Many developers avoid using generators. For example, many well-known python libraries use lists instead of generators. The generators themselves are slower than normal list loops, but their use in code greatly increases the speed of the application. Let&#8217;s discover why.</abstract>
                <slug>europython-2023-29260-what-are-you-yield-from</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33487'>Maxim Danilov</person>
                </persons>
                <language>en</language>
                <description>Many developers, avoid to use the generators in regular python code:

It is hard to debug,
it is not easy to profile,
it is not obviously to refactor.
it requires to use special algorithms.
In this talk i speak about generator pipelines, one-line-generators, builtin-generators, custom generators with yield and yield from.
I will show how to use generators and why we should use them. Also, we learn about situations where we can&#8217;t use generators and how to change our thinking to avoid such situations in the future. I give some hints and examples - how big python frameworks use lists instead of generators and therefore lose performance. At the end we can see how builtin zip function works in other world, where developers always use generators in own code.

Let see what we can yield from this talk&#8230;</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/QRBSUK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/QRBSUK/feedback/</feedback_url>
            </event>
            <event guid='d780a092-fbc2-52bf-8368-c889129d852c' id='29131' code='NYMGMF'>
                <room>Terrace 2B</room>
                <title>A Magic Implementation of NotImplemented</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>[Dirty Equals](https://github.com/samuelcolvin/dirty-equals) is a new python library by Samuel Colvin, the creator of Pydantic. It will transform how you write tests, especially for APIs. 

I made some contributions to it, which forever changed how I thought about `NotImplemented`. I thought it was a placeholder for unfinished work and unexpected use cases. I thought the language quirks it created in equality comparison were annoying. 

But in **DirtyEquals**, it&#8217;s a magic way to transform Python&#8217;s built in equality operator... And that changed how I think about language quirks, full stop.</abstract>
                <slug>europython-2023-29131-a-magic-implementation-of-notimplemented</slug>
                <track>Testing (2023)</track>
                
                <persons>
                    <person id='33647'>Alexander Darby</person>
                </persons>
                <language>en</language>
                <description>*Intro (5m)*

I adore Pydantic. It&apos;s a fantastic library that creates classes which check types at Python runtime. In short, it turns type hints into static types.

I had a crush on the code that did this. I thought it was so cool to trick Python into behaving this way. I wanted to learn how this library worked. But when I went to contribute to it, I saw it wasn&apos;t looking for contributions.

So, I decided to look at his other projects in the hope I could learn something there.

*What is Dirty Equals (10m)*

This is how I discovered **DirtyEquals**. This library lets you write tests in a whole new way. With **DirtyEquals**., you get to (mis)use Python&#8217;s equality operator in way that speeds up testing. 

**DirtyEquals** lets you write assert statements that compare objects to custom types, This makes your tests more declarative and more readable. I&#8217;ll go over several examples in this section.

*How Does It Work (10m)*

You might be thinking, isn&#8217;t it strange that the Python equality operator can work in this way? Shouldn&#8217;t it return False, since the **DirtyEquals**. types are different to the types they&#8217;re compared to?

This is where things get interesting. It turns out that if you write `x == y` in Python, three things happen:

1. First, Python looks at `x.__eq__` to see if x and y are the same.
2. If `y` is a new type, it returns `NotImplemented` because the `y`&apos;s type isn&#8217;t part of Python&#8217;s built ins. So there isn&#8217;t an implementation for how Python checks the type for equality.
3. But - here&#8217;s the kooky bit - Python then checks `y.__eq__` ! So if we can hook into the `y.__eq__` part, we can write our own rules for the equality operator.

There are so many things you can do mucking around with `.__eq__` and `.__ne__`, which is what I&#8217;ll cover in this section.

*Conclusion (5m)*

When it comes to coding, I think we should pursue our crushes. If there&#8217;s code that you find attractive, then see if you can contribute! As a result, I learnt things I would never have learnt any other way.

In fact, the main thing I learnt was a completely different approach to coding. To me, mucking around with the `.__eq__` seemed like a terrible idea that would cause untold errors.

But when I saw someone else do it so well, it seemed like a magic trick. I now no longer think of language quirks as problems. I consider them opportunities to perform magic tricks.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/NYMGMF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/NYMGMF/feedback/</feedback_url>
            </event>
            <event guid='f859a4d1-9b36-5dca-bd15-69f39e952596' id='30141' code='RAVZM9'>
                <room>Terrace 2B</room>
                <title>How well do we understand our Universe? Let&#8217;s Python it out!</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>As our understanding of the Universe is expanding, the desire to model the physics that govern cosmic evolution is more evident than ever, driving the emergence of cosmological simulations that model the Universe from the beginning of time till present day. In combination with Machine Learning, they allow for an unprecedented capability; one can train AI models on simulations, where the evolution history of galaxies is available, that can in turn be applied on real galaxies. In this work, we propose the use of Python as a ML tool, through the popular library Tensorflow, to quantify the impact of different cosmological models on the derivation of the history of galaxies. Python accompanies us at every step of the way, from creating the datasets and training the probabilistic neural networks to the visualization of the results, as we attempt to shed light on the cosmic past of galaxies, surpassing the unshakeable reality that we can only observe them at a specific moment in time.</abstract>
                <slug>europython-2023-30141-how-well-do-we-understand-our-universe-let-s-python-it-out</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='34559'>Eirini Angeloudi</person><person id='39501'>Regina Sarmiento</person>
                </persons>
                <language>en</language>
                <description>This talk is part of our research as a PhD students in the Institute of Astrophysics of the Canary Islands, studying the evolution and formation of galaxies. We would like to present how Python has helped us all the way providing an easy yet powerful ML framework (Tensorflow and tensorflow-probability) and great libraries for scientific processing and visualization (pandas, seaborn etc.). 

The key points of the talk will be:
1) Brief introduction to the formation and evolution of galaxies basics and cosmological simulations
2) Using simulation-based inference by training robust probabilistic convolutional neural network models across two cosmological simulations with a domain adaptation scheme
3) Building more complex neural network architectures with Python (e.g. Variational Autoencoders, Normalizing flows)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/RAVZM9/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/RAVZM9/feedback/</feedback_url>
            </event>
            <event guid='3271d2f9-c9a6-5fa2-98c9-d76e30bbe043' id='29383' code='PKCL9Z'>
                <room>Terrace 2B</room>
                <title>Whisper AI: Live English Subtitles for 96 Languages</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Whisper AI, a model from OpenAI, has been largely overlooked despite its impressive ability to accurately transcribe and translate human speech from audio.

In this talk I will explore the architecture of the model and explain why it works so well. Additionally, I will live demo the model&apos;s capabilities in three languages, showing how you can use it on your own computer to generate English subtitles for a wide range of content.</abstract>
                <slug>europython-2023-29383-whisper-ai-live-english-subtitles-for-96-languages</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33877'>Mathias Arens</person>
                </persons>
                <language>en</language>
                <description>From this talk you will gain a basic understanding of OpenAI&apos;s Whisper AI, how it works, how it was trained, and how to run it and experiment with it yourself.

I will demonstrate how you can use Whisper to generate real-time English subtitles for 97 spoken languages. Not only are the subtitles displayed with minimal delay, but this solution is also suitable for meetings with sensitive content as it can be run locally on your PC without relying on any third-party cloud services.

I&apos;ll also be sharing what I learned about Python&apos;s threading and queueing modules, and how to use parallel processing to achieve real-time performance.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PKCL9Z/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PKCL9Z/feedback/</feedback_url>
            </event>
            <event guid='7f2d673d-0f81-50b4-9c5b-62ee0bc09ea3' id='29081' code='PQHEAS'>
                <room>Terrace 2B</room>
                <title>Responding to Earthquakes using Machine Learning and Racing through Time</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-20T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Right after the devastating earthquakes in Turkey, there has been a massive flow of tweets and posts from survivors and their relatives, calling for help. There was a need to extract the data, make it meaningful and open to public, so we have come up with afetharita.com. The machine learning part of the application is completely based on open-source tools in Python and I will go through the pipeline and the process.</abstract>
                <slug>europython-2023-29081-responding-to-earthquakes-using-machine-learning-and-racing-through-time</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33580'>Merve Noyan</person>
                </persons>
                <language>en</language>
                <description>On February 6, 2023, earthquakes measuring 7.7 and 7.6 hit South Eastern Turkey, affecting 10 cities and resulting in more than 42,000 deaths and 120,000 injured as of February 21.

A few hours after the earthquake, a group of programmers started a Discord server to roll out an application called afetharita, literally meaning, disaster map. This application would serve search &amp; rescue teams and volunteers to find survivors and bring them help. The need for such an app arose when survivors posted screenshots of texts with their addresses and what they needed (including rescue) on social media. Some survivors also tweeted what they needed so their relatives knew they were alive and that they need rescue. Needing to extract information from these tweets, we developed various applications to turn them into structured data and raced against time in developing and deploying these apps.
The machine learning part of the application is completely based on open-source tools in Python and I will go through the pipeline and the process.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/PQHEAS/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/PQHEAS/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Open Space' guid='0fb91aae-4fa6-5849-a13f-b4cf9f4309c3'>
            <event guid='2b49c4c5-9bcd-548d-af3d-c4995ccde1bf' id='33483' code='UD3GZD'>
                <room>Open Space</room>
                <title>Reserved for EPS/PSF/PYO Session</title>
                <subtitle></subtitle>
                <type>Open Space</type>
                <date>2023-07-20T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>02:30</duration>
                <abstract></abstract>
                <slug>europython-2023-33483-reserved-for-eps-psf-pyo-session</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/UD3GZD/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/UD3GZD/feedback/</feedback_url>
            </event>
            <event guid='cd15f363-ee27-5b64-a268-1342b46e9290' id='33482' code='F9UBUW'>
                <room>Open Space</room>
                <title>Cyber Resilience Act Panel</title>
                <subtitle></subtitle>
                <type>Panel</type>
                <date>2023-07-20T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:00</duration>
                <abstract>The [EU Cyber Resilience Act (CRA)](https://digital-strategy.ec.europa.eu/en/library/cyber-resilience-act) may have a huge impact on the open-source community. There are concerns about how this framework would be applied to the open-source software contribution and distribution. If you would like to know more and voice out your concerns, join our sessions with leaders in the Python community and experts in the field.</abstract>
                <slug>europython-2023-33482-1-cyber-resilience-act-panel</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                <description>## Agenda

- 2:00 pm - 2:40 pm - CRA panel
- 2:40 pm - 3:00 pm - CRA panel Q&amp;A
- 3:00 pm - 3:30 pm - Coffee break
- 3:30 pm - 4:30 pm - CRA Unconference Discussion (at Open Space)

---

## CRA Panel

We have invited leaders in the Python community and domain experts to discuss the current state of CRA, related regulations and the potential effect to open-source, especially in the Python community. Confirmed Panelists are:

- Deb Nicholson - Executive Director at the Python Software Foundation
- Jannis Leidel - Founder of the Python Packaging Authority and the PSF Board of Directors
- Ciar&#225;n O&apos;Riordan - Senior Policy Advisor of OpenForum Europe

## CRA panel Q&amp;A

After the panel, it is your turn to ask questions and voice out your concern regarding the CRA. Are you a contributor to open-source software and wonder who will be held accountable for the software that you contributed? Are you working for a company that publishes open-source software and wonder if that will affect the business model of your company? Are you using open-source software and wonder if the open-source ecosystem would be the same after the CRA has been put into action? Join us to discuss all these.

## CRA Unconference Discussion

If you would like to discuss further about CRA and the related PLD (Product Liability Directive), and their potential effect in the open source community. We reserved a 1-hour session in the open space for unconference discussion.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/F9UBUW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/F9UBUW/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='5' date='2023-07-21' start='2023-07-21T04:00:00+02:00' end='2023-07-22T03:59:00+02:00'>
        <room name='PyCharm (Forum Hall)' guid='bde7cec6-20ad-5a61-8c4f-43220b09f87c'>
            <event guid='e3fbded7-b021-5c5e-9000-d1b7f3e43435' id='35611' code='XACJPR'>
                <room>PyCharm (Forum Hall)</room>
                <title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-21T08:00:00+02:00</date>
                <start>08:00</start>
                <duration>01:00</duration>
                <abstract>Welcome to EuroPython 2023! You can pick up your badges at any time during the week as long as we are open! If you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!

Queues will be sorted by your **first name** on your ticket. Your ticket can be located via your order confirmation email (from support@pretix.eu with the Subject: Your order: XXXX). If you ordered your ticket after we&apos;ve sent badges for printing (after 10 July), go directly to the Info Desk (also referred as Debugging Desk) and a volunteer will help!</abstract>
                <slug>europython-2023-35611-registration-welcome-forum-hall-foyer-1st-floor</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/XACJPR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/XACJPR/feedback/</feedback_url>
            </event>
            <event guid='af07d7ee-0b7a-5880-a768-7e3eccf08e95' id='34201' code='LWWPUS'>
                <room>PyCharm (Forum Hall)</room>
                <title>Morning Announcement</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-21T09:00:00+02:00</date>
                <start>09:00</start>
                <duration>00:15</duration>
                <abstract></abstract>
                <slug>europython-2023-34201-morning-announcement</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/LWWPUS/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/LWWPUS/feedback/</feedback_url>
            </event>
            <event guid='458bd5b1-5b8f-57e5-ab26-3a4aca01335c' id='33373' code='UNPKDU'>
                <room>PyCharm (Forum Hall)</room>
                <title>DevOps vs AGI</title>
                <subtitle></subtitle>
                <type>Keynote</type>
                <date>2023-07-21T09:15:00+02:00</date>
                <start>09:15</start>
                <duration>00:45</duration>
                <abstract>Are you afraid of AI? Are you afraid of your own government? Are you just a great developer who practices decent devops and wants to know how you might wind up helping the people who answered &quot;yes&quot; to the previous two questions? I&apos;ll review the nature of intelligence, ethics, and EU digital regulation, then we can all talk about how coders can help make the planet work better on solving problems like sustainability and peace.</abstract>
                <slug>europython-2023-33373-devops-vs-agi</slug>
                <track></track>
                
                <persons>
                    <person id='37655'>Joanna Bryson</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/UNPKDU/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/UNPKDU/feedback/</feedback_url>
            </event>
            <event guid='051f9bce-6154-5779-8b41-8c8f92f3888d' id='29317' code='DTXYKX'>
                <room>PyCharm (Forum Hall)</room>
                <title>Subclassing, Composition, Python, and You</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:45</duration>
                <abstract>Ever seen a code base where understanding a simple method meant jumping through tangled class hierarchies? We all have! And while &quot;Favor composition over inheritance!&quot; 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 &#8211; and because there&apos;s more than one type of subclassing!

Let&apos;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&apos;ll be more confident in deciding when subclassing will make your code more Pythonic and when composition will improve its clarity.</abstract>
                <slug>europython-2023-29317-subclassing-composition-python-and-you</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33829'>Hynek Schlawack</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/DTXYKX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/DTXYKX/feedback/</feedback_url>
            </event>
            <event guid='8d0f3d5e-a45f-5ca6-92f1-2e878a020166' id='28788' code='TKPZSM'>
                <room>PyCharm (Forum Hall)</room>
                <title>Face Off: Brute-force attack on Biometrical-databases</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Magic happens every time you take your phone out of your pocket. Somehow, just by looking at the screen, your phone recognizes you (and only you) and magically unlocks.

Have you ever stopped for a minute and thought to yourself - How does that even work? And maybe more importantly, how secure is it?

In this session, we&apos;re going to understand how facial recognition works under the hood. We&apos;ll dive into some potential security problems, and we&apos;ll show you how we were able to break into a biometric database built on the Dlib-python-library by applying a sophisticated brute-force attack. The results will surprise you.</abstract>
                <slug>europython-2023-28788-face-off-brute-force-attack-on-biometrical-databases</slug>
                <track>Security (2023)</track>
                
                <persons>
                    <person id='33323'>Roy M Mezan</person>
                </persons>
                <language>en</language>
                <description>**Outline:**
- Intro - The magic of Face ID [3 min]
- Under the hood - How Deep Learning Face ID works [5 min]
- Comparing faces - Exploring the Face-Space [4 min]
- Recap - Tying it all together [2 min]
- Exploitation - Weird behavior &amp; Possible weakness? [6 min]
- Shocking results! - [2 min]
- The Attack - Our attack on a Biometrical database [6 min]
- Summary [1 min]</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TKPZSM/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TKPZSM/feedback/</feedback_url>
            </event>
            <event guid='3b733697-1cad-5694-9a34-62481dbfb864' id='29539' code='EWBEZZ'>
                <room>PyCharm (Forum Hall)</room>
                <title>The Python&apos;s stability promise</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>Many modules you use and love have a portion of their implementation written in other languages, and for that a Python extension need to be made.
Python offers a C-API that allow people extending the language, and being a nice glue-language, C is also a bridge to many other languages as well.

So if everything is simple, what&apos;s the deal with stability?
Changes in the C-API might break the functionality in older versions, so PEP 387 saves the day with a policy for backward compatibility.
Starting from Python 3.2, the Limited API was introduced, which defined a subset of Python&apos;s C-API that it&apos;s promised that if used, the code can be compiled in one version, and run in many others as well.

Also, having a Stable ABI compatible wheel, allow you to only have one-wheel-per-OS, and not one-wheel-per-python-version, which can simplify your release process.

This talk will introduce the Limited API concept, and provide the necessary information to include it in your project.</abstract>
                <slug>europython-2023-29539-the-python-s-stability-promise</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='33979'>Cristi&#225;n Maureira-Fredes</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/EWBEZZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/EWBEZZ/feedback/</feedback_url>
            </event>
            <event guid='3a948daf-0b79-5e12-912a-bc9656afa02a' id='30109' code='YZSTKK'>
                <room>PyCharm (Forum Hall)</room>
                <title>Introducing Incompatible Changes in Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Python 2 to Python 3 migration used the D-day approach which failed. We learnt from our mistake and we are introducing incompatible changes differently now. Document changes, provide a way to write code compatible with the old and the new way, tooling to ease the migration, design long term approach to reduce the need for incompatible changes.</abstract>
                <slug>europython-2023-30109-introducing-incompatible-changes-in-python</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='34543'>Victor Stinner</person>
                </persons>
                <language>en</language>
                <description>In the Python 2 era, it was decided to migrate at a D-Day: convert all your code base to Python 3. It didn&apos;t go as well as expected. We learnt lessons from this mistake. Incompatible changes are now introduced differently in Python.

Today, changes start with a deprecation warning for at least two Python releases before removing old functions. We think about how to write a single code base working on the old and new Python versions. More and more often, instructions to migrate existing code are provided, or even automated tools. Changes breaking too many projects are reverted when there is not enough time to update enough projects. Code search helps detecting affected projects, notify them, and maybe also propose changes to prepare their code.

In the future, Python is working on a stable ABI to be able to build C extensions once and use them on many Python versions. The HPy project is an interesting candidate for this goal. More and more projects are being tested on the Python version currently under development (Python 3.12).</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/YZSTKK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/YZSTKK/feedback/</feedback_url>
            </event>
            <event guid='496a34ab-40e5-5075-9208-2fcb06a12d27' id='33375' code='STLLDQ'>
                <room>PyCharm (Forum Hall)</room>
                <title>Python Organizers&apos; Panel: Exploring Community-Driven Python Conferences</title>
                <subtitle></subtitle>
                <type>Panel</type>
                <date>2023-07-21T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>01:00</duration>
                <abstract>Did you know that Python conferences are primarily organized by the community? Go backstage and join us at the Python 

Join us for an engaging and insightful discussion as we bring together a group of passionate Python conference organizers from the community. Discover the vibrant ecosystem behind Python conferences and gain valuable insights into their experiences, motivations, and learnings. 

Whether you are an aspiring organizer, a Python enthusiast, or simply curious about the inner workings of community-driven events, this panel promises to provide a wealth of knowledge and inspiration. Don&apos;t miss the opportunity to hear firsthand from the dedicated individuals who make Python conferences an incredible experience for all!</abstract>
                <slug>europython-2023-33375-python-organizers-panel-exploring-community-driven-python-conferences</slug>
                <track></track>
                
                <persons>
                    <person id='33549'>Alexander CS Hendorf</person><person id='39337'>Alessia Marcolini</person><person id='39541'>Jimena Berm&#250;dez</person><person id='39517'>B&#225;ra Drbohlavov&#225;</person><person id='39524'>Honza Javorek</person><person id='39518'>Tim (&#25991;&#26124;) Hsu</person><person id='39596'>David Vaz</person>
                </persons>
                <language>en</language>
                <description>Did you know that Python conferences are primarily organized by the community? Go backstage and join us at the Python Organizers&apos; Panel.

Join us for an engaging and insightful discussion as we bring together a group of passionate Python conference organizers from the community. Discover the vibrant ecosystem behind Python conferences and gain valuable insights into their experiences, motivations, and learnings.

In this panel, we aim to shed light on the efforts and dedication of the individuals who selflessly devote their time and energy to create enriching events for the Python community.

You will get a glance behind the scenes and get a better grasp on why community-run conferences are so authentic, inclusive and diverse..

Our panelists, seasoned organizers of Python conferences, will share their unique perspectives, recounting their journeys and the challenges and fun anecdotes planning and executing successful events.

During the discussion, we will explore a wide range of topics, including:

1. Behind the Scenes: Gain a behind-the-scenes understanding of what it takes to organize a Python conference.

2. Community Engagement: Discover how Python conferences foster a sense of community and bring together Python enthusiasts from diverse backgrounds. Explore the ways in which organizers encourage participation, inclusivity, and collaboration.

3. Motivations and Inspirations: Hear the personal stories of our panelists as they share what drives their passion for organizing Python conferences. Learn about their motivations, inspirations, and the impact they hope to make in the Python community.

4. Challenges, Lessons Learned and Personal Growth: Delve into the challenges faced by organizers and the lessons they have learned along the way. Gain valuable insights into how they tackle obstacles, adapt to changing circumstances, and continually improve the conference experience. Furthermore, hear about takeaways organizers have for their professional and personal life.

Whether you are an aspiring organizer, a Python enthusiast, or simply curious about the inner workings of community-driven events, this panel promises to provide a wealth of knowledge and inspiration. Don&apos;t miss the opportunity to hear firsthand from the dedicated individuals who make Python conferences an incredible experience for all!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/STLLDQ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/STLLDQ/feedback/</feedback_url>
            </event>
            <event guid='05432b01-f3d3-59ba-ab99-3328dd81c64d' id='33366' code='GKHPZB'>
                <room>PyCharm (Forum Hall)</room>
                <title>Power Django with PyCharm</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>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&#8230;joyful?

In this session we&#8217;ll put PyCharm to work, at helping us work. Navigation, refactoring, autocomplete &#8211; the usual suspects. We&#8217;ll also see &#8220;test-first&#8221; development to stay in the IDE, plus how this can apply to frontends.</abstract>
                <slug>europython-2023-33366-power-django-with-pycharm</slug>
                <track></track>
                
                <persons>
                    <person id='37797'>Paul Everitt</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/GKHPZB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/GKHPZB/feedback/</feedback_url>
            </event>
            <event guid='cdd99192-0998-5593-8392-967cadbc119f' id='35744' code='AYGCLM'>
                <room>PyCharm (Forum Hall)</room>
                <title>Cython 3 &#8211; Python at the speed of C</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Cython started as a language designed to write extension modules, and has long become the most widely used static compiler for Python, bringing C and C++ data types into the language. Use it to talk to existing C/C++ code or to bring your Python code up to C speed.</abstract>
                <slug>europython-2023-35744-cython-3-python-at-the-speed-of-c</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='39581'>Stefan Behnel</person>
                </persons>
                <language>en</language>
                <description>Cython has come a long way from its beginnings as Pyrex in 2002 up to the latest stable major release: Cython 3.0.  It started as a language designed to write extension modules, and it became the most widely used static compiler for Python, bringing C and C++ data types into the language.

This talk will present new features built into the language, from static C types in the modern Python typing syntax to automatic ufunc generation, that make writing lightning fast Python code easy and pythonic.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/AYGCLM/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/AYGCLM/feedback/</feedback_url>
            </event>
            <event guid='dac1b296-f3e5-5fb4-a2cd-1a60e1aeb9cd' id='34205' code='P7CVWV'>
                <room>PyCharm (Forum Hall)</room>
                <title>Lightning Talks Friday</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:45:00+02:00</date>
                <start>16:45</start>
                <duration>00:45</duration>
                <abstract>Enjoy Friday&apos;s lightning talks, hosted by Mia Baji&#263; &#11015;&#65039;

- **Fusion Engine, Custom Game Engine Using Python** &#8212; Dima Marhitych 
- **What is the PSF? ... and Can We Be Friends?** &#8212; Deb Nicholson 
- **Testing Files Like a Pro** &#8212; Artur Barseghyan 
- **Kata - Discipline &amp; Motivation** &#8212; Sena Sahin 
- **Foxdot** &#8212; This Green Guy (definitely not Mois&#233;s Guimar&#227;es)
- **WIKI CRAWL - Yet Another Crawler** &#8212; Julian Maurin 
- **Python in Your Language** &#8212; Cristi&#225;n Maureira-Fredes 
- **Artis** &#8212; Gabriel Jover
- **Fedora Loves Python** &#8212; Miro Hron&#269;ok
- __F**k it - How to Fix Production Code in 5 Minutes__ &#8212; Sebastien Crocquevieille 
- **Django Girls** &#8212; &#199;a&#287;&#305;l Ulu&#351;ahin S&#246;nmez 
- **AI Game Tournament Awards** &#8212; Neil Vaytet</abstract>
                <slug>europython-2023-34205-lightning-talks-friday</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/P7CVWV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/P7CVWV/feedback/</feedback_url>
            </event>
            <event guid='e81eee4b-a855-56da-b77c-2204bc2840bf' id='34206' code='SURAC3'>
                <room>PyCharm (Forum Hall)</room>
                <title>Sprint Orientation</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T17:30:00+02:00</date>
                <start>17:30</start>
                <duration>00:20</duration>
                <abstract></abstract>
                <slug>europython-2023-34206-sprint-orientation</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/SURAC3/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/SURAC3/feedback/</feedback_url>
            </event>
            <event guid='25de0591-d6d1-510a-926d-f499d1665ff4' id='34207' code='ZUPSUD'>
                <room>PyCharm (Forum Hall)</room>
                <title>Closing Session</title>
                <subtitle></subtitle>
                <type>Announcements</type>
                <date>2023-07-21T17:50:00+02:00</date>
                <start>17:50</start>
                <duration>00:30</duration>
                <abstract></abstract>
                <slug>europython-2023-34207-closing-session</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ZUPSUD/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ZUPSUD/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='South Hall 2A' guid='b4aa8885-f330-5bc6-b7b3-d64f56d62691'>
            <event guid='f22ba644-ce97-5917-b1ba-c627d57b3f2e' id='29742' code='UAEJZX'>
                <room>South Hall 2A</room>
                <title>A Brief History of Data Storage</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>For millennia, humans have known things. Pretty quickly, we started writing them down; our brains aren&apos;t very good at storing all the things we know reliably, and we needed something more durable.

A long time ago, this meant clay tablets with cuneiform on them, and things have only got more complicated from there. Nowadays, we try to store data so that computers can understand it too, and that&apos;s given us a bewildering array of options - portable hard drives, magnetic tape storage and so much more.

In this talk, we&apos;ll take a look at the history of data storage, and discuss why some methods have worked better than others. We&apos;ll talk about why writing things down for humans is different than doing it for computers, and why it&apos;s difficult to do both at the same time (this is what code is). Finally, we&apos;ll look at today&apos;s state-of-the-art for keeping data safe, and discuss what the future might hold.

This talk has no prerequisites, although a fondness for weird facts will help!</abstract>
                <slug>europython-2023-29742-a-brief-history-of-data-storage</slug>
                <track>~ None of these topics (2023)</track>
                
                <persons>
                    <person id='34182'>Eli Holderness</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/UAEJZX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/UAEJZX/feedback/</feedback_url>
            </event>
            <event guid='05fc6625-52dc-5f18-b4ce-f186d0141cbf' id='29259' code='GY9LZC'>
                <room>South Hall 2A</room>
                <title>Ultimative session about hidden gems of Django Admin.</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>The Django Admin Panel is a complex and bad-documented tool in the Django that can greatly speed up development if you start to understand it.
&#8220;Isn&#8217;t it easier for us to write our Backend?&#8221; I will answer: &#8220;No, it&#8217;s not easier!&#8221;. 8 years of insights and discoveries in my Talk. Here i want talk about multiple admin sites, ModelAdmins possibilities, object state versioning and app configs as completely forgotten hidden power.</abstract>
                <slug>europython-2023-29259-ultimative-session-about-hidden-gems-of-django-admin</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33487'>Maxim Danilov</person>
                </persons>
                <language>en</language>
                <description>The following questions should be in this Talk:
1. Review of ideas Django.contrib.admin module.
2. Django admin panel as it could be.
3. Django admin sites multiplication.
4. How to remove the legacy of older versions of Django im admin panel
5. Undocumented Django.contrib.admin features.
6. Using Django Admin Panel for third-party Backend implementations.

I have presented many talks about Django Contrib Admin on PyCon RU, PyCon DE, Django Con EU, Django Con US. Here should be ultimative session about important parts and Vulnerabilities of this Library.
This talk for advanced and experienced developers.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/GY9LZC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/GY9LZC/feedback/</feedback_url>
            </event>
            <event guid='28121e70-3ff7-57e4-b0b6-9bbcce94b968' id='29392' code='WB8ZWV'>
                <room>South Hall 2A</room>
                <title>Python interoperability: building a Python-first, petabyte-scale database</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>How can you scale Python to run at petabyte scale, with the reliability needed to trade billions of dollars? With ArcticDB we have been doing exactly that for the last four years, by leveraging interoperability between Python and high-performance C++, with a detailed understanding of the data structures inside Python and a few extra tricks up our sleeves.

Come take a peek under Python&apos;s bonnet and learn how to hotwire a few things along the way.</abstract>
                <slug>europython-2023-29392-python-interoperability-building-a-python-first-petabyte-scale-database</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33887'>William Dealtry</person>
                </persons>
                <language>en</language>
                <description>This talk aims to introduce experienced Pythonistas to the workings of Python&apos;s C API and provide you with the means to get started with building Python modules, particularly in modern C++. It&apos;s now much easier than you think to write your first Python extension, and despite its reputation for gnarly syntax and lack of memory safety, features that have been gradually added to the C++ language over the last decade such as tuple return types with structured bindings and automatic type deduction, mean that your C++ can be more Pythonic than you might think. Since one of the most common reasons for writing an extension module is to leverage optimized machine code and multi-threading to handle really big data, we&apos;ll look at how we avoid shooting ourselves in the performance foot at the boundary between native code and Python.

In this talk we will lay out the potential pitfalls of interacting with the Python C API, share some of the hard-won experience we gained in engineering ArcticDB and running it at petabyte scale for critical Python trading applications. We&apos;ll also let you in on some tricks for implementing zero-copy data interchange, managing memory ownership and lifetimes, getting the most out of multi-threading through sensitive handling of the Global Interpreter Lock, and interacting with Pandas. 

Of course, nothing stays the same forever. The Python data landscape is changing rapidly and with the advent of Pandas 2.0, the old workhorse NumPy is gradually being supplanted by Apache Arrow, a project that has interoperability at the core of its design. Some things will get easier, some problems will remain. We&apos;ll examine the landscape ahead and share vital information to help you future-proof your development both inside and alongside Python.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/WB8ZWV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/WB8ZWV/feedback/</feedback_url>
            </event>
            <event guid='86c6b494-8d24-5a0b-8230-a036ec5795c0' id='29660' code='3XQWYC'>
                <room>South Hall 2A</room>
                <title>Hitchhickers Guide to D&amp;D &#128009;</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>This talk is meant to be an hitchhickers guide to **Dungeons and Dragons** (`D&amp;D`) _for programmers_. 
We will leverage on our wit and intelligence to explore a very perilious dungeon &#129497; , where a venomous dragon is hiding in the shadows &#128009; . 
Thanks to a magical potion in an ancient flask, our wizardly skills have been enhanced with Pythonic capabilities &#128013; making us the most powerful and geeky magician of the realm.
These new acquired power revealed _unprecedented strategies_ (i.e. algorithms &#128579;) that will guide us through the maze avoiding all the traps and pitfalls &#9876;&#65039;, and will help us maximising the power of our _fire magic_ &#9732;&#65039; to finally slay the dragon.

If you would like to know more about this new Pythonic spell, and the secrets it unveiled, or if you&apos;re simply interested in **new graph algorithms** that can run balzingly _fast_ maximising your CPU capabilities, **this is the talk for you!**</abstract>
                <slug>europython-2023-29660-hitchhickers-guide-to-d-d</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='34082'>Valerio Maggio</person>
                </persons>
                <language>en</language>
                <description>I am playing D&amp;D since I was 13, and that is indeed a fantastic game for so many reasons. Even more fantastic if you could combine your geeky programming skills to it, whenever you have to explore hidden dungeons. 
In facts, **graphs** are the most versatile, and fascinating data abstraction that could help us handling these challenges in a very programmatic way.
In Python we would have many solutions to work with Graph problems: from `scipy.sparse` to `networkx`.
However, none of these solutions are generally known to be fast and efficient, and this can represent a huge impediment when the size of the graph in question (in terms of nodes, and edges) increases.
But _What if_ **graph** algorithms could be expressed as **linear algebraic** operations ? And _what if_ this _translation_ would make graph algorithms super efficient so that this would represent a viable and scalable alternative for high-performance graph analytics ? 
And _what if_ we could leverage on these new and blanzingly fast algiorithms, while still using the **same** libraries (and abstractions) we would normally use with `networkx`?

In this talk, we will introduce [`python-graphblas`](https://github.com/python-graphblas/python-graphblas), i.e. the official Python API to [GraphBLAS](https://graphblas.org/): a powerful framework for creating graph algorithms expressed as linear algebra sparse matrix operations.  
We will explore two practical examples (working on our D&amp;D use case) showcasing performance, and how `python-graphblas` with  [`graphblas-algorithms`](https://github.com/python-graphblas/graphblas-algorithms) integrate with `networkX`.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3XQWYC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3XQWYC/feedback/</feedback_url>
            </event>
            <event guid='b24adb58-811a-5dc0-8515-16eb8b9f8441' id='30146' code='NYEBMZ'>
                <room>South Hall 2A</room>
                <title>What a screen reader can teach you about remote Python debugging</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>The NVDA screen reader is a Python application packaged with Py2exe, along with C++ extensions for low-level system access and improved performance. Its functionality can be expanded through addons that are also written in Python, which makes the ability to debug both the core and addon code highly desirable.

However, debugging code within an embedded or packaged Python environment can be quite challenging, especially if you are a visually impaired programmer trying to debug your own screen reader, since hitting a breakpoint will freeze the tool you rely on for computer access!

In this presentation, I will demonstrate how I addressed this challenge by leveraging Microsoft&apos;s debugpy library for remote debugging. I will showcase how this technique can be used to debug Python applications running within an embedded Python environment, regardless of the host language. Additionally, I will explore its applicability in debugging applications running on different operating systems or environments than the one where you prefer to use your debugging IDE.</abstract>
                <slug>europython-2023-30146-what-a-screen-reader-can-teach-you-about-remote-python-debugging</slug>
                <track>~ None of these topics (2023)</track>
                
                <persons>
                    <person id='34570'>Ram&#243;n Corominas</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/NYEBMZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/NYEBMZ/feedback/</feedback_url>
            </event>
            <event guid='dd163a05-b5bd-5f73-9b5b-6e2cdb6961b8' id='30070' code='DA3GWB'>
                <room>South Hall 2A</room>
                <title>GraphQL Subscriptions: Real-time Data with WebSockets* and Strawberry &#127827;</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Bring your GraphQL APIs to life with real-time data using Strawberry! &#127775; In this talk, we&apos;ll dive into GraphQL Subscriptions and explore how to leverage WebSockets for interactive, real-time updates. Say goodbye to constant polling and hello to efficient, seamless communication!

Key insights:

- Understanding GraphQL Subscriptions and their role in real-time data delivery.
- Setting up WebSocket connections and integrating them with your GraphQL server using Strawberry.
- Designing subscription schemas and handling server-side events for seamless updates.
- Enhancing client-side experiences with real-time data and updates.</abstract>
                <slug>europython-2023-30070-graphql-subscriptions-real-time-data-with-websockets-and-strawberry</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34511'>Patrick Arminio</person>
                </persons>
                <language>en</language>
                <description>GraphQL Subscriptions offer a powerful solution to deliver real-time data
efficiently, without the need for constant polling. In this talk, we&apos;ll explore
the power of GraphQL Subscriptions using WebSockets and Strawberry,
empowering you to build dynamic, real-time applications with ease.

During this session, we&apos;ll cover:

1. An introduction to GraphQL Subscriptions: We&apos;ll discuss the concept of
   GraphQL Subscriptions, their role in real-time data delivery, and how they
   differ from traditional polling techniques. You&apos;ll gain a deep understanding
   of their importance in creating modern, responsive applications.

2. Setting up WebSockets with GraphQL and Strawberry: We&apos;ll guide you through
   the process of integrating WebSocket connections with your GraphQL server
   using the Strawberry library. Learn how to establish and manage secure,
   real-time communication channels between your server and clients.

3. Designing and implementing subscription schemas: We&apos;ll walk you through the
   process of designing and implementing subscription schemas using Strawberry,
   allowing you to define the structure and behavior of real-time updates. Learn
   how to handle server-side events and ensure seamless updates for clients.

4. Enhancing client-side experiences: Discover how to leverage real-time data
   and updates in your client-side applications to create engaging and
   interactive experiences for users. We&apos;ll share best practices for handling
   GraphQL Subscriptions on the client-side, enabling you to build dynamic,
   real-time applications that delight your users.

By the end of this talk, you&apos;ll be well-equipped to harness the power of GraphQL
Subscriptions using WebSockets and Strawberry, enabling you to create
responsive, real-time applications!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/DA3GWB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/DA3GWB/feedback/</feedback_url>
            </event>
            <event guid='173eb41b-e6cf-5347-b364-ed6a0fa01948' id='28778' code='URF3Z9'>
                <room>South Hall 2A</room>
                <title>GraphQL as an umbrella for microservices</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Systems built with microservices tend to become complex over time. There are several approaches that encapsulate complex distributed system layouts with an API Gateway, or backends for frontends. Having a GraphQL gateway is one of the available options. This method of delivering client-facing APIs has become the standard with modern single-page applications.</abstract>
                <slug>europython-2023-28778-graphql-as-an-umbrella-for-microservices</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33312'>Artur Sm&#281;t</person>
                </persons>
                <language>en</language>
                <description>During this talk you will:

* Discover the basics of GraphQL as the communication layer and it&apos;s core differences from REST approach
* See the real life example of how my team used [Ariadne](https://ariadnegraphql.org/) - an open-source python GraphQL server, to abstract the complexity of a large-scale, microservice-oriented system
* Learn about some common mistakes, caveats, and outtakes from taking such an approach
* Discover how deploying GraphQL as an API gateway speeds up the development process, makes the engineering team more productive and allows both, front-end and back-end engineers to shape the APIs together</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/URF3Z9/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/URF3Z9/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='South Hall 2B' guid='eca0a8bd-c83c-5ce2-b5c8-78da7df606c8'>
            <event guid='88abcaad-5633-5818-b9a8-08d50e4d3f56' id='29571' code='MD3PX3'>
                <room>South Hall 2B</room>
                <title>Test your data like you test your code</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>I will introduce the concept of data unit tests and why they are important in the workflow of data scientists when building data products. In this talk, you will learn a new tool you can use to ensure the quality of the products you build.</abstract>
                <slug>europython-2023-29571-test-your-data-like-you-test-your-code</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='34014'>Theodore Meynard</person>
                </persons>
                <language>en</language>
                <description>When data scientists build data products, they usually need to combine multiple data sources to train their models and then serve predictions. Making sure that the code and the data will be as expected throughout the full lifetime of the project is complex. To ensure the quality of the code, it is a best practice in software engineering to use automatic testing, this has a large corpus of support material. However, ensuring the quality of the data input and output holistically is not yet as well covered. 

In this talk, I will explain the concept of data unit tests and why they are important. Then I will present an overview of the current libraries helping to build data unit tests. Finally, I will explain how we integrated it into our workflow at GetYourGuide.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MD3PX3/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MD3PX3/feedback/</feedback_url>
            </event>
            <event guid='4afab68e-f908-52da-8715-99a048c7f7a4' id='29381' code='DQ9RA9'>
                <room>South Hall 2B</room>
                <title>Too Big for DAG Factories?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Do you need to transform, optimize and scale your data workflow? In this talk, we&#8217;ll review use cases, and you&#8217;ll learn how to dynamically generate thousands of DAGs (Directed Acyclic Graphs) with Airflow.</abstract>
                <slug>europython-2023-29381-too-big-for-dag-factories</slug>
                <track>PyData: Data Engineering (2023)</track>
                
                <persons>
                    <person id='35141'>Calvin Hendryx-Parker</person>
                </persons>
                <language>en</language>
                <description>You&#8217;re working on a project that needs to aggregate petabytes of data, and it doesn&#8217;t make sense to manually hard-code thousands of tables, DAGs (Directed Acyclic Graphs) and pipelines. How can you transform, optimize and scale your data workflow? Developers around the world (especially those who love Python) are using Apache Airflow &#8212; a platform created by the community to programmatically author, schedule and monitor workflows without limiting the scope of your pipelines. 

In this talk, we&#8217;ll review use cases, and you&#8217;ll learn best practices for how to:

- use Airflow to transfer data, manage your infrastructure and more;
- implement Airflow in practical use cases, including as a:
    - workflow controller for ETL pipelines loading big data;
    - scheduler for a manufacturing process; and/or
    - batch process coordinator for any type of enterprise;
- scale and dynamically generate thousands of DAGs that come from JSON configuration files;
- automate the release of both the DAGs and infrastructure updates via a CI/CD pipeline;
- run all tasks simultaneously using Airflow.

Both beginner and intermediate developers will benefit from this talk, and it is ideal for developers wanting to learn how to use Airflow for managing big data. Beginners will learn about dynamic DAG factories, and intermediate developers will learn how to scale DAG factories to thousands of DAGS &#8212; which is something Airflow can&#8217;t do out of the box.

After this talk and live demo, people will learn best practices (including access to a code repo) that will allow them to scale to thousands of DAGs and spend more time having fun with big data.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/DQ9RA9/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/DQ9RA9/feedback/</feedback_url>
            </event>
            <event guid='549bcb4c-0fb3-58bc-94eb-03f89d29b9c8' id='28976' code='TZLHXN'>
                <room>South Hall 2B</room>
                <title>Orchestrating Python Workflows in Apache Airflow</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>[**Apache Airflow**](https://github.com/apache/airflow) is an Open Source workflow orchestrator. It is a python library that allows you to automate complex code and integrate it with a plethora of Data Sources. It is provided with an integrated UI and API for both your human and programmatic needs.

After 5 years of running Airflow in production, I hope to share some insights on the technology. The strengths and weaknesses, recommended features and more dangerous ones, and similar considerations on the UI.

I&apos;ll also be talking about how **you** can make your own *Operators* in Airflow.

Come take a deeper dive into the same solution used by Airbnb, Slack, Walmart and many more to efficiently run their data pipelines.</abstract>
                <slug>europython-2023-28976-orchestrating-python-workflows-in-apache-airflow</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='33493'>Sebastien Crocquevieille</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TZLHXN/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TZLHXN/feedback/</feedback_url>
            </event>
            <event guid='f2262dd8-0e04-5b12-8a8a-faac48d0177c' id='29205' code='KFMCSK'>
                <room>South Hall 2B</room>
                <title>Scipp: multi-dimensional arrays with labeled dimensions and physical units</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Inspired by Xarray, Scipp ([scipp.github.io](https://scipp.github.io)) enriches raw NumPy-like multi-dimensional data arrays by adding named dimensions and associated coordinates.
For an even more intuitive and less error-prone user experience, Scipp adds physical units to arrays and their coordinates.
Scipp data arrays additionally support a dictionary of masks, as well as histogram bin-edge coordinates.

One of Scipp&apos;s key features is the possibility of using multi-dimensional non-destructive binning to sort record-based &quot;tabular&quot;/&quot;event&quot; data into arrays of bins.
This provides fast and flexible binning, rebinning, and filtering operations, all while preserving the original individual records.

Scipp ships with data display and visualization features for Jupyter notebooks, including a powerful plotting interface.
Named Plopp, this tool uses a graph of connected nodes to provide interactivity between multiple plots and widgets, requiring only a few lines of code from the user.</abstract>
                <slug>europython-2023-29205-scipp-multi-dimensional-arrays-with-labeled-dimensions-and-physical-units</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33709'>Neil Vaytet</person>
                </persons>
                <language>en</language>
                <description>This presentation will be in the form of a live demo of the Scipp package in Jupyter.
Scipp is an open-source project developed by the [European Spallation Source](https://europeanspallationsource.se/) under the BSD-3 licence.
It is a Python library built around a C++ core, which uses TBB for multi-threading, providing good out-of-the-box performance.
It is installable on Linux, Mac and Windows via `pip` and `conda`, and the documentation is hosted at https://scipp.github.io .
The source code can be found at https://github.com/scipp .
Co-authors (but not co-speakers): Simon Heybrock, Jan-Lukas Wynen, Sunyoung Yoo.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/KFMCSK/resources/scipp-europython2023_CjFEojX.ipynb">Jupyter notebook used for the presentation</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/KFMCSK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/KFMCSK/feedback/</feedback_url>
            </event>
            <event guid='b8c4ffca-fee5-534c-a93c-48a5b4fe25a2' id='29995' code='WNSZ9R'>
                <room>South Hall 2B</room>
                <title>The digital State of the European Union</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>What is the European digital identity? How can you access digital public services from another EU country? Why is it so hard to create an European ecosystem of  digital services? Does the EU support open source?

This (opinionated) talk will present the current State of the digital services in the EU. Will summarize the normative and technical challenges, and their impacts on the resulting platforms in terms of UX, cybersecurity and maintainability.</abstract>
                <slug>europython-2023-29995-the-digital-state-of-the-european-union</slug>
                <track>Ethics, Philosophy &amp; Politics (2023)</track>
                
                <persons>
                    <person id='33694'>Roberto Polli</person>
                </persons>
                <language>en</language>
                <description>European Union members started many years ago to plan common infrastructures in order to provide shared digital services to EU citizens. Some of them are consolidated, like the visa and the VAT information system, others are going to be revised - like the eID. Many new services are under development.

The cornerstone of these services is the &quot;Once Only Principle&quot;: citizens provide diverse data only once in contact with public administrations, while public administration bodies take actions to internally share and reuse these data &#8211; even across borders.

After a brief presentation of some existing EU services (e.g. participate to an EC consultation authenticating with your eID, [VAT information system API](https://ec.europa.eu/taxation_customs/vies/#/vat-validation), the [EU data portal](https://data.europa.eu/en) , ..) the talk will cover:

- the four categories of challenges: legal -&gt; organizational -&gt; semantic -&gt; technical, and the importance of addressing them **in order**;
- how shifting-right challenges from the legal and organizationa level down to the technical one affects the UX and the cybersecurity of the resulting platforms;
- challenges in procurement.

Finally, a focus on the technical level:

- the role that the EU can play to support open source and open standards.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/WNSZ9R/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/WNSZ9R/feedback/</feedback_url>
            </event>
            <event guid='231c8e43-2119-5416-aeb5-e43ce1be0352' id='29613' code='BHWTKF'>
                <room>South Hall 2B</room>
                <title>How Python can help monitor governments</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>With the risk of losing access to information, Python has been used to create means for society to continue having the right to know what government officials are doing in Brazil.

This lecture aims to show how the difficulty of accessing Brazilian government information has been combated by creating tools that use Python and how the language has been a useful tool for those who seek to leave society in the light of information.</abstract>
                <slug>europython-2023-29613-how-python-can-help-monitor-governments</slug>
                <track>Ethics, Philosophy &amp; Politics (2023)</track>
                
                <persons>
                    <person id='34042'>Judite Cypreste</person><person id='34143'>Patricia Bongiovanni Catandi</person>
                </persons>
                <language>en</language>
                <description>With the imminent risk of the collapse of democracies and the constant attacks on journalism, access to information becomes increasingly difficult. As a result, civil society and journalists have been looking for ways to ensure that society is not left in the dark and that government monitoring continues.

With the popularization of Python in several professional areas, the language has become increasingly present in the fight for a more open government in Brazil, whether in the construction of monitoring tools or in the analysis of data from a government agency. Initiatives by government entities are also helping to enable transparency. 

In this talk we will see examples of the use of Python to monitor the Brazilian government and how the language was fundamental for Brazilian society not to be left in the dark by misinformation. The idea is to show examples of civic uses that the programming language is gaining in the fight for transparency in Brazil.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BHWTKF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BHWTKF/feedback/</feedback_url>
            </event>
            <event guid='f9651de3-a194-5358-a156-72013b89cb11' id='29555' code='3TUMQT'>
                <room>South Hall 2B</room>
                <title>What my 300+ fantastic young students taught me about Python.</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Computer pRogramming, Technology, Bit-coinism Success, Climate Change and Billionaires are all associated with one another.
This talk will describe how a cohort of  299+ young people (aged 11-14) were introduced to Python Programming, at the same time, for the very first time.
And in this talk, I  would like to share with a great secret in that I have actually learnt more from the young students than they learnt from me. 
This talk is about how these young people have opened my eyes, mind  and heart about alternative ways of looking at and appreciating:- 
The humble IF statement;  the under-rated FOR loop, the dry Return Statement, the functional Maths &amp; Random modules, etc. as if one were an artist.
We will talk about the renewed delight of looking at these things from fresh pairs of eyes and how we can take these new learnings forward.</abstract>
                <slug>europython-2023-29555-what-my-300-fantastic-young-students-taught-me-about-python</slug>
                <track>Education, Teaching &amp; Training (2023)</track>
                
                <persons>
                    <person id='33999'>Lilian</person>
                </persons>
                <language>en</language>
                <description>Computer pRogramming, Technology, Bit-coinism Success, Climate Change and Billionaires are all associated with one another.
This talk will describe how a cohort of  299+ young people (aged 11-14) were introduced to Python Programming, at the same time, for the very first time.
And in this talk, I  would like to share with a great secret in that I have actually learnt more from the young students than they learnt from me. 
This talk is about how these young people have opened my eyes, mind  and heart about alternative ways of looking at and appreciating:- 
The humble IF statement;  the under-rated FOR loop, the dry Return Statement, the functional Maths &amp; Random modules, etc. as if one were an artist.
We will talk about the renewed delight of looking at these things from fresh pairs of eyes and how we can take these new learnings forward.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments>
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/3TUMQT/resources/Copy_of_EuroPython_2023_jQXACcR.pdf">Slides of the Talk</attachment>
                
                    <attachment href="https://programme.europython.eu/media/europython-2023/submissions/3TUMQT/resources/Copy_of_EuroPython_2023_3Gzf3tA.pdf">Slides of the Talk</attachment>
                </attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3TUMQT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3TUMQT/feedback/</feedback_url>
            </event>
            <event guid='319c089b-025c-5a36-990d-7fa9614068cf' id='30063' code='HN3EDM'>
                <room>South Hall 2B</room>
                <title>Teaching Children Python-What Works?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>We will explore the latest research on how children gain programming knowledge, how to keep them interested and excited, and how this might inform the way we support adult newcomers to programming. Practical advice and suggestions for activities will be given to attendees.</abstract>
                <slug>europython-2023-30063-teaching-children-python-what-works</slug>
                <track>Education, Teaching &amp; Training (2023)</track>
                
                <persons>
                    <person id='34507'>Mykalin Jones</person>
                </persons>
                <language>en</language>
                <description>Have you ever tried to teach your kids programming? Do you have friends trying to learn as an adult? Have you ever wondered if you would have been better off learning to code earlier in life? The push for more people to learn to code has caused an explosion in the educational industry. Boot camps and certification programs of dramatically varying quality have emerged in nearly every corner of the world. These programs are often accompanied by lofty claims and promises. Children have been no exception to this, as more and more companies attempt to capitalize on the claim that children should start learning early because it&apos;s &quot;like learning a language&quot;. However, research suggests that this might not be the most solid argument. We will be exploring:
-What benefits are there in teaching them early? 
-How do children acquire programming knowledge? 
-How does our language around the concepts affect their understanding? 
-How do we keep their interest?
-Can the answer to these questions inform how we teach adults coming in from non-STEM fields? 
This talk will focus on these questions by presenting the current data we have, in conjunction with anecdotal evidence from sessions with children and adults who code in python.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/HN3EDM/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/HN3EDM/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='North Hall' guid='a05be9db-82c0-57ef-b134-93cda35ef695'>
            <event guid='35b5f446-2461-55cb-915a-16d9c4c36b5c' id='29790' code='E9QUAW'>
                <room>North Hall</room>
                <title>Caching in microservices</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:45</duration>
                <abstract>There are two hard problems in programming: naming things and cache invalidation. I&apos;ll cover the latter, in a microservice-based system. Given a fairly standard setup with API Gateway and a backend service with its own database, I&apos;ll show how to implement cache that allows us to avoid database queries without modifying API client.

The whole talk is based on live coding.</abstract>
                <slug>europython-2023-29790-caching-in-microservices</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34241'>Micha&#322; Lowas-Rzechonek</person>
                </persons>
                <language>en</language>
                <description>In the talk I will go through the implementation of both sides of an ETag cache.

First part will be a ASGI middleware (using FastAPI as an example) that
captures resources returned by REST endpoints and creates ETags for them.

The middleware will also allow views to affect cache key construction, so that
the mechanism can be made aware of e.g. custom headers.

This middleware will be installed in the &quot;backend&quot; service.

On the &quot;backend&quot; side, I will also show how to invalidate the cache when
data used to create a given resource is modified.

The second part is an extension of aiohttp&apos;s ClientSession that stores ETagged
response bodies. This will be installed inside the API Gateway, allowing
external clients to utilize the cache without even knowing about it.

Finally, I&apos;ll mention how to make it usable in a distributed system, by
implementing a simple content-based pubsub mechanism.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/E9QUAW/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/E9QUAW/feedback/</feedback_url>
            </event>
            <event guid='05c02da1-504b-58f6-a7c0-d10408a0d78a' id='29691' code='MRLACS'>
                <room>North Hall</room>
                <title>Designing an HTTP client</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>HTTPX is a fully featured HTTP client for Python 3, which provides sync and async APIs, and support for both HTTP/1.1 and HTTP/2. It also includes a built-in command-line client.

We&apos;ll be taking a look at the architecture of the client, learning from the design decisions behind it, and gaining a better understanding of HTTP along the way.</abstract>
                <slug>europython-2023-29691-designing-an-http-client</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='35118'>Tom Christie</person>
                </persons>
                <language>en</language>
                <description>Some of the aspects we&apos;ll be taking a look at include:

* Layered designs. How to design for separation of responsibilities. Why it matters, and the benefits it provides.
* What are you saying? From the bytes on the wire, though SSL, content encoding, compression, media and text encodings.
* Connection pooling in HTTP.
* Building packages that support both sync and async concurrency models.
* HTTP/1.1, HTTP/2, and HTTP/3.
* Supporting more complex requirements. Handling WebSockets and other protocol upgrades.
* Keeping it clean. Managing resource lifespans.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MRLACS/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MRLACS/feedback/</feedback_url>
            </event>
            <event guid='39165b8e-5a20-5c13-81b0-fa1ec082b6de' id='29618' code='VCGQWF'>
                <room>North Hall</room>
                <title>Performance tips by the FastAPI Expert</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>Is your FastAPI really fast? Did you benchmark it, or you just have faith?

On this talk, Marcelo will give tips to improve the performance of your FastAPI application, and you&#8217;ll see how impactful those changes can be.</abstract>
                <slug>europython-2023-29618-performance-tips-by-the-fastapi-expert</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34050'>Marcelo Trylesinski</person>
                </persons>
                <language>en</language>
                <description>We&#8217;ll go through FastAPI common mistakes regarding performance, and how to make improvements.

We&#8217;ll make a small study about how those improvements can impact on your applications, and you&#8217;ll find out that even small details can make a tremendous impact.

As part of the study, we&apos;ll talk about points like encoding and decoding your data, the event loop, specific details about validation, and so on.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/VCGQWF/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/VCGQWF/feedback/</feedback_url>
            </event>
            <event guid='258b15a6-ec3f-581e-ae4f-4a0436d96c95' id='30102' code='ATGCBX'>
                <room>North Hall</room>
                <title>Fighting Money Laundering with Python and Open Source Software</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>In this talk proposal, we will discuss how to detect the chain of fraudulent transactions and help the investigation agencies by providing useful insights to fight money laundering with the help of Python programming language and packages.</abstract>
                <slug>europython-2023-30102-fighting-money-laundering-with-python-and-open-source-software</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34539'>Gajendra Deshpande</person>
                </persons>
                <language>en</language>
                <description>In this talk proposal, we will discuss the chain of fraudulent transactions and help the investigation agencies to fight money laundering with the help of Python programming language and packages.
The working of the proposed solution is described below
Step 1: The investigation officer obtains data of suspicious accounts across banks.
Step 2: Using Benford&#8217;s Law the accounts data will be checked for possible fraud and marked for further analytics.
Step 3: The account details will also be matched with Politically Exposed Persons(PEP), Relatives and Close Associates (RCA), and Sanctions Data. If a match is found then it increases the probability of possible money laundering. 
Step 4: Generate graphs showing the links between transactions of different bank accounts for step 2 and step 3.
Step 5: Apply Graph Machine Learning techniques and graph algorithms to identify the fraudulent chains between depositor and receiver accounts. 
Step 6: Find a correlation between transactions and bank accounts to form a fraudulent chain.
Step 7: Generate results in the form of reports and interactive visualizations
Step 8: Verify the result for genuineness and false positive rate.
Step 9: Keep track of all the activities and tasks executed from steps 2 through 8. 
Step 10: Generate a report for step 9 in a human-readable and understandable form.

The application has been developed using Scipy, numpy, pandas, matplotlib, NetworkX, Altair, scikit-learn, and Dash packages.

The participants will learn about a new use case of python in crime investigation.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/ATGCBX/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/ATGCBX/feedback/</feedback_url>
            </event>
            <event guid='a68370b5-38c4-5195-a54f-f91ab6a4bad1' id='29664' code='N7DVSG'>
                <room>North Hall</room>
                <title>Working in Units: How to Decouple the Database and Domain Layers in Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>A crucial element of architecting a software application for scale is the collaboration of domain experts and developers. For that to happen, the application must separate the domain layer&#8212; where elements that represent the real world reside&#8212;from the infrastructure layer&#8212;where these elements are translated into precise software processes.

Within the Fintech team at Kiwi.com, we are rearchitecting a critical service to accept more payment providers. As part of this refactor, we are adopting the Unit of Work pattern to disentangle domain entities from the database processes that represent them. This way, domain experts can share their knowledge with developers more easily, and developers can find opportunities for optimization without the involvement of domain experts in the process.

Attendees will gain a solid understanding of how to implement the UoW pattern in their Python applications, how it fits into the broader context of DDD, and how to prepare their code for future growth.</abstract>
                <slug>europython-2023-29664-working-in-units-how-to-decouple-the-database-and-domain-layers-in-python</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33855'>Alvaro Duran</person>
                </persons>
                <language>en</language>
                <description>As developers modelling a domain into a software product, how can we make the most of the insights that we receive from domain experts? Crucially, a system that reads similar to how domain experts talk and think about their area of expertise enables the team to look at the codebase as a whole, and not as a mix of modules.

But in order to do that, the system must be designed in such a way that what&#8217;s relevant to the domain takes a centre stage, and implementation details stay in the background. In order to do that, we can layer the codebase so that the domain&#8212;where elements that represent the concepts and interactions that domain experts talk about&#8212; is clearly delineated from the infrastructure&#8212;where these elements find a way to be implemented in purely software engineering terms.

At Kiwi.com, we are redesigning one of our most critical services in order to expand the number of payment providers that we are integrating with, enabling us to serve a bigger and more diverse pool of customers. As part of this redesign, we are making use of the Unit of Work pattern, with which the interaction between domain entities gets abstracted from the specifics of the database in which those interactions are recorded. Much has been said about the use of abstracting elementary domain objects into a clean data model, but it is the very interaction between those objects where, in practice, the delineation between the domain and the infrastructure layer collapses.

In this talk, we will cover the limitations of ORMs as a way to abstract the database details from the rest of the application, and will introduce the Unit of Work pattern to address those limitations. By means of real-world examples, the attendees will learn the advantages and trade-offs that the UoW pattern was designed to overcome, and will come away with practical use cases in which this pattern makes applications cleaner and more future-proof.
The outline of the talk is the following:

1. Introduction, or &#8220;ORMs are the Vietnam of Computer Science&#8221; (5min)
a. Impedance mismatch - Code and Database
b. Impedance between Domain and Code
c. Domain Driven Design
2. Understanding the Unit of Work pattern (5min)
a. Definition and purpose
b. Trade-offs
3. Advantages of UoW (5min)
a. Isolation of data access from business logic
b. Polyglot persistence
4. UoW in the wild (10min)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/N7DVSG/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/N7DVSG/feedback/</feedback_url>
            </event>
            <event guid='7bdd00cf-d5c1-579c-b60e-1472cb7afc27' id='29623' code='3TWGAB'>
                <room>North Hall</room>
                <title>PyTorch 2.0 - Why Should You Care</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>Pytorch is one of the most popular machine learning frameworks, and its latest iteration (PyTorch 2.0) landed just a couple of days back. Among other things, PyTorch 2.0 offers faster performance with a fully backward-compatible API that guarantees the development ergonomics that PyTorch is known for. 

In this talk, we will examine how practitioners (researchers and engineers) can benefit from optimizations provided by PyTorch 2.0 and what other improvements are on the horizon.</abstract>
                <slug>europython-2023-29623-pytorch-2-0-why-should-you-care</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34052'>Shagun Sodhani</person>
                </persons>
                <language>en</language>
                <description>In this talk, we will talk about the following:

(i) Performance benefits provided by PyTorch 2.0, even without changing even a single line of code.
(ii) How to leverage the best of PyTorch 2.0, sometimes by changing just a single line of code.
(iii) A quick overview of &quot;behind-the-scenes&quot; technologies underpinning PyTorch 2.0 - TorchDynamo, AOTAutograd, PrimTorch, and TorchInductor.
(iv) API improvements to PyTorch 2.0 that makes the user experience even more ergonomic.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/3TWGAB/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/3TWGAB/feedback/</feedback_url>
            </event>
            <event guid='b2057e14-b55d-51c9-8999-be43d37f38bd' id='30123' code='MMQTLC'>
                <room>North Hall</room>
                <title>We can get more from spatial, GIS and public domain datasets!</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>- Are prices of short-term rental apartments in your region similar? How similar are they, and at which distance do they tend to be correlated?
- Do you have access to a few air pollution measurements but must provide a smooth map over the whole area?
- Is your machine learning model based on remote sensing data from Earth Observation satellites, and do you want to include data sampled on Earth?
- Do you work with county-level socio-economic factors, but you want to get insights at a finer scale?

`if any(answer)`, then come and see what we can do with the `pyinterpolate` package designed exactly for spatial interpolation!</abstract>
                <slug>europython-2023-30123-we-can-get-more-from-spatial-gis-and-public-domain-datasets</slug>
                <track>PyData: Machine Learning, Stats (2023)</track>
                
                <persons>
                    <person id='34551'>SzymonMolinski</person>
                </persons>
                <language>en</language>
                <description>The talk introduces spatial interpolation in Python at the intermediate/advanced level. You should know Python basics and the statistical concepts of variance and correlation to understand the presentation.

Spatial interpolation is the new kid on the block, and in the future, with IoT devices everywhere, it will gain much more weight (along with its relative - time-series modeling). Heavily based on statistics, it falls into a single concept:

*Everything is related to everything else, but near things are more connected than distant things*. (**W. Tobler**).

The presentation will focus on one concept and two techniques:
- the concept of spatial correlation (the example from the leisure &amp; tourism market),
- the point kriging technique used to interpolate values at unseen locations (weather readings enhancement),
- the Poisson Kriging Area-to-Point technique for preparation of the input from regional statistics that fit into satellite-based observations (cancer rates in U.S. counties).

Techniques for spatial data interpolation are used by:
- mining industry,
- agriculture &amp; forestry,
- defense &amp; security,
- retail,
- public health,
- administration, urban planning, water management,
- weather forecasting,
- and everywhere where we sample events distributed over an area or analyze regional statistics.

Why should we bother from the business perspective? We have various ML models, and house-price prediction is a topic of many tutorials. There are a few reasons: with spatial interpolation, we get knowledge about spatial dependencies between our samples, we get uncertainty measures, and we may perform analysis on a relatively small sample (&gt; 50 samples) that won&apos;t work with the ML pipeline. We may even link geostatistical models within complex machine-learning pipelines. And finally, we may save a lot of money on sampling.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MMQTLC/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MMQTLC/feedback/</feedback_url>
            </event>
            <event guid='e1d4e723-5a17-5775-b4df-c016964b54ee' id='29445' code='TJW3YZ'>
                <room>North Hall</room>
                <title>Site Unseen: hidden python customization</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Python offers us the ability to customize how it starts up. In some cases arbitrary python code can get executed before the first line of your module is reached. This is necessary for some of its dynamic nature, like virtualenvs but can also be harnessed to make the interpreter experience truly personal.</abstract>
                <slug>europython-2023-29445-site-unseen-hidden-python-customization</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='33924'>Jeremiah Paige</person>
                </persons>
                <language>en</language>
                <description>Python does a lot of work to customize itself when starting up. It also provides hooks for even more customization from users and packages during startup. Some of these are on by default while others must be enabled. Learn how to take advantage of Python&apos;s startup to craft a custom interpreter.

Python has a dizzying array of environment variables, many of which are used for startup tuning. The list has grown so long that recent Python versions have split the description of these variables into their own help (--help-env). It is valuable to a Pythonista to know about all of these, but this talk will show you how to use a subset to personalize the Python runtime environment to your development needs and preferences.

As powerful as this customization is, much of it is possible through arbitrary code execution or otherwise manipulating the expected behavior of lookups. Since many of these behaviors happen automatically, it is important to know how to disable them for many reasons: security, reproducibility, and speed among them.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/TJW3YZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/TJW3YZ/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Terrace 2A' guid='ab4602e3-05dd-5b83-a1c0-aebd23a49cdc'>
            <event guid='2ffff93a-b4ad-5084-9ccc-1c8146e48fdb' id='29584' code='K9VPWE'>
                <room>Terrace 2A</room>
                <title>Python 3.11 What&#8217;s new?</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>The topic aims to introduce participants to the latest from Python in version 3.11, released in early October 2022, which includes:

&#8226; Speed improvements;
&#8226; Standard Libraries Improvements;
&#8226; Self type;
&#8226; Exception Notes;
&#8226; Better Error Messages;
&#8226; Improved Type Variables;
&#8226; Variadic generics;
&#8226; Marking individual TypedDict items as required or potentially missing;
&#8226; Arbitrary literal string type;
&#8226; Data class transforms;
&#8226; TOML read-only support in stdlib;
&#8226; Exception Groups;
&#8226; Negative Zero Formatting.</abstract>
                <slug>europython-2023-29584-python-3-11-what-s-new</slug>
                <track>Python Internals &amp; Ecosystem (2023)</track>
                
                <persons>
                    <person id='34025'>Dilyan Grigorov</person>
                </persons>
                <language>en</language>
                <description>My presentation aims to consider the most interesting new features of Python 3.11 which have been discussed among the software engineers since the official release of the new version of the language. Then real practical examples will be taken into account and implemented for real solutions of problems.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/K9VPWE/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/K9VPWE/feedback/</feedback_url>
            </event>
            <event guid='ac94b7c6-6b6c-5ab4-887b-900057715b9c' id='29484' code='BEVEFH'>
                <room>Terrace 2A</room>
                <title>Asyncio Evolved: Enhanced Exception Handling with TaskGroup in Python 3.11</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>With the release of Python 3.11 in October 2022, PEP 654 &quot;Exception Groups and except&quot; was accepted, and asyncio.TaskGroup() was added. This enhancement of exception and cancellation handling has allowed asyncio to evolve more flexibly, addressing the existing issues with asyncio APIs, such as insufficient cancellation and exception handling in asyncio.gather.

In this talk, I would like to discuss the problems of existing asyncio APIs and how the newly introduced asyncio.TaskGroup() solves these issues. Attendees will learn about the improved way of handling exceptions and cancellations using asyncio.TaskGroup(), enabling them to write more efficient and robust asynchronous code with Python 3.11.</abstract>
                <slug>europython-2023-29484-asyncio-evolved-enhanced-exception-handling-with-taskgroup-in-python-3-11</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33951'>Junya Fukuda</person>
                </persons>
                <language>en</language>
                <description>###  Description
In Python 3.11, asyncio.TaskGroup() and asyncio timeout context managers were added. Additionally, get_event_loop() was deprecated in 3.10, and loop objects were further obscured, making the already less intimidating asyncio even less scary.  

I will discuss the basic usage of asyncio in Python 3.11, which has become simpler and more flexible, focusing on exception and cancellation handling.  

I hope that this will be helpful for those who choose asyncio when writing web applications using ASGI frameworks or Python scripts where asynchronous I/O is useful.

### By the end of this talk, attendees will be able to:

* Understand the limitations of the existing asyncio APIs, specifically regarding cancellation and exception handling in asyncio.gather.
* Learn how Python 3.11&apos;s asyncio.TaskGroup() overcomes these limitations and improves exception and cancellation handling.
* Apply the new asyncio.TaskGroup() features in their asynchronous programming to build more resilient and efficient applications.

### Planned Outline
* Overview of asyncio.taskgroup (5 min)
  * New &quot;except*&quot; syntax
    * PEP 654 Exception Groups and except
* Capturing concurrent exceptions(10 min)
  * Using asyncio.gather() / asyncio.TaskGroup()
* Cancelling tasks on exception(10 min)
  * Using asyncio.gather() / asyncio.TaskGroup()
* Writing &quot;predictable&quot; and &quot;safe&quot; asyncio code(5 min)
  * Introducing the new standard &quot;Hello-ish world&quot; example</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BEVEFH/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BEVEFH/feedback/</feedback_url>
            </event>
            <event guid='28334e47-8727-557a-bb6d-cee4e20455fd' id='29305' code='DE3XED'>
                <room>Terrace 2A</room>
                <title>Diving into Event-Driven Architectures with Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>Event-Driven Architectures (EDAs) target a real need in today&apos;s application landscape, as systems grow more complex or need to scale organically.

The talk will introduce the architecture and provide insights into different components which can be managed, connected and implemented with Python.</abstract>
                <slug>europython-2023-29305-diving-into-event-driven-architectures-with-python</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='33816'>Marc-Andr&#233; Lemburg</person>
                </persons>
                <language>en</language>
                <description>Event-driven architectures (EDAs) and AsyncAPI are being pushed at the moment as the new big thing after REST/OpenAPI and GraphQL. Indeed, EDAs target a real need in today&apos;s application landscape, as systems grow more complex or need to scale both vertically and horizontally.

Python can help build such architectures by leveraging existing event bus/queue systems or by providing the needed async interfaces directly.

The talk will introduce the architecture and terminology around it, such as AsyncAPI, as well as provide insights into different components which can be managed, connected and implemented with Python.

It is also meant to spark some more interest in getting Python into a more prominent position within the AsyncAPI community, where Node and Java still dominate.

Resources:
- https://en.wikipedia.org/wiki/Event-driven_architecture
- https://www.asyncapi.com/</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/DE3XED/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/DE3XED/feedback/</feedback_url>
            </event>
            <event guid='eff12395-ae53-59e0-9dd4-0c821c12dd40' id='33363' code='MAGZUV'>
                <room>Terrace 2A</room>
                <title>Best Practices for GraphQL API Development</title>
                <subtitle></subtitle>
                <type>Sponsored</type>
                <date>2023-07-21T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Must-have tools for running GraphQL in production

Gear up for a groundbreaking transformation of your GraphQL prowess! Join us for an engaging and informative session as we unveil a set of indispensable tools and practices that will take your GraphQL APIs to new heights in production environments.</abstract>
                <slug>europython-2023-33363-best-practices-for-graphql-api-development</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='37775'>Ahter Sonmez</person>
                </persons>
                <language>en</language>
                <description>In this talk, we&apos;ll tackle the toughest challenges head-on. From conquering query depth limits and query complexity constraints to mastering authorization checks, role-based access control (RBAC), we&apos;ve got the insider GraphQL knowledge you need. As we plunge into the depths of GraphQL sorcery (where Krakens live) you&apos;ll uncover the secrets to unleashing lightning-fast pagination, implementing intelligent rate-limiting, and harnessing a treasure trove of indispensable monitoring tools.

Don&apos;t miss out on this opportunity to supercharge your GraphQL API skills. By embracing these must-have tools and practices, you&apos;ll confidently navigate production environments, delivering outstanding user experiences and leaving your stakeholders in awe.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/MAGZUV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/MAGZUV/feedback/</feedback_url>
            </event>
            <event guid='fc218fca-7057-559b-9b63-64e0409650c5' id='28838' code='8M8UCT'>
                <room>Terrace 2A</room>
                <title>How Python can help victims of violence</title>
                <subtitle></subtitle>
                <type>Poster</type>
                <date>2023-07-21T13:00:00+02:00</date>
                <start>13:00</start>
                <duration>01:00</duration>
                <abstract>There are two values that everyone agrees with: Judicial Truth (criminals should be prosecuted, but innocent people left free), and Privacy (others shouldn&apos;t know unnecessarily about my private life).

But these two values are constantly put in opposition, e.g. videosurveillance helps gather evidence of crime, but it endangers our legitimate rights as citizens.

That&apos;s why we launched the WitnessAngel initiative, a research effort to invent new concepts and technologies able to reconcile Judicial Truth and Privacy.

With algorithms like Flightbox, with ideas like VideoTestimony and Familiar, and with the open-source code we provide, we work with associations and enterprises to eventually put life-changing solutions into the hands of the general public. So that countless victims of rape, abuse, bullying, stop facing the usual brick wall: &quot;it&apos;s your word against theirs&quot;.</abstract>
                <slug>europython-2023-28838-how-python-can-help-victims-of-violence</slug>
                <track>Ethics, Philosophy &amp; Politics (2023)</track>
                
                <persons>
                    <person id='33352'>Pascal Chambon</person>
                </persons>
                <language>en</language>
                <description>This poster will summarize the concepts, technological blocks, frequently asked questions, and challenges still to be tackled by the WitnessAngel project.

It will provide an overview of our roadmaps, and of how people can contribute to this effort, so that one day #metoo and other global scandals become a thing of the past.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links>
                    <link href="https://witnessangel.com/en/explanatory-comic-strip/">A comic strip to show our concepts</link>
                </links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/8M8UCT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/8M8UCT/feedback/</feedback_url>
            </event>
            <event guid='5ee70c7f-0723-5eff-a3df-5b8740699291' id='29356' code='UPEWP3'>
                <room>Terrace 2A</room>
                <title>Fish and chips and Apache Kafka&#174;</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>Apache Kafka&#174; is the de facto standard in the data streaming world for sending messages from multiple producers to multiple consumers, in a fast, reliable and scalable manner.

Come and learn the basic concepts and how to use it, by modelling a traditional British fish and chips shop!</abstract>
                <slug>europython-2023-29356-fish-and-chips-and-apache-kafka</slug>
                <track>Infrastructure: Cloud &amp; Hardware (2023)</track>
                
                <persons>
                    <person id='33851'>Tibs</person>
                </persons>
                <language>en</language>
                <description>Handling large numbers of events is an increasing challenge in our cloud centric world. For instance, in the IoT (Internet of Things) industry, devices are all busy announcing their current state, which we want to manage and report on, and meanwhile we want to send firmware and other updates back to specific groups of devices.

Traditional messaging solutions don&apos;t scale well for this type of problem. We want to guarantee not to lose events, to handle high volumes in a timely manner, and to be able to distribute message reception or production across multiple consumers or producers (compare to sharding for database reads).

As it turns out, there is a good solution available: Apache Kafka&#174; - it provides all the capabilities we are looking for.

In this talk, rather than considering some imaginary IoT scenario, I&apos;m going to look at how one might use Kafka to model the events required to run a traditional British fish and chip shop: ordering (plaice and chips for me, please), food preparation, accounting and so on.

I&apos;ll demonstrate handling of multiple producers and consumers, automatic routing of events as new consumers are added, persistence, which allows a new consumer to start consuming events from the past, and more.

Find the slides and demos on [Aiven Labs](https://github.com/Aiven-Labs/fish-and-chips-and-kafka)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/UPEWP3/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/UPEWP3/feedback/</feedback_url>
            </event>
            <event guid='2a6d0cca-fc10-5710-8498-4cae13bd53a9' id='29558' code='79HLM8'>
                <room>Terrace 2A</room>
                <title>How LocalStack is recreating AWS with Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>At LocalStack, we are building a platform that enables development and testing of cloud applications on your local machine. The core is an [open source AWS emulator](https://github.com/localstack/localstack) that is primarily written in Python. It is among the top Python projects on GitHub, and has seen a massive uptake in contributions over the past two years. Many Python software developers and architects will relate to the struggles of maintaining a large and complex Python codebase, while keeping developer teams productive. In this talk, we&apos;ll explore how we at LocalStack tackle these as we re-create AWS for local development. We&apos;ll explain our approaches to automating around AWS specifications, building a highly modular and pluggable system to make it easy for teams to integrate their components, the software patterns we use to keep devs productive, as well as our approach to automated contract testing using pytest.</abstract>
                <slug>europython-2023-29558-how-localstack-is-recreating-aws-with-python</slug>
                <track>Software Engineering &amp; Architecture (2023)</track>
                
                <persons>
                    <person id='34006'>Thomas Rausch</person>
                </persons>
                <language>en</language>
                <description>This talk aims to provide a broad overview of LocalStack and its implementation, and at the same time provide listeners with relatable insights from our experience in architecting, developing, and maintaining a large, complex Python code base.

The outline is roughly as follows:

- Intro: What&apos;s LocalStack, who am I, what problems are we solving?
- Software patterns we use, and how they are implemented in Python. These include:
  - A web framework based on WSGI/Werkzeug that implements the chain-of-responsibility pattern: I&apos;ll explain how this pattern is similar to WSGI middleware, and demonstrate how it allows us to plug in different types of functionality into the HTTP request processing, when this pattern is beneficial (compared to traditional web frameworks: much more flexible), and what the drawbacks are (hard to debug!)
  - Other patterns found in the code base: Visitor, Adapter, Proxy, Singleton
  - Monkey patching: I will briefly explain how monkey patching works, how it helps us move fast, but also how it can hurt (with real examples of when things blew up in our face), but why the trade-off leans towards using monkey patching.
  - Dynamic code loading: We built an open source framework called Plux that builds a higher-level plugin mechanism around Python entrypoints. will explain both the benefits (super flexible, allows clean code organization) and the drawbacks (pretty hard at times to figure out what&apos;s going on) of dynamic code loading.
- Strategies we use to maintain parity with AWS: People are usually skeptical that an idea like LocalStack can even work. 
  - We automate a lot around the AWS specs, for example we get weekly PRs when service APIs change. I&apos;ll demonstrate how we do server-side code generation from the AWS specs, and how that helps us.
  - Snapshot testing: We have built our own contract testing framework around pytest. We use that to write contract tests against AWS, that we then run against LocalStack to ensure parity. I&apos;ll go into a bit of details of the challenges with this approach, but also how we couldn&apos;t work without it.
- Wrap up and conclusion: I will tie together all the presented solutions and summarize how they help us solve the challenges. After this, the audience should have a deeper appreciation for how Python helps build something like LocalStack. I&apos;ll conclude by pointing out some of the overarching themes in this talk (like the tradeoffs between introducing certain patterns on maintainability).</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/79HLM8/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/79HLM8/feedback/</feedback_url>
            </event>
            <event guid='b16a5f21-4e08-5b5d-9e16-2d743c80d6fa' id='30085' code='KPHVEL'>
                <room>Terrace 2A</room>
                <title>Language Model Zen</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>Beautiful is better than ugly.

The frontier of AI Language Models awaits exploration.

 We, Pythonistas, face choices on how to use these tools.

Advanced models like GPT-4, BARD, and LLaMa generate human-like responses.

The nature of Language Models is fear,

But tools like TransformerLens show The Way.

Understanding The Model is possible.

The nature of Language Models is excitement.

Using them out of the box is one option.

Prompt engineering is another.

ChatGPT plugins and LangChain offer a third choice.

Fine-tuning them presents a fourth.

Training them from scratch is the fifth option.

Not using them at all is the final option. It may be safer.

The output for one LM is the prompt for another.

While openai is an excellent library, and

LangChain composes language models and utilities.

GPT&apos;s plugin system also composes language models and utilities, and

There should be one-- and preferably only one --obvious way to do it.</abstract>
                <slug>europython-2023-30085-language-model-zen</slug>
                <track>PyData: Ethics in AI (2023)</track>
                
                <persons>
                    <person id='34525'>Jamie Coombes</person>
                </persons>
                <language>en</language>
                <description>This talk explores the complex frontier of Language Modeling, recognizing the importance of mitigating risks and ethical considerations while exploring opportunities and challenges. It provides practical examples using OpenAI, LangChain, and GPT&apos;s plugin system to showcase the different ways to use these powerful tools.

The Capability in AI focus is provided by the comparison between LangChain and the GPT Plugin System.

The Ethics in AI focus is provided by demonstrating the TransformerLens library. 

TransformerLens allows surgeon-like analysis of language model internals. This mechanistic Interpretability library created by the London-based Researcher, Neel Nanda, This talk will compare the abundant code-quality linting and tooling available for static and dynamic analysis of code, to the comparatively weaker MLOps ecosystem, and the almost non-existent MLSafetyOps (Mechanistic Interpretability) ecosystem. 

This talk will propose a greater focus on open-source interpretability tooling.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/KPHVEL/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/KPHVEL/feedback/</feedback_url>
            </event>
            <event guid='5b88c851-e21c-5f65-b247-374740ed74df' id='29324' code='G9NKUY'>
                <room>Terrace 2A</room>
                <title>Language Models for Music Recommendation</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>Music streaming services like Spotify and youtube are famous for their recommendation systems and each service takes a unique approach to recommending and personalize content. While most users are happy with the recommendations provided, there are a section of users who are curious how and why a certain track is recommended. Complex recommendation systems take various factors like track metadata, user metadata, and play counts along with the track content itself. 

Inspired by Andrej Karpathy to build an own GPT, we have to use Language Models to build our own music recommendation system.</abstract>
                <slug>europython-2023-29324-language-models-for-music-recommendation</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='33832'>Nischal Harohalli Padmanabha</person><person id='33833'>Raghotham Sripadraj</person>
                </persons>
                <language>en</language>
                <description>Music streaming services like spotify and youtube are famous for their recommendation systems and each service takes a unique approach to recommend and personalize content. While most users are happy with the recommendations provided, there are a section of users who are curious how and why a certain track is recommended. Complex recommendation systems take various factors like track metadata, user metadata, play counts along with the track content itself. 

As music aficionados who love techno, trance, deep house and classical genres, we want to understand the following questions:

1. Can we analyze the signals from the song track and identify the different instruments used?
2. How can we create embeddings of all the tracks and index these for further analysis?
3. How do we create a simple User interface to pick a song track, retrieve relevant embeddings from a section of the track and get recommendations based on just the music content.
4. As a side effect, can I retrieve similar sections of music across various tracks.
5. Using audio LMs, can we generate high quality music based of the embeddings?</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/G9NKUY/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/G9NKUY/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Terrace 2B' guid='3fcaeaa9-6c50-5e80-9387-b6a42febf14b'>
            <event guid='79ce89fc-9ddc-5a44-b0f0-c86820dcab53' id='29015' code='J3PUYZ'>
                <room>Terrace 2B</room>
                <title>Upgrading Django - from legacy to latest</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>00:30</duration>
                <abstract>Django is a framework that&apos;s been around for more than 15 years, which makes for enough legacy projects to deal with.

In this talk we&apos;ll show practical tips and tricks for how to get Django from legacy to latest &amp; greatest.</abstract>
                <slug>europython-2023-29015-upgrading-django-from-legacy-to-latest</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='33531'>Radoslav Georgiev</person><person id='39613'>Kamen Kotsev</person>
                </persons>
                <language>en</language>
                <description>As developers, we love working with the latest version of our favorite tools &amp; frameworks.

But sometimes, we have to deal with legacy projects &amp; since Django has been around for more than 15 years - there are plenty of legacy Django projects to work with.

We either inherit one, or, somehow, we start with good intentions, but things deteriorate and we end up running Django that&#8217;s 2 or 3 major versions behind.

No matter how we end up in that legacy situation, we usually have 2 choices:

1. Stay within the boundaries of the existing project.
2. Try upgrading Django &amp; the rest of the dependencies.

This talk will cover point 2, giving practical advice, derived from experience of migrating large legacy Django projects from versions 1 &amp; 2, all the way to latest &amp; greatest.

We will approach the problem in a structured way, going through different scenarios and showing practical steps, tips &amp; tricks, so a human can deal with the challenges of upgrading a legacy Django project.

We will talk about starting from scratch vs. gradually upgrading.

The talk will cover the following topics:

1. We will start with the most important question - How reckless can we be?
    - Is this in production?
    - Is this mission critical?
    - Is backwards compatibility important?
    - Are there tests? Automated? Test cases? Documentation?
    - Are we building from scratch or are we gradually upgrading?
2. Next, we will go through various scenarios.
    - We are dealing with Django 2. What now?
    - We are dealing with Django 1 &amp; Python 2. What now?
    - There are core dependencies that are no longer supported. What now?
3. Finally, after we managed to get to Django 4, we will talk about how not to end up in the same situation again.

The end goal of the talk is to show that keeping up to date is possible, even if we start with a big legacy project.

The talk should serve as inspiration &amp; example for those, who want to push their legacy Django projects forward.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/J3PUYZ/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/J3PUYZ/feedback/</feedback_url>
            </event>
            <event guid='2eb7c153-6675-5e74-9118-c3b440717bcb' id='29687' code='UWKSPN'>
                <room>Terrace 2B</room>
                <title>Time Made Easy: Simplify Date and Time Handling with Python&apos;s Pendulum</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:20:00+02:00</date>
                <start>11:20</start>
                <duration>00:30</duration>
                <abstract>Pendulum is a Python package for working with dates, times, and timezones. It offers a simple and intuitive API for common date/time operations and provides advanced functionality for dealing with more complex scenarios. Some of the interesting points of Pendulum include support for leap years, time zones, and daylight saving time, as well as a fluent API for creating and modifying dates and times.

One of the standout features of Pendulum is its support for time zones. The library comes with a comprehensive list of time zones, and it can automatically adjust dates and times to the local time zone of a given location. Additionally, Pendulum can handle time zone conversions with ease, making it easy to work with date/time data across different time zones.

Pendulum also provides a powerful API for creating and modifying dates and times. With its fluent interface, developers can create and manipulate dates and times using a natural, human-readable syntax.</abstract>
                <slug>europython-2023-29687-time-made-easy-simplify-date-and-time-handling-with-python-s-pendulum</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34091'>Abhinand C</person><person id='33552'>Jothir Adithyan</person>
                </persons>
                <language>en</language>
                <description>Pendulum is a Python library designed to simplify the handling of dates, times, and time zones. It offers an easy-to-use API that allows developers to perform common date/time operations with ease, while also providing advanced functionality for more complex scenarios. With its support for time zones, leap years, and daylight saving time, Pendulum is a comprehensive solution for managing date/time data in Python. Its fluent interface and intuitive syntax make it easy to create and manipulate dates and times in a natural way, while its robust documentation and helpful community make it easy to get started with the library. Whether you&apos;re building a simple date calculator or a complex scheduling application, Pendulum can help you work with time-related data more efficiently and effectively.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/UWKSPN/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/UWKSPN/feedback/</feedback_url>
            </event>
            <event guid='74664e1d-c37e-5c5d-b1bc-54ef5d366878' id='29640' code='BRY8JS'>
                <room>Terrace 2B</room>
                <title>Leveraging the power of Django REST Framework&apos;s renderers with HTMX.</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T11:55:00+02:00</date>
                <start>11:55</start>
                <duration>00:30</duration>
                <abstract>HTMX has been quite popular lately in the Django circles and has demonstrated how powerful it can be with vanilla Django. But... have you thought about HTMX paired with Django REST Framework and more specifically paired with DRF&apos;s flexible renderer system?</abstract>
                <slug>europython-2023-29640-leveraging-the-power-of-django-rest-framework-s-renderers-with-htmx</slug>
                <track>Web (2023)</track>
                
                <persons>
                    <person id='34062'>Emma Delescolle</person>
                </persons>
                <language>en</language>
                <description>Django is most known for its admin. Ironically it is also one of the less Django-like parts of Django and one with many dimensions that make it harder to extend and fully customize. That&apos;s probably why, for several years, people have been trying to find alternatives to Django admin, packages that have had variables amounts of success like Django Grappelli, Django Admin2 or Django Admin Bootstrap.

One of these attempts is actually part of a very popular Django package, it&apos;s the Admin Renderer from Django REST Framework. Although it is quite powerful, I&apos;m not sure it really ever caught on in the Django community.

But the Admin renderer is not the only renderer packaged with DRF, most of us are likely familiar with the Browsable API renderer and some of us have probably heard of the Template HTML renderer.

Before diving into the renderer itself, we will do a quick round-up of the capabilities DRF offers, both out-of-the box and also with a few extra addons and compare that to what Django Admin offers.

Finally we will look at the mechanics of DRF renderers and how, coupled with HTMX, the Template HTML renderer can bring dynamicity to an admin-like, feature-rich, CRUD interface born of Django REST Framework.

It will be up to you to decide... Is Django REST Framework going to be the basis of the admin of your next Django project???</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BRY8JS/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BRY8JS/feedback/</feedback_url>
            </event>
            <event guid='284d006b-78e9-5c9f-babb-4b2e58a158b1' id='30066' code='BSZFSA'>
                <room>Terrace 2B</room>
                <title>Pygoat - Learn Django security the hard way</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T12:30:00+02:00</date>
                <start>12:30</start>
                <duration>00:30</duration>
                <abstract>Learn to secure your Django apps by attacking (and then securing) Pygoat - An intentionally vulnerable Python Django application. Explore the OWASP top 10 vulnerabilities and understand how to mitigate them from Django apps.</abstract>
                <slug>europython-2023-30066-pygoat-learn-django-security-the-hard-way</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34058'>Adarsh Divakaran</person><person id='36607'>Thameem Karakkoth</person>
                </persons>
                <language>en</language>
                <description>Pygoat is an intentionally vulnerable Python Django application that can be used to learn to secure our Django apps. In this talk, we will attack a deployed Pygoat application, identify the underlying security issues in our code, and then secure it. We will learn about common security vulnerabilities (OWASP Top 10) in Django apps and how to fix them so that we can keep our applications safe from attackers.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/BSZFSA/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/BSZFSA/feedback/</feedback_url>
            </event>
            <event guid='c2a77339-67bd-561f-850e-92bc9051e153' id='30124' code='HSRTCT'>
                <room>Terrace 2B</room>
                <title>We are Python Weekend!</title>
                <subtitle></subtitle>
                <type>Poster</type>
                <date>2023-07-21T13:00:00+02:00</date>
                <start>13:00</start>
                <duration>01:00</duration>
                <abstract>code.kiwi.com community has been running Python Weekend &#8212; an educational community project &#8212; since 2016. Over the past 7 years we helped hundreds of Python developers complete the program accelerating their careers, traveled to 10+ cities all over Europe and collaborated with numerous local Python communities to make it happen.

At first glance, Python Weekend is a 2.5-day supervised coding event for Junior+ Python devs, where  participants build the prototype of core Kiwi.com technology, while getting support from a group of experienced engineers, for free. But there&#8217;s so much more to this.

At this poster session, we will share how to run an educational Python project so the community, business and local tech scene would benefit. We will show how to shape the culture of connecting real-business challenges and junior talent. We will see how dev edu projects can impact the culture of mentorship and present feedback of mentees from all over the world to share their experience.</abstract>
                <slug>europython-2023-30124-we-are-python-weekend</slug>
                <track>Education, Teaching &amp; Training (2023)</track>
                
                <persons>
                    <person id='33342'>Alena Osipova</person><person id='35987'>Andrej Zaujec</person><person id='36216'>Luk&#225;&#353; Kubi&#353;</person>
                </persons>
                <language>en</language>
                <description>I think We are Python Weekend talk can be also presented as a poster session. 
We plan
- million of stories
- inspiration for everyone who wants to run their own Python project for the community
- a lot of photos and feedback from the folks who have been part of the project - from a CS student, graphic designer, ex-WizzAir pilot, and more amazing people of Python Weekend.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/HSRTCT/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/HSRTCT/feedback/</feedback_url>
            </event>
            <event guid='b88b64c5-c764-50fb-a791-6a5d2a3c78b4' id='29462' code='GQAARK'>
                <room>Terrace 2B</room>
                <title>Unleashing the Power of dbt and Python for Modern Data Stack</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:00:00+02:00</date>
                <start>14:00</start>
                <duration>00:30</duration>
                <abstract>This talk will introduce dbt and demonstrate how to leverage Python to unlock its full potential. Attendees will learn best practices for working with dbt, how to integrate it with other tools in their data stack, and how to use Python packages like fal to perform complex data analysis. With real-world examples and use cases, this talk will equip attendees with the tools to build a modern, scalable, and maintainable data infrastructure.</abstract>
                <slug>europython-2023-29462-unleashing-the-power-of-dbt-and-python-for-modern-data-stack</slug>
                <track>PyData: Software Packages &amp; Jupyter (2023)</track>
                
                <persons>
                    <person id='33931'>Meder Kamalov</person>
                </persons>
                <language>en</language>
                <description>Data modeling, transformation, and analysis are integral parts of data pipelines. However, managing and maintaining data infrastructure can be a daunting task. dbt (data build tool) is a powerful open source package that helps data teams build modular, maintainable, and scalable data transformations.

In this talk, we will introduce dbt to the Python community and demonstrate its full potential. We will go over best practices for data modeling and transformation, and how to integrate dbt into your existing data stack. We will also show how to use Python packages such as fal to interact with dbt and perform complex data analysis.

Attendees will learn: 

- What is dbt and why it&#8217;s a game-changer for data engineering and analysis 

- Best practices for data modeling and transformation with dbt 

- How to integrate dbt into your existing data stack and work with data warehouses such as Snowflake and BigQuery 

- How to leverage Python packages such as fal to interact with dbt and perform advanced data analysis 

- Real-world examples and use cases of dbt and Python in action

By the end of this talk, attendees will have a solid understanding of how to use dbt and Python together to build a modern, scalable, and maintainable data stack. Whether you&#8217;re a data engineer, analyst, or scientist, this talk will give you the knowledge and tools to take your data infrastructure to the next level.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/GQAARK/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/GQAARK/feedback/</feedback_url>
            </event>
            <event guid='c98d888d-f879-5ac7-b20f-9574f3093178' id='29814' code='REVKYV'>
                <room>Terrace 2B</room>
                <title>Deep Dive into Asynchronous SQLAlchemy - Transactions and Connections</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T14:35:00+02:00</date>
                <start>14:35</start>
                <duration>00:30</duration>
                <abstract>SQLAlchemy is one of the most popular ORM libraries in Python. In this talk I will try to present caveats and gotchas that other Pythonists can find on their way while writing the asynchronous backend application using SQLAlchemy as an ORM. Mainly we will focus on how SQLAlchemy handles transactions and connections to the database and what issues we may face because of it.</abstract>
                <slug>europython-2023-29814-deep-dive-into-asynchronous-sqlalchemy-transactions-and-connections</slug>
                <track>Python Libraries (2023)</track>
                
                <persons>
                    <person id='34276'>Damian Wysocki</person>
                </persons>
                <language>en</language>
                <description>The presentation is about SQLAlchemy, which is an Object-Relational Mapping (ORM) library used in Python for working with databases. 

The presenter will discuss the challenges and potential problems that developers may encounter when using SQLAlchemy to create asynchronous backend applications.

The main focus of the talk will be on how SQLAlchemy handles transactions and connections to the database, which are crucial components of building a robust and reliable backend system. The presenter will explain some of the common caveats and gotchas that can arise when using SQLAlchemy in this context.

Overall, the talk aims to provide valuable insights and practical advice for Python developers who are interested in working with SQLAlchemy and building scalable, high-performance backend applications.

As a bonus we&apos;ll see how other popular asynchronous ORM handles connections to the database.</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/REVKYV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/REVKYV/feedback/</feedback_url>
            </event>
            <event guid='2f54385e-69df-5959-b3f8-1af2db18b97d' id='29661' code='F78KKP'>
                <room>Terrace 2B</room>
                <title>Threat to Life: Preventing Planned Murders with Python</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>00:30</duration>
                <abstract>At the Netherlands Forensic Institute (NFI), we&apos;ve developed a Python-based deep learning model to spot life-threatening messages in lawfully intercepted communication data, like those from the infamous chat service Encrochat.

Thanks to the application of our model in collaboration with the Dutch Police, dozens of potential victims of violent crimes, including murder, serious assault, and kidnapping, have been warned and safeguarded. In this talk, we&apos;ll dive into the development, implementation, and success of our deep learning model in the fight against violent criminal activities. We&apos;ll also tackle the risks tied to using deep learning for these cases and discuss the precautions we took to ensure responsible and accurate use.</abstract>
                <slug>europython-2023-29661-threat-to-life-preventing-planned-murders-with-python</slug>
                <track>PyData: Deep Learning, NLP, CV (2023)</track>
                
                <persons>
                    <person id='34083'>Edwin Rijgersberg</person>
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/F78KKP/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/F78KKP/feedback/</feedback_url>
            </event>
            <event guid='244a05ff-52c6-5f39-9467-ad5dbe6de0a0' id='29596' code='VFLKKR'>
                <room>Terrace 2B</room>
                <title>Building and Deploying Fair and Unbiased ML Systems : An Art, Not Science</title>
                <subtitle></subtitle>
                <type>Talk</type>
                <date>2023-07-21T16:05:00+02:00</date>
                <start>16:05</start>
                <duration>00:30</duration>
                <abstract>There has been a renaissance around Artificial Intelligence systems in recent years. However, despite the hype, only a small percentage, i.e. 13% of Machine Learning models see the light of day!
Well, effectively building and deploying machine learning models is more of an art than science! ML models are indeed inherently complex, have fuzzy boundaries, and rely heavily on data distribution. But what if they are trained on biased data? Then they&#8217;ll generate highly biased decisions! As the famous saying goes by,  &#8220;Garbage in, garbage out,&#8221; so if the model is trained on skewed and unfair data distribution, they are bound to produce fuzzy output!
So, join me in this talk as I will share my learnings in developing effective practices to build and deploy ethical, fair and unbiased machine learning models into production.</abstract>
                <slug>europython-2023-29596-building-and-deploying-fair-and-unbiased-ml-systems-an-art-not-science</slug>
                <track>TBD - Multiple Tracks (2023)</track>
                
                <persons>
                    <person id='34033'>Rashmi Nagpal</person>
                </persons>
                <language>en</language>
                <description>Have you ever wondered why the increasing reliance on Machine Learning systems raises concerns about fairness and bias in their data-driven decisions? What if ML models are built on skewed data or are not designed to mitigate bias - then they can perpetuate and even amplify existing inequalities and injustices!

Since there&apos;s no one-size-fits-all approach, thus, building and deploying a fair and unbiased ML system is more of an art than a science! In this talk, firstly, we will explore the challenges involved in building and deploying fair and unbiased ML systems. Secondly, we will understand the technical debts which incur while building such systems and how to investigate them. Finally, we will learn fundamental strategies and best practices for ensuring your ML models are fair, unbiased, and ethical!</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/VFLKKR/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/VFLKKR/feedback/</feedback_url>
            </event>
            
        </room>
        <room name='Open Space' guid='0fb91aae-4fa6-5849-a13f-b4cf9f4309c3'>
            <event guid='159793d2-6115-578c-9075-f19b5f4d77d2' id='33703' code='GDZU3R'>
                <room>Open Space</room>
                <title>Reserved for Mentored Sprint</title>
                <subtitle></subtitle>
                <type>Open Space</type>
                <date>2023-07-21T10:30:00+02:00</date>
                <start>10:30</start>
                <duration>02:30</duration>
                <abstract>&#10024; We are running mentored sprints for diverse community members at EuroPython this year &#10024;

&#128073;&#127997; Apply to be a mentor on the day or feature your open source project: email [cheuk@europython.eu](mailto:cheuk@europython.eu)

&#128073;&#127997; Apply to participate as a contributor (sprint on the day): [fill in this form](https://forms.gle/56EbHh4g19Mevo9i8).

If you are not a member of an underrepresented group of the community and want to take on the sprint we encourage you to bring someone from an underrepresented group with you.

&#128073;&#127997;Volunteer for our Git Helpdesk (4 volunteers needed): Help new contributors with git/GitHub, such as cloning repo, creating branch, committing, resolving merge conflicts. [fill in this form](https://forms.gle/56EbHh4g19Mevo9i8)

&#128214; Check out our online handbook to learn more about our approach to sprinting: https://mentored-sprints.netlify.app/</abstract>
                <slug>europython-2023-33703-reserved-for-mentored-sprint</slug>
                <track></track>
                
                <persons>
                    <person id='33929'>Cheuk Ting Ho</person>
                </persons>
                <language>en</language>
                <description>Open source projects such as Python and its multiple stacks (web, scientific, etc.) are nothing but a collaborative effort from many community members. It is the constant involvement of the numerous maintainers, contributors, and users that make open-source software sustainable and keep the community as a whole going.

Walking the path from user to collaborator, and thus contributing to an open-source project, can sometimes be intimidating especially for newcomers. From a technical perspective, interacting with web-based hosting services (such as GitHub, GitLab, etc.), branching and opening pull requests can be overwhelming if these are not everyday actions of your workflow. The correctness of the code and potential bugs are other common obstacles and fears any newcomer might face. Not to mention the time and frustration accumulated over the task of finding a &#8216;beginner-friendly&#8217; issue to work on.

We also recognize that some groups are traditionally underrepresented in the open-source community and we would like to support them in their open-source path. We are running the mentored sprints for individuals from underrepresented groups willing to start contributing to Python projects. This event will provide a supportive, friendly, and safe environment for all the attendees and partner open source projects.

To achieve this goal, we are seeking to work with a number of Python projects and their maintainers interested in providing mentorship to these individuals. In return, we will provide guidance and advice on how to prepare the projects for the day and to better serve a diverse range of contributors.

Check out more details at [https://ep2023.europython.eu/mentored-sprint](https://ep2023.europython.eu/mentored-sprint)</description>
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/GDZU3R/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/GDZU3R/feedback/</feedback_url>
            </event>
            <event guid='adb6d931-6cab-5429-b8a9-135ebe38e3db' id='34244' code='7VLWUV'>
                <room>Open Space</room>
                <title>Reserved for Tournament</title>
                <subtitle></subtitle>
                <type>Open Space</type>
                <date>2023-07-21T15:30:00+02:00</date>
                <start>15:30</start>
                <duration>01:30</duration>
                <abstract></abstract>
                <slug>europython-2023-34244-reserved-for-tournament</slug>
                <track></track>
                
                <persons>
                    
                </persons>
                <language>en</language>
                
                <recording>
                    <license></license>
                    <optout>false</optout>
                </recording>
                <links></links>
                <attachments></attachments>

                <url>https://programme.europython.eu/europython-2023/talk/7VLWUV/</url>
                <feedback_url>https://programme.europython.eu/europython-2023/talk/7VLWUV/feedback/</feedback_url>
            </event>
            
        </room>
        
    </day>
    <day index='6' date='2023-07-22' start='2023-07-22T04:00:00+02:00' end='2023-07-23T03:59:00+02:00'>
        
    </day>
    <day index='7' date='2023-07-23' start='2023-07-23T04:00:00+02:00' end='2023-07-24T03:59:00+02:00'>
        
    </day>
    
</schedule>
