Recently the interest in asynchronous programming has grown dramatically.
 Unfortunately, asynchronous programs do not always have reproducible behavior. Even when they are run with the same inputs, their results can be radically different.
	In this talk I'll show you different approaches on how to debug asynchronous programs in Python.

In this talk I'll show you different approaches on how to debug asynchronous programs in Python.

Luckily, when it comes to debugging asynchronous applications in python, we have a couple of options to consider. The writers of the asyncio module have very kindly provided a debug mode, which is quite powerful and can really aid us in our debugging adventures without the overhead of modifying the system's code base too dramatically. In particular I'll show you what asyncio debug mode means for developers, and how to source tracebacks for unhandled exceptions in futures. Also how to detect accidental blocking for I/O. We discuss how to monitor the asyncio event loop and collect metrics in statsD.
Finally we discuss monitor and cli capabilities for asyncio applications based on aiomonitor and aioconsole. Also we discuss how asynchronous python works in REPL via autoawait based on ipython and how to do it in vanilla python REPL.

Andrii Soldatenko

Debugging asynchronous programs in Python

When processing data, validating its structure and its type is critical. Bad record types or changes in structure can often result in processing errors or worst in wrong data output. Yet, solving this problem cleanly and efficiently can be challenging. It often results in complicated code logic and increases complexity; consequently decreasing code readability. Pydantic is an efficient and elegant answer to these challenges

We expect you'll leave this talk with a good understanding of:

- Existing challenges in data validation
- What Pydantic Models, Validators, and Convertors are
- How to leverage Pydantic in your day to day (using real-life examples)
- [Bonnus] How to use Code Generation to create Pydantic Models from any data sources

Leverage the power of Pydantic to validate your data efficiently

Teddy Crepineau

Simple data validation and setting management with Pydantic

How annoying is it to find out that everything went to hell on the pipeline because you forgot to run the formatters? 

Don’t waste precious time and learn how it is possible to automate these little things, but most importantly understand why it is important to have them in your code!

Don't waste your time and learn why you should set up automations to run formatters automatically when you commits. Learn why they are important to improve your code!

Have you ever been in a situation where you check your pipelines to see if he’s finished running the tests and you find that he hasn’t even started because you forgot to run the linters locally?

I contribute to the development of [PyCon Italia](https://pycon.it), [Strawberry GraphQL](https://strawberry.rocks) and Poetry Package Manager and coding with these organizations I discovered fantastic tools such as [pre-commit](https://pre-commit.com/), [Poetry](https://python-poetry.org) and many others. In this talk I would like to share with you my findings, think about the pros and cons and understand a little bit better why you should start using them.

[Slides available here :)](https://www.slideshare.net/EsterBeltrami1/automate-cleaning-code-in-few-easy-steps)

Ester Beltrami

Automate cleaning code in few easy steps!

JSON Web Tokens, or JWTs for short, are all over the web. They can be used to track bits of information about a user in a very compact way and can be used in APIs for authorization purposes. Join me and learn what JWTs are, what problems it solves, how you can use JWTs, and how to be safer when using JWTs on your applications.

Learn what JWTs are, what problems it solves, how you can use JWTs, and how to be safer when using JWTs on your applications

JSON Web tokens dominated the way we give access to APIs and how we carry data from users, but to use JWTs safely we need to understand how they came to life and how JWTs can be useful.
In this talk we will take a closer look at the famous three-part structure that forms a JSON Web Token, and the claims each JWT can carry.
But knowing it’s history and structure is not enough, we need also to understand the algorithms used in creating a token and how you can use JWTs as access tokens or as ID tokens.
After understanding JWTs on a deeper level, we will create and validate a JWT together using the PyJWT library and discuss things you should avoid doing to be safer when using JWTs in your projects.

1. How did JWT come to life? Talk about the JOSE specification;
2. What actually is a JSON Web Token and its structure: header, payload, and signature;
3. What is a claim and its standardization efforts;
4. The different types of algorithms that can be used to create JWTs and what is JWKs;
5. Let's create a token together using PyJWT;
6. What is an access token and an ID token;
7. Things to avoid to be safer with JWTs

Jessica Temporal

Let's talk about JWT

Databases are beautiful beasts built with several layers of abstractions that we rarely have to know or even care about, now it's time to break them open and discuss the different components that maketh a database and how one would go about building one if they wanted. This would be based on my learnings when I went about building my own Toy Database in Python

Lets break them the different components that maketh a database and how one would go about building one in Python !

This talk will help unlock the internal workings of a Database by breaking down the abstractions that make it. We will use Python as our weapon of choice to slowly discuss how you would 
go about building the different components of a database.

1) Talking to your Database: We start by building out an interface and a language that helps us communicate with our database. We will use the Prompt toolkit to build a REPL & use a simple SQL-based language with basic regular expressions that can parse it to instruction to execute.

2) Working with Data: Now that we can communicate with our database using instructions. we start the actual work in building out the Datastore, We initially store all the data in a simple in-memory dictionary and then move to persist this data to disk. We now read the data from the disk to memory every time we query the data and write back the data to the disk but this makes things very slow :(
This problem is our entry into the beautiful world of Indexes so by building a very basic Btree index to store references in memory to quickly access only what we require from the data on disk we can actually speed up our access times for basic row access queries from O(N) to O(1) where N is the number of rows in a table

3) Future: We can now proudly demo our new and polished database that can store data, persist it, and can run queries that are quite fast thanks to our Btree Indexes. We also discuss how this Database can be improved in the future by supporting full ACID Transactions, allowing concurrency, and handling locks

Our Database journey now comes to an End and As they say, The best way to understand something is to build it yourself :)

Sangarshanan

Build-A-Database with Python

In this talk, we aim to find if polarization is induced in a neural
network by feeding it newspaper articles with manufactured sentiments according to the
Allsides Media Bias chart for the level of faith people on various aisles of the political
spectrum. This project consists of a set of experiments on similar data-sets from news
agencies across the various subsets in the ”media-bias” chart. News Media perceived bias
is common across consumers that belong to various political affiliations. While anecdotal
evidence of this exists and there exist annotated datasets that aim to annotate the ”spin”
a news agency puts on certain events and entities, whether this is a widespread problem
and whether it can be detected by the neural network topically or temporally is a problem that needs to be explored. The news media bias analysis is modelled as a Natural
Language Processing sentiment analysis task and a fake news binary classification task to
deduce the level of polarization in a neural network by feeding it headlines embedded using
pre-trained sentiment models from news publications across the political spectrum. When
it came to fake news vulnerability, news from all kinds of perceived politically affiliated
news media holds up well against a fake news dataset with a very good accuracy. None of
the accuracies dropped below 95%. This is a significant result that sort of debunks the AllSlides categorization

Is news media polarization based in fact or is it conditioned due to the consumption of alternative news media?

This work is an example of an intersection of a non
scientific field with computer science and mathematics, trying to quantify, measure and identify
non mathematical phenomena in the language of mathematics. It is important because it could
be the basis of the scientific approaches that the next generation policy makers, voters, non
profit social organizations and governments could use to make life changing decisions for their
citizens.
2
The questions that this study tries to answer is whether a neural network can learn biases from
the news media based on perceived bias scores obtained from independent agencies. It also
seeks to answer whether any of these political leanings of the news media affect the vulnerability of their consumer when it comes to fake news. The results of this experiment aim to show

Conclusions
1. SVMs perform better clustering with respect to the categories than neural networks, however the maximum does not cross 67%
2. The most significant conclusion from this work is that though there is a perceived bias
when it comes to news agencies, when looked at from a neural networks standpoint, it
is negligible. Mainstream news agencies are not able to polarize a neural network with
inherent biases in their headlines.
3. There may be topical biases that need to be examined by using an Entity linking and bias
calculation approach
4. Most mainstream news agencies do not make the consumer vulnerable to believing fake
news. This study needs to be conducted with data from popular social media ”news”
groups or popular TV shows that masquerade as news but may technically not even be
news channels.
5. It is safe to conclude that the perceived bias that stems from social media polarization is
being extended to news media when their contribution to the polarization may be negligible.

Aroma Rodrigues

Is the news media polarized? Or are we being conditioned to think it is?

An introduction to the **correlate** Python library.  You tell **correlate** about two datasets that should map to each other, and it determines the best matches for you.  The novel scoring algorithm at the heart of **correlate** means it copes exceedingly well with messy real-world data.  **correlate** supports fuzzy matching, weighted matching, and ordering.

"correlate" finds good matches between two sets of messy real-world data!  How?  Come find out!

Data correlation!  What could be more computer science-y!  Ever needed to find matching items between two sets of data?  Maybe even messy real-world data, with inexact string matches?  Come find out how the novel scoring algorithm and clever heuristics at the heart of **correlate** solve this problem with ease!

Larry Hastings

Correlating messy data with "correlate"

Data science experiments have a lot of moving parts. Datasets, models, hyperparameters all have multiple knobs and dials. This means that keeping track of the exact parameter values can be tedious or error prone.

Thankfully you're not the only ones facing this problem and solutions are becoming available. One of them is Hydra from Meta AI Research. Hydra is an open-source application framework, which helps you handle complex configurations in an easy and elegant way. Experiments written with Hydra are traceable and reproducible with minimal boilerplate code.

In my talk I will go over the main features of Hydra and the OmegaConf configuration system it is based on. I will show examples of elegant code written with Hydra and talk about ways to integrate it with other open-source tools such as MLFlow.

In my talk I will go over the main features of Hydra, an open-source application framework, which helps you handle complex configurations in an easy and elegant way

Michal Karzynski

Managing complex data science experiment configurations with Hydra

Memory Problems are the worst nightmare of every developer whose code is serving large files in a production environment. If you ever faced issues of memory leaking in application or if frequent unexpected Out of Memory Exception is raising your anxiety levels, then this talk is for you. This talk aims to summarize the common Memory issues in Python. It is overwhelming to see them even when logic in code is properly optimized. However it is more scary that some of these errors are hard to find and harder to fix.

This talk aims to summarize the common Memory issues in Python. It is overwhelming to see them even when logic in code is properly optimized. However it is more scary that some of these errors are hard to find and harder to fix.

In recent years, we have seen many improvements in Python Garbage Collection but there are some instances when it doesn’t work as expected. This results in memory crunch for the application leading it to crash. Although there are multiple ways to overcome the memory challenges, sometimes it is difficult to find what we can improve in our code and infrastructure that can make them memory efficient. In such cases, it helps to have an understanding of what is going on behind the curtains at a low level where memory is being managed.

This presentation aims to give a quick overview of

1. How CPython manages the Memory allocation
2. Common memory errors we see in day to day production code and how we can improve them

We will share what we have learned so far and encourage you to try it with your own projects. We'll walk through a simple example, with screenshots and code wherever required.

Pratibha Jagnere

Memory Problems, Did Collector Forgot to Clean the Garbage?

In this session, we will have a look at common mistakes in Python, that can cause serious code vulnerabilities, specifically for Kubernetes deployments of the code. We will subsequently have a look at what those vulnerabilities actually can result in and how your containerized application can get “hacked” as a result. We will also discuss how developer and security teams struggle to talk in a common language to prevent and mitigate these vulnerabilities. Lastly, we will see how you can prevent and mitigate these vulnerabilities in real-life.

Want to avoid serious code vulnerabilities when using Python in Kubernetes? This talk has you covered.

In this session, we will have a look at common mistakes in Python, that can cause serious code vulnerabilities, specifically for Kubernetes deployments of the code. We will subsequently have a look at what those vulnerabilities actually can result in and how your containerized application can get "compromised" as a result. We will also discuss how developer and security teams struggle to talk in a common language to prevent and mitigate these vulnerabilities. Lastly, we will see how you can prevent and mitigate these vulnerabilities in real-life using tools like Falco, TUF, Open Policy Agent and Bandit. We will also see how a CI/CD pipeline should look like, to build, test and deploy something in real-life. During this session you will learn a ton, see cool demos and all of the samples will be available to the attendees afterwards.

My session will benefit the ecosystem by pointing out common mistakes that can be made when writing Python code and deploying this via Kubernetes. This can cause serious breaches when exploited by attackers. The goal of the session is to both educate attendees on these vulnerabilities, as well as on how to fix them.
I will be talking about multiple open source projects that can secure code and deployment. I will not cover any commercial products.
Falco
TUF
Open Policy Agent
Bandit (not CNCF)
GitLab (not CNCF)

Flo Pachinger

Common Python Mistakes with Kubernetes, How They Can Cause Vulnerabilities and How to Solve Them!

As the most popular programming language nowadays, it has been pointed out that Python static code analysis has not yet received enough attention from the research and OSS community.  For instance, to the best of our knowledge, there is no general static analysis framework proposed to facilitate the implementation of dedicated Python static analyzers (e.g., compared to the Java Soot/WALA framework). 

Easy to use and fast to prototyping, what makes Python stand out is bringing challenges to static analysis tasks. To fill this gap, we design and implement [Scalpel](https://github.com/SMAT-Lab/Scalpel) (A Python Static Analysis Framework) and make it publicly available as an open-source project. The Scalpel framework has already integrated a number of fundamental static analysis functions (e.g., call graph constructions, control-flow graph constructions, alias analysis, etc.) that are ready to be reused by developers to implement client applications focusing on statically resolving dedicated Python problems such as detecting bugs or fixing vulnerabilities. In addition, documentation and the user guide are provided for users. 

The objective of the Scalpel framework is to (1) improve Python software quality and (2) support addressing  research challenges (e.g. API studies) in software engineering research;

As the star of programming languages, let’s use “Scapel” to make it healthier.

Scalpel is a Python Static Analysis Framework. It provides essential program analysis functions for facilitating the implementation of client applications focusing on statically resolving dedicated problems.

We aim to provide Scalpel as a generic Python static analysis framework that includes as many functions as possible (e.g., to easily build inter-function control-flow graph, to interpret the import relationship of different Python modules, etc.) towards facilitating developers to implement their dedicated problem-focused static analyzers. 

Scalpel’s Github page has received around 100 stars from researchers and practitioners around the world in only three-month after being made public.

Jiawei Wang

Li Li

Scalpel: The Python Static Analysis Framework

Python web frameworks, like FastAPI, Flask, Quartz, Tornado, and Twisted, are important for writing high-performance web applications and for their contributions to the web ecosystem. However, even they posit some bottlenecks either due to their synchronous nature or due to the usage of python runtime. Most of them don’t have the ability to speed themselves due to their dependence on *SGIs. This is where Robyn comes in. Robyn tries to achieve near-native Rust throughput along with the benefit of writing code in Python. In this talk, we will learn more about Robyn. From what is Robyn to the development in Robyn.

Robyn: A Python Web Framework with a runtime written in Rust

With the effort put in at every Python version to increase the runtime performance, we know that throughput efficiency is one of the top priority items in the Python ecosystem.

Inspired by the extensibility and ease of use of the Python Web ecosystem and the increased focus on performance, Robyn was born. 

Robyn is one of the fastest, if not the fastest Python web framework in the current Python web ecosystem. With a runtime written in Rust, Robyn tries to achieve near-native rust performance while still having the ease of writing Python code. 

This talk will demonstrate the reasons why Robyn was created, the technical decisions behind Robyn, the increased performance by using the rust runtime, how to use Robyn to develop web apps, and most importantly, how the community is helping Robyn grow!
Finally, I will be sharing the future plans of Robyn and would love to get feedback from the developers to see what they would like to see in it.

Debugging asynchronous programs in Python

Abstract

Description

The speaker