The mono vs. multi-repo is an age-old debate in the DevOpsphere, and one that can still cause flame wars.  What if I were to tell you that you don't have to choose?
In this talk we will dive into how we built a centralized Git workflow that can work with any kind of repo architecture, delivered with Python.

One of the greatest recurring pains in CI/CD is the need to reinvent the wheel and define your CI workflow for each and every repository or (micro)service, when eventually 99% of the config is the same.  What if we could hard reset this paradigm and create a single, unified workflow that is shared by all of our repos and microservices?  In this talk, we will showcase how a simple solution implemented in Python, demoed on Github as the SCM, and Github Actions for our CI, enabled us to unify this process for all of our services, and improve our CI/CD velocity by orders of magnitude.

Forget Mono vs. Multi-Repo that's old news...let's talk about how you can simplify all git workflows with Python.  Join this talk to learn how.

Daniel Koch

Forget Mono vs. Multi-Repo - Building Centralized Git Workflows with Python

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

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

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.

ABHISHEK

This talk explains how geospatial Python libraries can help us understand and predict Land Surface Temperature in urban areas using historical openly available satellite images and urban morphological data. This makes data science a powerful tool to plan and design urban areas while reducing the impact of urban warming.

Geospatial Python libraries can help us predict land surface temperature in urban areas with openly available satellite images. Deep learning gives us a powerful tool to reduce the impact of urban warming.

Dealing with extreme heatwaves can be challenging, it has become the necessity to understand the land surface temperature (LST) change and its driving factors to reduce the impact and achieve more sustainable planning methods for city growth.

This module will help you understand how to calculate LST from the openly available satellite imageries and merge it with urban morphological factors (like building height, building count, FSI, building block coverage, etc.) to predict the temperature trend and mitigate the impact.

We will demonstrate an end-to-end methodology using geospatial Python libraries to understand the use of spatial regression methods taking into account the variation over time. This talk will also throw light upon:

- Getting the large imagery datasets into DL friendly format
- Spatial aggregation of different variables
- Understanding correlation between variables for feature engineering
- Application & comparison of different regression methods on the same data
- Future scope

We'll also showcase the geo-visualization portal we created and the technologies used, how you can use Python to convert large GeoJSON output to light vector tiles, and create a seamless experience for the user through an intuitive front-end.

Anand S

Predicting urban heat islands in Calgary

You can have the best product in your expertise area, but if your documentation isn’t on par with the flawless experience you want to offer to the world, success is not guaranteed. Let’s be real here: documentation is often an afterthought and rarely included in life cycle development processes. Still, documentation is the secret weapon for greater adoption, and growth that you may have not known you could achieve.

It’s time for you to step up your game and measure up to the big players. Learn about the benefits of high quality and educational documentation and the true role it plays in the developer community. You’ll also learn the principles of a solid foundation, and tips on how to use one of the most powerful developer relations’ tools.

🎶 My Tech Docs Bring All the Devs to the Yard 🎶  It’s time for you to step up your game & unleash your secret weapon: a high quality technical documentation that will bring value to your users by really educating them. Learn how with @fharper!

Frédéric Harper

Developers Documentation: your secret weapon

In this talk we will introduce PyArrow and talk bout the transformation that the Arrow format is allowing in the Data Analytics world.

PyArrow provides an in-memory format, a disk format, a network exchange protocol, a dataframe library and a query engine all integrated in a single library. But the Arrow ecosystem doesn't stop there and allows you to work integrating multiple different technologies. It can be a swiss army knife for data engineers and it integrates zero cost with NumPy and Pandas in many cases.

PyArrow can be a swiss army knife for data engineers, providing an in-memory format, a disk format, a network exchange protocol, a dataframe api and a query engine all integrated in a single library.

Alessandro Molina

PyArrow and the future of data analytics

⭐ The talk will cover the Django codebase internals and showcase various moving parts in the code.

⭐ Talk will cover the internals of CGI, WSGI, working on runserver, views, Middleware, app loading, Django settings load, ORM, Django utilities, etc.

Talk will walk through key flows such as runserver, ORM, request serving etc in Django.

⭐ Talk will start with the introduction of how does end to end web request works internally in Django.

⭐ The talk will introduce users to the internals of ORM, database backend, middleware, etc.

⭐ The talk will also cover, all processes Django does internally to start a server.

⭐ At the end of the talk attendees will be able to understand the internal code structure of Django, how does Django server start, how does Django serves the requests, etc.

Hitul Mistry

Walk-through of Django internals

Did you know that Python preallocates integers from -5 to 257? Reusing them 1000 times, instead of allocating memory for a bigger integer, can save you a couple milliseconds of code’s execution time. If you want to learn more about this kind of optimizations then, … well, probably this presentation is not for you :) Instead of going into such small details, I will talk about more “sane” ideas for writing faster code.

After a brief overview of different levels of optimization and how they work in Python, I will show you simple and fast ways of measuring the execution time of your code and finally, discuss examples of how some code structures could be improved.

You will see:

* The fastest way of removing duplicates from a list
* How much faster your code is when you reuse the built-in functions instead of trying to reinvent the wheel
* What is faster than the “for loop”
* If the lookup is faster in a list or a set
* When it’s better to beg for forgiveness than to ask for permission

Source code level optimization is often neglected - people don’t bother because getting a faster server often gives better results. But if you - like me - always wonder what is the most efficient way to write some code, then this talk is for you!

Forget Mono vs. Multi-Repo - Building Centralized Git Workflows with Python

Abstract

The speakers