<?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>CYUDQ7@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CYUDQ7</pentabarf:event-slug>
            <pentabarf:title>Friday Welcome Session</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T110000</dtstart>
            <dtend>20220916T113000</dtend>
            <duration>003000</duration>
            <summary>Friday Welcome Session</summary>
            <description>Welcome</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/CYUDQ7/</url>
            <location>Assembly Room</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7ANG8N@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7ANG8N</pentabarf:event-slug>
            <pentabarf:title>Unexploded Bombs</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T113000</dtstart>
            <dtend>20220916T123000</dtend>
            <duration>010000</duration>
            <summary>Unexploded Bombs</summary>
            <description>The SS Richard Montgomery is a ship with a strange history. Sunk in the mouth of the Thames Estuary during WWII, she&apos;s filled with an unknown number of explosives. There have been various attempts over the years to figure out the danger from this ship and potentially clear her - but so far, nothing has been done.

Every codebase has its own unexploded bombs. potentially serious problems lurking beneath the surface of our code. How can we identify and tackle them? Software is just as vital to our safety as other kinds of engineering - I&apos;ll delve into some famous cases such as the Therac-25 incidents to show what can go wrong when we don&apos;t appreciate this.

Let&apos;s use the Richard Montgomery as a metaphor to explore ways to make our code safer and more robust. Together, we can develop into software professionals and clear up problems in advance. *Before* we set anything on fire.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/7ANG8N/</url>
            <location>Assembly Room</location>
            
            <attendee>Hannah Hazi</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YHNSLQ@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YHNSLQ</pentabarf:event-slug>
            <pentabarf:title>Exception Groups and except*</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T133000</dtstart>
            <dtend>20220916T140000</dtend>
            <duration>003000</duration>
            <summary>Exception Groups and except*</summary>
            <description>Python 3.11 introduces new features that make it possible to raise and handle multiple unrelated exceptions at the same time (see PEP 654). This talk, given by one of the authors of PEP 654, will describe how they work and some of the design decisions we made while developing these features. In particular, why we needed to add the new syntax except\* to handle exception groups.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/YHNSLQ/</url>
            <location>Assembly Room</location>
            
            <attendee>Irit Katriel</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HHT3R8@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HHT3R8</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>20220916T140000</dtstart>
            <dtend>20220916T143000</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 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.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/HHT3R8/</url>
            <location>Assembly Room</location>
            
            <attendee>Tibs</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QZQXHA@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QZQXHA</pentabarf:event-slug>
            <pentabarf:title>PyScript and my journey to the Web</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T143000</dtstart>
            <dtend>20220916T150000</dtend>
            <duration>003000</duration>
            <summary>PyScript and my journey to the Web</summary>
            <description>This talk chronicles how I used Python to journey from web &#8216;noob&#8217; to something greater.  

While I&#8217;ve been using Python to develop back-end services for several years, I had not previously developed any web applications. PyScript presented an excellent opportunity for me to leverage my existing Python knowledge to help fill this gap in my skills.

PyScript is a framework that enables developers to create Python applications in the browser using HTML&apos;s interface and the power of Pyodide, WebAssembly (WASM), and other modern web technologies. It was announced by Peter Wang during his recent keynote at PyCon US 2022. While it is classed as &#8220;very alpha&#8221; and not yet suitable for production, it has proven to be a useful tool for exploration and learning.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/QZQXHA/</url>
            <location>Assembly Room</location>
            
            <attendee>Scott Irwin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>339VBF@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-339VBF</pentabarf:event-slug>
            <pentabarf:title>It&apos;s Your Call(able): a tour of Python&apos;s callable (function) interface</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T150000</dtstart>
            <dtend>20220916T153000</dtend>
            <duration>003000</duration>
            <summary>It&apos;s Your Call(able): a tour of Python&apos;s callable (function) interface</summary>
            <description>Functions are fundamental to python, and are amongst the first features of python that most users learn. We define a function with parameters, and call it arguments to create a callable object, which then returns a value. 

However, there is more to this callable interface than meets the eye, and there are lots of useful and powerful things we can do with callables in python. You may have come across some of these already: (anonymous) lambda functions, the __call__ magic method, the decorator pattern, the __doc__ property, and modules like functools and inspect which provide detailed about functions and allow us to alter functions at runtime. The now-retired Python 3.6 release added typing __annotations__ to this mix, and opened up a new world of metadata to use alongside your callables.

Lots of libraries, particularly web frameworks like Flask, Django, and FastAPI, and testing toolkits like pytest, use this callable interface to implement their API. As developers, understanding these advanced features of python&#8217;s callable interface is particularly useful when writing generic, automation focused code, and understanding how such prominent libraries work.

This talk gives a deep-dive into python functions, and the associated callable interface. We&#8217;ll start with a quick tour of the basics, before covering python&#8217;s more advanced callable features, and exploring some examples about how, why, and when you may wish to use these features yourself.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/339VBF/</url>
            <location>Assembly Room</location>
            
            <attendee>Dom Weldon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PYYTBF@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PYYTBF</pentabarf:event-slug>
            <pentabarf:title>I hate writing tests, that&apos;s why I use Hypothesis</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T160000</dtstart>
            <dtend>20220916T163000</dtend>
            <duration>003000</duration>
            <summary>I hate writing tests, that&apos;s why I use Hypothesis</summary>
            <description>In this talk, we will explore what is property-based testing and why it can do a lot of heavy lifting in writing tests for us. As a contributor, I will introduce Hypothesis, a Python library that can help perform property-based tests with ease.

At the start of the talk, we will understand the power of property-based tests, what is it, how is it different from what we &#8220;normally do&#8221; - testing by example, and why is it useful in testing our code. This will be followed by demonstrations using Hypothesis. With a few examples, we will have a glimpse of how to create strategies - recipes for describing the test data you want to generate.

After that, we will also explore the Ghostwriters in Hypothesis which will actually write the test for you.

This talk is for Pythonistas who are new to property-based testing and found thinking of what parameters to use for testing a difficult task. This talk may provide them with a new approach to writing tests, which will be more efficient for some cases.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/PYYTBF/</url>
            <location>Assembly Room</location>
            
            <attendee>Cheuk Ting Ho</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>L3YEB3@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-L3YEB3</pentabarf:event-slug>
            <pentabarf:title>How to wag a dog</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T163000</dtstart>
            <dtend>20220916T170000</dtend>
            <duration>003000</duration>
            <summary>How to wag a dog</summary>
            <description>The tail of the dog expresses its disposition and reflects its health, and we expect it to be a reliable outward sign of what&apos;s going on inside the dog. We expect the same kind of relationship between software and documentation: that documentation should reliably tell us about the software, providing clear and up-to-date insights into it.

I think that this is a na&#239;ve view of both dogs and software. 

I will discuss, with examples, why it&apos;s a problematic idea for documentation. It&apos;s not actually true, and failing to recognise this is one reason why documentation is often so bad. Recognising the true nature of the relationship on the other hand puts documentation authors in a much more powerful position than they are usually understood to have - and that&apos;s something they can use to their advantage. 

In other words, the tail is already wagging the dog, and that&apos;s the way it should be.

This talk is about documentation, but it&apos;s also an exploration and critique of some commonly-held ideas about the relationship between supposedly active and creative activities - of which making software is one example - and those seen as more passive and interpretive ones - like documentation.

Along the way, this talk will discuss topics including: the relationship between seeing and looking, riding on motorbikes, visiting museums, and why we should reconsider now-discredited pre-Newtonian theories of vision. 

We&apos;ll get from dogs and their tales to an approach to documentation that improves **both** documentation and software, and gives us a tool for reassessing other patterns of work and life too.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/L3YEB3/</url>
            <location>Assembly Room</location>
            
            <attendee>Daniele Procida</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MQUB8J@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MQUB8J</pentabarf:event-slug>
            <pentabarf:title>Friday Lightning Talks</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T170000</dtstart>
            <dtend>20220916T180000</dtend>
            <duration>010000</duration>
            <summary>Friday Lightning Talks</summary>
            <description>Lightning Talks</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/MQUB8J/</url>
            <location>Assembly Room</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LZKN7F@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LZKN7F</pentabarf:event-slug>
            <pentabarf:title>Introduction to Data Analysis Using Pandas</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T133000</dtstart>
            <dtend>20220916T150000</dtend>
            <duration>013000</duration>
            <summary>Introduction to Data Analysis Using Pandas</summary>
            <description>This tutorial is for anyone with basic knowledge of Python and an interest in learning how to analyze data in Python. We will be working with Jupyter Notebooks, so attendees should familiarize themselves with the interface (i.e., know how to run/edit a cell) beforehand.

#### Section 1: Getting Started With Pandas
We will begin by introducing the `Series`, `DataFrame`, and `Index` classes, which are the basic building blocks of the pandas library, and showing how to work with them. By the end of this section, you will be able to create DataFrames and perform operations on them to inspect and filter the data.

#### Section 2: Data Wrangling
To prepare our data for analysis, we need to perform data wrangling. In this section, we will learn how to clean and reformat data (e.g. renaming columns, fixing data type mismatches), restructure/reshape it, and enrich it (e.g. discretizing columns, calculating aggregations, combining data sources).

We will take breaks for exercises throughout and all solutions, slides, and notebooks will be provided.

#### Environment Setup
Follow the setup instructions [here](https://github.com/stefmolin/pandas-workshop#setup-instructions) to get your environment up and running before the session.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/LZKN7F/</url>
            <location>Room A</location>
            
            <attendee>Stefanie Molin</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FVMZRE@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FVMZRE</pentabarf:event-slug>
            <pentabarf:title>Creating your first documentation site for your Python code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T133000</dtstart>
            <dtend>20220916T150000</dtend>
            <duration>013000</duration>
            <summary>Creating your first documentation site for your Python code</summary>
            <description>Good API documentation is crucial to a new library&#8217;s popularity and its adoption by other developers.

In this workshop, you will learn how to build a documentation website for your Python code from scratch using Sphinx, a powerful documentation generation tool. Sphinx makes it easy to keep your API docs in sync with your code and you will put it in practice in a provided example project.

By the end of the session you will learn how to:

- generate HTML documentation for your API
- customise your website&#8217;s appearance
- host your documentation online on GitHub Pages
- version your docs to follow the releases of your code
- use GitHub Actions to automate all the above as your new code updates are merged into your source

Prerequisites:

In order to attend this workshop you will need to bring a laptop with `git` and `python` installed ([`python3.10`](https://www.python.org/downloads/) is recommended), as well as a GitHub account.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/FVMZRE/</url>
            <location>Room B</location>
            
            <attendee>Olga Matoula</attendee>
            
            <attendee>Aya Elsayed</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JECQCM@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JECQCM</pentabarf:event-slug>
            <pentabarf:title>Training, Deploying, and Running a ML model using Python and Snowpark</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220916T133000</dtstart>
            <dtend>20220916T150000</dtend>
            <duration>013000</duration>
            <summary>Training, Deploying, and Running a ML model using Python and Snowpark</summary>
            <description>In this session, we will train a Linear Regression model to predict future ROI (Return On Investment) of variable advertising spend budgets across multiple channels including search, video, social media, and email using Snowpark for Python and scikit-learn. By the end of the session, you will have an interactive web application deployed visualizing the ROI of different allocated advertising spend budgets. 

During this hands-on session, we will:

- Set up your favorite IDE (e.g. Jupyter, VSCode) for Snowpark and ML
- Analyze data and perform data engineering tasks using Snowpark DataFrames 
- Use open-source Python libraries from a curated Anaconda channel with near-zero maintenance or overhead
- Deploy ML model training code to Snowflake using Python Stored Procedures
- Create and register Python User-Defined Functions (UDFs) for inference
- Create Streamlit web application that uses the UDF for real-time prediction</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/JECQCM/</url>
            <location>Room C</location>
            
            <attendee>Dash Desai</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HQL7HK@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HQL7HK</pentabarf:event-slug>
            <pentabarf:title>Saturday Welcome Session</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T090000</dtstart>
            <dtend>20220917T093000</dtend>
            <duration>003000</duration>
            <summary>Saturday Welcome Session</summary>
            <description>Welcome</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/HQL7HK/</url>
            <location>Assembly Room</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SLAQBH@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SLAQBH</pentabarf:event-slug>
            <pentabarf:title>Do not trust my [or any] computational research.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T093000</dtstart>
            <dtend>20220917T103000</dtend>
            <duration>010000</duration>
            <summary>Do not trust my [or any] computational research.</summary>
            <description>In this talk I will describe the research publication pipeline that is based on peer review. Peer review in some sense resembles what happens on an open source software pull request but it is also fundamentally different. For example it is often a somewhat secretive affair with ambiguous comments from referees with no room for discussion.

I will discuss the historic origins of peer review and highlight a number of problems that are prevalent as a result.

This will lead to thoughts on the difference between trust and confidence. Should we trust research which implies trusting the peer review process, or should we instead aim to have confidence in the research? And, if that&apos;s the goal, how can that be achieved?

I will include some examples of specific peer review processes from pure mathematics (my original field of research) but also discuss topics related to the wider software development industry (such as zero-trust security).

This will conclude with a hopefully optimistic answer to the question: &quot;If we were inventing the research publication pipeline today, what would it look like?&quot;.

I hope that this talk will not only be of interest to Python users doing research but also to the wider Python community who might be interested in understanding what &quot;trust the research&quot; means.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/SLAQBH/</url>
            <location>Assembly Room</location>
            
            <attendee>Vincent Knight</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3MZXZL@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3MZXZL</pentabarf:event-slug>
            <pentabarf:title>Using python to create a prototype for web accessibility research</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T110000</dtstart>
            <dtend>20220917T113000</dtend>
            <duration>003000</duration>
            <summary>Using python to create a prototype for web accessibility research</summary>
            <description>The web was designed to be accessible to all people regardless of their ability, use of hardware, software, language, and location. Web accessibility means designing websites, tools, and technology to be inclusive to people with disabilities so that they can perceive, understand, navigate, and interact with the web and contribute to it. Web accessibility evaluation means verifying that this is the case.
 
The process of automatic accessibility evaluation is of interest to accessibility practitioners and researchers given that manual evaluation requires a lot of time and effort. My research has shown that most accessibility evaluations are conducted using a single evaluation tool.
This talk discusses how using the python ecosystem has allowed the development of a prototype to ensemble the results from multiple automated accessibility evaluation tools. The prototype generated a HTML report which aggregated results from the different evaluation tools removing the reliance of the results from a single tool.
 
Python&#8217;s rich set of libraries such as wxPython, matplotlib, numpy and pandas made this project possible within a short timeframe.
 
The results from developing this prototype tool was included in research published at HCI International 2022 - https://link.springer.com/chapter/10.1007/978-3-031-06417-3_71
This talk hopes to inspire others to use python to conduct research and improve web accessibility.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/3MZXZL/</url>
            <location>Assembly Room</location>
            
            <attendee>Peter Johnson</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KCWJKX@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KCWJKX</pentabarf:event-slug>
            <pentabarf:title>Living With Technical Debt: Acknowledge It, Specify It, Reduce It</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T113000</dtstart>
            <dtend>20220917T120000</dtend>
            <duration>003000</duration>
            <summary>Living With Technical Debt: Acknowledge It, Specify It, Reduce It</summary>
            <description>## Summary

In this talk, we make tech debt more tangible by dividing it into 3 categories and showing strategies for each:

- vague issues
- antipatterns
- fixable problems

In each category, we&apos;ll discuss not just the technical complexities, but also the business impact and the organizational challenges. We&apos;ll introduce several tools to mitigate the consequences and to eliminate parts of the tech debt.

## Vague Issues: Acknowledge Them

- Make it visible when working with the code.
- Make it visible when taking business decisions.
- Acknowledge the business impact: longer development time, higher probability of bugs.
- Encourage open and constructive discussion.
- Gather info about this specific issue and recognize general patterns.

## Identify Antipatterns And Express Them As Code

- General vs specific to your codebase: Not an either - or, but rather a continuum.
- Express antipatterns as code.
- Find similar issues across the whole code base.
- Avoid adding even more debt of the same kind.

## Automatically fix straightforward issues

- If the antipattern can be codified, perhaps the fix can be codified as well.
- Roll out fixes with large-scale changes.
- Risks of large-scale changes.
- Avoid re-adding the same kind of debt.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/KCWJKX/</url>
            <location>Assembly Room</location>
            
            <attendee>Tim Gilboy</attendee>
            
            <attendee>Reka Horvath</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GHLPMP@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GHLPMP</pentabarf:event-slug>
            <pentabarf:title>Meta Generators: Playing Safe with Long Sequences</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T120000</dtstart>
            <dtend>20220917T123000</dtend>
            <duration>003000</duration>
            <summary>Meta Generators: Playing Safe with Long Sequences</summary>
            <description>Through this talk, I want to highlight the dangers of trying to write very large or theoretically infinite Python generators to lists (obvious), and the ease with which it can be done accidentally (less obvious).

The talk will start with an example of when one might want to use some very large generators to solve a problem. I will discuss some common operations that we use to combine generators (chain, product, zip, etc.), and then go into detail about why some of these are &quot;safe&quot; to use on very large generators (chain, zip), while others are very much not (product).

The second part of the talk, which will explain our solution to this problem &#8211; &quot;meta-generators&quot; &#8211; also doubles as a recommendation for a future language feature.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/GHLPMP/</url>
            <location>Assembly Room</location>
            
            <attendee>Ally Stanley</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JK7FAJ@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JK7FAJ</pentabarf:event-slug>
            <pentabarf:title>HPy: a better C API for Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T123000</dtstart>
            <dtend>20220917T130000</dtend>
            <duration>003000</duration>
            <summary>HPy: a better C API for Python</summary>
            <description>The official Python C API is specific to the current implementation of CPython. It has served us well and forms the basis upon which our entire extension ecosystem rests. 
However, it exposes a lot of internal details which makes it hard to implement it for other Python implementations (e.g. PyPy, GraalPython, Jython, IronPython, etc.), and 
prevents major evolutions of CPython itself, such as using a GC instead of refcounting, or removing the GIL.

This is where HPy comes in. It&apos;s a new C API designed from the ground up according to the following goals:
* running much faster on alternate implementations, and at native speed on CPython
* making it possible to compile a single binary which runs unmodified on all supported Python implementations and versions
* being simpler and more manageable than the Python/C API
* providing an improved debugging experience.

We&apos;ll discuss its current status and show how existing extensions can be gradually ported to it.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/JK7FAJ/</url>
            <location>Assembly Room</location>
            
            <attendee>Ronan Lamy</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XQPLM7@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XQPLM7</pentabarf:event-slug>
            <pentabarf:title>Property-Based Testing the Python Way</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T140000</dtstart>
            <dtend>20220917T143000</dtend>
            <duration>003000</duration>
            <summary>Property-Based Testing the Python Way</summary>
            <description>This is an introductory talk about property-based testing. The talk requires some previous knowledge about testing to make the most out of it but if you are new and curious I think you would get something out of it.

The talk approaches a simple problem from two different testing perspectives. Giving you an idea about property-based testing and how it&#8217;s different from the traditional approach with Python. 

The main focus of the topic would be Hypothesis and how you can achieve your testing goals with it. 

By the end of this talk you would have a solid understanding of property-based testing with Hypothesis, that would help you decide which testing approach fits your need. 

Given below is a rough overview of the talk structure:
  The testing problem. 
  The traditional approach.
  Cons of traditional approach.
  What property-based testing.
  Intro to Hypothesis. 
  Same problem solution with Hypothesis.
  Why choose Hypothesis as a go-to property based testing tool.
  Parameterized testing with Pytest vs Hypothesis approach. 
  When or when not to use property based testing. 
  How you can adopt `hypothesis` in your code base.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/XQPLM7/</url>
            <location>Assembly Room</location>
            
            <attendee>Emma Saroyan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JBGRFC@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JBGRFC</pentabarf:event-slug>
            <pentabarf:title>Giving Python to non-developers: A real-life story</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T143000</dtstart>
            <dtend>20220917T150000</dtend>
            <duration>003000</duration>
            <summary>Giving Python to non-developers: A real-life story</summary>
            <description>When JPMorgan decided to give Python development tools to hundreds of non-developers, it was a no-brainer.

Given the huge amounts of financial data available and the tools becoming easier to use, it made sense to allow the business to extract relevant information directly themselves.  

But how?

Clearly the infrastructure had to be there: a Python development &amp; runtime environment, access to data and to JPMorgan analytics.

But having the infrastructure ready was only the beginning.  We needed training.  It needed to be relevant, rewarding, and even fun.  

And what about the culture?  How do we get non-developers to take their first plunge into Python, and then get into good development habits, without becoming full-time developers?

This is the story of our on-going journey.  We learnt some important lessons along the way.  We&#8217;ll share them so that you too can give Python to non-developers.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/JBGRFC/</url>
            <location>Assembly Room</location>
            
            <attendee>Philippe Masson</attendee>
            
            <attendee>Rita Kesrouani</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EHRMFR@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EHRMFR</pentabarf:event-slug>
            <pentabarf:title>An introduction to async programming - Writing a Telegram Antispam Bot in Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T150000</dtstart>
            <dtend>20220917T153000</dtend>
            <duration>003000</duration>
            <summary>An introduction to async programming - Writing a Telegram Antispam Bot in Python</summary>
            <description>The talk will provide a quick introduction to the basic concepts of async programming and demonstrate the techniques based on a Telegram antispam bot using the async library Pyrogram.

The async event loop will be covered, co-routines, the concept of awaiting input and how to think &quot;async&quot;.

The code for the project is available as a real working product at https://github.com/eGenix/egenix-telegram-antispam-bot

Slides of the talk are available at: https://downloads.egenix.com/python/PyCon-UK-2022-Talk-Intro-to-Async.pdf</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/EHRMFR/</url>
            <location>Assembly Room</location>
            
            <attendee>Marc-Andr&#233; Lemburg</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TWJLXS@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TWJLXS</pentabarf:event-slug>
            <pentabarf:title>Vectorise all the things! How basic linear algebra can speed up your data science code</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T160000</dtstart>
            <dtend>20220917T163000</dtend>
            <duration>003000</duration>
            <summary>Vectorise all the things! How basic linear algebra can speed up your data science code</summary>
            <description>Have you found that your data science code works beautifully on a few dozen test rows, but leaves you wondering how to spend the next couple of hours after you start looping through your full data set? Are you only familiar with Python, and wish there was a way to speed things up without subjecting yourself to learning C? In this talk, I will show you some simple tricks, borrowed from linear algebra, which can give you significant performance gains in your Python data science code. I will gently take you through the basics of linear algebra, explaining core operations such as matrix addition, subtraction and multiplication, scalar multiplication and the dot product. I will then show you some examples of how you can easily utilise these concepts in your machine learning code to speed up common data science operations such as distance calculations, classification tasks and finding nearest neighbours.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/TWJLXS/</url>
            <location>Assembly Room</location>
            
            <attendee>Jodie Burchell</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>VLMQNA@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-VLMQNA</pentabarf:event-slug>
            <pentabarf:title>Rapid prototyping in BBC News with Python and AWS</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T163000</dtstart>
            <dtend>20220917T170000</dtend>
            <duration>003000</duration>
            <summary>Rapid prototyping in BBC News with Python and AWS</summary>
            <description>BBC News Labs is an innovation team within BBC R&amp;D, working with journalists and production teams to build prototypes to demonstrate and trial new ideas for ways to help journalists or bring new experiences to audiences.

We work in short project cycles to research and build prototypes. We have worked with the BBC&apos;s flagship radio news programme production team to enrich programme timelines with metadata to provide enhanced experiences to the audience. We are currently working with local radio teams around the UK to provide the means to capture highlights in live radio for re-use and for social media, reducing the workload for producers, and getting more mileage from linear broadcast programmes.

Working in short cycles, it&apos;s important for us to be able to quickly build processing pipelines connected to BBC services, test and iterate on ideas and demonstrate working prototypes. We make use of modern cloud technologies to accelerate delivery and reduce friction.

In this talk I will share our ways of working, our ideation and research methods, and the tools we use to be able to build, deploy and iterate quickly, the BBC&apos;s cloud deployment platform, and our use of serverless AWS services such as Lambda, Step Functions and Serverless Postgres.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/VLMQNA/</url>
            <location>Assembly Room</location>
            
            <attendee>Ben Nuttall</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7Q3PWL@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7Q3PWL</pentabarf:event-slug>
            <pentabarf:title>Saturday Lightning Talks</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T170000</dtstart>
            <dtend>20220917T180000</dtend>
            <duration>010000</duration>
            <summary>Saturday Lightning Talks</summary>
            <description>1. Sean Sabbage: ADHD &amp; Me
2. Alastair Stanley: How to walk in a straight line
3. Alex Carney: Introducing Esbonio
4. Larry Hastings: Give your programs appeal!
5. Adrian Covaci: The secret life of Monads
6. Heather Williams: Chaos Game
7. Colin Moore-Hill: Build communities
8. Max Kahan: SnakeViz will get you a promotion
9. Mark Shannon: How you can help make Python 3.12 faster
10. Eshwari Chandrashekhar: Build vs Buy</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/7Q3PWL/</url>
            <location>Assembly Room</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>PUA8SW@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-PUA8SW</pentabarf:event-slug>
            <pentabarf:title>Getting started with Apache Airflow</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T110000</dtstart>
            <dtend>20220917T123000</dtend>
            <duration>013000</duration>
            <summary>Getting started with Apache Airflow</summary>
            <description>Have you wondered about what to do when cronjobs are not enough? Have you heard about Apache Airflow but don&apos;t know where to start? Come and join us!

This session aims to smoothly introduce the open-source data orchestration platform, teaching critical concepts through practical examples. We&apos;ll be encouraging best practices in writing workflows with Python, including using the Task Flow API, dynamic tasks and the open-source library Astro Python SDK.

Some of the topics covered:

* Building attractive DAGs (Direct Acyclic Graphs)
* How to not miss the schedule
* Running your DAGs locally
* Deploying Airflow
* Troubleshooting

The examples used in the session are based on open datasets.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/PUA8SW/</url>
            <location>Room A</location>
            
            <attendee>Tatiana Al-Chueyr</attendee>
            
            <attendee>Kaxil Naik</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UUZ7AM@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UUZ7AM</pentabarf:event-slug>
            <pentabarf:title>Coders: The Next Generation</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T140000</dtstart>
            <dtend>20220917T153000</dtend>
            <duration>013000</duration>
            <summary>Coders: The Next Generation</summary>
            <description>There is a big gap between the number of young people finishing school with digital skills and the jobs available, leaving companies struggling to fill roles. Corporate outreach and individual volunteering can be a great way of inspiring some of these young people to consider a career in computing, but it can be difficult to know where to start.

- Hear from educators working with young people, and how they adapt workshops for different age groups and settings
- Get tips and techniques for explaining complex concepts and communicating with young people
- Find out about various national organisations you can get involved with

After an interactive talk to cover the main points, we will workshop some of your outreach ideas in groups - bring along an activity that you would like to run with young people, or a concept/idea from your workplace that you would be interested in communicating, and together we will begin to develop them into interactive, exciting and accessible activities for young people.

Slides: bit.ly/coders_tng</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/UUZ7AM/</url>
            <location>Room A</location>
            
            <attendee>Sarah Townson</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KKCJXK@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KKCJXK</pentabarf:event-slug>
            <pentabarf:title>Build an automated watering system</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T110000</dtstart>
            <dtend>20220917T123000</dtend>
            <duration>013000</duration>
            <summary>Build an automated watering system</summary>
            <description>This workshop meant for max 30 people which will work in teams of 3, the workshop is suitable for beginners. 

Prerequisite:
Before the workshop, I would setup ssh on the Raspberry Pis and connect them to the wifi, additionally I would install pip3 on all Pis. I would also make sure every team has a pump, jumper cables, a battery and a relay. 

Step 1 (approximately 15 min):
I would ask the participants to form teams of three, ideally with mixed experience (e.g. 2 beginners and one advanced) 
Then I would briefly explain what ssh is and show them how to remote connect to their assigned Raspberry Pi by sharing my terminal. 

Step 2 (20 - 25 min): 
I would ask each team to install gpiozero using pip3 (showing on my terminal how it is done) and then encourage them to have a look at the gpiozero documentation and think how we could increase the voltage output for a certain amount of time on specific pins. After about 5 -10 min I would share a working script.

Step 3 (20 min):
In this step I will ask the teams to connect the relay to the Raspberry Pi, I will show a Powerpoint slide, showing the circuit, I will also briefly explain what a relay is, how it works and why we need it. 
After the teams have their relays connected they will be able to test their script by running it and seeing the control led on the relay flash for a moment.

Step 4 (20 min):
In this step the teams will connect the 5V battery and the pump to the relay and test whether the pump is working.

Step 5 (10 min):
Wrap up and feedback
We can discuss possible extensions (e.g. using a solar panel instead of a battery)
Get a feel for if people enjoyed the workshop/learned something</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/KKCJXK/</url>
            <location>Room B</location>
            
            <attendee>Astrid Novicky</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WZREUV@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WZREUV</pentabarf:event-slug>
            <pentabarf:title>Bulletproof Python &#8211; Property-Based Testing with Hypothesis</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T110000</dtstart>
            <dtend>20220917T123000</dtend>
            <duration>013000</duration>
            <summary>Bulletproof Python &#8211; Property-Based Testing with Hypothesis</summary>
            <description>Do you find yourself working through pages of copied and pasted tests to accommodate a simple code change? Does your software frequently break in unexpected ways despite your testing efforts? Don&#8217;t despair! Property-based testing could be your way out of that mess. Rather than working harder and writing more test code, property-based testing forces you to work smarter and test more code with fewer tests.

Traditional tests are example-based. They require the developer to come up with arbitrary inputs and check a system&#8217;s behavior against explicit outputs. More often than not, developers only think of inputs that are handled correctly by their code, thus leaving bugs hidden. Property-based tests generate the inputs for you and in many cases they&#8217;re more likely to find invalid inputs than humans. The difficulty lies in formulating these test cases.

After this workshop you&#8217;ll be comfortable with property-based testing using Hypothesis. You&#8217;ll have experience requesting appropriate test data from Hypothesis and in writing tests for common and more advanced properties. At work, your co-workers will be impressed by your unbreakable code ;)

Participants are expected to have basic familiarity with unit testing and a testing framework. Provided code examples use pytest.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/WZREUV/</url>
            <location>Room C</location>
            
            <attendee>Michael Seifert</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BQFTXC@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BQFTXC</pentabarf:event-slug>
            <pentabarf:title>Intro to FARM Stack: FastAPI, React &amp; MongoDB</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220917T140000</dtstart>
            <dtend>20220917T153000</dtend>
            <duration>013000</duration>
            <summary>Intro to FARM Stack: FastAPI, React &amp; MongoDB</summary>
            <description>A full-stack web application usually consists of a front-end that talks to a server, and a database that the server uses to store data. The FARM stack is a stack that consists of React on the frontend, FastAPI on the server, and MongoDB behind the scenes, storing the data.

This tutorial will introduce the stack components as part of a small application that will be partly pre-written. Once the component pieces have been introduced, I&apos;ll show how the application can be modified and extended, and how this affects each layer of the application. I&apos;ll explain how changes to the React model require changes to the FastAPI layer, and how these migrations can be applied to the database.

90 minutes isn&apos;t very long to introduce so many topics! Attendees will leave with an understanding of the advantages and disadvantages of using these components to build complete web applications, an idea of what it&apos;s like to work with a FARM application, and a thorough list of places to go to find out more.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/BQFTXC/</url>
            <location>Room C</location>
            
            <attendee>Mark Smith</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>M37RMN@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-M37RMN</pentabarf:event-slug>
            <pentabarf:title>Welcome &amp; UKPA AGM</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T090000</dtstart>
            <dtend>20220918T093000</dtend>
            <duration>003000</duration>
            <summary>Welcome &amp; UKPA AGM</summary>
            <description>Welcome</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/M37RMN/</url>
            <location>Assembly Room</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>9SWH88@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-9SWH88</pentabarf:event-slug>
            <pentabarf:title>Alternative History Retrocomputing</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T093000</dtstart>
            <dtend>20220918T100000</dtend>
            <duration>003000</duration>
            <summary>Alternative History Retrocomputing</summary>
            <description>We&apos;re all guilty of rolling our own implementation of existing code, but how far have you taken it? Ever reimplemented multiplication? Did you use CPU instructions that had _literally never been used before_?

The development of microprocessors like the Zilog Z80 and MOS 6502 in the 1970s eventually gave rise to the 8-bit home computers that many remember fondly. When Marcel van Kervinck and Walter Belgers designed the Gigatron, a quirky but surprisingly capable computer made from 74xx series logic ICs, they showed that a different course of history was possible - we could have had microcomputers without microprocessors, perhaps much earlier. They also created a world of unclimbed mountains: on the Gigatron you can be the first person to implement your favourite game or algorithm.

A few years ago I built a Gigatron, and I&apos;m having great fun with it. I started off trying to implement a Forth interpreter, but while I&apos;ve programmed for many years, I&apos;d never written low-level code before. I really thought it would be easy! In this talk I&apos;ll show what I&apos;ve achieved with the Gigatron, how working within the challenging architecture has broadened my perspective on programming, and how Python was at the heart of it all.

The talk will explore technical details, but won&apos;t require specialist knowledge. It&apos;s likely to touch on:
* Python as an assembly language
* Test Driven Development
* CFFI
* Hypothesis
* Data analysis with Matplotlib and other parts of the scientific stack.
* System Architecture
* Hard real-time programming
* Programming language implementation.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/9SWH88/</url>
            <location>Assembly Room</location>
            
            <attendee>Peter Russell</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>TT79KT@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-TT79KT</pentabarf:event-slug>
            <pentabarf:title>Visualising large datasets: everyone in the UK Census</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T100000</dtstart>
            <dtend>20220918T103000</dtend>
            <duration>003000</duration>
            <summary>Visualising large datasets: everyone in the UK Census</summary>
            <description>This talk provides a simple introduction into the use of Datashader to visualise large datasets. Rather than using some esoteric or fabricated data, it uses UK Census data that is relevant to everyone who was in the UK for the 2011 Census as it includes them all.

The talk begins with static plots produced by Datashader showing the locations and some key demographics of the Census data. This is then extended through the use of HoloViews and Bokeh to provide a more interactive experience.

No prior knowledge of Datashader is necessary but a basic familiarity with Pandas and Jupyter will be helpful.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/TT79KT/</url>
            <location>Assembly Room</location>
            
            <attendee>Ian Thomas</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>NWR7CE@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-NWR7CE</pentabarf:event-slug>
            <pentabarf:title>Pointers? In my Python? It&apos;s more likely than you think</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T110000</dtstart>
            <dtend>20220918T113000</dtend>
            <duration>003000</duration>
            <summary>Pointers? In my Python? It&apos;s more likely than you think</summary>
            <description>Python is a wonderful thing that takes all the complication of memory management away from us. We don&#8217;t have to worry about pre-allocating memory for our objects, or remember to free it once we&#8217;re done. So, given that we&#8217;re not doing it manually, how do these things happen? Do we have to care? Well, sometimes. Maybe.

In this talk, we&#8217;ll discuss what a pointer is, where they crop up in Python, and what you need to know in order to avoid getting tripped up by them. We&#8217;ll also cover the `id` of an object, how it varies between different implementations like IronPython and PyPy, and why `is` is different from `==`. Finally, we&#8217;ll talk about garbage collection, what reference counting is, and how CPython knows when it&#8217;s time to get rid of unused objects.

Whether you just want to understand what&#8217;s going on under the hood without having to dive into the implementation, or you&#8217;re on the hunt for some new diabolical things to do with code (self-referential lists are only the beginning!), come along to this talk and learn about the pointers in your Python.

This talk is aimed at anyone with an interest in how Python handles objects in memory, or who&#8217;s ever been confused by side-effects popping up in their code. Absolutely no knowledge of C is required, and Python beginners are extremely welcome.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/NWR7CE/</url>
            <location>Assembly Room</location>
            
            <attendee>Eli Holderness</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GS8JNQ@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GS8JNQ</pentabarf:event-slug>
            <pentabarf:title>Connecting those thoughts: Personal knowledge management with Python</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T113000</dtstart>
            <dtend>20220918T120000</dtend>
            <duration>003000</duration>
            <summary>Connecting those thoughts: Personal knowledge management with Python</summary>
            <description>Software has emerged in the last few years, such as Roam Research and Obsidian.md, for writing notes in a highly-connected format.  These apps can display notes in an extensive knowledge graph and have enabled a new wave of personal knowledge management (PKM) for the digital age.  This talk provides an introduction to personal knowledge management and shows how I used Python to improve my learning through my Obsidiantools package.

During my MPhil programme in Health Data Science at the University of Cambridge in 2021-22, I wrote all my notes as markdown files through Obsidian.md.  I developed the Obsidiantools package for analysing Obsidian.md vaults, in order to improve my Obsidian workflows and analyse my notes via the Python data science stack, NLP packages and NetworkX.  Within 3 months, I had written over 65k words in 250+ notes and used network analysis through the Python data stack to improve my strategy for studying.

Connected notes even go back hundreds of years in an analogue format, through the use of index cards and Zettelkasten systems.  In a more modern form, digital note vaults are at the intersection of NLP and network analysis, so there are data science challenges to tackle in those domains (Roam Research even offers a $150k prize for one of those challenges, in case you are tempted).

Talk structure:
- Introduction to personal knowledge management (PKM)
- My MPhil notes as connected notes
- The Obsidiantools package
- Data science challenges and wrap-up</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/GS8JNQ/</url>
            <location>Assembly Room</location>
            
            <attendee>Mark Farragher</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EPCHLV@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EPCHLV</pentabarf:event-slug>
            <pentabarf:title>OpenSAFELY: a python powered response to the COVID pandemic</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T120000</dtstart>
            <dtend>20220918T123000</dtend>
            <duration>003000</duration>
            <summary>OpenSAFELY: a python powered response to the COVID pandemic</summary>
            <description>OpenSAFELY is a secure, transparent, open-source software platform for analysis of electronic health records (EHR) data, built in Python.

OpenSAFELY was built as a fast response to the Covid-19 pandemic to provide almost real-time analysis of millions of NHS records related to Covid data such as hospitalisations, deaths, risk factors and vaccinations.

In this talk, we will tell the story of how OpenSAFELY came to be, the privacy, security and research goals it addresses with software, and how research best practices can be achieved by a cross-disciplinary team of researchers, epidemiologists and software developers working alongside each other.  

We will describe the particular challenges that face researchers working with potentially identifiable patient data, and how the inherent risks of such data can be mitigated.

A key concept is the idea of pseudonymised data; i.e. data where a patient&apos;s immediately identifiable information (name, exact address, date of birth etc) has been obfuscated). While this sort of data has been superficially anonymised, it can be quite easy to re-identify individuals from the information available. For example, a malicious intruder might easily find and read Boris Johnson&#8217;s entire health record by searching for a patient who matches information that is openly available on his Wikipedia page: his age, the dates he tested positive and was admitted to hospital for Covid-19, and the fact that he lives in London.  

OpenSAFELY is a range of tools that aims to allow analysis of EHR data while adhering to these principles; it aims to substantially exceed, by design, the current requirements on securing sensitive healthcare data.  OpenSAFELY does not move patient data outside of the secure environments where it already resides: instead, trusted analysts can run large scale computation across pseudonymised patient records in situ, and in near-real-time.

OpenSAFELY contains a range of flexible, pragmatic, but broadly standardised tools that users work with to convert raw patient data into &#8220;research ready&#8221; datasets, and to then execute code across those datasets. We will discuss the architecture of the platform, some of the tools we chose to use, and reasons for the design decisions made.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/EPCHLV/</url>
            <location>Assembly Room</location>
            
            <attendee>Becky Smith</attendee>
            
            <attendee>Simon Davy</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>YAGBSK@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-YAGBSK</pentabarf:event-slug>
            <pentabarf:title>Sunday Lightning Talks</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T123000</dtstart>
            <dtend>20220918T130000</dtend>
            <duration>003000</duration>
            <summary>Sunday Lightning Talks</summary>
            <description>1. Ian Thomas: Visualising large datasets
2. Adam Johnson: My PyCon photos
3. George Angelchev: How to keep calm and dev on
4. Alexander Fleischli: The coolest keyboard
5. Michal Grochmal: Let&apos;s write a (bad) programming language in 30 lines of python</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/YAGBSK/</url>
            <location>Assembly Room</location>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GS8EXT@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GS8EXT</pentabarf:event-slug>
            <pentabarf:title>Python on Hardware Community Showcase (Open Session)</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T110000</dtstart>
            <dtend>20220918T123000</dtend>
            <duration>013000</duration>
            <summary>Python on Hardware Community Showcase (Open Session)</summary>
            <description>Python on hardware is awesome, we have cPython, Micropython, CircuitPython, Snek and/or AnyOtherPython running on things like Rasberrpy Pis, micro:bits, CircuitPlaygrouds, Pyboards, Picos, ESP boards, and any other embedded device or Single Board Computer you can think of!

But what&#8217;s really cool is all the amazing things the community makes.
This is YOUR chance to show the world what you have been working on!

No matter how big or small, simple or complex, hacky or professional, we would love to check it out and hear all about it. And we meant it! This is an open space for all levels, from a blinking LED to a robot to conquer the world (well, maybe just make sure there is a kill- switch).
So, make a little bit of space in your suitcase and bring your Python on Hardware projects to Cardiff.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Something Else</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/GS8EXT/</url>
            <location>Room A</location>
            
            <attendee>Carlos Pereira Atencio</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BS8EA8@@pretalx.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BS8EA8</pentabarf:event-slug>
            <pentabarf:title>Introduction to Di&#225;taxis</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20220918T110000</dtstart>
            <dtend>20220918T123000</dtend>
            <duration>013000</duration>
            <summary>Introduction to Di&#225;taxis</summary>
            <description>I have run this workshop about 20 times in the last year; it&apos;s thoroughly road-tested with a wide range of audiences. 

It gives participants the opportunity to work though key aspects of the Di&#225;taxis framework in a structured, collaborative context.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Workshop</category>
            <url>https://pretalx.com/pycon-uk-2022/talk/BS8EA8/</url>
            <location>Room C</location>
            
            <attendee>Daniele Procida</attendee>
            
        </vevent>
        
    </vcalendar>
</iCalendar>
