Python 3.11 is between 10% and 60% faster than Python 3.10, depending on the application. 
We have achieved this in a fully portable way by making the interpreter adapt to the 
program being run, and by streamlining key data structures.

In this talk I will explain what changes we have made, and how they improve performance.

Python 3.11 is faster than 3.10. Find out how we have achieved this.

The "Faster CPython" project aims to speed up Python, specifically CPython, by a large factor over the next few releases.
The first release to see the benefits of this work is Python 3.11.

Python 3.11 includes the following major changes:

* Adaptive specializing interpreter (PEP 659)
* Consecutively allocated execution frames
* Zero cost try-except
* More regular object layout
* Lazily created object dictionaries.

I will describe each of these, describing how each helps speed up Python, and how they interact with each other.

I will end the talk with some possible directions for Python 3.12.

Mark Shannon

How we are making Python 3.11 faster

Sharing and explaining the results of your analysis can be a lot easier and more fun when you can create an animated story of the charts containing your insights. [ipyvizzu](https://github.com/vizzuhq/ipyvizzu) - a new open-source charting tool for Jupyter & Databricks notebooks and similar platforms, enables just that with a simple Python interface. In this talk, the creator of ipyvizzu shows how their technology works and provides examples of the advantages of using animation for storytelling with data.
Links:  
- [ipyvizzu](https://github.com/vizzuhq/ipyvizzu) - animated charts within the notebooks
- [ipyvizzu-story](https://github.com/vizzuhq/ipyvizzu-story) - this adds the presentation functionality
- [slides to download](https://docs.google.com/presentation/d/149SxV5jJFR1bSSn14sL1qbZfFldLEgz1/edit?usp=sharing&ouid=100620473426791623869&rtpof=true&sd=true)

Create animated data stories in Jupyter & Databricks notebooks with ipyvizzu using Python. Sharing your insight and engaging your audience is now much easier and more fun! More info:https://github.com/vizzuhq/ipyvizzu

In this talk we'll cover the following topics:

- The problem with the well-known chart taxonomies: starting from "what would you like to show"
- Creating a generic chart morphing engine
- Advantages of using animation for storytelling - from the presenter's and the audience's perspective
- Examples and best practices of using ipyvizzu

Peter Vidos

Use animated charts to present & share your findings with ipyvizzu

Many of our sponsors are looking to hire talented people and EuroPython is the perfect place to reach out to them!

In this session, our sponsors will each give a short presentation about their company and what they do with Python. You can then approach them directly at their booth to discuss more details.

Many of our sponsors are looking to hire talented people and EuroPython is the perfect place to reach out to them!  In this session, our sponsors Optiver, Bloomberg, Microsoft, Trayport, Numberly and Jetbrains will each give a short presentation about their co

Sponsor Recruitment Session

Since it inception, online voting has been an apealing but controversial technology.

Indeed, what seems like a modern way of making vote cheaper and more convenient is often considered by activist and reserchers as a pandora box unleashing never-ending privacy and authenticity concerns.

However with Covid 19 shriking our public interaction, many have considered the benefits overcome the theorical issues and online voting system have skyrocketed like never before...

The Neovote voting system has been massively used in France: tenths of Universty, hundreds of private companies and, more importantly, it was chosen to organise
3 of the 5 main primary elections for the French Presidential election of 2022 (Primaires de l'Écologie, Les Républicains and Primaire Populaire).

Neovote claims to have the highest possible level of security, the voter being even able to access the final ballot box to do the recount by himself and ensure his own vote has been taken into account !

So challenge accepted, this talk will walk you through the Neovote voting system to understand why their claims are "slightly" exagerated ;-)

Online voting system used for primary elections for the French Presidential, must be secure right ?

Emmanuel Leblond

The Blue Brain Project hosts several online portals from which users can download single neuron model implementations. These contain the information necessary to simulate the electrical behavior of a neuron. EModelRunner is a Python library that provides a unified interface to the users to run these downloaded models. It gives the users the ability to customize the properties of the neurons, apply various stimuli in order to observe the corresponding behavior, or activate the synapses that are present on the morphology of the neuron. This way neuroscientists can investigate the neurons in a self-contained environment and conduct digital experiments on them.

EModelRunner: a Python package to run online available biological neuron model implementations

The brain is undoubtedly the most complex organ in the human body. Over the decades, scientists have been using theoretical and experimental approaches to understand the brain. With the recent advancement of computer systems and the availability of big data, a new discipline, namely simulation neuroscience, is emerged as a complementary approach alongside experimental, theoretical and clinical neuroscience. As the name suggests, simulation neuroscience attempts to understand the brain by simulating it in a computer.
Here we present EModelRunner, a Python package designed to run the simulated neuron model implementations provided by the Blue Brain Project online portals. It is capable of simulating biologically detailed neuron models. A neuron model describes a single cell in the brain and consists of a morphology and equations that simulate its electrical behavior. EModelRunner uses the Neuron simulator under the hood. The Neuron simulator is implemented in C++, but also provides a Python interface to the user. For computing the properties of the membrane channels, Neuron uses compiled mechanisms written using the Neuron Model Description Language (NMODL). EModelRunner abstracts away the Neuron and NMODL implementation layers from the end-users and provides them with a pure Python API. It supplies the users with the ability to customize the properties of the neurons and apply various stimuli to them in order to observe their behavior. Another use-case for the EModelRunner is to provide a standard way of running the neuron models provided by the Blue Brain Project.

Anıl Tuncel

I will the present the first public release of [ShapePipe](https://cosmostat.github.io/shapepipe/), an open-source and modular weak-lensing measurement, analysis and validation pipeline written in Python. I will begin by giving an (easy-to-follow) introduction on how and why we measure the shapes of galaxies to map the distribution of dark matter in the Universe. I will then describe the design of the software, mentioning the numerous Python packages we used, and justify the choices we made. I will conclude by discussing some of the lessons we learned along the way and how these can be applied to other scientific software development projects.

ShapePipe: A modular weak-lensing processing and analysis pipeline

#### Why would you want to listen to this talk?

Cosmology is the study of the origin, evolution, structure and ultimate fate of the Universe. From the largest galaxies down to the smallest Python programmers our story begins with the **Big Bang**. The particles that make up all of things we can touch and see only account for 5% of the energy density of the Universe. Leaving us quite literally in the dark! Weak gravitational lensing, a barely perceptible change to the shape of **galaxies** that we observe, is an indispensable tool for understanding the nature of **dark matter** and **dark energy**. However, measuring the shape of galaxies to the precision required is actually quite a tricky problem.

What could be more interesting? 😁

#### What does this have to do with Python?

Well, Python has steadily become the standard programming language for cosmologists over the last decade or so... and we are no exception! In this talk I will describe the tools we have developed in Python to help us solve some of the problems with measuring the shapes of galaxies and how various existing Python packages have made this possible. 

We hope that some of the things we have learned could be useful to other teams, in particular those developing scientific software.

##### Resources
- [ShapePipe Repository](https://github.com/CosmoStat/shapepipe)
- [ShapePipe Documentation](https://cosmostat.github.io/shapepipe/)
- [Slides](https://drive.google.com/file/d/1vQYCV1278oUvFzqGID6yhbQwwDyboCIv/view?usp=sharing)

Samuel FARRENS

Python has a full set of tools for asynchronous programming - multiprocessing, multithreading, coroutines, etc. And Django uses most of them.

Since Django 3, we have the ability to create fully async non-blocking Django views that could handle thousands of requests concurrently.

In this talk, we'll focus on 2 key topics:
1. The motivation and the decisions behind the Django async support
2. Choosing the right tools to make our views async and efficient

Tools and tips for implementing async non-blocking Django Views

This talk will cover:

1. What is the difference between asynchrony and concurrency?
2. Python and Django tools for asynchronous programming.
3. Examples of efficient and inefficient "async" Django views.
4. How does Django handle requests asyncronously - the path from `NGINX` to the database
5. How should we handle thread-blocking operations?
6. A brief history and roadmap of Django's async support

Ivaylo Donchev

Async Django

Python has had a transformational effect on countless fields so far, but its permeation can be accelerated through the integration of Python into non-computing coursework. Currently, Python’s presence within secondary and post-secondary schools varies greatly between different institutions, but the continuity in the lack of interdisciplinary coursework is a key limiting factor in the widespread growth of computing education. This is due to a variety of factors, including stereotypes and policy issues, but the bottom line is that Python being restricted to only computing classes restricts career opportunities and misrepresents the professional world. With support from a case-study of college-level physics students exposed to scientific programming, we propose novel methods of integrating Python into traditional coursework during this talk. The overarching mission of this discussion is to demonstrate how Python literacy in non-computing coursework can ultimately help in streamlining processes and accelerating progress in various industries. Attendees will have the opportunity to hear about the exciting prospect of expanding Python beyond the confines of computer science, and will have an exclusive look at a case-study that offers insight into student benefits of integrated coursework: as concerned stakeholders, it is ultimately well-informed Python community members who must unite to make a positive impact on the education system.

To the detriment of education systems around the world, Python remains confined to only computer science classes. Come see why Python’s currentstatus within education is a problem via a case-study of students, and learn how you can make a difference!

Introduction and Motivation: 

The goal of many within the Python community has been to increase the reach of computer science education in classrooms and institutions around the world. Various studies have pointed out the problem-solving and planning abilities forged by computer science coursework (Salehi et al., 2020; Arfé et al., 2020), and other research has investigated the social stigma (McCartney et al., 2017) and instructor bottlenecks (Raman et al., 2015) that inhibit accessibility to computer science courses. In recent years, significant steps have been taken towards increasing computer science education. However, most of these efforts are largely focused on the introduction of standalone computer science courses rather than integrated coursework.

In this talk, we explore the seldom-discussed idea of integrating programming into traditional, non-computing fields such as mathematics, social studies, and science. Interdisciplinary coursework is not a new concept in education: students in an English class are expected to be able to understand, produce, and analyze data visualizations, and mathematics students learn to communicate their work formally in language (Lynch, 2020). However, the current belief in the education realm is that computer science is only for a small sect of highly capable students expressing a deep career interest in the field, a clear misconception that has been debunked by studies (Patitsas et al., 2019) and the experiences of countless professionals applying computational resources in traditionally non-computing industries. As a result of such factors, computer science education is fundamentally isolated from the core curriculum, which is to the detriment of learners and the fields that they pursue. 

In support of the discussion, we unveil the results of surveys given to physics students enrolled in college-level coursework. In this case-study, students of varied backgrounds in computing are given a lecture on chaotic dynamical systems, and are then shown Python-implemented Runge-Kutta numerical integration methods and simulations to solve and visualize the systems. The insights provided by these students provide great perspective on benefits, reception, and nuances in integrating Python into core classes. Overwhelmingly, many indicated that they believed that the Python demonstrations aided in their understanding of the material. For the attendee, this exclusive look at a case-study will help develop a well-informed perspective on the role of Python beyond just computer science.

We conclude the presentation with recommendations for integrated Python coursework, calling for global policymakers and Python community members to step forward and do their part as stakeholders. We pinpoint why Python is the best choice, touching on factors such as its readable syntax, high volume of functional open-source libraries, ever-growing industry demand. The versatility afforded by such elements makes learners of all backgrounds better equipped for solving the challenging problems they will face in their careers. Community members in attendance will gain essential knowledge regarding the issue of Python integration, making them better equipped to argue on behalf of the educational community.

For students, seeing how complex differential equations can be numerically approached and solved by computers, understanding how new solar systems are discovered by crunching vast astronomical data, and witnessing a computer rapidly sequence a lengthy DNA chain forges an instant, permanent connection that fosters career interests and prepares students for an increasingly computerized professional world. We seek to advocate for every student to have this opportunity.

The key takeaway for talk attendees will be a fresh perspective on the issue of Python’s absence beyond the confines of computer science coursework, as well as methods for mitigation and steps that they can take. Changing education with programming is a long-term investment that will unequivocally accelerate student preparedness and capabilities, but it begins with the focused efforts of an informed public rallying in support of progress. 

Schedule and Format:

5 minutes: The problem of computer science in education and why we should focus on increasing Python’s role in non-computing classes

10 minutes: Presenting research: a case study on introducing scientific Python to physics students

5 minutes: Why Python is the best option and the role and impact on the Python community

5 minutes: Proposals for Solutions to the Problem

5 minutes: Question and Answer Session

Srivatsa Kundurthy

Revolutionizing Education: How Python is Essential Beyond Computer Science

Keeping in mind the **Pythonic** principle that _“simple is better than complex”_ we'll see how to create a web **map** with the **Python** based _web framework_ **Django** using its **GeoDjango** module, storing _geographic data_ in your _local database_ on which to run _geospatial queries_.

"Maps with Django" Keeping in mind the Pythonic principle that simple is better than complex we'll see how to create a web map with the Python based web framework Django using its GeoDjango module, storing geographic data in your database #europython

A *map* in a website is the best way to make geographic data easily accessible to users because it represents, in a simple way, the information relating to a specific geographical area and is in fact used by many online services.

Implementing a web *map* can be complex and many adopt the strategy of using external services, but in most cases this strategy turns out to be a major data and cost management problem.

In this talk we'll see how to create a web *map* with the **Python** based web framework **Django** using its **GeoDjango** module, storing geographic data in your local database on which to run geospatial queries.

Through this intervention you can learn how to add a *map* on your website, starting from a simple *map* based on **Spatialite/SQLite** up to a more complex and interactive *map* based on **PostGIS/PostgreSQL**.

##### Slides
- [https://www.paulox.net/2022/07/14/europython-2022/](https://www.paulox.net/2022/07/14/europython-2022/)

Paolo Melchiorre

Maps with Django

Our generation of young people in school (aged 5-18) have noticed the connection between Computer pRogramming, Technology, Bitcoinism Success, Climate Change and Billionaires.

On mass young people are clamouring to master the skill of Computer pRogramming. It has been dubbed the ‘4th’ R’ (computer pRogramming) along with Reading, wRiting and aRithmetic. So, governments worldwide have launched initiatives to have it taught in schools from Kindergarten to all the way to high school. And now young people are successfully mastering this skill.

This talk will describe a case study whereby Computer Programming (Python) was introduced for the first time to a group of young people and how the young people are using it to explore and understand real world problems and data such as those relating to climate change, world population growth and carbon dioxide emissions with Python visualisation libraries such as Matplotlib, Numpy and Pandas. We will talk about the joys and challenges and discoveries made by the young people. We will conclude with suggestions on how to proceed in this area.

Young People using Data Visualisation (Matplotlib) to look at Climate Change.

Lilian

Creating the Next Generation of Billionaires - Part 4

When starting a new python project, the “hypermodern” python ‘template’ is a popular choice. Its style is opinionated and strict, and it brings a consistent style and today's best practices. How do I bring my legacy codebase up to this standard?

A Consistent style and standard and the consistent use of the same tools in all your code, makes it easier to reason about, reduces context switching, thus reducing waste (in the LEAN sense). A clean environment is good for your health and safety, enabling you to deliver quality faster.

This talk goes deeper into how to modernize your legacy codebase to reduce your technical debt, to make it easier for you to tackle the real challenges without ever having to discuss a style guide again. It will provide tips, tricks and tools to make your “hypermodernization” effort as smooth and easy as possible.

Christian Ledermann

A Tale of two Kitchens, hyper modernizing your codebase.

For more than 10 years, scikit-learn has been bringing machine learning and data science methods to the world. Since then, the library always aimed to deliver quality implementations, focusing on a clear and accessible code-base built on top of the PyData ecosystem.

This talk aims at explaining the recent on-going work of the scikit-learn developers to boost the native performances of the library.

Scaling scikit-learn native performances: introducing new sets of computational routines

scikit-learn is an open-source scientific library for machine learning in Python.

Since its first release in 2010, the library gained a lot of traction in education, research and the wider society, and has set several standards for API designs in ML software. Nowadays scikit-learn is of one the most used scientific library in the world for data analysis. It provides reference implementations of many methods and algorithms to a userbase of millions.

With the renewed interest in machine-learning based methods in the last years, other libraries providing efficient and highly optimised methods (such as for instance LightGBM and XGBoost for Gradient-Boosting-based methods) have emerged. Those libraries have encountered a similar success, and have put performance and computational efficiency as top priorities.

In this talk, we will present the recent work carried over by the scikit-learn core-developers team to improve its native performance.

This talk will cover elements of the PyData ecosystem and the CPython interpreter with an emphasis on their impact on performances. Computationally expensive patterns will then be covered before presenting the technical choices associated with the new routines implementations, keeping the project requirements in mind. At the end, we will take a quick look at the future work and collaborations on hardware-specialised computational routines.

Julien Jerphanion

Scaling scikit-learn: introducing new sets of computational routines

Recommendation systems are increasingly in demand to provide a personalized customer experience for diversified product mix offerings. Traditionally we use interaction information based on user preferences and item characteristics. This brings in collaborative filtering-driven recommendations with higher accuracy and relevance. However, such a method has certain limitations in utilizing implicit information like cross-domain specific factors that are equally important for making personalized recommendations. We propose an improvised way of using network embeddings based matrix factorization technique with multi-factors to make a match between both implicit and explicit features resulting in more accurate recommendation.

A Network Embeddings based Recommendation Model with multi-factor consideration

The method consists of three main steps: First, network embedding formulation performed on each user specific behavior network; Then, embeddings weight distribution estimated through intermediate layers of network with final layer for target (item purchased as labels); Finally, both factors: (a) Learned weights from implicit data (cross-domain) and (b) explicit factors from domain data used by multi-factorization method for recommendations. 
The proposed method transfers knowledge across implicit and explicit factors and associated dimensions. The suggested approach tested real-world data with evidence of outperforming existing algorithms with significant lift in recommendation accuracy. Empirical experimentation outcomes illustrate the potential of both factors for making effective recommendations.

How we are making Python 3.11 faster

Abstract

Description

The speaker