Merge pull request #1194 from pyvideo/pycon-uk-2022

PyCon UK 2022 and 2023

pycon-uk-2022/category.json

@@ -0,0 +1,3 @@
+{
+    "title": "PyCon UK 2022"
+}

pycon-uk-2022/videos/alternative-history-retrocomputing.json

@@ -0,0 +1,22 @@
+{
+    "description": "Python is a very high-level programming language. I've been using it for very low-level programming. We'll meet an unusual computer.\n\nWe'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_?\n\nThe 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.\n\nA 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.\n\nThe talk will explore technical details, but won't require specialist knowledge. It's likely to touch on:\n* Python as an assembly language\n* Test Driven Development\n* CFFI\n* Hypothesis\n* Data analysis with Matplotlib and other parts of the scientific stack.\n* System Architecture\n* Hard real-time programming\n* Programming language implementation.",
+    "language": "eng",
+    "recorded": "2022-09-18",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Peter Russell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/1gIX_-ABHs8/hqdefault.jpg",
+    "title": "Alternative History Retrocomputing",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=1gIX_-ABHs8"
+        }
+    ]
+}

pycon-uk-2022/videos/an-introduction-to-async-programming-writing-a-telegram-antispam-bot-in-python.json

@@ -0,0 +1,22 @@
+{
+    "description": "Learn how easy it is to get started with asynchronous programming in Python.\n\nThe 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.\n\nThe 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.\n\nThe async event loop will be covered, co-routines, the concept of awaiting input and how to think \"async\".\n\nThe code for the project is available as a real working product at https://github.com/eGenix/egenix-telegram-antispam-bot\n\nSlides of the talk are available at: https://downloads.egenix.com/python/PyCon-UK-2022-Talk-Intro-to-Async.pdf",
+    "language": "eng",
+    "recorded": "2022-09-17",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Marc-Andr\u00e9 Lemburg"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nq2GkEK01CA/hqdefault.jpg",
+    "title": "An introduction to async programming - Writing a Telegram Antispam Bot in Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=nq2GkEK01CA"
+        }
+    ]
+}

pycon-uk-2022/videos/connecting-those-thoughts-personal-knowledge-management-with-python.json

@@ -0,0 +1,22 @@
+{
+    "description": "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.\n\nSoftware 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.\n\nDuring 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.\n\nConnected 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).\n\nTalk structure:\n- Introduction to personal knowledge management (PKM)\n- My MPhil notes as connected notes\n- The Obsidiantools package\n- Data science challenges and wrap-up",
+    "language": "eng",
+    "recorded": "2022-09-18",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Mark Farragher"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/rom7BzoxD8c/hqdefault.jpg",
+    "title": "Connecting those thoughts: Personal knowledge management with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=rom7BzoxD8c"
+        }
+    ]
+}

pycon-uk-2022/videos/do-not-trust-my-or-any-computational-research.json

@@ -0,0 +1,22 @@
+{
+    "description": "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.\n\nIn 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.\n\nI will discuss the historic origins of peer review and highlight a number of problems that are prevalent as a result.\n\nThis 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?\n\nI 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).\n\nThis will conclude with a hopefully optimistic answer to the question: \"If we were inventing the research publication pipeline today, what would it look like?\".\n\nI 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.",
+    "language": "eng",
+    "recorded": "2022-09-17",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Vincent Knight"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/kHxXdMA2LvI/hqdefault.jpg",
+    "title": "Do not trust my [or any] computational research.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=kHxXdMA2LvI"
+        }
+    ]
+}

pycon-uk-2022/videos/exception-groups-and-except.json

@@ -0,0 +1,22 @@
+{
+    "description": "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.\n\nPython 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.",
+    "language": "eng",
+    "recorded": "2022-09-16",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Irit Katriel"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/uARIj9eAZcQ/hqdefault.jpg",
+    "title": "Exception Groups and except*",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=uARIj9eAZcQ"
+        }
+    ]
+}

pycon-uk-2022/videos/fish-and-chips-and-apache-kafka-r.json

@@ -0,0 +1,22 @@
+{
+    "description": "Apache Kafka\u00ae is the de facto standard in the data streaming world for sending\nmessages from multiple producers to multiple consumers, in a fast, reliable\nand scalable manner.\n\nCome and learn the basic concepts and how to use it, by modelling a fish and\nchips shop!\n\nHandling large numbers of events is an increasing challenge in our cloud\ncentric world. For instance, in the IoT (Internet of Things) industry, devices\nare all busy announcing their current state, which we want to\nmanage and report on, and meanwhile we want to send firmware and other updates\n*back* to specific groups of devices.\n\nTraditional messaging solutions don't scale well for this type of problem. We\nwant to guarantee not to lose events, to handle high volumes in a timely\nmanner, and to be able to distribute message reception or production across\nmultiple consumers or producers (compare to sharding for database reads).\n\nAs it turns out, there is a good solution available: Apache Kafka\u00ae - it\nprovides all the capabilities we are looking for.\n\nIn this talk, rather than considering some imaginary IoT scenario, I'm going\nto look at how one might use Kafka to model the events required to run a fish\nand chip shop: ordering (plaice and chips for me, please), food preparation,\naccounting and so on.\n\nI'll demonstrate handling of multiple producers and consumers, automatic routing of\nevents as new consumers are added, persistence, which allows a new consumer to\nstart consuming events from the past, and more.",
+    "language": "eng",
+    "recorded": "2022-09-16",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Tibs"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/uFUjnpCJ7xI/hqdefault.jpg",
+    "title": "Fish and Chips and Apache Kafka\u00ae",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=uFUjnpCJ7xI"
+        }
+    ]
+}

pycon-uk-2022/videos/friday-lightning-talks.json

@@ -0,0 +1,20 @@
+{
+    "description": "Lightning Talks\n\nLightning Talks",
+    "language": "eng",
+    "recorded": "2022-09-16",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [],
+    "thumbnail_url": "https://i.ytimg.com/vi/bDo0FKmosnA/hqdefault.jpg",
+    "title": "Friday Lightning Talks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=bDo0FKmosnA"
+        }
+    ]
+}

pycon-uk-2022/videos/friday-welcome-session.json

@@ -0,0 +1,20 @@
+{
+    "description": "Welcome\n\nWelcome",
+    "language": "eng",
+    "recorded": "2022-09-16",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [],
+    "thumbnail_url": "https://i.ytimg.com/vi/YUoKAl6-w5I/hqdefault.jpg",
+    "title": "Friday Welcome Session",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=YUoKAl6-w5I"
+        }
+    ]
+}

pycon-uk-2022/videos/giving-python-to-non-developers-a-real-life-story.json

@@ -0,0 +1,23 @@
+{
+    "description": "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.\n\nWhen JPMorgan decided to give Python development tools to hundreds of non-developers, it was a no-brainer.\n\nGiven 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.  \n\nBut how?\n\nClearly the infrastructure had to be there: a Python development & runtime environment, access to data and to JPMorgan analytics.\n\nBut having the infrastructure ready was only the beginning.  We needed training.  It needed to be relevant, rewarding, and even fun.  \n\nAnd 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?\n\nThis is the story of our on-going journey.  We learnt some important lessons along the way.  We\u2019ll share them so that you too can give Python to non-developers.",
+    "language": "eng",
+    "recorded": "2022-09-17",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Philippe Masson",
+        "Rita Kesrouani"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/6vL_ObBL2dI/hqdefault.jpg",
+    "title": "Giving Python to non-developers: A real-life story",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=6vL_ObBL2dI"
+        }
+    ]
+}

pycon-uk-2022/videos/how-to-wag-a-dog.json

@@ -0,0 +1,22 @@
+{
+    "description": "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.\n\nThe 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.\n\nI think that this is a na\u00efve view of both dogs and software. \n\nI 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. \n\nIn other words, the tail is already wagging the dog, and that's the way it should be.\n\nThis 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.\n\nAlong 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. \n\nWe'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.",
+    "language": "eng",
+    "recorded": "2022-09-16",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Daniele Procida"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/rNGj2lFGyiA/hqdefault.jpg",
+    "title": "How to wag a dog",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=rNGj2lFGyiA"
+        }
+    ]
+}

pycon-uk-2022/videos/hpy-a-better-c-api-for-python.json

@@ -0,0 +1,22 @@
+{
+    "description": "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.\n\nThe 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. \nHowever, 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 \nprevents major evolutions of CPython itself, such as using a GC instead of refcounting, or removing the GIL.\n\nThis is where HPy comes in. It's a new C API designed from the ground up according to the following goals:\n* running much faster on alternate implementations, and at native speed on CPython\n* making it possible to compile a single binary which runs unmodified on all supported Python implementations and versions\n* being simpler and more manageable than the Python/C API\n* providing an improved debugging experience.\n\nWe'll discuss its current status and show how existing extensions can be gradually ported to it.",
+    "language": "eng",
+    "recorded": "2022-09-17",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://2022.pyconuk.org/"
+        }
+    ],
+    "speakers": [
+        "Ronan Lamy"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/R9lmvVfGqdo/hqdefault.jpg",
+    "title": "HPy: a better C API for Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=R9lmvVfGqdo"
+        }
+    ]
+}