A huge welcome to everyone leading into our morning talks.

Did you know you can (mostly) replicate all of Python 3.8's syntax using only 11 core pieces of syntax (plus some magical functions)? Come to this talk to hear about how "simple" things like + and . actually unravel into chunks of Python code!

Distributed tracing is a powerful tool for understanding microservices. Join this talk to learn what distributed tracing is, how to add it to your Python applications, an overview of how it works, and some reflections from someone who has implemented it across projects.

Django being one of the most popular Python-based web frameworks, applications developed using Django are always on the radar of hackers who try to find the vulnerabilities in the Django application and exploit the same for their benefit. This talk will discuss how to secure Django Web applications.

What happens on the computer when you run print(“Hello world”)? This talk attempts to dissect how Python code gets translated for execution. While many programmers can live without interacting with compiler internals, a stronger understanding of CPython can help make us better programmers.

One of the things that makes Python easy to work with is that you don't need a compile step before you can check that your code works. What if you could skip the save and run steps, too? Live coding lets you constantly run your code, as you edit it, and shows you what's happening inside. It's also great for visual tools like Matplotlib and Pillow.

I'll be demonstrating my Live Coding in Python project that includes plugins for PyCharm, Emacs, and SublimeText, as well as live tutorials that use Pyodide to let the reader experiment with code samples right in the browser.

As software is increasingly integrated with many third party components, particularly open-source components, it is essential to have a clear understanding of all of the software that is being deployed. With an increasing focus on improving the Cybersecurity of the many different parts of the supply chain, there is a growing expectation that a Software Bill of Materials (SBOM) will become a key artefact of any software component to help capture all of the software assets being used. This talk will briefly introduce the concept of SBOMs and show how a number of Python tools will help in the production, management and use of SBOMs as part of a system lifecycle.

"But it worked on machine" is one the most frustrating lines to hear when collaborating on a project. Creating and configuring reproducible environments is a major part of modern software development and had led to the popularity of tools like Docker to specify where and how code runs. Setting up Docker and Development Containers in VS Code make it easy to configure not only the where the code runs, but also the developer workspace. Setting up these tools can reduce effort for maintainers, bootstrap contributors, and make running events like workshops or sprints easier.

In this talk, we will cover why setting up container infrastructure like Docker can be useful for your project, and how you can extend that with Dev Containers to configure a full development experience in VS Code. We will also take a look at two common OSS project scenarios and how workflows for using Docker, Dev Containers and Codespaces make things easier. No container experience required, and some knowledge of VS Code helpful, but not necessary.

Metaprogramming is writing programs that manipulate programs. Dive into the deeper python magic of metaprogramming and enhance your understanding of object orientation in Python and its working under the hood.

When it comes to choosing a light, simple and high performance database for your python application, SQLite surely comes to mind. Learning and befriending SQlite has several benefits, and it is a must have tool for every programmer. But have you ever wondered what is happening behind the scenes which makes its storage and retrieval so efficient? How is data being managed internally? Let's explore the SQLite database using python while learning some intriguing underlying principles.

The Zen of Python, the well known list of 20 Python aphorisms (of which only 19 are written down), contains a lot of prescriptive advice for what makes "Good" Python code… or it would, if one of them didn't give you permission to ignore the rest of them.

Focusing on one piece of the 19 aphorisms, this talk explores the contradictions in the Zen of Python's advice, and how even with prescriptive rules, writing "Good" Python remains a subjective exercise.

Wrapping up our first day of talks.

Welcome to PyCascades 2023 day 2.

Rapid-fire talks by various presenters! Interested in giving a talk? Submit your lightning talk & slides using this form: bit.ly/PyCascades2023LightningTalks

Digital sensors have become a standard way of collecting data in the physical world. Join me as we delve into the realm of digital bus sensors by creating a driver for an I2C light-to-digital converter.

Infrastructure From Code (IfC) is a relatively new trend in Cloud DevOps automation aiming at the automatic generation of cloud deployment templates directly from the application code. There are already several solutions primarily focused on the TypeScript programming language. This talk is about what could be done for the Python ecosystem.

pytest rocks, obviously. When people start using pytest as a team, they often come up with cool fixtures that would be great to share across projects. In fact, many great Python packages come pre-loaded with pytest fixtures. This talk describes how easy it is to share fixtures using the pytest plugin model.

After learning doing in Python, we started multiple Python or Data Science projects. Dependency management becomes a skill that we need to avoid requirement conflicts amount projects. In this talk, we will learn how dependencies management tools work and how to choose the right one to use.

Secure software supply chains with 0 vulnerabilities sounds like a great idea, but once you start looking through entire dependency chains and large systems, it can be a lot harder to achieve than one might expect. Using the free, open source, CVE Binary Tool vulnerability scanner (written in python!), we'll show what it looks like to set up vulnerability scanning, what kinds of fun things you find, and how keeping things up to date can mean an ongoing maintenance burden that is more like a free puppy than a free beer. We'll talk about how naive policies, governmental mandates and capitalism may ruin your day, and what we can do to stay secure and help everyone get past the puppy phase without sending anyone back to the pound.

Code coverage is a great metric - how much of your code is actually tested by your unit tests. However, this doesn’t tell you how good your tests actually are at picking up changes to your codebase - if your tests aren’t well thought-out, it’s possible for changes to get past your unit tests but break production.

Mutation testing is a great (and massively underrated) way to understand how valuable your tests are. Mutation score quantifies how much trust you should put in your tests to stop mutant versions of your code escaping from your lab and wreaking havoc in production. In this talk, I’ll show you examples of how to get started with mutation testing and how to integrate it into your CI/CD pipeline.

After the session, you’ll be ready to use mutation testing with wild abandon and you'll be ready to integrate it into your release engineering process, testing your mutant code without needing to set foot in the lab at all!

Parsing tools aren't just for compilers! You can use parsing tools to read, parse, and manipulate all sorts of data. We'll use Lark, a Python parsing library, to look at some basic examples and the resulting parse trees, demonstrating the end-to-end process of input, parse tree, and output.

This talk is for anyone that has used Python to read in data from a text file.

Python has a variety of looping mechanisms for iterables engineered using functions and language keywords. Is it possible that two loops with same complexity have different runtimes? Which mechanism is the fastest and the slowest, Which one should you use to optimize your application?

With a little wiring and a few lines of code, one can create your own hyperlocal air sensor system to send alerts, activate smart-windows, and gather data. A sensor measures air particulate density and sends the values to a Raspberry Pi compute unit. The Raspberry Pi then sends the data along with a timestamp and location information to a cloud instance of Redis, a NoSQL data store. Once in Redis, the data can trigger SMS notifications, feed data visualization libraries, or activate electronics such as air purifiers or motors to open or close windows. This can be scaled to monitor air quality in multiple rooms, offices, city blocks, or cities.

Final words for the main conference days!