diff --git a/pycon-uk-2022/category.json b/pycon-uk-2022/category.json new file mode 100644 index 000000000..a25719a49 --- /dev/null +++ b/pycon-uk-2022/category.json @@ -0,0 +1,3 @@ +{ + "title": "PyCon UK 2022" +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/alternative-history-retrocomputing.json b/pycon-uk-2022/videos/alternative-history-retrocomputing.json new file mode 100644 index 000000000..b588757b6 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/an-introduction-to-async-programming-writing-a-telegram-antispam-bot-in-python.json b/pycon-uk-2022/videos/an-introduction-to-async-programming-writing-a-telegram-antispam-bot-in-python.json new file mode 100644 index 000000000..5f5cba997 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/connecting-those-thoughts-personal-knowledge-management-with-python.json b/pycon-uk-2022/videos/connecting-those-thoughts-personal-knowledge-management-with-python.json new file mode 100644 index 000000000..949142279 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/do-not-trust-my-or-any-computational-research.json b/pycon-uk-2022/videos/do-not-trust-my-or-any-computational-research.json new file mode 100644 index 000000000..557bd2f06 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/exception-groups-and-except.json b/pycon-uk-2022/videos/exception-groups-and-except.json new file mode 100644 index 000000000..3572055b6 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/fish-and-chips-and-apache-kafka-r.json b/pycon-uk-2022/videos/fish-and-chips-and-apache-kafka-r.json new file mode 100644 index 000000000..76ee437d0 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/friday-lightning-talks.json b/pycon-uk-2022/videos/friday-lightning-talks.json new file mode 100644 index 000000000..adc9d014e --- /dev/null +++ b/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" + } + ] +} diff --git a/pycon-uk-2022/videos/friday-welcome-session.json b/pycon-uk-2022/videos/friday-welcome-session.json new file mode 100644 index 000000000..5893b5c43 --- /dev/null +++ b/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" + } + ] +} diff --git a/pycon-uk-2022/videos/giving-python-to-non-developers-a-real-life-story.json b/pycon-uk-2022/videos/giving-python-to-non-developers-a-real-life-story.json new file mode 100644 index 000000000..5545060d4 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/how-to-wag-a-dog.json b/pycon-uk-2022/videos/how-to-wag-a-dog.json new file mode 100644 index 000000000..ddf0d8d8f --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/hpy-a-better-c-api-for-python.json b/pycon-uk-2022/videos/hpy-a-better-c-api-for-python.json new file mode 100644 index 000000000..0d69def25 --- /dev/null +++ b/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" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/i-hate-writing-tests-that-s-why-i-use-hypothesis.json b/pycon-uk-2022/videos/i-hate-writing-tests-that-s-why-i-use-hypothesis.json new file mode 100644 index 000000000..c9c22c5ef --- /dev/null +++ b/pycon-uk-2022/videos/i-hate-writing-tests-that-s-why-i-use-hypothesis.json @@ -0,0 +1,22 @@ +{ + "description": "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.\n\nIn 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.\n\nAt the start of the talk, we will understand the power of property-based tests, what is it, how is it different from what we \u201cnormally do\u201d - 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.\n\nAfter that, we will also explore the Ghostwriters in Hypothesis which will actually write the test for you.\n\nThis 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.", + "language": "eng", + "recorded": "2022-09-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Cheuk Ting Ho" + ], + "thumbnail_url": "https://i.ytimg.com/vi/A_Ow-XdmyLU/hqdefault.jpg", + "title": "I hate writing tests, that's why I use Hypothesis", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=A_Ow-XdmyLU" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/it-s-your-call-able-a-tour-of-python-s-callable-function-interface.json b/pycon-uk-2022/videos/it-s-your-call-able-a-tour-of-python-s-callable-function-interface.json new file mode 100644 index 000000000..7ef636f32 --- /dev/null +++ b/pycon-uk-2022/videos/it-s-your-call-able-a-tour-of-python-s-callable-function-interface.json @@ -0,0 +1,22 @@ +{ + "description": "A deep dive into python functions and the callable interface. We take a tour into everything that happens on on a \u201cdef\u201d 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.\n\nFunctions 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. \n\nHowever, 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.\n\nLots 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\u2019s callable interface is particularly useful when writing generic, automation focused code, and understanding how such prominent libraries work.\n\nThis talk gives a deep-dive into python functions, and the associated callable interface. We\u2019ll start with a quick tour of the basics, before covering python\u2019s more advanced callable features, and exploring some examples about how, why, and when you may wish to use these features yourself.", + "language": "eng", + "recorded": "2022-09-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Dom Weldon" + ], + "thumbnail_url": "https://i.ytimg.com/vi/a63rn66Hu74/hqdefault.jpg", + "title": "It's Your Call(able): a tour of Python's callable (function) interface", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=a63rn66Hu74" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/living-with-technical-debt-acknowledge-it-specify-it-reduce-it.json b/pycon-uk-2022/videos/living-with-technical-debt-acknowledge-it-specify-it-reduce-it.json new file mode 100644 index 000000000..788580dd4 --- /dev/null +++ b/pycon-uk-2022/videos/living-with-technical-debt-acknowledge-it-specify-it-reduce-it.json @@ -0,0 +1,23 @@ +{ + "description": "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:\n\n- Gather info about **vague** issues.\n- Express **antipatterns** as code.\n- Automatically fix **straightforward** issues.\n\n## Summary\n\nIn this talk, we make tech debt more tangible by dividing it into 3 categories and showing strategies for each:\n\n- vague issues\n- antipatterns\n- fixable problems\n\nIn 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.\n\n## Vague Issues: Acknowledge Them\n\n- Make it visible when working with the code.\n- Make it visible when taking business decisions.\n- Acknowledge the business impact: longer development time, higher probability of bugs.\n- Encourage open and constructive discussion.\n- Gather info about this specific issue and recognize general patterns.\n\n## Identify Antipatterns And Express Them As Code\n\n- General vs specific to your codebase: Not an either - or, but rather a continuum.\n- Express antipatterns as code.\n- Find similar issues across the whole code base.\n- Avoid adding even more debt of the same kind.\n\n## Automatically fix straightforward issues\n\n- If the antipattern can be codified, perhaps the fix can be codified as well.\n- Roll out fixes with large-scale changes.\n- Risks of large-scale changes.\n- Avoid re-adding the same kind of debt.", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Reka Horvath", + "Tim Gilboy" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Ugyz8aEyBMo/hqdefault.jpg", + "title": "Living With Technical Debt: Acknowledge It, Specify It, Reduce It", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Ugyz8aEyBMo" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/meta-generators-playing-safe-with-long-sequences.json b/pycon-uk-2022/videos/meta-generators-playing-safe-with-long-sequences.json new file mode 100644 index 000000000..f90cd1d35 --- /dev/null +++ b/pycon-uk-2022/videos/meta-generators-playing-safe-with-long-sequences.json @@ -0,0 +1,22 @@ +{ + "description": "Let\u2019s 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.\n\nThrough 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).\n\nThe 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).\n\nThe second part of the talk, which will explain our solution to this problem \u2013 \"meta-generators\" \u2013 also doubles as a recommendation for a future language feature.", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Alastair Stanley" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Pk3ijT7O-S0/hqdefault.jpg", + "title": "Meta Generators: Playing Safe with Long Sequences", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Pk3ijT7O-S0" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/opensafely-a-python-powered-response-to-the-covid-pandemic.json b/pycon-uk-2022/videos/opensafely-a-python-powered-response-to-the-covid-pandemic.json new file mode 100644 index 000000000..d7dd62745 --- /dev/null +++ b/pycon-uk-2022/videos/opensafely-a-python-powered-response-to-the-covid-pandemic.json @@ -0,0 +1,23 @@ +{ + "description": "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.\n\nOpenSAFELY is a secure, transparent, open-source software platform for analysis of electronic health records (EHR) data, built in Python.\n\nOpenSAFELY 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.\n\nIn 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. \n\nWe 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.\n\nA 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\u2019s 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. \n\nOpenSAFELY 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.\n\nOpenSAFELY contains a range of flexible, pragmatic, but broadly standardised tools that users work with to convert raw patient data into \u201cresearch ready\u201d 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.", + "language": "eng", + "recorded": "2022-09-18", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Becky Smith", + "Simon Davy" + ], + "thumbnail_url": "https://i.ytimg.com/vi/L55mq5wi3Cc/hqdefault.jpg", + "title": "OpenSAFELY: a python powered response to the COVID pandemic", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=L55mq5wi3Cc" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/pointers-in-my-python-it-s-more-likely-than-you-think.json b/pycon-uk-2022/videos/pointers-in-my-python-it-s-more-likely-than-you-think.json new file mode 100644 index 000000000..0dd8d2bc6 --- /dev/null +++ b/pycon-uk-2022/videos/pointers-in-my-python-it-s-more-likely-than-you-think.json @@ -0,0 +1,22 @@ +{ + "description": "Learn about Python's memory handling, including:\n- what pointers are, and why it matters\n- what object IDs are, and what they mean\n- how CPython can tell when you're done with an object, and what happens next\n\nNo C knowledge required!\n\nPython is a wonderful thing that takes all the complication of memory management away from us. We don\u2019t have to worry about pre-allocating memory for our objects, or remember to free it once we\u2019re done. So, given that we\u2019re not doing it manually, how do these things happen? Do we have to care? Well, sometimes. Maybe.\n\nIn this talk, we\u2019ll 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\u2019ll 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\u2019ll talk about garbage collection, what reference counting is, and how CPython knows when it\u2019s time to get rid of unused objects.\n\nWhether you just want to understand what\u2019s going on under the hood without having to dive into the implementation, or you\u2019re 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.\n\nThis talk is aimed at anyone with an interest in how Python handles objects in memory, or who\u2019s ever been confused by side-effects popping up in their code. Absolutely no knowledge of C is required, and Python beginners are extremely welcome.", + "language": "eng", + "recorded": "2022-09-18", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Eli Holderness" + ], + "thumbnail_url": "https://i.ytimg.com/vi/ITr3O3sqhVg/hqdefault.jpg", + "title": "Pointers? In my Python? It's more likely than you think", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=ITr3O3sqhVg" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/property-based-testing-the-python-way.json b/pycon-uk-2022/videos/property-based-testing-the-python-way.json new file mode 100644 index 000000000..3de479021 --- /dev/null +++ b/pycon-uk-2022/videos/property-based-testing-the-python-way.json @@ -0,0 +1,22 @@ +{ + "description": "What if I told you that you could write simpler tests but get better results?\n\nWhat if I told you can automatically generate your test data?\n\nThis may sound difficult to your traditional testing approach but can be easily done with Hypothesis, the Python library used for property-based testing.\n\nThis 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.\n\nThe talk approaches a simple problem from two different testing perspectives. Giving you an idea about property-based testing and how it\u2019s different from the traditional approach with Python. \n\nThe main focus of the topic would be Hypothesis and how you can achieve your testing goals with it. \n\nBy 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. \n\nGiven below is a rough overview of the talk structure:\n The testing problem. \n The traditional approach.\n Cons of traditional approach.\n What property-based testing.\n Intro to Hypothesis. \n Same problem solution with Hypothesis.\n Why choose Hypothesis as a go-to property based testing tool.\n Parameterized testing with Pytest vs Hypothesis approach. \n When or when not to use property based testing. \n How you can adopt `hypothesis` in your code base.", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Emma Saroyan" + ], + "thumbnail_url": "https://i.ytimg.com/vi/CBZkgR6a1IM/hqdefault.jpg", + "title": "Property-Based Testing the Python Way", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=CBZkgR6a1IM" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/pyscript-and-my-journey-to-the-web.json b/pycon-uk-2022/videos/pyscript-and-my-journey-to-the-web.json new file mode 100644 index 000000000..e2c1c3334 --- /dev/null +++ b/pycon-uk-2022/videos/pyscript-and-my-journey-to-the-web.json @@ -0,0 +1,22 @@ +{ + "description": "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!\n\nThis talk chronicles how I used Python to journey from web \u2018noob\u2019 to something greater. \n\nWhile I\u2019ve 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.\n\nPyScript 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 \u201cvery alpha\u201d and not yet suitable for production, it has proven to be a useful tool for exploration and learning.", + "language": "eng", + "recorded": "2022-09-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Scott Irwin" + ], + "thumbnail_url": "https://i.ytimg.com/vi/R1e6JuaVyxg/hqdefault.jpg", + "title": "PyScript and my journey to the Web", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=R1e6JuaVyxg" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/rapid-prototyping-in-bbc-news-with-python-and-aws.json b/pycon-uk-2022/videos/rapid-prototyping-in-bbc-news-with-python-and-aws.json new file mode 100644 index 000000000..aecdd4918 --- /dev/null +++ b/pycon-uk-2022/videos/rapid-prototyping-in-bbc-news-with-python-and-aws.json @@ -0,0 +1,22 @@ +{ + "description": "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.\n\nBBC 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.\n\nWe 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.\n\nWorking 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.\n\nIn 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.", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Ben Nuttall" + ], + "thumbnail_url": "https://i.ytimg.com/vi/LIy964OVRKw/hqdefault.jpg", + "title": "Rapid prototyping in BBC News with Python and AWS", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=LIy964OVRKw" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/saturday-lightning-talks.json b/pycon-uk-2022/videos/saturday-lightning-talks.json new file mode 100644 index 000000000..91c84a4d0 --- /dev/null +++ b/pycon-uk-2022/videos/saturday-lightning-talks.json @@ -0,0 +1,20 @@ +{ + "description": "Lightning Talks\n\n1. Sean Sabbage: ADHD & Me\n2. Alastair Stanley: How to walk in a straight line\n3. Alex Carney: Introducing Esbonio\n4. Larry Hastings: Give your programs appeal!\n5. Adrian Covaci: The secret life of Monads\n6. Heather Williams: Chaos Game\n7. Colin Moore-Hill: Build communities\n8. Max Kahan: SnakeViz will get you a promotion\n9. Mark Shannon: How you can help make Python 3.12 faster\n10. Eshwari Chandrashekhar: Build vs Buy", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [], + "thumbnail_url": "https://i.ytimg.com/vi/FFZHt_BPXXE/hqdefault.jpg", + "title": "Saturday Lightning Talks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=FFZHt_BPXXE" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/saturday-welcome-session.json b/pycon-uk-2022/videos/saturday-welcome-session.json new file mode 100644 index 000000000..df4457cda --- /dev/null +++ b/pycon-uk-2022/videos/saturday-welcome-session.json @@ -0,0 +1,20 @@ +{ + "description": "Welcome\n\nWelcome", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [], + "thumbnail_url": "https://i.ytimg.com/vi/mRm9AjnGoBs/hqdefault.jpg", + "title": "Saturday Welcome Session", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=mRm9AjnGoBs" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/sunday-lightning-talks.json b/pycon-uk-2022/videos/sunday-lightning-talks.json new file mode 100644 index 000000000..6afeb39f0 --- /dev/null +++ b/pycon-uk-2022/videos/sunday-lightning-talks.json @@ -0,0 +1,26 @@ +{ + "description": "Lightning Talks\n\n1. Ian Thomas: Visualising large datasets\n2. Adam Johnson: My PyCon photos\n3. George Angelchev: How to keep calm and dev on\n4. Alexander Fleischli: The coolest keyboard\n5. Michal Grochmal: Let's write a (bad) programming language in 30 lines of python", + "language": "eng", + "recorded": "2022-09-18", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Adam Johnson", + "Alexander Fleischli", + "George Angelchev", + "Ian Thomas", + "Michal Grochmal" + ], + "thumbnail_url": "https://i.ytimg.com/vi/NbkD0hNyetg/hqdefault.jpg", + "title": "Sunday Lightning Talks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=NbkD0hNyetg" + } + ] +} diff --git a/pycon-uk-2022/videos/unexploded-bombs.json b/pycon-uk-2022/videos/unexploded-bombs.json new file mode 100644 index 000000000..5c5e5032d --- /dev/null +++ b/pycon-uk-2022/videos/unexploded-bombs.json @@ -0,0 +1,22 @@ +{ + "description": "Find the flaws in your codebase ... before they explode\n\nThe 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.\n\nEvery 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.\n\nLet'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.", + "language": "eng", + "recorded": "2022-09-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Hannah Hazi" + ], + "thumbnail_url": "https://i.ytimg.com/vi/9N6Ykdv9T2E/hqdefault.jpg", + "title": "Unexploded Bombs", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=9N6Ykdv9T2E" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/using-python-to-create-a-prototype-for-web-accessibility-research.json b/pycon-uk-2022/videos/using-python-to-create-a-prototype-for-web-accessibility-research.json new file mode 100644 index 000000000..e6537c006 --- /dev/null +++ b/pycon-uk-2022/videos/using-python-to-create-a-prototype-for-web-accessibility-research.json @@ -0,0 +1,22 @@ +{ + "description": "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.\n\nThe 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.\n \nThe 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.\nThis 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.\n \nPython\u2019s rich set of libraries such as wxPython, matplotlib, numpy and pandas made this project possible within a short timeframe.\n \nThe 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\nThis talk hopes to inspire others to use python to conduct research and improve web accessibility.", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Peter Johnson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/9l7H9s1VRrg/hqdefault.jpg", + "title": "Using python to create a prototype for web accessibility research", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=9l7H9s1VRrg" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/vectorise-all-the-things-how-basic-linear-algebra-can-speed-up-your-data-science-code.json b/pycon-uk-2022/videos/vectorise-all-the-things-how-basic-linear-algebra-can-speed-up-your-data-science-code.json new file mode 100644 index 000000000..705dfc485 --- /dev/null +++ b/pycon-uk-2022/videos/vectorise-all-the-things-how-basic-linear-algebra-can-speed-up-your-data-science-code.json @@ -0,0 +1,22 @@ +{ + "description": "Do you feel like your data science code is horribly inefficient, but you don\u2019t know how to make things faster? Fear not! In this talk, we\u2019ll speed up some common operations using tricks from linear algebra - all within the comfort of the Python ecosystem.\n\nHave 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.", + "language": "eng", + "recorded": "2022-09-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [ + "Jodie Burchell" + ], + "thumbnail_url": "https://i.ytimg.com/vi/9_mhjjlKjDo/hqdefault.jpg", + "title": "Vectorise all the things! How basic linear algebra can speed up your data science code", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=9_mhjjlKjDo" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2022/videos/welcome-ukpa-agm.json b/pycon-uk-2022/videos/welcome-ukpa-agm.json new file mode 100644 index 000000000..bef520f6a --- /dev/null +++ b/pycon-uk-2022/videos/welcome-ukpa-agm.json @@ -0,0 +1,20 @@ +{ + "description": "Welcome\n\nWelcome", + "language": "eng", + "recorded": "2022-09-18", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2022.pyconuk.org/" + } + ], + "speakers": [], + "thumbnail_url": "https://i.ytimg.com/vi/5JeO7nToajk/hqdefault.jpg", + "title": "Welcome & UKPA AGM", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=5JeO7nToajk" + } + ] +} diff --git a/pycon-uk-2023/category.json b/pycon-uk-2023/category.json new file mode 100644 index 000000000..7715dc0e7 --- /dev/null +++ b/pycon-uk-2023/category.json @@ -0,0 +1,3 @@ +{ + "title": "PyCon UK 2023" +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/3-lessons-data-scientists-can-learn-from-world-war-ii.json b/pycon-uk-2023/videos/3-lessons-data-scientists-can-learn-from-world-war-ii.json new file mode 100644 index 000000000..75a76bb1b --- /dev/null +++ b/pycon-uk-2023/videos/3-lessons-data-scientists-can-learn-from-world-war-ii.json @@ -0,0 +1,22 @@ +{ + "description": "We\u2019ll revisit three stories from WWII where statisticians for the Allied forces got things perfectly right - and terribly wrong. We'll explore the flaws of averages, survivorship bias, and the German tanks problem. Drawing parallels to modern business situations, we'll discuss the takeaways for modern day data scientists.\n\nWorld War II, the largest armed conflict in human history, not only required unfathomable firepower but also unprecedented brain power. Data scientists - or statisticians as they were called back in the day - worked tirelessly to advance military technology and produce indispensable intelligence reports. Eighty years on, the lessons they learned remain relevant and are important for anyone doing data science or analysis at present.\n\nIn this talk, we\u2019ll visit three stories from WWII and discuss how the lessons learned then apply for modern day business settings. We\u2019ll explore:\n- How the flaw of averages made the scientifically optimised cockpit to be a perfect fit for no-one.\n- How survivorship bias impacted the armour placed on bomber planes.\n- How the need to assess the monthly rate of German tank production bred a simple solution.\n\nIn the second part of the talk we\u2019ll discuss how learnings from these stories can be used in a business environment, working through business use-cases with real (looking) data and some basic Python manipulations.\n\nWhile the talk was prepared with data scientists and analysts in mind, anyone with a curious mind may find it worthwhile. Basic familiarity of Python is helpful but not required. By the end of this talk audience members will be familiar with several common pitfalls in data science and equipped to handle business problems in a more mature and well-rounded way.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Alon Nir" + ], + "thumbnail_url": "https://i.ytimg.com/vi/yXGQBB_RFec/hqdefault.jpg", + "title": "3 Lessons Data Scientists Can Learn from World War II", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=yXGQBB_RFec" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/adventures-in-unicode-the-str-less-travelled.json b/pycon-uk-2023/videos/adventures-in-unicode-the-str-less-travelled.json new file mode 100644 index 000000000..379f363a7 --- /dev/null +++ b/pycon-uk-2023/videos/adventures-in-unicode-the-str-less-travelled.json @@ -0,0 +1,22 @@ +{ + "description": "Python 3's `str` was a leap forward but not a panacea. Join me to dive into the strange world of unicode, how it can bite you, and what to do about it.\n\nIn Python 3 we finally got a Unicode-native `str` type throughout, and there was much rejoicing. But Unicode is a tricky beast, difficult to tame, and there are still plenty of ways it can bite you if you are not careful.\n\nWe will look at some of these ways, the eldritch abominations looming in shadowy corners of Python's text; we will discover how the siren-song of seemingly innocuous strings can dash you upon the rocks, the deep peculiarity of the humble flag, and finally come to inner peace and harmony as we understand true grapheme-nature.\n\nWe will then touch on the deeper mysteries of bidirectional text, and our hearts will turn to despair. It will be a fun time.", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Alistair Lynn" + ], + "thumbnail_url": "https://i.ytimg.com/vi/1yJi5DmZR-E/hqdefault.jpg", + "title": "Adventures in Unicode: the `str` less travelled", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=1yJi5DmZR-E" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/domain-driven-design-and-python.json b/pycon-uk-2023/videos/domain-driven-design-and-python.json new file mode 100644 index 000000000..52af4a90d --- /dev/null +++ b/pycon-uk-2023/videos/domain-driven-design-and-python.json @@ -0,0 +1,22 @@ +{ + "description": "Have you heard of Domain Driven Design? Not well known in the Python world, it's an influential development approach that aims to 'tackle complexity in the heart of software'. If you're working on complex problems, come find out more: it may change the way you think!\n\nI've been writing code for 25 years. Over that time I've been through a few, rare, exhilarating paradigm shifts where my thinking as a developer suddenly changed. One was early on, when I suddenly understood object oriented programming. Test driven development was another. And then, six years ago, I read Eric Evan's 2003 book _Domain Driven Design_.\n\nThe book opened up for me a whole new way of thinking about the practice of software development. It is focused not on traditional technical concerns we're used to reading about, but on the conceptual world of modelling. It views an application's _domain model_ as one of its most important assets, and presents a wealth of wisdom about how to orient our thinking, code and working practices around that model.\n\nBut, for some reason, these ideas are not well known in the Python community. \n\nI now work on a highly complex project: Kraken, a Python monolith of tens of thousands of modules, serving energy and utility companies in a variety of countries. Domain Driven Design has, for me, been an invaluable influence.\n\nIn this talk, I'll outline the key ideas of Domain Driven Design, ideas that are beyond any one language, technology or architecture. I'll also ground it with some practical examples of how it can look in Python. Are you looking for your next paradigm shift? Perhaps this could be it!", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "David Seddon" + ], + "thumbnail_url": "https://i.ytimg.com/vi/4XKhH9whNX0/hqdefault.jpg", + "title": "Domain Driven Design and Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=4XKhH9whNX0" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/fear-the-mutants-love-the-mutants.json b/pycon-uk-2023/videos/fear-the-mutants-love-the-mutants.json new file mode 100644 index 000000000..d8fcb320b --- /dev/null +++ b/pycon-uk-2023/videos/fear-the-mutants-love-the-mutants.json @@ -0,0 +1,22 @@ +{ + "description": "Developers often use code coverage as a target, which makes it a bad measure of test quality. Mutation testing changes the game and fixes the problem.\n\nCome and learn to use it in your CI/CD process. I promise, you'll never look at penguins the same way again!\n\nCode coverage (the percentage of your code tested by your tests) is a great metric. However, coverage doesn\u2019t tell you how good your tests are at picking up changes to your codebase - if your tests aren\u2019t well-designed, changes can pass your unit tests but break production.\n\nMutation testing is a great (and massively underrated) way to quantify how much you can trust your tests. Mutation tests work by changing your code in subtle ways, then applying your unit tests to these new, \"mutant\" versions of your code. If your tests fail, great! If they pass\u2026 that\u2019s a change that might cause a bug in production.\n\nIn this talk, I\u2019ll show you how to get started with mutation testing and how to integrate it into your CI/CD pipeline. After the session, you\u2019ll be ready to use mutation testing with wild abandon. Soon, catching mutant code will be a routine part of your release engineering process, and you\u2019ll never look at penguins the same way again!", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Max Kahan" + ], + "thumbnail_url": "https://i.ytimg.com/vi/8Gl_Brl4GVI/hqdefault.jpg", + "title": "Fear the mutants. Love the mutants.", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=8Gl_Brl4GVI" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/friday-lightning-talks.json b/pycon-uk-2023/videos/friday-lightning-talks.json new file mode 100644 index 000000000..11d6ffb89 --- /dev/null +++ b/pycon-uk-2023/videos/friday-lightning-talks.json @@ -0,0 +1,20 @@ +{ + "description": "Lightning Talks\n\nLightning Talks", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "thumbnail_url": "https://i.ytimg.com/vi/O2ApDUsPDSc/hqdefault.jpg", + "speakers": [], + "title": "Friday Lightning Talks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=O2ApDUsPDSc" + } + ] +} diff --git a/pycon-uk-2023/videos/friday-welcome-and-introductions.json b/pycon-uk-2023/videos/friday-welcome-and-introductions.json new file mode 100644 index 000000000..4a4747f60 --- /dev/null +++ b/pycon-uk-2023/videos/friday-welcome-and-introductions.json @@ -0,0 +1,22 @@ +{ + "description": "Welcome and Introductions\n\nWelcome and Introductions", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Ann Barr" + ], + "thumbnail_url": "https://i.ytimg.com/vi/D3oaUdCdEto/hqdefault.jpg", + "title": "Friday Welcome and Introductions", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=D3oaUdCdEto" + } + ] +} diff --git a/pycon-uk-2023/videos/how-i-used-postgresql-r-to-find-pictures-of-me-at-a-party.json b/pycon-uk-2023/videos/how-i-used-postgresql-r-to-find-pictures-of-me-at-a-party.json new file mode 100644 index 000000000..9e32ea87f --- /dev/null +++ b/pycon-uk-2023/videos/how-i-used-postgresql-r-to-find-pictures-of-me-at-a-party.json @@ -0,0 +1,22 @@ +{ + "description": "At an event, a photographer can take many photos. Which ones do you appear in? Find out how to search for faces using Python, OpenCV, OpenAI and, yes, PostgreSQL\u00ae.\n\nPython ties it all together, and PostgreSQL's pgvector extension allows making SQL queries to find photos with my face.\n\nNowadays, if you attend an event you're bound to end up with a catalogue of photographs to look at. Formal events are likely to have a professional photographer, and modern smartphones mean that it's easy to make a photographic record of just about any gathering. It can be fun to look through the pictures, to find yourself or your friends and family, but it can also be tedious.\n\nAt our company get-together earlier in the year, the photographers did indeed take a lot of pictures. Afterwards the best of them were put up on our internal network - and like many people, I combed through them looking for those in which I appeared (yes, for vanity, but also with some amusement).\n\nIn this talk, I'll explain how to automate finding the photographs I'm in (or at least, mostly so). I'll walk through Python code that extracts faces using OpenCV, calculates vector embeddings using imgbeddings and OpenAI, and stores them in PostgreSQL\u00ae using pgvector. Given all of that, I can then make an SQL query to find which pictures I'm in.\n\nPython is a good fit for data pipelines like this, as it has good bindings to machine learning packages, and excellent support for talking to PostgreSQL.\n\nYou may be wondering why that sequence ends with PostgreSQL (and SQL) rather than something more machine learning specific. I'll talk about that as well, and in particular about how PostgreSQL allows us to cope when the amount of data gets too large to be handled locally, and how useful it is to be able to relate the similarity calculations to other columns in the database - in our case, perhaps including the image metadata.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Tibs" + ], + "thumbnail_url": "https://i.ytimg.com/vi/_FqKxKVJGWQ/hqdefault.jpg", + "title": "How I used PostgreSQL\u00ae to find pictures of me at a party", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=_FqKxKVJGWQ" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/how-to-keep-your-database-happy.json b/pycon-uk-2023/videos/how-to-keep-your-database-happy.json new file mode 100644 index 000000000..098b46c31 --- /dev/null +++ b/pycon-uk-2023/videos/how-to-keep-your-database-happy.json @@ -0,0 +1,22 @@ +{ + "description": "5 simple things you can put in place to make sure you have a database that runs smoothly and performs well.\n\nYou don't want to spend too much time looking after your database; you've got better things to do with your time. You do, however, want your database to run smoothly and perform well. Fortunately, there are a few simple things that you can do to make sure your database ticks along nicely in the background.\nI've put together my top 5 tips, based on things that have been useful to me as a DBA and as a database consultant. These are things you can put in place, without too much effort, to make sure your database works well. The focus will be on PostgreSQL, but most of the tips are also relevant to other databases.\nYou'll come away with some simple ways to keep your database happy, leaving you free to concentrate on developing your application.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Karen Jex" + ], + "thumbnail_url": "https://i.ytimg.com/vi/G7glaoEa9WQ/hqdefault.jpg", + "title": "How to keep your database happy", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=G7glaoEa9WQ" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/i-plugged-a-z80-into-a-pi-pico-here-s-how-it-happened.json b/pycon-uk-2023/videos/i-plugged-a-z80-into-a-pi-pico-here-s-how-it-happened.json new file mode 100644 index 000000000..0c0c048e6 --- /dev/null +++ b/pycon-uk-2023/videos/i-plugged-a-z80-into-a-pi-pico-here-s-how-it-happened.json @@ -0,0 +1,22 @@ +{ + "description": "I've always wanted to build a retro computer based on an old-stock Z80 cpu. The biggest roadblock for me in this endeavor has always been finding a way to manage I/O and a modern display.\n\nThe Pi Pico solved all this for me.\n\nIntroducing the Raspberry Pi Pico Z80-Based Retro Computer: A Revolutionary Fusion of Modern Technology, geekiness and Nostalgic Computing!\n\nPrepare to be blown away by this project, where the almighty Pi Pico take on the role of the ultimate multitasker \u2014a graphics card, clock, ROM, and keyboard controller\u2014 for a Z80-based retro computer. Did I ignite your inner geek yet?!\n\nImagine a Z80 cpu, like the one that powers the BBC micro but with vibrant 8-bit color graphics coming to life on a VGA screen! All thanks the Raspberry Pi Pico and its PIO capabilities. The Pico in this project has been turned into a somewhat efficient graphics card, enabling smooth rendering of retro-style visuals on modern screens. Experience the nostalgia of blocky pixels.... **in 4K** (with an HDMI adapter)\n\nThe Raspberry Pi Pico's versatility extends beyond its graphics capabilities. Acting as the clock, it allows for varying the speed of the cpu and do \"fancy\" things like step by step debugging of Z80 assembly.\n\nOne of the most delightful aspects of the project is using the Pico as a ROM. Gone are the days of meticulously erasing and rewriting chips, as this setup allows you to effortlessly load files instead.\n\nAnd with the Pico acting as a USB host, you are free to plug in modern hardware directly into this fancy retro computer! USB keyboard and mouse, SD-card reader, you name it!", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Emma Delescolle" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Ea3yX3fQCEo/hqdefault.jpg", + "title": "I plugged a Z80 into a Pi Pico, here's how it happened", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Ea3yX3fQCEo" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/if-you-cant-give-me-poetry-cant-you-give-me-poetical-science.json b/pycon-uk-2023/videos/if-you-cant-give-me-poetry-cant-you-give-me-poetical-science.json new file mode 100644 index 000000000..828e692b6 --- /dev/null +++ b/pycon-uk-2023/videos/if-you-cant-give-me-poetry-cant-you-give-me-poetical-science.json @@ -0,0 +1,22 @@ +{ + "description": "Technology is often hidden backstage at the theatre \u2013 a toolkit to enhance performance, not something artists make plays about. But generations of audience members have \u2018grown up online\u2019. To tell contemporary stories, don\u2019t we need to put tech centre stage? What is digital theatre \u2013 and is it still theatre?\n\nAda Lovelace was the daughter of a social reformer and a mad/bad/dangerous-to-know poet. She grew up to be a mathematician, an analyst, a musician, a gambler, and the first computer programmer. But the engine she coded for was never built \u2013 and she didn\u2019t live to see whether her programme worked or not. \n\nI\u2019m the daughter of an English tutor and a \u2018works in software\u2019. I\u2019ve grown up to be a playwright and a digital theatre-maker. I was also commissioned to research, write, and develop a play about Ada Lovelace, music, AI, and poetical science. But it was never staged \u2013 and I have no idea if it works in performance or not. \n\nLuckily I\u2019m not dead yet, and I have actually managed to stage other work exploring how tech-y themes, online communities, and virtual spaces work in live theatre. My theatre-making overlaps with gaming, radio, film, and livestreaming. I love thinking about how staging the tech can create restrictions/opportunities, feeding into the form and the theme of a story. And I\u2019m especially interested in how theatre \u2013 an artform that had to change dramatically to survive lockdown \u2013 might move forwards now that audiences are more reluctant to leave their homes than ever.\n\nIf you\u2019re not the kind of person who goes to the theatre then you might be the kind of person who\u2019s up for digital theatre \u2013 poetical science, maybe, rather than just poetry. If, of course, we can agree on what digital theatre even is\u2026", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Emily Holyoake" + ], + "thumbnail_url": "https://i.ytimg.com/vi/PeUb0D8VDWU/hqdefault.jpg", + "title": "If you can\u2019t give me poetry, can\u2019t you give me poetical science?", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=PeUb0D8VDWU" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/interactive-web-pages-with-django-or-flask-without-writing-javascript.json b/pycon-uk-2023/videos/interactive-web-pages-with-django-or-flask-without-writing-javascript.json new file mode 100644 index 000000000..c15b40902 --- /dev/null +++ b/pycon-uk-2023/videos/interactive-web-pages-with-django-or-flask-without-writing-javascript.json @@ -0,0 +1,22 @@ +{ + "description": "Bring your Django, Flask, etc. pages to life using htmx. \n\nNo Javascript, nor refreshing the page. Create, update and delete data; change the date range for a chart; drill down using a sequence of dropdowns; create an interactive search box, an infinite scrolling page or a sortable drag & drop table.\n\nPython has many excellent back-end frameworks, but we can't use it yet for mainstream front-end development. How do we bring our web pages to life without having to write Javascript, and without learning a front end framework like React or AngularJS?\n\nThe htmx library uses simple tag attributes to add behaviour to HTML tags. It gives you access to AJAX, CSS Transitions, WebSockets and Server Sent Events directly in HTML for modern user interfaces. \n\nLearn how, without refreshing the page, you can: create, update and delete data; change the date range for a chart; drill down using a sequence of dropdowns; and create an interactive search box.\n\nDiscover how to use htmx with any Python web framework. The examples will mostly use Django, plus a single example of how to use the same ideas in Flask.\n\nYou will also see how to create an infinite scrolling page, a sortable drag and drop table, and more.", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Coen de Groot" + ], + "thumbnail_url": "https://i.ytimg.com/vi/iPraT0gscDU/hqdefault.jpg", + "title": "Interactive web pages with Django or Flask, without writing Javascript", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=iPraT0gscDU" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/investigating-environmental-issues-with-python.json b/pycon-uk-2023/videos/investigating-environmental-issues-with-python.json new file mode 100644 index 000000000..d853b9827 --- /dev/null +++ b/pycon-uk-2023/videos/investigating-environmental-issues-with-python.json @@ -0,0 +1,22 @@ +{ + "description": "Earth's sustainability is on the brink. However, with today's information wars this situation isn't universally accepted. This talk democratises citizen environmental investigation by applying Python to selected Green issues. By separating facts from fiction humanity can be better informed to safeguard our existence.\n\nExistential threats to humanity as a result of decades of damage inflicted to the planet are already in motion. From the first climate refugees in 2014, to escalating public health crises of air pollution and food insecurity around the world, Earth becomes less inhabitable every day.\n\nAnd yet concern isn't as widespread as is warranted. Many parties profit from unsustainable practices, and therefore have motive to obfuscate the long-term harmful consequences. In today's post-truth world, exacerbated by generative AI and other mis-used tech, public opinion is the battleground between multiple opposing influences, only to the detriment of society.\n\nThis talk aims to better equip citizens to bypass/counter the deliberate informational noise and investigate environmental issues themselves, being more empowered to come to their own conclusions about the actual state of our world. \n\nA selection of scientific workflows, using open-source Python and publicly available resources, will be presented, each delving into a topical environmental issue to produce actionable insight. Designed to be accessible and reproducible by tech literate citizens without domain expertise, the audience will takeaway transferable Python skills for undertaking similar scientific computing exploration. \n\nLet's democratise Python's potential for citizen access to discovery of environmental facts, so that humanity can be better informed to better influence the safeguarding of our planet, and ultimately our existence.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Mx Chiin-Rui Tan" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Sbkdf6vl6n0/hqdefault.jpg", + "title": "Investigating Environmental issues with Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Sbkdf6vl6n0" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/live-highlights-in-bbc-iplayer.json b/pycon-uk-2023/videos/live-highlights-in-bbc-iplayer.json new file mode 100644 index 000000000..f8a88b620 --- /dev/null +++ b/pycon-uk-2023/videos/live-highlights-in-bbc-iplayer.json @@ -0,0 +1,22 @@ +{ + "description": "How we built a prototype to allow journalists to add highlight markers to interesting moments on BBC News in iPlayer, and how we went from idea to prototype to production.\n\nIn BBC News Labs, we work closely with journalists and we try to come up with innovative approaches to meeting their needs - either to improve or automate internal processes or to enhance the audience experience.\n\nAn idea was born from discussions with a BBC News editor to add markers to indicate to users where the big important moments are on the news channel. We built a minimum viable product, and extended the reach of the prototype over the next few months. We launched our first audience facing trial on news live pages, and then it was used on Eurovision, Springwatch, Glastonbury and Wimbledon.\n\nThe project was built using AWS lambda functions (Python), FastAPI and postgres, a React / TypeScript frontend and an iPlayer plugin (also TypeScript).\n\nThis talk will cover our rapid prototyping process, the tech stack used, as well as how we managed to deliver a production audience-facing project - and where we go from here.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Ben Nuttall" + ], + "thumbnail_url": "https://i.ytimg.com/vi/UEGMR0oCOqI/hqdefault.jpg", + "title": "Live highlights in BBC iPlayer", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=UEGMR0oCOqI" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/multi-objective-linear-programming-to-find-the-best-pokemon-team.json b/pycon-uk-2023/videos/multi-objective-linear-programming-to-find-the-best-pokemon-team.json new file mode 100644 index 000000000..41d49a2a1 --- /dev/null +++ b/pycon-uk-2023/videos/multi-objective-linear-programming-to-find-the-best-pokemon-team.json @@ -0,0 +1,22 @@ +{ + "description": "What is the best Pok\u00e9mon team? Who should I pick? What attacks should they learn? Here, I use multi-objective linear programming, and a bit of simulation, to figure it out.\n\nHere I give an example of using Python to solve a combinatorial problem from the mathematical field of Operational Research: How to find the best Pok\u00e9mon team. Using a variety of Python libraries a mulit-objective linear programming problem is used to find the best combination of Pok\u00e9mon, and their attacks. PuLP is used to formulate and solve the multi-objective linear programming problems, and a Pareto front is found by varying the importance of each objective. Then, a third objective, a Pok\u00e9mon team's performance in a Monte Carlo simulation of Pok\u00e9mon battles, is used to differentiate between Pareto optimal solutions and find the definitive best team of Pok\u00e9mon. I relate how this fun problem is related to more serious scheduling and timetabling problems.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Geraint Palmer" + ], + "thumbnail_url": "https://i.ytimg.com/vi/HVcS_X5p1h8/hqdefault.jpg", + "title": "Multi-Objective Linear Programming to find the Best Pok\u00e9mon Team", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=HVcS_X5p1h8" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/open-source-developer-friendly-observability-in-only-a-few-lines-code.json b/pycon-uk-2023/videos/open-source-developer-friendly-observability-in-only-a-few-lines-code.json new file mode 100644 index 000000000..8ae9c76b6 --- /dev/null +++ b/pycon-uk-2023/videos/open-source-developer-friendly-observability-in-only-a-few-lines-code.json @@ -0,0 +1,22 @@ +{ + "description": "I want a clear picture of how my application is performing in production, but proper observability involves a lot of faff. So let's look at how to add metrics to an application with only a few lines of code and an open-source library called autometrics-py.\n\nMarie Curie said, \u201cNothing in life is to be feared, it is only to be understood.\u201d\n\nFor developers, writing code is a big part of our lives. And if we want to understand how the code we write is actually performing out in the wild, then we need to use techniques and tooling from the world of observability.\n\nThis poses a problem for many of us, including myself: Observability tooling is itself fear-inducing! \n\nYes, I would love to understand how my code is doing after I release it onto the scary internets. (Please. Tell me. I have no idea.)\n\nHowever, the path to an observable codebase is full of easy-to-take wrong turns and very confusing signage. Speaking personally, I needed to get to know the the quirks of a time-series database, determine what to measure (and how to measure it), label my data correctly, and then learn a new query language to generate charts that would help me understand whether or not my app is doing as well as I (really, really) hope it is.\n\nI am a developer. I\u2019ve been creating web applications for a decade. And yet, before working for an observability company, I still relied mostly on carefully placed log statements to debug my production code.\n\nThis is why I started contributing to autometrics-py, which is a small, open source micro-framework that exposes a cute little python decorator to make implementing observability best practices much, much simpler for developers. (To be clear: I am by no measure an expert in observability, but that\u2019s exactly why I\u2019m excited to share what I\u2019ve learned while helping to make it easier for others.)\n\nIn this talk, we\u2019ll cover what makes observability tricky, especially for devs, and how we can do away with this trickiness by making some smarty-pants assumptions about the type of data we are most interested in. We\u2019ll focus on the unique power of getting metrics at the function level (because who doesn\u2019t love functions?!), and emerge with the confidence of Marie Curie when it comes to understanding the health of our codebase in production.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Brett Beutell" + ], + "thumbnail_url": "https://i.ytimg.com/vi/ayH-vn7BLyk/hqdefault.jpg", + "title": "Open-source, developer-friendly observability in only a few lines code", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=ayH-vn7BLyk" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/optimizing-graphql-performance-tips-and-techniques.json b/pycon-uk-2023/videos/optimizing-graphql-performance-tips-and-techniques.json new file mode 100644 index 000000000..df690275d --- /dev/null +++ b/pycon-uk-2023/videos/optimizing-graphql-performance-tips-and-techniques.json @@ -0,0 +1,22 @@ +{ + "description": "In this talk, we'll explore techniques to optimize GraphQL performance for snappy, scalable, and resource-efficient APIs. Attendees will learn about batching queries with DataLoader, managing query complexity and depth, leveraging persisted queries for reduced network overhead, and implementing \ncaching strategies on both server and client-side.\n\nAPI performance is crucial for delivering a smooth and responsive user\nexperience. GraphQL has gained popularity as a flexible and efficient query\nlanguage, but without proper optimization, it may underperform or even become a\nbottleneck in your application.\n\nIn this talk, we'll dive into the essential techniques and best practices to\noptimize GraphQL performance, ensuring that your APIs are snappy, scalable, and\nresource-efficient. Attendees will learn:\n\n- The importance of batching queries and how to implement it using DataLoader or\n similar libraries.\n- The concept of query complexity and depth, and how to set up limits to prevent\n resource abuse.\n- Leveraging persisted queries to reduce network overhead and improve caching\n capabilities.\n- Implementing caching strategies, both on the server and client-side, to\n minimize redundant requests and reduce load times.\n- Exploring monitoring and observability tools that can help you identify\n performance bottlenecks and continuously optimize your GraphQL implementation\n for maximum efficiency.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Patrick Arminio" + ], + "thumbnail_url": "https://i.ytimg.com/vi/-6bDHd0uB3c/hqdefault.jpg", + "title": "Optimizing GraphQL Performance: Tips and Techniques", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=-6bDHd0uB3c" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/saturday-lightning-talks.json b/pycon-uk-2023/videos/saturday-lightning-talks.json new file mode 100644 index 000000000..a7005ed42 --- /dev/null +++ b/pycon-uk-2023/videos/saturday-lightning-talks.json @@ -0,0 +1,20 @@ +{ + "description": "Lightning Talks\n\nLightning Talks", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "thumbnail_url": "https://i.ytimg.com/vi/mpVDJBySGbg/hqdefault.jpg", + "speakers": [], + "title": "Saturday Lightning Talks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=mpVDJBySGbg" + } + ] +} diff --git a/pycon-uk-2023/videos/saturday-welcome-and-introductions.json b/pycon-uk-2023/videos/saturday-welcome-and-introductions.json new file mode 100644 index 000000000..21e816ad2 --- /dev/null +++ b/pycon-uk-2023/videos/saturday-welcome-and-introductions.json @@ -0,0 +1,22 @@ +{ + "description": "Welcome and Introductions\n\nWelcome and Introductions", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Ann Barr" + ], + "thumbnail_url": "https://i.ytimg.com/vi/NV2u3QyNQBQ/hqdefault.jpg", + "title": "Saturday Welcome and Introductions", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=NV2u3QyNQBQ" + } + ] +} diff --git a/pycon-uk-2023/videos/secure-modern-and-simple-dependency-management-with-pdm-and-friends.json b/pycon-uk-2023/videos/secure-modern-and-simple-dependency-management-with-pdm-and-friends.json new file mode 100644 index 000000000..f737ecc40 --- /dev/null +++ b/pycon-uk-2023/videos/secure-modern-and-simple-dependency-management-with-pdm-and-friends.json @@ -0,0 +1,22 @@ +{ + "description": "What actually happens when you import a package? Let's find out, then explore recent packaging developments, including the new tool PDM, comparing it to pip and poetry. We'll also cover some (opinionated) best practices for handling metadata, and building secure, modern applications using third party libraries in python.\n\nPython has a rich ecosystem of open source packages available to assist with almost any conceivable requirement. Installing, using, and updating these packages should be quick, easy, and secure, however, dependency management and python packaging has historically been a source of frustration for developers, particularly with the added complications of virtual environments, and subtle differences between python versions. Furthermore, software supply chain security has attracted particular importance of late as increasing numbers of major vulnerabilities have been discovered requiring fast, sometimes immediate, mitigation.\n\nIn recent years, efforts have been made to improve packaging and dependency management in python, and we have seen the release of a number of developer tools, including poetry, pipenv, and pipx. These work alongside pip and earlier tools such as disutils, setuptools, and easy_install, and offer higher level interfaces for developers to work with. In 2020, a new tool was released called PDM (Python Dependency Manager), and is gaining traction amongst developers in recent months. \n\nThis talk will start by giving an overview of how python imports work, before moving on to cover a brief history of package management in python, and an overview of the current state of play, and the vulnerabilities that we are exposed to by supply chain attacks. We'll then give a brief introduction to PDM, before discussing what practical steps we can take to both improve our developer experiences, and ensure the code we write is modern, secure, and maintainable.\n\nWe'll ask questions including some of the below.\n\n* What actually happens 'under the hood' when we use the import statement?\n* How many different ways can we import a package in python?\n* What does a dependency manager do, and how does it work?\n* What does a supply chain attack look like, and how do we try and stop them happening?\n\nFinally, the speaker will offer an opinionated guide to some of the best python tooling and package management setups available to python developers in 2023.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Dom Weldon" + ], + "thumbnail_url": "https://i.ytimg.com/vi/TI8gHpI-OHQ/hqdefault.jpg", + "title": "Secure, Modern, and Simple Dependency Management with PDM and Friends", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=TI8gHpI-OHQ" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/sign-to-text-unleashing-the-power-of-google-ai-for-real-time-asl-transcription.json b/pycon-uk-2023/videos/sign-to-text-unleashing-the-power-of-google-ai-for-real-time-asl-transcription.json new file mode 100644 index 000000000..ac976249a --- /dev/null +++ b/pycon-uk-2023/videos/sign-to-text-unleashing-the-power-of-google-ai-for-real-time-asl-transcription.json @@ -0,0 +1,22 @@ +{ + "description": "In this talk, we will delve into how leveraging Google's cutting-edge tools and frameworks, combined with Python, can revolutionize the way we bridge the communication gap between sign language users and the wider world.\n\nCommunication barriers between the deaf and hard-of-hearing community and the wider world have created significant challenges in effective interaction.However the good news is cutting-edge AI technologies can revolutionize the way we transcribe American Sign Language (ASL) and enable inclusive communication.\n\nUsing the power of Python libraries and Google's AI tools, including the Google Cloud Vision API for hand and finger tracking, TensorFlow for deep learning models, and AutoML for data scarcity challenges, I will demonstrate Sign_To_Text, a revolutionary system that transforms how sign language users connect with the world.\n\nWitness live demonstrations as I seamlessly integrate Google AI technologies to translate fingerspelled letters in real time into textual representations, empowering individuals and fostering inclusive communication.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Atieno Ouma" + ], + "thumbnail_url": "https://i.ytimg.com/vi/TIKORzyk8Xg/hqdefault.jpg", + "title": "SIGN-TO-TEXT:Unleashing the Power of Google AI for real time ASL transcription", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=TIKORzyk8Xg" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/sunday-lightning-talks.json b/pycon-uk-2023/videos/sunday-lightning-talks.json new file mode 100644 index 000000000..8f4a6d9bd --- /dev/null +++ b/pycon-uk-2023/videos/sunday-lightning-talks.json @@ -0,0 +1,20 @@ +{ + "description": "Lightning Talks\n\nLightning Talks", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [], + "thumbnail_url": "https://i.ytimg.com/vi/chxsC2WYNTE/hqdefault.jpg", + "title": "Sunday Lightning Talks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=chxsC2WYNTE" + } + ] +} diff --git a/pycon-uk-2023/videos/technical-neglect.json b/pycon-uk-2023/videos/technical-neglect.json new file mode 100644 index 000000000..bce63bea0 --- /dev/null +++ b/pycon-uk-2023/videos/technical-neglect.json @@ -0,0 +1,22 @@ +{ + "description": "Unmanaged technical debt weighs down many codebases, exerting drag on their schedules, but it is more often an effect than a cause. We will look at what technical debt is (and is not) with a view to properly attributing the root and recurring cause as technical neglect than technical debt.\n\nMany developers evoke the mischievous spirit and day-to-day burden of technical debt to explain the misfortunes and troubles of their codebase and delivery. While unmanaged technical debt weighs down many codebases and exerts drag on their schedules, it is more often an effect than a cause. In this talk, we will look at what is and is not meant by technical debt \u2014 and other metaphors \u2014 with a view to properly attributing the root and recurring cause as technical neglect than technical debt. Without seeing technical neglect for what it is, we will continue to misattribute our problems to an effect rather than a cause.", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Kevlin Henney" + ], + "thumbnail_url": "https://i.ytimg.com/vi/YJPu_TNedTs/hqdefault.jpg", + "title": "Technical Neglect", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=YJPu_TNedTs" + } + ] +} diff --git a/pycon-uk-2023/videos/the-accidental-conference-director.json b/pycon-uk-2023/videos/the-accidental-conference-director.json new file mode 100644 index 000000000..2fb0a4248 --- /dev/null +++ b/pycon-uk-2023/videos/the-accidental-conference-director.json @@ -0,0 +1,22 @@ +{ + "description": "TBC\n\nTBC", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Ann Barr" + ], + "thumbnail_url": "https://i.ytimg.com/vi/QCRyvIzM6NA/hqdefault.jpg", + "title": "The Accidental Conference Director", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=QCRyvIzM6NA" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/the-magic-of-self-how-python-inserts-self-into-methods.json b/pycon-uk-2023/videos/the-magic-of-self-how-python-inserts-self-into-methods.json new file mode 100644 index 000000000..d7673d7b3 --- /dev/null +++ b/pycon-uk-2023/videos/the-magic-of-self-how-python-inserts-self-into-methods.json @@ -0,0 +1,22 @@ +{ + "description": "Have you ever wondered how `self` works? Whenever you call a method, `self` seems to magically appear as an argument. But behind this dark magic lies a well-defined protocol, the descriptor protocol, that you can implement yourself. Join me and learn how Python inserts `self` into methods!\n\nA phrase that I hear a lot is that \u201cPython is easy to learn but hard to master\u201d. In a way that\u2019s true: Python\u2019s many abstractions allow you to focus on the business logic of your code instead of the lower-level implementation details.\n\nAt the same time, most of Python\u2019s abstractions aren\u2019t *magical*: Its versatile data model allows you to hook into almost every aspect of the language to implement objects that behave just as Python\u2019s built-in objects do. This enables you to create new types of objects that have high-level interfaces of their own.\n\nIn this talk, I want to entice you to explore the wonderful landscape of Python\u2019s data model by diving into an especially magical feature: The automatic insertion of `self` into methods.\n\nWhen you first came across `self` in a method signature, chances are that you learned that inserting the instance into methods is just something Python does for you; that you shouldn\u2019t worry too much about it. I will go one step further and show you that there\u2019s a well-defined protocol behind this magic, the descriptor protocol.\n\nBy the end, not only should you be able to implement descriptors of your own, but you should also be able to recognize that some well-known features of Python, such as properties and classmethods, are implemented using the same descriptor protocol.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Sebastiaan Zeeff" + ], + "thumbnail_url": "https://i.ytimg.com/vi/hNM91G41m3c/hqdefault.jpg", + "title": "The Magic of Self: How Python inserts self into methods", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=hNM91G41m3c" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/the-programmer-s-imagination.json b/pycon-uk-2023/videos/the-programmer-s-imagination.json new file mode 100644 index 000000000..01778d4dc --- /dev/null +++ b/pycon-uk-2023/videos/the-programmer-s-imagination.json @@ -0,0 +1,22 @@ +{ + "description": "As creators of software, we're repeatedly told that we're not merely imagining the future of the world, but bringing it into being. Let's suppose that's true. What, exactly, are we imagining, and why does it matter?\n\nOf all our faculties, imagination is usually considered the freest, the seat of creation. I'm interested in what we are doing with this freedom, and I am suspicious of it.\n\nAt the same time, I believe that our imagination tells us truths we might not always want to hear, forcefully. \n\nIn this talk I want to pay attention to the programmer's imagination, and show how the imagination draws lines between things as disparate as Django's success page for new projects and [Dracoraptor hanigani](https://en.wikipedia.org/wiki/Dracoraptor), the recently discovered Welsh dinosaur (on view at the National Museum, next door to Cardiff City Hall). \n\nAs programmers, our imagination conjures up new worlds on blank pages, but I think that imagination can always be traced back to assumptions, prejudices and desires that are active right now - the programmer's imagination isn't telling us about the future, but about *now* - and what's wrong with it.\n\nI want to show what the imagination has meant for what we do with the software we create, and what it means for the future. I will use it to identify some of the things we have lost in the last decades, and how we can find them again.\n\nAmongst other things I'll discuss dinosaurs and birds, palaeoart and 1980s computer programming books, David H Ahl and Joseph Wiezenbaum, to help make sense of what we're doing, what we think we're doing, the relationship between them - and what, perhaps, we *should* be doing.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Daniele Procida" + ], + "thumbnail_url": "https://i.ytimg.com/vi/25onRvaR3MA/hqdefault.jpg", + "title": "The programmer's imagination", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=25onRvaR3MA" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/the-sound-of-your-footsteps-can-predict-for-dementia.json b/pycon-uk-2023/videos/the-sound-of-your-footsteps-can-predict-for-dementia.json new file mode 100644 index 000000000..7204265db --- /dev/null +++ b/pycon-uk-2023/videos/the-sound-of-your-footsteps-can-predict-for-dementia.json @@ -0,0 +1,22 @@ +{ + "description": "This talk will present how one can use acoustic-based clinical gait analysis to predict onset & progression of cognitive decline as well as assess increase in risk of falls in highly frail and vulnerable demographics of the population, especially older adults who live alone and with multiple co-morbidities.\n\nDo you know how the sound of your footsteps can be used to predict the likelihood of a fatal fall? Do you know that they can also be used to predict whether you will develop dementia in the next 6 months or so?\n\nThis talk will be a gentle introduction to the world of clinical gait analysis and how your gait (a.k.a the way you walk) is a digital biomarker for predicting physical and cognitive health. We will take an strong multidisciplinary approach where we will combine know-how of clinical science, remote monitoring, assistive technology and state-of-art acoustic AI engineering to showcase how this is possible.\n\nThe topics that we will cover are as follows:\n\nDigital Biomarker Engineering : We will discuss the framework of how you can feature engineer health indictors (\"biomarkers\") from data collected by sensors in an IOT ecosystem like PIR, magnetic sensors and even microphones/audio recorders.\nGait Analysis : We will do a crash course on Human Gait to set the foundation required to use gait data to predict for neurodegenerative conditions and cognitive decline.\nAcoustic Gait Analysis : We will spend majority of our time here to understand how acoustics engineering and machine learning can help in analysing human gait from just audio recordings to predict for cognitive decline discussed in #2 earlier.\nTo demonstrate a real life application, I will share how this concept was used to track the progression of dementia of an older adult over the past 2 years.\n\nI will showcase the tech stack to make this possible.\nI will showcase the challenges we faced along the way in undertaking niche research, architecture development, AI development and real-life feedback from the older adult, family members and care-givers.", + "language": "eng", + "recorded": "2023-09-23", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Debayan Das" + ], + "thumbnail_url": "https://i.ytimg.com/vi/4M9VNKVEX5o/hqdefault.jpg", + "title": "The Sound of Your Footsteps can Predict for Dementia", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=4M9VNKVEX5o" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/the-standard-library-tour.json b/pycon-uk-2023/videos/the-standard-library-tour.json new file mode 100644 index 000000000..a25f48e1b --- /dev/null +++ b/pycon-uk-2023/videos/the-standard-library-tour.json @@ -0,0 +1,22 @@ +{ + "description": "Tired of complex code? Python's standard library has tools to simplify your tasks! Join us for a tour of the standard library where we'll dive into less-known modules that do well-known things and well-known modules that do less-known things.\n\nThe Standard Library Tour is designed to provide attendees with an understanding of Python's standard library less known features. Have you ever found yourself writing complex code only to discover that Python has tools available within its library that could have made your job easier? Then this talk is for you!\n\nThe outline of the talk:\n\n* Basic information about the library\n* Well-known modules which do less-known things\n\n - functools less-known features: @singledispatch, partial(), @cache\n - itertools less-known features: product(), filterfalse(), zip_longest()\n - collections less-known features: ChainMap, defaultdict\n\n* Less-known modules which do well-known things\n * doctest for testing: testmod()\n * Difflib & Filecmp for comparison: Difflib.SequenceMatcher, Filecmp.cmpfiles()\n * contextlib for tasks involving the with statement: @contextmanager, @asynccontextmanager\n\n\nBy attending this session, you'll gain a deeper understanding of Python's standard library and you'll discover the \"unknown unknowns\" - tools that you may not even know exist within Python's standard library. By becoming familiar with the library and all of its capabilities, you'll be better equipped to solve problems and build applications more efficiently, without reinventing the wheel. You'll also receive recommendations on where to find additional resources and information so you can continue learning and exploring Python's tools after the conference has ended.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Mia Baji\u0107" + ], + "thumbnail_url": "https://i.ytimg.com/vi/9J3Wfizht9E/hqdefault.jpg", + "title": "The Standard Library Tour", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=9J3Wfizht9E" + } + ] +} diff --git a/pycon-uk-2023/videos/vulnerability-management-with-cvss.json b/pycon-uk-2023/videos/vulnerability-management-with-cvss.json new file mode 100644 index 000000000..a8b73b9b9 --- /dev/null +++ b/pycon-uk-2023/videos/vulnerability-management-with-cvss.json @@ -0,0 +1,22 @@ +{ + "description": "Do you find it difficult to keep up with the increasing number of reported vulnerabilities? Are you unclear about the severity of a vulnerability in your system? Look no further than the Common Vulnerability Scoring System (CVSS).\n\nDo you find it difficult to keep up with the increasing number of reported vulnerabilities? Are you unclear about the severity of a vulnerability in your system? Look no further than the Common Vulnerability Scoring System (CVSS). \nThis standardized framework provides an objective method for scoring security vulnerabilities on a scale from 0 to 10, enabling you to prioritize resources and improve your system's security and resilience. Our talk will demonstrate how to utilize CVSS in Python projects, enabling you to efficiently prioritize efforts and set up automated vulnerability reports. Don't let vulnerabilities go unnoticed - utilize CVSS to enhance your software security today.", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Tomas Horacek" + ], + "thumbnail_url": "https://i.ytimg.com/vi/J9ve3bLaOZA/hqdefault.jpg", + "title": "Vulnerability Management with CVSS", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=J9ve3bLaOZA" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/welcome-and-ukpa-agm.json b/pycon-uk-2023/videos/welcome-and-ukpa-agm.json new file mode 100644 index 000000000..aae68f1ad --- /dev/null +++ b/pycon-uk-2023/videos/welcome-and-ukpa-agm.json @@ -0,0 +1,22 @@ +{ + "description": "Welcome and Introduction\n\nWelcome and Introduction", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Owen Campbell" + ], + "thumbnail_url": "https://i.ytimg.com/vi/FuaJ1-b7LOc/hqdefault.jpg", + "title": "Welcome and UKPA AGM", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=FuaJ1-b7LOc" + } + ] +} diff --git a/pycon-uk-2023/videos/well-well-ml-is-not-the-answer-to-everything.json b/pycon-uk-2023/videos/well-well-ml-is-not-the-answer-to-everything.json new file mode 100644 index 000000000..154463b46 --- /dev/null +++ b/pycon-uk-2023/videos/well-well-ml-is-not-the-answer-to-everything.json @@ -0,0 +1,22 @@ +{ + "description": "Datasets with potential to predict contaminated water are more than just numbers. They can mean the difference between drawing safe drinking water from a well and drawing unsafe levels of arsenic. This talk compares ways of generating a predictive model and addresses the ethical importance of application over technological ideology.\n\nBetween 1970 and the year 2000, the United Nations Children's Fund (UNICEF) worked with the Bangladesh government to provide safe drinking water to 80% of the population by the year 2000. The strategy was to achieve this goal by installing tubewells within the country. Unfortunately, many of these wells produced water contaminated with harmful arsenic content. \n\nWhen applying machine learning to this problem, the complexities of providing clean drinking water to an entire country highlight the limitations of foundational technological principles. I experienced this when contributing to the project iArsenic, which used data from these wells to predict a well's arsenic content.\n\nUsing iArsenic, individuals can submit data about their own well in Bangladesh and have a prediction generated to classify the safety of this well. Armed with fundamental principles of data science, I came into this project keen to enlighten the geoscience team about the data science sins they had committed. \n\nWhere was the evaluation? \nWhere was the train and test split? \nWhy does it matter if the model is opaque or transparent? \n\nUltimately, the question I was not asking gave the most valuable insight. Do these data science fundamentals matter? Surely, if we have a model that is 51% accurate all the time, it would be beneficial to use this model to tell people whether they should drink from a well or not, because 1% of people would benefit. In reality, these models are over 80% accurate.\n\nSitting in front of a MacBook Pro in a university library doing this data science project, it can look obvious that this model can be used to tell these people what is good for them and to give them the opportunity to make over 80% of the problem disappear in a take it or leave it fashion. So why is this seemingly simple and effective approach never deployed? When considering whether you would trust your health to a model with a 51% accuracy, does it still seem so simple or is the problem being underestimated by a colonial mindset?\n\nThis talk explores the computing culture shocks experienced when different fields collaborate, discussing how the convictions that help people navigate within a field can raise barriers between fields. Perhaps learning to embrace our convictions with flexibility will break barriers instead of building them.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Kane Swartz" + ], + "thumbnail_url": "https://i.ytimg.com/vi/xNY0FBICi4w/hqdefault.jpg", + "title": "Well well. ML is not the answer to everything.", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=xNY0FBICi4w" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/what-on-earth-is-a-code-sprint.json b/pycon-uk-2023/videos/what-on-earth-is-a-code-sprint.json new file mode 100644 index 000000000..b8df12d8f --- /dev/null +++ b/pycon-uk-2023/videos/what-on-earth-is-a-code-sprint.json @@ -0,0 +1,22 @@ +{ + "description": "Monday at PyCon UK is dedicated to [our code sprints](https://2023.pyconuk.org/sprints/). We'd love to have you joining in!\n\nCode sprints are a fantastic way to get started as an open-source software contributor, in a friendly, supportive environment where experienced contributors are on hand to help others get started.", + "language": "eng", + "recorded": "2023-09-22", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Daniele Procida" + ], + "thumbnail_url": "https://i.ytimg.com/vi/MLMpjDs2jzg/hqdefault.jpg", + "title": "What on earth is a code sprint?", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=MLMpjDs2jzg" + } + ] +} \ No newline at end of file diff --git a/pycon-uk-2023/videos/when-to-rebuild-things-that-already-exist.json b/pycon-uk-2023/videos/when-to-rebuild-things-that-already-exist.json new file mode 100644 index 000000000..9f0d4015d --- /dev/null +++ b/pycon-uk-2023/videos/when-to-rebuild-things-that-already-exist.json @@ -0,0 +1,22 @@ +{ + "description": "This year I built a library that already exists. The existing solutions didn\u2019t quite meet my needs, I wanted something that ticked all of my boxes. When thinking about building something new people referred me to xkcd #927. But I did it anyway.\n\nFor the last 6 years I\u2019ve maintained dask-kubernetes, a Python library for deploying Dask clusters on Kubernetes. In that time I\u2019ve tried nearly every Python Kubernetes client library on PyPI. In fact dask-kubernetes today uses over five different libraries and tools to interact with the Kubernetes API. Each one has different strengths and weaknesses, features and bugs. To satisfy all of the needs of Dask Kubernetes there is no one library that can do it alone.\n\nShould I continue to build wrappers and shims in dask-kubernetes to homogenize the various dependencies? Should I contribute to an existing one to fill in the blanks? Or can I build one library to rule them all?\n\nEarlier this year I decided to build exactly the library I needed. Not a perfect universal library to supersede everything, not a wrapper for everything that exists. Just the library I need to solve my problems, to reduce complexity in my projects and to help me learn the things I need to know to maintain these projects into the future. \n\nIn this talk I will dig into my perspective on when to wrap a dependency, when to contribute to a dependency and when to build a new dependency from scratch.", + "language": "eng", + "recorded": "2023-09-24", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://2023.pyconuk.org/" + } + ], + "speakers": [ + "Jacob Tomlinson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/f6VtdBLAKn4/hqdefault.jpg", + "title": "When to rebuild things that already exist", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=f6VtdBLAKn4" + } + ] +} \ No newline at end of file