PyCon UK 2022

Find the flaws in your codebase ... before they explode

The SS Richard Montgomery is a ship with a strange history. Sunk in the mouth of the Thames Estuary during WWII, she'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'll delve into some famous cases such as the Therac-25 incidents to show what can go wrong when we don't appreciate this. Let'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.

You have built an awesome API; time for some exposure! How do you keep a documentation website up-to-date as your code evolves? This workshop teaches you how to write, generate, host, automate and version your documentation easily so it becomes part of your software development life cycle.

Good API documentation is crucial to a new library’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’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.

In this session, we will train a ML model to predict ROI of variable advertising spend budgets across multiple channels including search, video, social media, and email using Snowpark for Python and scikit-learn.

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

Data often doesn’t come in the best format for analysis, and understanding it enough to extract insights requires both time and the skills to filter, aggregate, reshape, and visualize it. This session will equip you with the knowledge you need to effectively use pandas to make this process easier.

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.

Python 3.11 introduces new features that make it possible to raise and handle multiple unrelated exceptions. This talk briefly covers what they do and how they work, and answers a frequently asked question: why we needed to add new language syntax to handle exception groups.

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.

Apache Kafka® is the de facto standard in the data streaming world for sending messages from multiple producers to multiple consumers, in a fast, reliable and scalable manner. Come and learn the basic concepts and how to use it, by modelling a fish and chips shop!

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'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® - it provides all the capabilities we are looking for. In this talk, rather than considering some imaginary IoT scenario, I'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'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.

While PyScript is not yet ready for production use, it has provided an opportunity for a back-end Python developer like me to learn more about front-end web development. This talk chronicles how I used PyScript in my journey to better understand how to build web applications in Python!

This talk chronicles how I used Python to journey from web ‘noob’ to something greater. While I’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'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 “very alpha” and not yet suitable for production, it has proven to be a useful tool for exploration and learning.

A deep dive into python functions and the callable interface. We take a tour into everything that happens on on a “def” line and when you call the resulting function. We'll also explore how to harness detailed function metadata, and how to hack the decorator pattern.

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’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’ll start with a quick tour of the basics, before covering python’s more advanced callable features, and exploring some examples about how, why, and when you may wish to use these features yourself.

Ok, I lied, I still write tests. But instead of the example-based tests that we normally write, have you heard of property-based testing? By using Hypothesis, instead of thinking about what data I should test it for, it will generate test data, including boundary cases, for you.

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 “normally do” - 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.

Dogs wag their tails. When the opposite happens, it represents a disturbing, problematic reversal of the proper order. But not in software and its documentation! I believe the tail of documentation can and should wag the dog of software, and I'll show just how powerful this tail can be.

The tail of the dog expresses its disposition and reflects its health, and we expect it to be a reliable outward sign of what'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ïve view of both dogs and software. I will discuss, with examples, why it's a problematic idea for documentation. It'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's something they can use to their advantage. In other words, the tail is already wagging the dog, and that's the way it should be. This talk is about documentation, but it'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'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.

In research, peer review is considered a pillar of trust. This is problematic. A lot of research is, at best, not reproducible or, sometimes, even wrong, despite peer review. This talk will discuss the origins of peer review, problems with peer review and some things that could be better.

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'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: "If we were inventing the research publication pipeline today, what would it look like?". 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 "trust the research" means.

Property-based testing is a great benefit to the robustness and maintainability of your software. Yet, the technique is still vastly underused in the Python community. The workshop gives a hands-on introduction to Hypothesis and practices different approaches for writing property-based tests.

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’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’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’re more likely to find invalid inputs than humans. The difficulty lies in formulating these test cases. After this workshop you’ll be comfortable with property-based testing using Hypothesis. You’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.

In this workshop we will use a Raspberry Pi, a relay, a pump and a battery to build a watering system from scratch. I built this system during the pandemic, in the hope my plants would survive after being allowed to travel again.

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

Learning Apache Airflow may seem daunting for those adventuring in the data world. This workshop aims to save engineers and scientists time. By the end of this session, attendees will have written two workflows which solve practical problems, running them locally and deploying them in a production-like environment.

Have you wondered about what to do when cronjobs are not enough? Have you heard about Apache Airflow but don'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'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.

According to the WHO over 1 billion people live with some form of disability; almost everyone is likely to experience some form of disability at some point. This talk discusses the importance of web accessibility and how I used python to develop a tool that ensembles multiple accessibility evaluation tools.

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’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.

Technical debt is the elephant in the room: complex engineering problems meet awkward organizational issues. To make it more tangible, we'll divide it into 3 categories and discuss engineering and business strategies for each: - Gather info about **vague** issues. - Express **antipatterns** as code. - Automatically fix **straightforward** issues.

## 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'll discuss not just the technical complexities, but also the business impact and the organizational challenges. We'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.

Let’s take a closer look at generators and why you may not be getting your expected improvements. Sometimes the memory benefit is negated by necessity; sometimes it's by mistake. "Meta generators" can solve this problem, allowing a much wider range of safe, fast operations on very large generators.

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 "safe" 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 – "meta-generators" – also doubles as a recommendation for a future language feature.

HPy is a new C API for Python. Unlike the standard one, it isn't tied to CPython implementation details. It is therefore fully compatible with alternate implementations and with any future changes to CPython itself.

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'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'll discuss its current status and show how existing extensions can be gradually ported to it.

Interested in running activities with young people, but unsure where to start? In this workshop you’ll hear some expert tips from educators, then work in groups to develop your concepts into accessible outreach activities!

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

FastAPI is an asynchronous Python web framework that is "performant, easy to learn, fast to code & ready for production; React is one of the most popular JavaScript frameworks; and MongoDB is a database that stores JSON-like data. Let's build an app to put them all together!

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'll show how the application can be modified and extended, and how this affects each layer of the application. I'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'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's like to work with a FARM application, and a thorough list of places to go to find out more.

What if I told you that you could write simpler tests but get better results? What if I told you can automatically generate your test data? This may sound difficult to your traditional testing approach but can be easily done with Hypothesis, the Python library used for property-based testing.

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’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.

Learn how JPMorgan gave access to Python to hundreds of non-developers: what infrastructure was required, what training was given and how to shift the culture. Lessons learnt from the human side of Python.

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 & 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’ll share them so that you too can give Python to non-developers.

Learn how easy it is to get started with asynchronous programming in Python. 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 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 "async". 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

Do you feel like your data science code is horribly inefficient, but you don’t know how to make things faster? Fear not! In this talk, we’ll speed up some common operations using tricks from linear algebra - all within the comfort of the Python ecosystem.

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.

BBC News Labs is an innovation team within BBC R&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 make use of modern cloud technologies to accelerate delivery and reduce friction.

BBC News Labs is an innovation team within BBC R&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'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'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's cloud deployment platform, and our use of serverless AWS services such as Lambda, Step Functions and Serverless Postgres.

Python is a very high-level programming language. I've been using it for very low-level programming. We'll meet an unusual computer.

We'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'm having great fun with it. I started off trying to implement a Forth interpreter, but while I've programmed for many years, I'd never written low-level code before. I really thought it would be easy! In this talk I'll show what I'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't require specialist knowledge. It'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.

Visualising large datasets requires care and specialised tools to understand both the big picture and the fine details. This talk uses Datashader to visualise the location and demographics of everyone in the UK. Expect beautiful plots and interesting things to learn about both the tools and the data.

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.

Learn about Python's memory handling, including: - what pointers are, and why it matters - what object IDs are, and what they mean - how CPython can tell when you're done with an object, and what happens next No C knowledge required!

Python is a wonderful thing that takes all the complication of memory management away from us. We don’t have to worry about pre-allocating memory for our objects, or remember to free it once we’re done. So, given that we’re not doing it manually, how do these things happen? Do we have to care? Well, sometimes. Maybe. In this talk, we’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’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’ll talk about garbage collection, what reference counting is, and how CPython knows when it’s time to get rid of unused objects. Whether you just want to understand what’s going on under the hood without having to dive into the implementation, or you’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’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.

Over the last year, the [Diátaxis documentation framework](https://diataxis.fr) has taken off in popularity. This workshop provides a brief introduction to the framework, and includes a number of hands-on exercises. It will be useful for anyone who has to work with software documentation.

I have run this workshop about 20 times in the last year; it's thoroughly road-tested with a wide range of audiences. It gives participants the opportunity to work though key aspects of the Diátaxis framework in a structured, collaborative context.

From tiny to massive, everything and everyone are welcomed! An open session for any conference attendee to bring their hardware projects and show them to the (PyCon UK) world. Just curious? Come around to check them out!

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’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.

Apps such as Obsidian.md have revolutionised note-taking for the digital age, through connected markdown files. I discuss how I developed a Python package that enabled me to become more effective at learning at university and built a knowledge graph of 500+ notes.

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

OpenSAFELY is a secure, transparent, open-source platform, built in Python, in response to the COVID pandemic. It provides almost real-time analysis of millions of electronic health records. We will discuss privacy, security and research goals achieved by a cross-disciplinary team of researchers, epidemiologists and developers working together.

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'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’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 “research ready” 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.