<?xml version='1.0' encoding='utf-8' ?>
<iCalendar xmlns:pentabarf='http://pentabarf.org' xmlns:xCal='urn:ietf:params:xml:ns:xcal'>
    <vcalendar>
        <version>2.0</version>
        <prodid>-//Pentabarf//Schedule//EN</prodid>
        <x-wr-caldesc></x-wr-caldesc>
        <x-wr-calname></x-wr-calname>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3HURZQ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3HURZQ</pentabarf:event-slug>
            <pentabarf:title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T083000</dtstart>
            <dtend>20230717T093000</dtend>
            <duration>010000</duration>
            <summary>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/3HURZQ/</url>
            <location>Club A</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8XKCB8@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8XKCB8</pentabarf:event-slug>
            <pentabarf:title>Asyncio without Asyncio</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T093000</dtstart>
            <dtend>20230717T110000</dtend>
            <duration>013000</duration>
            <summary>Asyncio without Asyncio</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/8XKCB8/</url>
            <location>Club A</location>
            
            <attendee>Yan Yanchii</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8XKCB8@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8XKCB8</pentabarf:event-slug>
            <pentabarf:title>Asyncio without Asyncio</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T111500</dtstart>
            <dtend>20230717T124500</dtend>
            <duration>013000</duration>
            <summary>Asyncio without Asyncio</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/8XKCB8/</url>
            <location>Club A</location>
            
            <attendee>Yan Yanchii</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3HDWUZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3HDWUZ</pentabarf:event-slug>
            <pentabarf:title>Geospatial Data Processing in Python: A Comprehensive Tutorial</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T134500</dtstart>
            <dtend>20230717T151500</dtend>
            <duration>013000</duration>
            <summary>Geospatial Data Processing in Python: A Comprehensive Tutorial</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/3HDWUZ/</url>
            <location>Club A</location>
            
            <attendee>Martin Christen</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3HDWUZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3HDWUZ</pentabarf:event-slug>
            <pentabarf:title>Geospatial Data Processing in Python: A Comprehensive Tutorial</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T153000</dtstart>
            <dtend>20230717T170000</dtend>
            <duration>013000</duration>
            <summary>Geospatial Data Processing in Python: A Comprehensive Tutorial</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/3HDWUZ/</url>
            <location>Club A</location>
            
            <attendee>Martin Christen</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PNYMHE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PNYMHE</pentabarf:event-slug>
            <pentabarf:title>How to MLOps: Experiment tracking &amp; deployment &#128202;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T093000</dtstart>
            <dtend>20230717T110000</dtend>
            <duration>013000</duration>
            <summary>How to MLOps: Experiment tracking &amp; deployment &#128202;</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/PNYMHE/</url>
            <location>Club E</location>
            
            <attendee>Jeroen Overschie</attendee>
            
            <attendee>Yke Rusticus</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PNYMHE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PNYMHE</pentabarf:event-slug>
            <pentabarf:title>How to MLOps: Experiment tracking &amp; deployment &#128202;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T111500</dtstart>
            <dtend>20230717T124500</dtend>
            <duration>013000</duration>
            <summary>How to MLOps: Experiment tracking &amp; deployment &#128202;</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/PNYMHE/</url>
            <location>Club E</location>
            
            <attendee>Jeroen Overschie</attendee>
            
            <attendee>Yke Rusticus</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SEBRJA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SEBRJA</pentabarf:event-slug>
            <pentabarf:title>Build, Serve, and Deploy a Fast, Production-Ready API with Python and Robyn</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T134500</dtstart>
            <dtend>20230717T151500</dtend>
            <duration>013000</duration>
            <summary>Build, Serve, and Deploy a Fast, Production-Ready API with Python and Robyn</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/SEBRJA/</url>
            <location>Club E</location>
            
            <attendee>Sanskar Jethi</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SEBRJA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SEBRJA</pentabarf:event-slug>
            <pentabarf:title>Build, Serve, and Deploy a Fast, Production-Ready API with Python and Robyn</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T153000</dtstart>
            <dtend>20230717T170000</dtend>
            <duration>013000</duration>
            <summary>Build, Serve, and Deploy a Fast, Production-Ready API with Python and Robyn</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/SEBRJA/</url>
            <location>Club E</location>
            
            <attendee>Sanskar Jethi</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BGEYP7@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BGEYP7</pentabarf:event-slug>
            <pentabarf:title>Decorators - A Deep Dive</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T093000</dtstart>
            <dtend>20230717T110000</dtend>
            <duration>013000</duration>
            <summary>Decorators - A Deep Dive</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/BGEYP7/</url>
            <location>Club H</location>
            
            <attendee>Mike M&#252;ller</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BGEYP7@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BGEYP7</pentabarf:event-slug>
            <pentabarf:title>Decorators - A Deep Dive</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T111500</dtstart>
            <dtend>20230717T124500</dtend>
            <duration>013000</duration>
            <summary>Decorators - A Deep Dive</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/BGEYP7/</url>
            <location>Club H</location>
            
            <attendee>Mike M&#252;ller</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>C7AZ33@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-C7AZ33</pentabarf:event-slug>
            <pentabarf:title>Build a terminal TODO app with Textual</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T134500</dtstart>
            <dtend>20230717T151500</dtend>
            <duration>013000</duration>
            <summary>Build a terminal TODO app with Textual</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/C7AZ33/</url>
            <location>Club H</location>
            
            <attendee>Rodrigo Gir&#227;o Serr&#227;o</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>C7AZ33@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-C7AZ33</pentabarf:event-slug>
            <pentabarf:title>Build a terminal TODO app with Textual</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T153000</dtstart>
            <dtend>20230717T170000</dtend>
            <duration>013000</duration>
            <summary>Build a terminal TODO app with Textual</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/C7AZ33/</url>
            <location>Club H</location>
            
            <attendee>Rodrigo Gir&#227;o Serr&#227;o</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CRTSNK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CRTSNK</pentabarf:event-slug>
            <pentabarf:title>sktime - python toolbox for time series</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T093000</dtstart>
            <dtend>20230717T110000</dtend>
            <duration>013000</duration>
            <summary>sktime - python toolbox for time series</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/CRTSNK/</url>
            <location>Club B</location>
            
            <attendee>Franz Kiraly</attendee>
            
            <attendee>Sagar Mishra</attendee>
            
            <attendee>Kiril Ralinovski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CRTSNK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CRTSNK</pentabarf:event-slug>
            <pentabarf:title>sktime - python toolbox for time series</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T111500</dtstart>
            <dtend>20230717T124500</dtend>
            <duration>013000</duration>
            <summary>sktime - python toolbox for time series</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/CRTSNK/</url>
            <location>Club B</location>
            
            <attendee>Franz Kiraly</attendee>
            
            <attendee>Sagar Mishra</attendee>
            
            <attendee>Kiril Ralinovski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>Z7HAUH@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-Z7HAUH</pentabarf:event-slug>
            <pentabarf:title>Food For Rabbits: Celery From Zero to Hero</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T134500</dtstart>
            <dtend>20230717T151500</dtend>
            <duration>013000</duration>
            <summary>Food For Rabbits: Celery From Zero to Hero</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/Z7HAUH/</url>
            <location>Club B</location>
            
            <attendee>Roy M Mezan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>Z7HAUH@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-Z7HAUH</pentabarf:event-slug>
            <pentabarf:title>Food For Rabbits: Celery From Zero to Hero</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T153000</dtstart>
            <dtend>20230717T170000</dtend>
            <duration>013000</duration>
            <summary>Food For Rabbits: Celery From Zero to Hero</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/Z7HAUH/</url>
            <location>Club B</location>
            
            <attendee>Roy M Mezan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BABLES@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BABLES</pentabarf:event-slug>
            <pentabarf:title>Humble Data</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T093000</dtstart>
            <dtend>20230717T110000</dtend>
            <duration>013000</duration>
            <summary>Humble Data</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/BABLES/</url>
            <location>Club C</location>
            
            <attendee>Jodie Burchell</attendee>
            
            <attendee>Lais Carvalho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BABLES@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BABLES</pentabarf:event-slug>
            <pentabarf:title>Humble Data</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T111500</dtstart>
            <dtend>20230717T124500</dtend>
            <duration>013000</duration>
            <summary>Humble Data</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/BABLES/</url>
            <location>Club C</location>
            
            <attendee>Jodie Burchell</attendee>
            
            <attendee>Lais Carvalho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>73TAHG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-73TAHG</pentabarf:event-slug>
            <pentabarf:title>Women in AI Workshop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T134500</dtstart>
            <dtend>20230717T151500</dtend>
            <duration>013000</duration>
            <summary>Women in AI Workshop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/73TAHG/</url>
            <location>Club C</location>
            
            <attendee>Nabanita Roy</attendee>
            
            <attendee>Liliya Akhtyamova</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>73TAHG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-73TAHG</pentabarf:event-slug>
            <pentabarf:title>Women in AI Workshop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T153000</dtstart>
            <dtend>20230717T170000</dtend>
            <duration>013000</duration>
            <summary>Women in AI Workshop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/73TAHG/</url>
            <location>Club C</location>
            
            <attendee>Nabanita Roy</attendee>
            
            <attendee>Liliya Akhtyamova</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JWTGPG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JWTGPG</pentabarf:event-slug>
            <pentabarf:title>Beginners&apos; Day - PyLadies Snake Workshop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T093000</dtstart>
            <dtend>20230717T110000</dtend>
            <duration>013000</duration>
            <summary>Beginners&apos; Day - PyLadies Snake Workshop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
            <location>Club D</location>
            
            <attendee>Petr Viktorin</attendee>
            
            <attendee>Mia Baji&#263;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JWTGPG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JWTGPG</pentabarf:event-slug>
            <pentabarf:title>Beginners&apos; Day - PyLadies Snake Workshop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T111500</dtstart>
            <dtend>20230717T124500</dtend>
            <duration>013000</duration>
            <summary>Beginners&apos; Day - PyLadies Snake Workshop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
            <location>Club D</location>
            
            <attendee>Petr Viktorin</attendee>
            
            <attendee>Mia Baji&#263;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JWTGPG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JWTGPG</pentabarf:event-slug>
            <pentabarf:title>Beginners&apos; Day - PyLadies Snake Workshop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T134500</dtstart>
            <dtend>20230717T151500</dtend>
            <duration>013000</duration>
            <summary>Beginners&apos; Day - PyLadies Snake Workshop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
            <location>Club D</location>
            
            <attendee>Petr Viktorin</attendee>
            
            <attendee>Mia Baji&#263;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JWTGPG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JWTGPG</pentabarf:event-slug>
            <pentabarf:title>Beginners&apos; Day - PyLadies Snake Workshop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230717T153000</dtstart>
            <dtend>20230717T170000</dtend>
            <duration>013000</duration>
            <summary>Beginners&apos; Day - PyLadies Snake Workshop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/JWTGPG/</url>
            <location>Club D</location>
            
            <attendee>Petr Viktorin</attendee>
            
            <attendee>Mia Baji&#263;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3KTQQW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3KTQQW</pentabarf:event-slug>
            <pentabarf:title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T083000</dtstart>
            <dtend>20230718T093000</dtend>
            <duration>010000</duration>
            <summary>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/3KTQQW/</url>
            <location>Club A</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FGWHPW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FGWHPW</pentabarf:event-slug>
            <pentabarf:title>Gathering data from the web using Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T093000</dtstart>
            <dtend>20230718T110000</dtend>
            <duration>013000</duration>
            <summary>Gathering data from the web using Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/FGWHPW/</url>
            <location>Club A</location>
            
            <attendee>Renne Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FGWHPW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FGWHPW</pentabarf:event-slug>
            <pentabarf:title>Gathering data from the web using Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T111500</dtstart>
            <dtend>20230718T124500</dtend>
            <duration>013000</duration>
            <summary>Gathering data from the web using Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/FGWHPW/</url>
            <location>Club A</location>
            
            <attendee>Renne Rocha</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WB7ALT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WB7ALT</pentabarf:event-slug>
            <pentabarf:title>Kubernetes &lt;3 Python - Deploy Python apps &amp; extend Kubernetes with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T134500</dtstart>
            <dtend>20230718T151500</dtend>
            <duration>013000</duration>
            <summary>Kubernetes &lt;3 Python - Deploy Python apps &amp; extend Kubernetes with Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/WB7ALT/</url>
            <location>Club A</location>
            
            <attendee>Oz Tiram</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WB7ALT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WB7ALT</pentabarf:event-slug>
            <pentabarf:title>Kubernetes &lt;3 Python - Deploy Python apps &amp; extend Kubernetes with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T153000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>013000</duration>
            <summary>Kubernetes &lt;3 Python - Deploy Python apps &amp; extend Kubernetes with Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/WB7ALT/</url>
            <location>Club A</location>
            
            <attendee>Oz Tiram</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3HR8HZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3HR8HZ</pentabarf:event-slug>
            <pentabarf:title>Practical tools for documentation at scale</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T093000</dtstart>
            <dtend>20230718T110000</dtend>
            <duration>013000</duration>
            <summary>Practical tools for documentation at scale</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/3HR8HZ/</url>
            <location>Club E</location>
            
            <attendee>Daniele Procida</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3HR8HZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3HR8HZ</pentabarf:event-slug>
            <pentabarf:title>Practical tools for documentation at scale</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T111500</dtstart>
            <dtend>20230718T124500</dtend>
            <duration>013000</duration>
            <summary>Practical tools for documentation at scale</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/3HR8HZ/</url>
            <location>Club E</location>
            
            <attendee>Daniele Procida</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TGRMDT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TGRMDT</pentabarf:event-slug>
            <pentabarf:title>pytest tips and tricks for a better testsuite</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T134500</dtstart>
            <dtend>20230718T151500</dtend>
            <duration>013000</duration>
            <summary>pytest tips and tricks for a better testsuite</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/TGRMDT/</url>
            <location>Club E</location>
            
            <attendee>Freya Bruhin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TGRMDT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TGRMDT</pentabarf:event-slug>
            <pentabarf:title>pytest tips and tricks for a better testsuite</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T153000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>013000</duration>
            <summary>pytest tips and tricks for a better testsuite</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/TGRMDT/</url>
            <location>Club E</location>
            
            <attendee>Freya Bruhin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PZQHFU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PZQHFU</pentabarf:event-slug>
            <pentabarf:title>Develop your Python cloud applications offline with LocalStack</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T093000</dtstart>
            <dtend>20230718T110000</dtend>
            <duration>013000</duration>
            <summary>Develop your Python cloud applications offline with LocalStack</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/PZQHFU/</url>
            <location>Club H</location>
            
            <attendee>Waldemar Hummer</attendee>
            
            <attendee>Thomas Rausch</attendee>
            
            <attendee>Alex Rashed</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PZQHFU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PZQHFU</pentabarf:event-slug>
            <pentabarf:title>Develop your Python cloud applications offline with LocalStack</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T111500</dtstart>
            <dtend>20230718T124500</dtend>
            <duration>013000</duration>
            <summary>Develop your Python cloud applications offline with LocalStack</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/PZQHFU/</url>
            <location>Club H</location>
            
            <attendee>Waldemar Hummer</attendee>
            
            <attendee>Thomas Rausch</attendee>
            
            <attendee>Alex Rashed</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AEAPDB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AEAPDB</pentabarf:event-slug>
            <pentabarf:title>Robust Data Transformation with Pandas: Typing, Validation, Testing</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T134500</dtstart>
            <dtend>20230718T151500</dtend>
            <duration>013000</duration>
            <summary>Robust Data Transformation with Pandas: Typing, Validation, Testing</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/AEAPDB/</url>
            <location>Club H</location>
            
            <attendee>Jakub Urban</attendee>
            
            <attendee>Jan Pipek</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AEAPDB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AEAPDB</pentabarf:event-slug>
            <pentabarf:title>Robust Data Transformation with Pandas: Typing, Validation, Testing</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T153000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>013000</duration>
            <summary>Robust Data Transformation with Pandas: Typing, Validation, Testing</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/AEAPDB/</url>
            <location>Club H</location>
            
            <attendee>Jakub Urban</attendee>
            
            <attendee>Jan Pipek</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZSCRBC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZSCRBC</pentabarf:event-slug>
            <pentabarf:title>Write your first web API with Rust!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T093000</dtstart>
            <dtend>20230718T110000</dtend>
            <duration>013000</duration>
            <summary>Write your first web API with Rust!</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZSCRBC/</url>
            <location>Club B</location>
            
            <attendee>Jeremy Lempereur</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZSCRBC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZSCRBC</pentabarf:event-slug>
            <pentabarf:title>Write your first web API with Rust!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T111500</dtstart>
            <dtend>20230718T124500</dtend>
            <duration>013000</duration>
            <summary>Write your first web API with Rust!</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZSCRBC/</url>
            <location>Club B</location>
            
            <attendee>Jeremy Lempereur</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ADBP8B@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ADBP8B</pentabarf:event-slug>
            <pentabarf:title>Build your first GraphQL API using Python &#127827;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T134500</dtstart>
            <dtend>20230718T151500</dtend>
            <duration>013000</duration>
            <summary>Build your first GraphQL API using Python &#127827;</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/ADBP8B/</url>
            <location>Club B</location>
            
            <attendee>Patrick Arminio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SXEJWS@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SXEJWS</pentabarf:event-slug>
            <pentabarf:title>Practical introduction to descriptors</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T153000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>013000</duration>
            <summary>Practical introduction to descriptors</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Tutorial</category>
            <url>https://programme.europython.eu/europython-2023/talk/SXEJWS/</url>
            <location>Club B</location>
            
            <attendee>Rodrigo Gir&#227;o Serr&#227;o</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MQRJXF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MQRJXF</pentabarf:event-slug>
            <pentabarf:title>WASM Summit</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T093000</dtstart>
            <dtend>20230718T110000</dtend>
            <duration>013000</duration>
            <summary>WASM Summit</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
            <location>Club C</location>
            
            <attendee>Roman Yurchak</attendee>
            
            <attendee>Nicholas Tollervey</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MQRJXF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MQRJXF</pentabarf:event-slug>
            <pentabarf:title>WASM Summit</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T111500</dtstart>
            <dtend>20230718T124500</dtend>
            <duration>013000</duration>
            <summary>WASM Summit</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
            <location>Club C</location>
            
            <attendee>Roman Yurchak</attendee>
            
            <attendee>Nicholas Tollervey</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MQRJXF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MQRJXF</pentabarf:event-slug>
            <pentabarf:title>WASM Summit</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T134500</dtstart>
            <dtend>20230718T151500</dtend>
            <duration>013000</duration>
            <summary>WASM Summit</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
            <location>Club C</location>
            
            <attendee>Roman Yurchak</attendee>
            
            <attendee>Nicholas Tollervey</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MQRJXF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MQRJXF</pentabarf:event-slug>
            <pentabarf:title>WASM Summit</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T153000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>013000</duration>
            <summary>WASM Summit</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Conference Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/MQRJXF/</url>
            <location>Club C</location>
            
            <attendee>Roman Yurchak</attendee>
            
            <attendee>Nicholas Tollervey</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>P77JBK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-P77JBK</pentabarf:event-slug>
            <pentabarf:title>Trans*Code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T093000</dtstart>
            <dtend>20230718T110000</dtend>
            <duration>013000</duration>
            <summary>Trans*Code</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
            <location>Club D</location>
            
            <attendee>Naomi Ceder</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>P77JBK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-P77JBK</pentabarf:event-slug>
            <pentabarf:title>Trans*Code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T111500</dtstart>
            <dtend>20230718T124500</dtend>
            <duration>013000</duration>
            <summary>Trans*Code</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
            <location>Club D</location>
            
            <attendee>Naomi Ceder</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>P77JBK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-P77JBK</pentabarf:event-slug>
            <pentabarf:title>Trans*Code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T134500</dtstart>
            <dtend>20230718T151500</dtend>
            <duration>013000</duration>
            <summary>Trans*Code</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
            <location>Club D</location>
            
            <attendee>Naomi Ceder</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>P77JBK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-P77JBK</pentabarf:event-slug>
            <pentabarf:title>Trans*Code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T153000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>013000</duration>
            <summary>Trans*Code</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Free Workshop</category>
            <url>https://programme.europython.eu/europython-2023/talk/P77JBK/</url>
            <location>Club D</location>
            
            <attendee>Naomi Ceder</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GRDPPX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GRDPPX</pentabarf:event-slug>
            <pentabarf:title>Beginner Conference Orientation</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230718T161000</dtstart>
            <dtend>20230718T170000</dtend>
            <duration>005000</duration>
            <summary>Beginner Conference Orientation</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/GRDPPX/</url>
            <location>Club D</location>
            
            <attendee>Cheuk Ting Ho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZPN8UC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZPN8UC</pentabarf:event-slug>
            <pentabarf:title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T080000</dtstart>
            <dtend>20230719T090000</dtend>
            <duration>010000</duration>
            <summary>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZPN8UC/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QUQSZH@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QUQSZH</pentabarf:event-slug>
            <pentabarf:title>Opening Session</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T090000</dtstart>
            <dtend>20230719T093000</dtend>
            <duration>003000</duration>
            <summary>Opening Session</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/QUQSZH/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>C7SMXT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-C7SMXT</pentabarf:event-slug>
            <pentabarf:title>Kindnesses &amp; Promises</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T093000</dtstart>
            <dtend>20230719T101500</dtend>
            <duration>004500</duration>
            <summary>Kindnesses &amp; Promises</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://programme.europython.eu/europython-2023/talk/C7SMXT/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Petr Viktorin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>C3GDXY@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-C3GDXY</pentabarf:event-slug>
            <pentabarf:title>How we are making CPython faster. Past, present and future</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T104500</dtstart>
            <dtend>20230719T111500</dtend>
            <duration>003000</duration>
            <summary>How we are making CPython faster. Past, present and future</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/C3GDXY/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Mark Shannon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BCDBBR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BCDBBR</pentabarf:event-slug>
            <pentabarf:title>f&quot;yeah!&quot; - How we are supercharging f-strings in Python 3.12</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T113500</dtstart>
            <dtend>20230719T120500</dtend>
            <duration>003000</duration>
            <summary>f&quot;yeah!&quot; - How we are supercharging f-strings in Python 3.12</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BCDBBR/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Pablo Galindo Salgado</attendee>
            
            <attendee>Marta Gomez</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NVW8EF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NVW8EF</pentabarf:event-slug>
            <pentabarf:title>HPy: The Future of Python Native Extensions</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T121000</dtstart>
            <dtend>20230719T124000</dtend>
            <duration>003000</duration>
            <summary>HPy: The Future of Python Native Extensions</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/NVW8EF/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>&#352;t&#283;p&#225;n &#352;indel&#225;&#345;</attendee>
            
            <attendee>Florian Angerer</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AAJLRW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AAJLRW</pentabarf:event-slug>
            <pentabarf:title>CPython Core Developer Panel</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T140000</dtstart>
            <dtend>20230719T150000</dtend>
            <duration>010000</duration>
            <summary>CPython Core Developer Panel</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Panel</category>
            <url>https://programme.europython.eu/europython-2023/talk/AAJLRW/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>&#321;ukasz Langa</attendee>
            
            <attendee>Petr Viktorin</attendee>
            
            <attendee>Pablo Galindo Salgado</attendee>
            
            <attendee>Mark Shannon</attendee>
            
            <attendee>Steve Dower</attendee>
            
            <attendee>Marta Gomez</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9GJFZZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9GJFZZ</pentabarf:event-slug>
            <pentabarf:title>Dynamically generated methods with a non-generic signature</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T153000</dtstart>
            <dtend>20230719T160000</dtend>
            <duration>003000</duration>
            <summary>Dynamically generated methods with a non-generic signature</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/9GJFZZ/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Adrin Jalali</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XW8RB3@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XW8RB3</pentabarf:event-slug>
            <pentabarf:title>Writing a Python interpreter from scratch, in half an hour.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T160500</dtstart>
            <dtend>20230719T165000</dtend>
            <duration>004500</duration>
            <summary>Writing a Python interpreter from scratch, in half an hour.</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/XW8RB3/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Tushar Sadhwani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LJZBKW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LJZBKW</pentabarf:event-slug>
            <pentabarf:title>Large Language Models: From Prototype to Production</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T170000</dtstart>
            <dtend>20230719T174500</dtend>
            <duration>004500</duration>
            <summary>Large Language Models: From Prototype to Production</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://programme.europython.eu/europython-2023/talk/LJZBKW/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Ines Montani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>938SAD@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-938SAD</pentabarf:event-slug>
            <pentabarf:title>Lightning Talks Wednesday</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T175000</dtstart>
            <dtend>20230719T183500</dtend>
            <duration>004500</duration>
            <summary>Lightning Talks Wednesday</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/938SAD/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UVUXFQ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UVUXFQ</pentabarf:event-slug>
            <pentabarf:title>Adding zero-downtime migrations strategy in a SaaS project</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T104500</dtstart>
            <dtend>20230719T111500</dtend>
            <duration>003000</duration>
            <summary>Adding zero-downtime migrations strategy in a SaaS project</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/UVUXFQ/</url>
            <location>South Hall 2A</location>
            
            <attendee>Iga Karbowiak</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PMNVR3@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PMNVR3</pentabarf:event-slug>
            <pentabarf:title>A quick guide to logging for Django developers</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T113500</dtstart>
            <dtend>20230719T120500</dtend>
            <duration>003000</duration>
            <summary>A quick guide to logging for Django developers</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/PMNVR3/</url>
            <location>South Hall 2A</location>
            
            <attendee>Ivaylo Donchev</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VPWTYU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VPWTYU</pentabarf:event-slug>
            <pentabarf:title>Stop using print! Understanding and using the &quot;logging&quot; module</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T121000</dtstart>
            <dtend>20230719T124000</dtend>
            <duration>003000</duration>
            <summary>Stop using print! Understanding and using the &quot;logging&quot; module</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/VPWTYU/</url>
            <location>South Hall 2A</location>
            
            <attendee>Reuven M. Lerner</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CUEWG8@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CUEWG8</pentabarf:event-slug>
            <pentabarf:title>Pydantic: Making life easier with data validation</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T140000</dtstart>
            <dtend>20230719T143000</dtend>
            <duration>003000</duration>
            <summary>Pydantic: Making life easier with data validation</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/CUEWG8/</url>
            <location>South Hall 2A</location>
            
            <attendee>Bojan Miletic</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MEXBJ7@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MEXBJ7</pentabarf:event-slug>
            <pentabarf:title>CLI application development made easier with typer</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T143500</dtstart>
            <dtend>20230719T150500</dtend>
            <duration>003000</duration>
            <summary>CLI application development made easier with typer</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/MEXBJ7/</url>
            <location>South Hall 2A</location>
            
            <attendee>Vin&#237;cius Gubiani Ferreira</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NLZZBQ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NLZZBQ</pentabarf:event-slug>
            <pentabarf:title>Polars vs Pandas - what&apos;s the difference?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T153000</dtstart>
            <dtend>20230719T160000</dtend>
            <duration>003000</duration>
            <summary>Polars vs Pandas - what&apos;s the difference?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/NLZZBQ/</url>
            <location>South Hall 2A</location>
            
            <attendee>Cheuk Ting Ho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EATNFR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EATNFR</pentabarf:event-slug>
            <pentabarf:title>The State of Production Machine Learning in 2023</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T160500</dtstart>
            <dtend>20230719T165000</dtend>
            <duration>004500</duration>
            <summary>The State of Production Machine Learning in 2023</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/EATNFR/</url>
            <location>South Hall 2A</location>
            
            <attendee>Alejandro Saucedo</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>D88LXE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-D88LXE</pentabarf:event-slug>
            <pentabarf:title>Building native Rust modules for Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T104500</dtstart>
            <dtend>20230719T111500</dtend>
            <duration>003000</duration>
            <summary>Building native Rust modules for Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/D88LXE/</url>
            <location>South Hall 2B</location>
            
            <attendee>Arthur Pastel</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>H3TBAP@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-H3TBAP</pentabarf:event-slug>
            <pentabarf:title>Rust for Python data engineers</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T113500</dtstart>
            <dtend>20230719T120500</dtend>
            <duration>003000</duration>
            <summary>Rust for Python data engineers</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/H3TBAP/</url>
            <location>South Hall 2B</location>
            
            <attendee>Karim Jedda</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AXWQBB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AXWQBB</pentabarf:event-slug>
            <pentabarf:title>Would Rust make you a better Pythonista?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T121000</dtstart>
            <dtend>20230719T125500</dtend>
            <duration>004500</duration>
            <summary>Would Rust make you a better Pythonista?</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/AXWQBB/</url>
            <location>South Hall 2B</location>
            
            <attendee>Alexys Jacob</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DQBDJE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DQBDJE</pentabarf:event-slug>
            <pentabarf:title>Continue Thinking Small: Next level machine learning with TinyML</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T140000</dtstart>
            <dtend>20230719T143000</dtend>
            <duration>003000</duration>
            <summary>Continue Thinking Small: Next level machine learning with TinyML</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/DQBDJE/</url>
            <location>South Hall 2B</location>
            
            <attendee>Maria Jose Molina Contreras</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NZ8J7S@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NZ8J7S</pentabarf:event-slug>
            <pentabarf:title>Async Robots</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T143500</dtstart>
            <dtend>20230719T150500</dtend>
            <duration>003000</duration>
            <summary>Async Robots</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/NZ8J7S/</url>
            <location>South Hall 2B</location>
            
            <attendee>Radomir Dopieralski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>T3JFHR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-T3JFHR</pentabarf:event-slug>
            <pentabarf:title>Bulletproof Python &#8211; Writing fewer tests with a typed code base</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T153000</dtstart>
            <dtend>20230719T160000</dtend>
            <duration>003000</duration>
            <summary>Bulletproof Python &#8211; Writing fewer tests with a typed code base</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/T3JFHR/</url>
            <location>South Hall 2B</location>
            
            <attendee>Michael Seifert</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FNLQH7@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FNLQH7</pentabarf:event-slug>
            <pentabarf:title>BDD - how to make it work?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T160500</dtstart>
            <dtend>20230719T165000</dtend>
            <duration>004500</duration>
            <summary>BDD - how to make it work?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/FNLQH7/</url>
            <location>South Hall 2B</location>
            
            <attendee>Sebastian Buczy&#324;ski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HSPJMX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HSPJMX</pentabarf:event-slug>
            <pentabarf:title>Apache Arrow and Substrait, the secret foundations of Data Engineering</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T104500</dtstart>
            <dtend>20230719T113000</dtend>
            <duration>004500</duration>
            <summary>Apache Arrow and Substrait, the secret foundations of Data Engineering</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/HSPJMX/</url>
            <location>North Hall</location>
            
            <attendee>Alessandro Molina</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RAXZVW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RAXZVW</pentabarf:event-slug>
            <pentabarf:title>Temporal Python &#8211; A Durable, Distributed Asyncio Event Loop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T113500</dtstart>
            <dtend>20230719T120500</dtend>
            <duration>003000</duration>
            <summary>Temporal Python &#8211; A Durable, Distributed Asyncio Event Loop</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/RAXZVW/</url>
            <location>North Hall</location>
            
            <attendee>Maxim Fateev</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EWHVWK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EWHVWK</pentabarf:event-slug>
            <pentabarf:title>Apache Spark vs cloud-native SQL engines</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T121000</dtstart>
            <dtend>20230719T124000</dtend>
            <duration>003000</duration>
            <summary>Apache Spark vs cloud-native SQL engines</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/EWHVWK/</url>
            <location>North Hall</location>
            
            <attendee>Franz W&#246;llert</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3AD79Q@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3AD79Q</pentabarf:event-slug>
            <pentabarf:title>Serverless billion-scale vector search for AI applications</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T140000</dtstart>
            <dtend>20230719T143000</dtend>
            <duration>003000</duration>
            <summary>Serverless billion-scale vector search for AI applications</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/3AD79Q/</url>
            <location>North Hall</location>
            
            <attendee>Chang She</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BBZVUP@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BBZVUP</pentabarf:event-slug>
            <pentabarf:title>The needle and the haystack: visualizing single datapoints out of billions</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T143500</dtstart>
            <dtend>20230719T150500</dtend>
            <duration>003000</duration>
            <summary>The needle and the haystack: visualizing single datapoints out of billions</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BBZVUP/</url>
            <location>North Hall</location>
            
            <attendee>Jean-Luc Stevens</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AG7JR9@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AG7JR9</pentabarf:event-slug>
            <pentabarf:title>From Algorithms to Agendas: A Beginner&apos;s Guide to Integer Programming</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T153000</dtstart>
            <dtend>20230719T160000</dtend>
            <duration>003000</duration>
            <summary>From Algorithms to Agendas: A Beginner&apos;s Guide to Integer Programming</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/AG7JR9/</url>
            <location>North Hall</location>
            
            <attendee>Florian Wilhelm</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3Y3BJN@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3Y3BJN</pentabarf:event-slug>
            <pentabarf:title>Solving Multi-Objective Constrained Optimisation Problems using Pymoo</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T160500</dtstart>
            <dtend>20230719T163500</dtend>
            <duration>003000</duration>
            <summary>Solving Multi-Objective Constrained Optimisation Problems using Pymoo</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/3Y3BJN/</url>
            <location>North Hall</location>
            
            <attendee>Pranjal Biyani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HMJU9J@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HMJU9J</pentabarf:event-slug>
            <pentabarf:title>An unbiased evaluation of environment management and packaging tools</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T104500</dtstart>
            <dtend>20230719T113000</dtend>
            <duration>004500</duration>
            <summary>An unbiased evaluation of environment management and packaging tools</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/HMJU9J/</url>
            <location>Terrace 2A</location>
            
            <attendee>Anna-Lena Popkes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LLHGKF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LLHGKF</pentabarf:event-slug>
            <pentabarf:title>The Python package repository accelerating software development at CERN</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T113500</dtstart>
            <dtend>20230719T120500</dtend>
            <duration>003000</duration>
            <summary>The Python package repository accelerating software development at CERN</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/LLHGKF/</url>
            <location>Terrace 2A</location>
            
            <attendee>Phil Elson</attendee>
            
            <attendee>Ivan Sinkarenko</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RRJAZA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RRJAZA</pentabarf:event-slug>
            <pentabarf:title>From Jupyter Notebooks to a Python Package: The Best of Both Worlds</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T121000</dtstart>
            <dtend>20230719T124000</dtend>
            <duration>003000</duration>
            <summary>From Jupyter Notebooks to a Python Package: The Best of Both Worlds</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/RRJAZA/</url>
            <location>Terrace 2A</location>
            
            <attendee>Sin-seok SEO</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WAZGKA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WAZGKA</pentabarf:event-slug>
            <pentabarf:title>From Dataset to Features: A Python-Based Evolutionary Approach</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T130000</dtstart>
            <dtend>20230719T140000</dtend>
            <duration>010000</duration>
            <summary>From Dataset to Features: A Python-Based Evolutionary Approach</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Poster</category>
            <url>https://programme.europython.eu/europython-2023/talk/WAZGKA/</url>
            <location>Terrace 2A</location>
            
            <attendee>Neeraj Pandey</attendee>
            
            <attendee>Hitesh Khandelwal</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VATHTK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VATHTK</pentabarf:event-slug>
            <pentabarf:title>Lessons from Prague</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T140000</dtstart>
            <dtend>20230719T143000</dtend>
            <duration>003000</duration>
            <summary>Lessons from Prague</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/VATHTK/</url>
            <location>Terrace 2A</location>
            
            <attendee>Daniele Procida</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RQCYKG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RQCYKG</pentabarf:event-slug>
            <pentabarf:title>Spiral Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T143500</dtstart>
            <dtend>20230719T150500</dtend>
            <duration>003000</duration>
            <summary>Spiral Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/RQCYKG/</url>
            <location>Terrace 2A</location>
            
            <attendee>Jan Kroon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JHY3ZK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JHY3ZK</pentabarf:event-slug>
            <pentabarf:title>Using NLP to Detect Knots in Protein Structures</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T153000</dtstart>
            <dtend>20230719T160000</dtend>
            <duration>003000</duration>
            <summary>Using NLP to Detect Knots in Protein Structures</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/JHY3ZK/</url>
            <location>Terrace 2A</location>
            
            <attendee>Eva Klimentov&#225;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VCNMWZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VCNMWZ</pentabarf:event-slug>
            <pentabarf:title>Robot Holmes and The MLington Murder Mysteries</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T160500</dtstart>
            <dtend>20230719T165000</dtend>
            <duration>004500</duration>
            <summary>Robot Holmes and The MLington Murder Mysteries</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/VCNMWZ/</url>
            <location>Terrace 2A</location>
            
            <attendee>Johannes Kolbe</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FFTHXB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FFTHXB</pentabarf:event-slug>
            <pentabarf:title>Python Linters at Scale</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T104500</dtstart>
            <dtend>20230719T111500</dtend>
            <duration>003000</duration>
            <summary>Python Linters at Scale</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/FFTHXB/</url>
            <location>Terrace 2B</location>
            
            <attendee>Jimmy Lai</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PNVM3S@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PNVM3S</pentabarf:event-slug>
            <pentabarf:title>Optimizing Your CI Pipelines</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T113500</dtstart>
            <dtend>20230719T120500</dtend>
            <duration>003000</duration>
            <summary>Optimizing Your CI Pipelines</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/PNVM3S/</url>
            <location>Terrace 2B</location>
            
            <attendee>Sebastian Witowski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>F3KLX7@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-F3KLX7</pentabarf:event-slug>
            <pentabarf:title>Zero downtime deployments: Is it worth the effort?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T121000</dtstart>
            <dtend>20230719T124000</dtend>
            <duration>003000</duration>
            <summary>Zero downtime deployments: Is it worth the effort?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/F3KLX7/</url>
            <location>Terrace 2B</location>
            
            <attendee>Rafa&#322; Nowicki</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YRM7GF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YRM7GF</pentabarf:event-slug>
            <pentabarf:title>Serve notebook as a Web App with Mercury framework</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T130000</dtstart>
            <dtend>20230719T140000</dtend>
            <duration>010000</duration>
            <summary>Serve notebook as a Web App with Mercury framework</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Poster</category>
            <url>https://programme.europython.eu/europython-2023/talk/YRM7GF/</url>
            <location>Terrace 2B</location>
            
            <attendee>Aleksandra Plonska</attendee>
            
            <attendee>Piotr P&#322;o&#324;ski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YPKPWV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YPKPWV</pentabarf:event-slug>
            <pentabarf:title>The Power of Spec-Based Testing:Adding Functional Requirements to Unit Test</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T140000</dtstart>
            <dtend>20230719T143000</dtend>
            <duration>003000</duration>
            <summary>The Power of Spec-Based Testing:Adding Functional Requirements to Unit Test</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/YPKPWV/</url>
            <location>Terrace 2B</location>
            
            <attendee>Anupama Tiruvaipati</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>M93HCV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-M93HCV</pentabarf:event-slug>
            <pentabarf:title>Q&amp;A panel for data science newbies</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T143500</dtstart>
            <dtend>20230719T150500</dtend>
            <duration>003000</duration>
            <summary>Q&amp;A panel for data science newbies</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/M93HCV/</url>
            <location>Terrace 2B</location>
            
            <attendee>Cheuk Ting Ho</attendee>
            
            <attendee>Vaibhav Srivastav</attendee>
            
            <attendee>Jodie Burchell</attendee>
            
            <attendee>Valerio Maggio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LQZ7BP@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LQZ7BP</pentabarf:event-slug>
            <pentabarf:title>Interactive, animated reports and dashboards in Streamlit with ipyvizzu.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T153000</dtstart>
            <dtend>20230719T160000</dtend>
            <duration>003000</duration>
            <summary>Interactive, animated reports and dashboards in Streamlit with ipyvizzu.</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/LQZ7BP/</url>
            <location>Terrace 2B</location>
            
            <attendee>Peter Vidos</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BXZD9Z@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BXZD9Z</pentabarf:event-slug>
            <pentabarf:title>DuckDB: Bringing analytical SQL directly to your Python shell</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230719T160500</dtstart>
            <dtend>20230719T165000</dtend>
            <duration>004500</duration>
            <summary>DuckDB: Bringing analytical SQL directly to your Python shell</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BXZD9Z/</url>
            <location>Terrace 2B</location>
            
            <attendee>Pedro Holanda</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XPARN3@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XPARN3</pentabarf:event-slug>
            <pentabarf:title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T080000</dtstart>
            <dtend>20230720T090000</dtend>
            <duration>010000</duration>
            <summary>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/XPARN3/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CHSAUC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CHSAUC</pentabarf:event-slug>
            <pentabarf:title>Morning Announcement</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T090000</dtstart>
            <dtend>20230720T091500</dtend>
            <duration>001500</duration>
            <summary>Morning Announcement</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/CHSAUC/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZJRTGW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZJRTGW</pentabarf:event-slug>
            <pentabarf:title>The Future of Microprocessors</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T091500</dtstart>
            <dtend>20230720T100000</dtend>
            <duration>004500</duration>
            <summary>The Future of Microprocessors</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZJRTGW/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Sophie Wilson</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZUSHKU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZUSHKU</pentabarf:event-slug>
            <pentabarf:title>PyScript and the magic of Python in the browser</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T111500</dtend>
            <duration>004500</duration>
            <summary>PyScript and the magic of Python in the browser</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZUSHKU/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Nicholas Tollervey</attendee>
            
            <attendee>Fabio Pliger</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XLLSWL@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XLLSWL</pentabarf:event-slug>
            <pentabarf:title>Running Python packages in the browser with Pyodide</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T112000</dtstart>
            <dtend>20230720T115000</dtend>
            <duration>003000</duration>
            <summary>Running Python packages in the browser with Pyodide</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/XLLSWL/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Roman Yurchak</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HL8XCC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HL8XCC</pentabarf:event-slug>
            <pentabarf:title>The CPU in your browser: WebAssembly demystified</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T115500</dtstart>
            <dtend>20230720T122500</dtend>
            <duration>003000</duration>
            <summary>The CPU in your browser: WebAssembly demystified</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/HL8XCC/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Antonio Cuni</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>B7WYKQ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-B7WYKQ</pentabarf:event-slug>
            <pentabarf:title>Packaging Python Apps with Briefcase</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T123000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>003000</duration>
            <summary>Packaging Python Apps with Briefcase</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/B7WYKQ/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Russell Keith-Magee</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>F9UBUW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-F9UBUW</pentabarf:event-slug>
            <pentabarf:title>Cyber Resilience Act Panel</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T140000</dtstart>
            <dtend>20230720T150000</dtend>
            <duration>010000</duration>
            <summary>Cyber Resilience Act Panel</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Panel</category>
            <url>https://programme.europython.eu/europython-2023/talk/F9UBUW/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CRPQGK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CRPQGK</pentabarf:event-slug>
            <pentabarf:title>Music information retrieval with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T160000</dtend>
            <duration>003000</duration>
            <summary>Music information retrieval with Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/CRPQGK/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Mateusz Modrzejewski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KYAWCJ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KYAWCJ</pentabarf:event-slug>
            <pentabarf:title>Games of Life: generative art in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T160500</dtstart>
            <dtend>20230720T165000</dtend>
            <duration>004500</duration>
            <summary>Games of Life: generative art in Python</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/KYAWCJ/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>&#321;ukasz Langa</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RMHLRA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RMHLRA</pentabarf:event-slug>
            <pentabarf:title>Welcome to Your World</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T165500</dtstart>
            <dtend>20230720T174000</dtend>
            <duration>004500</duration>
            <summary>Welcome to Your World</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://programme.europython.eu/europython-2023/talk/RMHLRA/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Andrew Smith</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YWGAUU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YWGAUU</pentabarf:event-slug>
            <pentabarf:title>Lightning Talks Thursday</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T174500</dtstart>
            <dtend>20230720T183000</dtend>
            <duration>004500</duration>
            <summary>Lightning Talks Thursday</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/YWGAUU/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SDEUCB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SDEUCB</pentabarf:event-slug>
            <pentabarf:title>Poisoned pickles make you ill</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T110000</dtend>
            <duration>003000</duration>
            <summary>Poisoned pickles make you ill</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/SDEUCB/</url>
            <location>South Hall 2A</location>
            
            <attendee>Adrian Gonzalez-Martin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>B3MU99@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-B3MU99</pentabarf:event-slug>
            <pentabarf:title>Unlocking the Power of What-If Analysis for BI, Data, and AI with Taipy</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T112000</dtstart>
            <dtend>20230720T115000</dtend>
            <duration>003000</duration>
            <summary>Unlocking the Power of What-If Analysis for BI, Data, and AI with Taipy</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/B3MU99/</url>
            <location>South Hall 2A</location>
            
            <attendee>Jean-Baptiste Braun</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZPH9PC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZPH9PC</pentabarf:event-slug>
            <pentabarf:title>High Volume PDF Text Extraction using Python Open-Source Tools</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T115500</dtstart>
            <dtend>20230720T122500</dtend>
            <duration>003000</duration>
            <summary>High Volume PDF Text Extraction using Python Open-Source Tools</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZPH9PC/</url>
            <location>South Hall 2A</location>
            
            <attendee>Harald Lieder</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>D9HP7Z@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-D9HP7Z</pentabarf:event-slug>
            <pentabarf:title>How dunder methods rule Python under the hood</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T123000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>003000</duration>
            <summary>How dunder methods rule Python under the hood</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/D9HP7Z/</url>
            <location>South Hall 2A</location>
            
            <attendee>Rodrigo Gir&#227;o Serr&#227;o</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XEQPYB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XEQPYB</pentabarf:event-slug>
            <pentabarf:title>pip install malware</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T140000</dtstart>
            <dtend>20230720T143000</dtend>
            <duration>003000</duration>
            <summary>pip install malware</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/XEQPYB/</url>
            <location>South Hall 2A</location>
            
            <attendee>Max Kahan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ETSMPK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ETSMPK</pentabarf:event-slug>
            <pentabarf:title>PEP 458 a solution not only for PyPI</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T143500</dtstart>
            <dtend>20230720T150500</dtend>
            <duration>003000</duration>
            <summary>PEP 458 a solution not only for PyPI</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/ETSMPK/</url>
            <location>South Hall 2A</location>
            
            <attendee>Kairo de Araujo</attendee>
            
            <attendee>Martin Vrachev</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BHXSQU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BHXSQU</pentabarf:event-slug>
            <pentabarf:title>Don&#8217;t Panic! A Developer&#8217;s Guide to Security</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T160000</dtend>
            <duration>003000</duration>
            <summary>Don&#8217;t Panic! A Developer&#8217;s Guide to Security</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BHXSQU/</url>
            <location>South Hall 2A</location>
            
            <attendee>Sebastiaan Zeeff</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XYLWJH@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XYLWJH</pentabarf:event-slug>
            <pentabarf:title>Sponsor Highlight &amp; Recruitment Fair</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T160500</dtstart>
            <dtend>20230720T165000</dtend>
            <duration>004500</duration>
            <summary>Sponsor Highlight &amp; Recruitment Fair</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/XYLWJH/</url>
            <location>South Hall 2A</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZCXMQK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZCXMQK</pentabarf:event-slug>
            <pentabarf:title>Understanding Neural Network Architectures with Attention and Diffusion</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T110000</dtend>
            <duration>003000</duration>
            <summary>Understanding Neural Network Architectures with Attention and Diffusion</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZCXMQK/</url>
            <location>South Hall 2B</location>
            
            <attendee>Micha&#322; Karzy&#324;ski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RGRQVQ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RGRQVQ</pentabarf:event-slug>
            <pentabarf:title>Story Generation using Stable Diffusion in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T112000</dtstart>
            <dtend>20230720T115000</dtend>
            <duration>003000</duration>
            <summary>Story Generation using Stable Diffusion in Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/RGRQVQ/</url>
            <location>South Hall 2B</location>
            
            <attendee>Nilesh Arnaiya</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SG3NQB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SG3NQB</pentabarf:event-slug>
            <pentabarf:title>Word Wranglers &amp; News Navigators: Taming GPT-3 Beast for Media Monitoring</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T115500</dtstart>
            <dtend>20230720T122500</dtend>
            <duration>003000</duration>
            <summary>Word Wranglers &amp; News Navigators: Taming GPT-3 Beast for Media Monitoring</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/SG3NQB/</url>
            <location>South Hall 2B</location>
            
            <attendee>Petr &#352;ime&#269;ek</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YNHRBS@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YNHRBS</pentabarf:event-slug>
            <pentabarf:title>Generative AI: Beyond technicalities &#8211; an ethical perspective</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T123000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>003000</duration>
            <summary>Generative AI: Beyond technicalities &#8211; an ethical perspective</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/YNHRBS/</url>
            <location>South Hall 2B</location>
            
            <attendee>Bhawna Singh</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DT9HXE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DT9HXE</pentabarf:event-slug>
            <pentabarf:title>Solving Data Problems in Management Accounting</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T140000</dtstart>
            <dtend>20230720T143000</dtend>
            <duration>003000</duration>
            <summary>Solving Data Problems in Management Accounting</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/DT9HXE/</url>
            <location>South Hall 2B</location>
            
            <attendee>Alexander CS Hendorf</attendee>
            
            <attendee>Lucas-Raphael M&#252;ller</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XRGTRX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XRGTRX</pentabarf:event-slug>
            <pentabarf:title>Give your program Appeal!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T143500</dtstart>
            <dtend>20230720T150500</dtend>
            <duration>003000</duration>
            <summary>Give your program Appeal!</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/XRGTRX/</url>
            <location>South Hall 2B</location>
            
            <attendee>Larry Hastings</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VHWTVF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VHWTVF</pentabarf:event-slug>
            <pentabarf:title>The Standard Library Tour</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T160000</dtend>
            <duration>003000</duration>
            <summary>The Standard Library Tour</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/VHWTVF/</url>
            <location>South Hall 2B</location>
            
            <attendee>Mia Baji&#263;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZFB73A@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZFB73A</pentabarf:event-slug>
            <pentabarf:title>The coding conventions that makes our lives easier</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T160500</dtstart>
            <dtend>20230720T163500</dtend>
            <duration>003000</duration>
            <summary>The coding conventions that makes our lives easier</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZFB73A/</url>
            <location>South Hall 2B</location>
            
            <attendee>&#199;a&#287;&#305;l Ulu&#351;ahin S&#246;nmez</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WUPCGU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WUPCGU</pentabarf:event-slug>
            <pentabarf:title>Unlocking the Power of Raft Consensus with rqlite using Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T110000</dtend>
            <duration>003000</duration>
            <summary>Unlocking the Power of Raft Consensus with rqlite using Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/WUPCGU/</url>
            <location>North Hall</location>
            
            <attendee>Tanya Sneh</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TYTBKX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TYTBKX</pentabarf:event-slug>
            <pentabarf:title>What polars does for you.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T112000</dtstart>
            <dtend>20230720T115000</dtend>
            <duration>003000</duration>
            <summary>What polars does for you.</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/TYTBKX/</url>
            <location>North Hall</location>
            
            <attendee>Ritchie Vink</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>W8J9MF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-W8J9MF</pentabarf:event-slug>
            <pentabarf:title>Learning the ropes: understanding Python generics</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T115500</dtstart>
            <dtend>20230720T122500</dtend>
            <duration>003000</duration>
            <summary>Learning the ropes: understanding Python generics</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/W8J9MF/</url>
            <location>North Hall</location>
            
            <attendee>David Seddon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8S3VD9@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8S3VD9</pentabarf:event-slug>
            <pentabarf:title>Designing a Human-Friendly CLI for API-Driven Infrastructure</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T123000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>003000</duration>
            <summary>Designing a Human-Friendly CLI for API-Driven Infrastructure</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/8S3VD9/</url>
            <location>North Hall</location>
            
            <attendee>Oliver Rew</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9CUAPR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9CUAPR</pentabarf:event-slug>
            <pentabarf:title>Zero-Copy Zen: Boost Performance with Memory View</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T140000</dtstart>
            <dtend>20230720T143000</dtend>
            <duration>003000</duration>
            <summary>Zero-Copy Zen: Boost Performance with Memory View</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/9CUAPR/</url>
            <location>North Hall</location>
            
            <attendee>Kesia Mary Joies</attendee>
            
            <attendee>Aby M Joseph</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3GWJCA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3GWJCA</pentabarf:event-slug>
            <pentabarf:title>Cultivating a Performance Mindset</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T143500</dtstart>
            <dtend>20230720T150500</dtend>
            <duration>003000</duration>
            <summary>Cultivating a Performance Mindset</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/3GWJCA/</url>
            <location>North Hall</location>
            
            <attendee>Nar Saynorath</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>U3SEG8@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-U3SEG8</pentabarf:event-slug>
            <pentabarf:title>Dive into codebase like a pro</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T160000</dtend>
            <duration>003000</duration>
            <summary>Dive into codebase like a pro</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/U3SEG8/</url>
            <location>North Hall</location>
            
            <attendee>Luka Raljevi&#263;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XYHXYP@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XYHXYP</pentabarf:event-slug>
            <pentabarf:title>From idea to production</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T160500</dtstart>
            <dtend>20230720T165000</dtend>
            <duration>004500</duration>
            <summary>From idea to production</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/XYHXYP/</url>
            <location>North Hall</location>
            
            <attendee>Flavio Percoco</attendee>
            
            <attendee>Honza Kr&#225;l</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7KAKAG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7KAKAG</pentabarf:event-slug>
            <pentabarf:title>Python on Arm architecture</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T111500</dtend>
            <duration>004500</duration>
            <summary>Python on Arm architecture</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/7KAKAG/</url>
            <location>Terrace 2A</location>
            
            <attendee>Diego Russo</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>S3LKMH@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-S3LKMH</pentabarf:event-slug>
            <pentabarf:title>Instrumenting CPython with eBPF</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T112000</dtstart>
            <dtend>20230720T115000</dtend>
            <duration>003000</duration>
            <summary>Instrumenting CPython with eBPF</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/S3LKMH/</url>
            <location>Terrace 2A</location>
            
            <attendee>Furkan Taha &#214;NDER</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TN3EXR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TN3EXR</pentabarf:event-slug>
            <pentabarf:title>Python, Visual Studio Code, Copilot - Revolutionizing the way you do data science</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T115500</dtstart>
            <dtend>20230720T122500</dtend>
            <duration>003000</duration>
            <summary>Python, Visual Studio Code, Copilot - Revolutionizing the way you do data science</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/TN3EXR/</url>
            <location>Terrace 2A</location>
            
            <attendee>Steve Dower</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FRZHZG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FRZHZG</pentabarf:event-slug>
            <pentabarf:title>Quantify Self</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T123000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>003000</duration>
            <summary>Quantify Self</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/FRZHZG/</url>
            <location>Terrace 2A</location>
            
            <attendee>Alisa Dammer</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SWSLHC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SWSLHC</pentabarf:event-slug>
            <pentabarf:title>You DON&apos;T know comprehensions &#129335;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T130000</dtstart>
            <dtend>20230720T140000</dtend>
            <duration>010000</duration>
            <summary>You DON&apos;T know comprehensions &#129335;</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Poster</category>
            <url>https://programme.europython.eu/europython-2023/talk/SWSLHC/</url>
            <location>Terrace 2A</location>
            
            <attendee>Rodrigo Gir&#227;o Serr&#227;o</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JHSMMJ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JHSMMJ</pentabarf:event-slug>
            <pentabarf:title>The challenges of doing Infra-As-Code without &quot;the cloud&quot;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T140000</dtstart>
            <dtend>20230720T143000</dtend>
            <duration>003000</duration>
            <summary>The challenges of doing Infra-As-Code without &quot;the cloud&quot;</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/JHSMMJ/</url>
            <location>Terrace 2A</location>
            
            <attendee>Nicolas Demarchi</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KT8QPL@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KT8QPL</pentabarf:event-slug>
            <pentabarf:title>Vector data cubes as a bridge between raster and vector worlds</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T143500</dtstart>
            <dtend>20230720T150500</dtend>
            <duration>003000</duration>
            <summary>Vector data cubes as a bridge between raster and vector worlds</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/KT8QPL/</url>
            <location>Terrace 2A</location>
            
            <attendee>Martin Fleischmann</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3MDSQN@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3MDSQN</pentabarf:event-slug>
            <pentabarf:title>Private Data Anonymization with Python, Fundamentals</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T160000</dtend>
            <duration>003000</duration>
            <summary>Private Data Anonymization with Python, Fundamentals</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/3MDSQN/</url>
            <location>Terrace 2A</location>
            
            <attendee>Abel Meneses Abad</attendee>
            
            <attendee>Oscar L. Garcell</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HUC9XE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HUC9XE</pentabarf:event-slug>
            <pentabarf:title>Unlocking Healthcare data: the power of Open Formats in Python Data Science</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T160500</dtstart>
            <dtend>20230720T165000</dtend>
            <duration>004500</duration>
            <summary>Unlocking Healthcare data: the power of Open Formats in Python Data Science</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/HUC9XE/</url>
            <location>Terrace 2A</location>
            
            <attendee>Stefano Cotta Ramusino</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>U9SNQ7@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-U9SNQ7</pentabarf:event-slug>
            <pentabarf:title>How to land your new Python Developer job: a Recruiter&apos;s perspective</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T110000</dtend>
            <duration>003000</duration>
            <summary>How to land your new Python Developer job: a Recruiter&apos;s perspective</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/U9SNQ7/</url>
            <location>Terrace 2B</location>
            
            <attendee>Giordano Tuvo</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BMYYTX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BMYYTX</pentabarf:event-slug>
            <pentabarf:title>Career Building Through Open Source &amp; Community Participation</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T112000</dtstart>
            <dtend>20230720T115000</dtend>
            <duration>003000</duration>
            <summary>Career Building Through Open Source &amp; Community Participation</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BMYYTX/</url>
            <location>Terrace 2B</location>
            
            <attendee>Omotola Eunice Omotayo</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EAPRY9@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EAPRY9</pentabarf:event-slug>
            <pentabarf:title>Breaking the Stereotype: Evolution &amp; Persistence of Gender Bias in Tech</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T115500</dtstart>
            <dtend>20230720T122500</dtend>
            <duration>003000</duration>
            <summary>Breaking the Stereotype: Evolution &amp; Persistence of Gender Bias in Tech</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/EAPRY9/</url>
            <location>Terrace 2B</location>
            
            <attendee>Ester Beltrami</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>S8H88E@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-S8H88E</pentabarf:event-slug>
            <pentabarf:title>All about djangoproject.com</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T123000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>003000</duration>
            <summary>All about djangoproject.com</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/S8H88E/</url>
            <location>Terrace 2B</location>
            
            <attendee>Paolo Melchiorre</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QRBSUK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QRBSUK</pentabarf:event-slug>
            <pentabarf:title>What are you yield from?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T130000</dtstart>
            <dtend>20230720T140000</dtend>
            <duration>010000</duration>
            <summary>What are you yield from?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Poster</category>
            <url>https://programme.europython.eu/europython-2023/talk/QRBSUK/</url>
            <location>Terrace 2B</location>
            
            <attendee>Maxim Danilov</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NYMGMF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NYMGMF</pentabarf:event-slug>
            <pentabarf:title>A Magic Implementation of NotImplemented</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T140000</dtstart>
            <dtend>20230720T143000</dtend>
            <duration>003000</duration>
            <summary>A Magic Implementation of NotImplemented</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/NYMGMF/</url>
            <location>Terrace 2B</location>
            
            <attendee>Alexander Darby</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RAVZM9@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RAVZM9</pentabarf:event-slug>
            <pentabarf:title>How well do we understand our Universe? Let&#8217;s Python it out!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T143500</dtstart>
            <dtend>20230720T150500</dtend>
            <duration>003000</duration>
            <summary>How well do we understand our Universe? Let&#8217;s Python it out!</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/RAVZM9/</url>
            <location>Terrace 2B</location>
            
            <attendee>Eirini Angeloudi</attendee>
            
            <attendee>Regina Sarmiento</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PKCL9Z@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PKCL9Z</pentabarf:event-slug>
            <pentabarf:title>Whisper AI: Live English Subtitles for 96 Languages</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T160000</dtend>
            <duration>003000</duration>
            <summary>Whisper AI: Live English Subtitles for 96 Languages</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/PKCL9Z/</url>
            <location>Terrace 2B</location>
            
            <attendee>Mathias Arens</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PQHEAS@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PQHEAS</pentabarf:event-slug>
            <pentabarf:title>Responding to Earthquakes using Machine Learning and Racing through Time</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T160500</dtstart>
            <dtend>20230720T163500</dtend>
            <duration>003000</duration>
            <summary>Responding to Earthquakes using Machine Learning and Racing through Time</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/PQHEAS/</url>
            <location>Terrace 2B</location>
            
            <attendee>Merve Noyan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UD3GZD@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UD3GZD</pentabarf:event-slug>
            <pentabarf:title>Reserved for EPS/PSF/PYO Session</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T103000</dtstart>
            <dtend>20230720T130000</dtend>
            <duration>023000</duration>
            <summary>Reserved for EPS/PSF/PYO Session</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Open Space</category>
            <url>https://programme.europython.eu/europython-2023/talk/UD3GZD/</url>
            <location>Open Space</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>F9UBUW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-F9UBUW</pentabarf:event-slug>
            <pentabarf:title>Cyber Resilience Act Panel</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230720T153000</dtstart>
            <dtend>20230720T163000</dtend>
            <duration>010000</duration>
            <summary>Cyber Resilience Act Panel</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Panel</category>
            <url>https://programme.europython.eu/europython-2023/talk/F9UBUW/</url>
            <location>Open Space</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XACJPR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XACJPR</pentabarf:event-slug>
            <pentabarf:title>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T080000</dtstart>
            <dtend>20230721T090000</dtend>
            <duration>010000</duration>
            <summary>Registration &amp; Welcome @ Forum Hall Foyer 1st Floor</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/XACJPR/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LWWPUS@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LWWPUS</pentabarf:event-slug>
            <pentabarf:title>Morning Announcement</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T090000</dtstart>
            <dtend>20230721T091500</dtend>
            <duration>001500</duration>
            <summary>Morning Announcement</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/LWWPUS/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UNPKDU@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UNPKDU</pentabarf:event-slug>
            <pentabarf:title>DevOps vs AGI</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T091500</dtstart>
            <dtend>20230721T100000</dtend>
            <duration>004500</duration>
            <summary>DevOps vs AGI</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Keynote</category>
            <url>https://programme.europython.eu/europython-2023/talk/UNPKDU/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Joanna Bryson</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DTXYKX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DTXYKX</pentabarf:event-slug>
            <pentabarf:title>Subclassing, Composition, Python, and You</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T111500</dtend>
            <duration>004500</duration>
            <summary>Subclassing, Composition, Python, and You</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/DTXYKX/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Hynek Schlawack</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TKPZSM@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TKPZSM</pentabarf:event-slug>
            <pentabarf:title>Face Off: Brute-force attack on Biometrical-databases</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T112000</dtstart>
            <dtend>20230721T115000</dtend>
            <duration>003000</duration>
            <summary>Face Off: Brute-force attack on Biometrical-databases</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/TKPZSM/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Roy M Mezan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EWBEZZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EWBEZZ</pentabarf:event-slug>
            <pentabarf:title>The Python&apos;s stability promise</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T115500</dtstart>
            <dtend>20230721T122500</dtend>
            <duration>003000</duration>
            <summary>The Python&apos;s stability promise</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/EWBEZZ/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Cristi&#225;n Maureira-Fredes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YZSTKK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YZSTKK</pentabarf:event-slug>
            <pentabarf:title>Introducing Incompatible Changes in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T123000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>003000</duration>
            <summary>Introducing Incompatible Changes in Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/YZSTKK/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Victor Stinner</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>STLLDQ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-STLLDQ</pentabarf:event-slug>
            <pentabarf:title>Python Organizers&apos; Panel: Exploring Community-Driven Python Conferences</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T140000</dtstart>
            <dtend>20230721T150000</dtend>
            <duration>010000</duration>
            <summary>Python Organizers&apos; Panel: Exploring Community-Driven Python Conferences</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Panel</category>
            <url>https://programme.europython.eu/europython-2023/talk/STLLDQ/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Alexander CS Hendorf</attendee>
            
            <attendee>Alessia Marcolini</attendee>
            
            <attendee>Jimena Berm&#250;dez</attendee>
            
            <attendee>B&#225;ra Drbohlavov&#225;</attendee>
            
            <attendee>Honza Javorek</attendee>
            
            <attendee>Tim (&#25991;&#26124;) Hsu</attendee>
            
            <attendee>David Vaz</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GKHPZB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GKHPZB</pentabarf:event-slug>
            <pentabarf:title>Power Django with PyCharm</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T160000</dtend>
            <duration>003000</duration>
            <summary>Power Django with PyCharm</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/GKHPZB/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Paul Everitt</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AYGCLM@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AYGCLM</pentabarf:event-slug>
            <pentabarf:title>Cython 3 &#8211; Python at the speed of C</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T160500</dtstart>
            <dtend>20230721T163500</dtend>
            <duration>003000</duration>
            <summary>Cython 3 &#8211; Python at the speed of C</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/AYGCLM/</url>
            <location>PyCharm (Forum Hall)</location>
            
            <attendee>Stefan Behnel</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>P7CVWV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-P7CVWV</pentabarf:event-slug>
            <pentabarf:title>Lightning Talks Friday</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T164500</dtstart>
            <dtend>20230721T173000</dtend>
            <duration>004500</duration>
            <summary>Lightning Talks Friday</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/P7CVWV/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SURAC3@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SURAC3</pentabarf:event-slug>
            <pentabarf:title>Sprint Orientation</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T173000</dtstart>
            <dtend>20230721T175000</dtend>
            <duration>002000</duration>
            <summary>Sprint Orientation</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/SURAC3/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZUPSUD@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZUPSUD</pentabarf:event-slug>
            <pentabarf:title>Closing Session</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T175000</dtstart>
            <dtend>20230721T182000</dtend>
            <duration>003000</duration>
            <summary>Closing Session</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Announcements</category>
            <url>https://programme.europython.eu/europython-2023/talk/ZUPSUD/</url>
            <location>PyCharm (Forum Hall)</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UAEJZX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UAEJZX</pentabarf:event-slug>
            <pentabarf:title>A Brief History of Data Storage</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T110000</dtend>
            <duration>003000</duration>
            <summary>A Brief History of Data Storage</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/UAEJZX/</url>
            <location>South Hall 2A</location>
            
            <attendee>Eli Holderness</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GY9LZC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GY9LZC</pentabarf:event-slug>
            <pentabarf:title>Ultimative session about hidden gems of Django Admin.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T112000</dtstart>
            <dtend>20230721T115000</dtend>
            <duration>003000</duration>
            <summary>Ultimative session about hidden gems of Django Admin.</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/GY9LZC/</url>
            <location>South Hall 2A</location>
            
            <attendee>Maxim Danilov</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WB8ZWV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WB8ZWV</pentabarf:event-slug>
            <pentabarf:title>Python interoperability: building a Python-first, petabyte-scale database</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T115500</dtstart>
            <dtend>20230721T122500</dtend>
            <duration>003000</duration>
            <summary>Python interoperability: building a Python-first, petabyte-scale database</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/WB8ZWV/</url>
            <location>South Hall 2A</location>
            
            <attendee>William Dealtry</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3XQWYC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3XQWYC</pentabarf:event-slug>
            <pentabarf:title>Hitchhickers Guide to D&amp;D &#128009;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T123000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>003000</duration>
            <summary>Hitchhickers Guide to D&amp;D &#128009;</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/3XQWYC/</url>
            <location>South Hall 2A</location>
            
            <attendee>Valerio Maggio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NYEBMZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NYEBMZ</pentabarf:event-slug>
            <pentabarf:title>What a screen reader can teach you about remote Python debugging</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T140000</dtstart>
            <dtend>20230721T143000</dtend>
            <duration>003000</duration>
            <summary>What a screen reader can teach you about remote Python debugging</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/NYEBMZ/</url>
            <location>South Hall 2A</location>
            
            <attendee>Ram&#243;n Corominas</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DA3GWB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DA3GWB</pentabarf:event-slug>
            <pentabarf:title>GraphQL Subscriptions: Real-time Data with WebSockets* and Strawberry &#127827;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T160000</dtend>
            <duration>003000</duration>
            <summary>GraphQL Subscriptions: Real-time Data with WebSockets* and Strawberry &#127827;</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/DA3GWB/</url>
            <location>South Hall 2A</location>
            
            <attendee>Patrick Arminio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>URF3Z9@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-URF3Z9</pentabarf:event-slug>
            <pentabarf:title>GraphQL as an umbrella for microservices</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T160500</dtstart>
            <dtend>20230721T163500</dtend>
            <duration>003000</duration>
            <summary>GraphQL as an umbrella for microservices</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/URF3Z9/</url>
            <location>South Hall 2A</location>
            
            <attendee>Artur Sm&#281;t</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MD3PX3@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MD3PX3</pentabarf:event-slug>
            <pentabarf:title>Test your data like you test your code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T110000</dtend>
            <duration>003000</duration>
            <summary>Test your data like you test your code</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/MD3PX3/</url>
            <location>South Hall 2B</location>
            
            <attendee>Theodore Meynard</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DQ9RA9@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DQ9RA9</pentabarf:event-slug>
            <pentabarf:title>Too Big for DAG Factories?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T112000</dtstart>
            <dtend>20230721T115000</dtend>
            <duration>003000</duration>
            <summary>Too Big for DAG Factories?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/DQ9RA9/</url>
            <location>South Hall 2B</location>
            
            <attendee>Calvin Hendryx-Parker</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TZLHXN@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TZLHXN</pentabarf:event-slug>
            <pentabarf:title>Orchestrating Python Workflows in Apache Airflow</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T115500</dtstart>
            <dtend>20230721T122500</dtend>
            <duration>003000</duration>
            <summary>Orchestrating Python Workflows in Apache Airflow</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/TZLHXN/</url>
            <location>South Hall 2B</location>
            
            <attendee>Sebastien Crocquevieille</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KFMCSK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KFMCSK</pentabarf:event-slug>
            <pentabarf:title>Scipp: multi-dimensional arrays with labeled dimensions and physical units</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T123000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>003000</duration>
            <summary>Scipp: multi-dimensional arrays with labeled dimensions and physical units</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/KFMCSK/</url>
            <location>South Hall 2B</location>
            
            <attendee>Neil Vaytet</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WNSZ9R@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WNSZ9R</pentabarf:event-slug>
            <pentabarf:title>The digital State of the European Union</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T140000</dtstart>
            <dtend>20230721T143000</dtend>
            <duration>003000</duration>
            <summary>The digital State of the European Union</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/WNSZ9R/</url>
            <location>South Hall 2B</location>
            
            <attendee>Roberto Polli</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BHWTKF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BHWTKF</pentabarf:event-slug>
            <pentabarf:title>How Python can help monitor governments</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T143500</dtstart>
            <dtend>20230721T150500</dtend>
            <duration>003000</duration>
            <summary>How Python can help monitor governments</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BHWTKF/</url>
            <location>South Hall 2B</location>
            
            <attendee>Judite Cypreste</attendee>
            
            <attendee>Patricia Bongiovanni Catandi</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3TUMQT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3TUMQT</pentabarf:event-slug>
            <pentabarf:title>What my 300+ fantastic young students taught me about Python.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T160000</dtend>
            <duration>003000</duration>
            <summary>What my 300+ fantastic young students taught me about Python.</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/3TUMQT/</url>
            <location>South Hall 2B</location>
            
            <attendee>Lilian</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HN3EDM@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HN3EDM</pentabarf:event-slug>
            <pentabarf:title>Teaching Children Python-What Works?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T160500</dtstart>
            <dtend>20230721T163500</dtend>
            <duration>003000</duration>
            <summary>Teaching Children Python-What Works?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/HN3EDM/</url>
            <location>South Hall 2B</location>
            
            <attendee>Mykalin Jones</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>E9QUAW@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-E9QUAW</pentabarf:event-slug>
            <pentabarf:title>Caching in microservices</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T111500</dtend>
            <duration>004500</duration>
            <summary>Caching in microservices</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/E9QUAW/</url>
            <location>North Hall</location>
            
            <attendee>Micha&#322; Lowas-Rzechonek</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MRLACS@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MRLACS</pentabarf:event-slug>
            <pentabarf:title>Designing an HTTP client</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T112000</dtstart>
            <dtend>20230721T115000</dtend>
            <duration>003000</duration>
            <summary>Designing an HTTP client</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/MRLACS/</url>
            <location>North Hall</location>
            
            <attendee>Tom Christie</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VCGQWF@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VCGQWF</pentabarf:event-slug>
            <pentabarf:title>Performance tips by the FastAPI Expert</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T115500</dtstart>
            <dtend>20230721T122500</dtend>
            <duration>003000</duration>
            <summary>Performance tips by the FastAPI Expert</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/VCGQWF/</url>
            <location>North Hall</location>
            
            <attendee>Marcelo Trylesinski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ATGCBX@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ATGCBX</pentabarf:event-slug>
            <pentabarf:title>Fighting Money Laundering with Python and Open Source Software</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T123000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>003000</duration>
            <summary>Fighting Money Laundering with Python and Open Source Software</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/ATGCBX/</url>
            <location>North Hall</location>
            
            <attendee>Gajendra Deshpande</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>N7DVSG@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-N7DVSG</pentabarf:event-slug>
            <pentabarf:title>Working in Units: How to Decouple the Database and Domain Layers in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T140000</dtstart>
            <dtend>20230721T143000</dtend>
            <duration>003000</duration>
            <summary>Working in Units: How to Decouple the Database and Domain Layers in Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/N7DVSG/</url>
            <location>North Hall</location>
            
            <attendee>Alvaro Duran</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3TWGAB@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3TWGAB</pentabarf:event-slug>
            <pentabarf:title>PyTorch 2.0 - Why Should You Care</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T143500</dtstart>
            <dtend>20230721T150500</dtend>
            <duration>003000</duration>
            <summary>PyTorch 2.0 - Why Should You Care</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/3TWGAB/</url>
            <location>North Hall</location>
            
            <attendee>Shagun Sodhani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MMQTLC@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MMQTLC</pentabarf:event-slug>
            <pentabarf:title>We can get more from spatial, GIS and public domain datasets!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T160000</dtend>
            <duration>003000</duration>
            <summary>We can get more from spatial, GIS and public domain datasets!</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/MMQTLC/</url>
            <location>North Hall</location>
            
            <attendee>SzymonMolinski</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TJW3YZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TJW3YZ</pentabarf:event-slug>
            <pentabarf:title>Site Unseen: hidden python customization</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T160500</dtstart>
            <dtend>20230721T163500</dtend>
            <duration>003000</duration>
            <summary>Site Unseen: hidden python customization</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/TJW3YZ/</url>
            <location>North Hall</location>
            
            <attendee>Jeremiah Paige</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>K9VPWE@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-K9VPWE</pentabarf:event-slug>
            <pentabarf:title>Python 3.11 What&#8217;s new?</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T110000</dtend>
            <duration>003000</duration>
            <summary>Python 3.11 What&#8217;s new?</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/K9VPWE/</url>
            <location>Terrace 2A</location>
            
            <attendee>Dilyan Grigorov</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BEVEFH@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BEVEFH</pentabarf:event-slug>
            <pentabarf:title>Asyncio Evolved: Enhanced Exception Handling with TaskGroup in Python 3.11</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T112000</dtstart>
            <dtend>20230721T115000</dtend>
            <duration>003000</duration>
            <summary>Asyncio Evolved: Enhanced Exception Handling with TaskGroup in Python 3.11</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BEVEFH/</url>
            <location>Terrace 2A</location>
            
            <attendee>Junya Fukuda</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DE3XED@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DE3XED</pentabarf:event-slug>
            <pentabarf:title>Diving into Event-Driven Architectures with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T115500</dtstart>
            <dtend>20230721T122500</dtend>
            <duration>003000</duration>
            <summary>Diving into Event-Driven Architectures with Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/DE3XED/</url>
            <location>Terrace 2A</location>
            
            <attendee>Marc-Andr&#233; Lemburg</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MAGZUV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MAGZUV</pentabarf:event-slug>
            <pentabarf:title>Best Practices for GraphQL API Development</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T123000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>003000</duration>
            <summary>Best Practices for GraphQL API Development</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Sponsored</category>
            <url>https://programme.europython.eu/europython-2023/talk/MAGZUV/</url>
            <location>Terrace 2A</location>
            
            <attendee>Ahter Sonmez</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8M8UCT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8M8UCT</pentabarf:event-slug>
            <pentabarf:title>How Python can help victims of violence</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T130000</dtstart>
            <dtend>20230721T140000</dtend>
            <duration>010000</duration>
            <summary>How Python can help victims of violence</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Poster</category>
            <url>https://programme.europython.eu/europython-2023/talk/8M8UCT/</url>
            <location>Terrace 2A</location>
            
            <attendee>Pascal Chambon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UPEWP3@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UPEWP3</pentabarf:event-slug>
            <pentabarf:title>Fish and chips and Apache Kafka&#174;</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T140000</dtstart>
            <dtend>20230721T143000</dtend>
            <duration>003000</duration>
            <summary>Fish and chips and Apache Kafka&#174;</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/UPEWP3/</url>
            <location>Terrace 2A</location>
            
            <attendee>Tibs</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>79HLM8@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-79HLM8</pentabarf:event-slug>
            <pentabarf:title>How LocalStack is recreating AWS with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T143500</dtstart>
            <dtend>20230721T150500</dtend>
            <duration>003000</duration>
            <summary>How LocalStack is recreating AWS with Python</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/79HLM8/</url>
            <location>Terrace 2A</location>
            
            <attendee>Thomas Rausch</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KPHVEL@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KPHVEL</pentabarf:event-slug>
            <pentabarf:title>Language Model Zen</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T160000</dtend>
            <duration>003000</duration>
            <summary>Language Model Zen</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/KPHVEL/</url>
            <location>Terrace 2A</location>
            
            <attendee>Jamie Coombes</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>G9NKUY@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-G9NKUY</pentabarf:event-slug>
            <pentabarf:title>Language Models for Music Recommendation</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T160500</dtstart>
            <dtend>20230721T163500</dtend>
            <duration>003000</duration>
            <summary>Language Models for Music Recommendation</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/G9NKUY/</url>
            <location>Terrace 2A</location>
            
            <attendee>Nischal Harohalli Padmanabha</attendee>
            
            <attendee>Raghotham Sripadraj</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>J3PUYZ@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-J3PUYZ</pentabarf:event-slug>
            <pentabarf:title>Upgrading Django - from legacy to latest</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T110000</dtend>
            <duration>003000</duration>
            <summary>Upgrading Django - from legacy to latest</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/J3PUYZ/</url>
            <location>Terrace 2B</location>
            
            <attendee>Radoslav Georgiev</attendee>
            
            <attendee>Kamen Kotsev</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UWKSPN@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UWKSPN</pentabarf:event-slug>
            <pentabarf:title>Time Made Easy: Simplify Date and Time Handling with Python&apos;s Pendulum</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T112000</dtstart>
            <dtend>20230721T115000</dtend>
            <duration>003000</duration>
            <summary>Time Made Easy: Simplify Date and Time Handling with Python&apos;s Pendulum</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/UWKSPN/</url>
            <location>Terrace 2B</location>
            
            <attendee>Abhinand C</attendee>
            
            <attendee>Jothir Adithyan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BRY8JS@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BRY8JS</pentabarf:event-slug>
            <pentabarf:title>Leveraging the power of Django REST Framework&apos;s renderers with HTMX.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T115500</dtstart>
            <dtend>20230721T122500</dtend>
            <duration>003000</duration>
            <summary>Leveraging the power of Django REST Framework&apos;s renderers with HTMX.</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BRY8JS/</url>
            <location>Terrace 2B</location>
            
            <attendee>Emma Delescolle</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BSZFSA@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BSZFSA</pentabarf:event-slug>
            <pentabarf:title>Pygoat - Learn Django security the hard way</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T123000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>003000</duration>
            <summary>Pygoat - Learn Django security the hard way</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/BSZFSA/</url>
            <location>Terrace 2B</location>
            
            <attendee>Adarsh Divakaran</attendee>
            
            <attendee>Thameem Karakkoth</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HSRTCT@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HSRTCT</pentabarf:event-slug>
            <pentabarf:title>We are Python Weekend!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T130000</dtstart>
            <dtend>20230721T140000</dtend>
            <duration>010000</duration>
            <summary>We are Python Weekend!</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Poster</category>
            <url>https://programme.europython.eu/europython-2023/talk/HSRTCT/</url>
            <location>Terrace 2B</location>
            
            <attendee>Alena Osipova</attendee>
            
            <attendee>Andrej Zaujec</attendee>
            
            <attendee>Luk&#225;&#353; Kubi&#353;</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GQAARK@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GQAARK</pentabarf:event-slug>
            <pentabarf:title>Unleashing the Power of dbt and Python for Modern Data Stack</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T140000</dtstart>
            <dtend>20230721T143000</dtend>
            <duration>003000</duration>
            <summary>Unleashing the Power of dbt and Python for Modern Data Stack</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/GQAARK/</url>
            <location>Terrace 2B</location>
            
            <attendee>Meder Kamalov</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>REVKYV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-REVKYV</pentabarf:event-slug>
            <pentabarf:title>Deep Dive into Asynchronous SQLAlchemy - Transactions and Connections</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T143500</dtstart>
            <dtend>20230721T150500</dtend>
            <duration>003000</duration>
            <summary>Deep Dive into Asynchronous SQLAlchemy - Transactions and Connections</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/REVKYV/</url>
            <location>Terrace 2B</location>
            
            <attendee>Damian Wysocki</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>F78KKP@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-F78KKP</pentabarf:event-slug>
            <pentabarf:title>Threat to Life: Preventing Planned Murders with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T160000</dtend>
            <duration>003000</duration>
            <summary>Threat to Life: Preventing Planned Murders with Python</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/F78KKP/</url>
            <location>Terrace 2B</location>
            
            <attendee>Edwin Rijgersberg</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VFLKKR@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VFLKKR</pentabarf:event-slug>
            <pentabarf:title>Building and Deploying Fair and Unbiased ML Systems : An Art, Not Science</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T160500</dtstart>
            <dtend>20230721T163500</dtend>
            <duration>003000</duration>
            <summary>Building and Deploying Fair and Unbiased ML Systems : An Art, Not Science</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://programme.europython.eu/europython-2023/talk/VFLKKR/</url>
            <location>Terrace 2B</location>
            
            <attendee>Rashmi Nagpal</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GDZU3R@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GDZU3R</pentabarf:event-slug>
            <pentabarf:title>Reserved for Mentored Sprint</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T103000</dtstart>
            <dtend>20230721T130000</dtend>
            <duration>023000</duration>
            <summary>Reserved for Mentored Sprint</summary>
            <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>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Open Space</category>
            <url>https://programme.europython.eu/europython-2023/talk/GDZU3R/</url>
            <location>Open Space</location>
            
            <attendee>Cheuk Ting Ho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7VLWUV@@programme.europython.eu</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7VLWUV</pentabarf:event-slug>
            <pentabarf:title>Reserved for Tournament</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20230721T153000</dtstart>
            <dtend>20230721T170000</dtend>
            <duration>013000</duration>
            <summary>Reserved for Tournament</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Open Space</category>
            <url>https://programme.europython.eu/europython-2023/talk/7VLWUV/</url>
            <location>Open Space</location>
            
        </vevent>
        
    </vcalendar>
</iCalendar>
