Merge pull request #1168 from pyvideo/pycon-us-2023

PyCon US 2023

pycon-us-2023/category.json

@@ -0,0 +1,3 @@
+{
+    "title": "PyCon US 2023"
+}

pycon-us-2023/videos/10-ways-to-shoot-yourself-in-the-foot-with-tests.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Tests are great.\n\nExcept when they\u2019re not.\n\nAlmost every developer who\u2019s worked with tests has encountered a test\nsuite that caused a lot of pain.\n\nSome of them just don\u2019t protect us when we need them, some are flaky,\nsome keep breaking because of unrelated changes, some take hours to\ndebug whenever they fail.\n\nAnd while every company is different, there are definitely patterns. A\nlot of these problems are the result of some common pitfalls that trap\nmany teams. These pitfalls might be common, but they're not easy to spot\n- I\u2019ve seen all of them happen in strong, capable, experienced teams.\nMost of these I fell into myself at least once.\n\nIn this session, we'll take a look at a selection of problematic testing\nchoices, with examples that show these in the context of common Python\nframeworks and libraries. We'll discuss how to identify them, what\nproblems they might cause and what alternatives we have so we can save\nourselves the pain.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/89/"
+        }
+    ],
+    "speakers": [
+        "Shai Geva"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Ub31Ae6S1BY/maxresdefault.jpg",
+    "title": "10 Ways To Shoot Yourself In The Foot With Tests",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Ub31Ae6S1BY"
+        }
+    ]
+}

pycon-us-2023/videos/a-per-interpreter-gil-concurrency-and-parallelism-with-subinterpreters.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "We live in a world of *concurrent* code and *multi-core* computing, so\ncome learn about a *new* solution for both in Python 3.12. We'll quickly\nexplain the new feature (and an old one), and then show you how to take\nadvantage of it, for *simpler* concurrency and *faster* code.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/54/"
+        }
+    ],
+    "speakers": [
+        "Eric Snow"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/3ywZjnjeAO4/maxresdefault.jpg",
+    "title": "A Per-Interpreter GIL: Concurrency and Parallelism with Subinterpreters",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=3ywZjnjeAO4"
+        }
+    ]
+}

pycon-us-2023/videos/a-pythonic-full-text-search.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "A **full-text search** on a website is the best way to make its\n**contents** easily accessible to **users** because it returns better\nresults and is in fact used in *online search engines* or *social\nnetworks*.\n\nThe implementation of full-text search can be complex and many adopt the\nstrategy of using **dedicated search engines** in addition to the\n**database**, but in most cases this strategy turns out to be a big\nproblem of **architecture** and **performance**.\n\nIn this talk we'll see a **pythonic** way to implement full-text search\non a website using only Django and PostgreSQL, taking advantage of all\nthe **innovations** introduced in latest years, and we'll analyze the\n**problems** of using additional search engines with examples deriving\nfrom my experience on *djangoproject.com*.\n\nThrough this talk you can learn how to add a full-text search on your\n**website**, if it's based on **Django** and **PostgreSQL**, or you can\nlearn how to update the search function of your website if you use other\nsearch engines.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/148/"
+        }
+    ],
+    "speakers": [
+        "Paolo Melchiorre"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/NS31C726xEw/maxresdefault.jpg",
+    "title": "A pythonic full-text search",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=NS31C726xEw"
+        }
+    ]
+}

pycon-us-2023/videos/accelerate-your-workflow-from-local-python-prototype-to-the-cloud-sponsor-microsoft.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Have you ever struggled taking a Python application from your local\nmachine to the cloud? Had a hard time figuring out what infrastructure\nyou need or how to configure it for your app? Spent too much time\nresearching how to set up your local development environment for cloud\ndevelopment? Learn how to use real-world cloud development application\ntemplates via CLI to go from local development environment to the cloud.\nScaffold your application, provision resources, deploy code, monitor\nyour application health, and set up a CI/CD pipeline, all in a couple of\nsteps and just a few minutes.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/154/"
+        }
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/KBYE53i7eGU/maxresdefault.jpg",
+    "speakers": [
+        "Savannah Ostrowski"
+    ],
+    "title": "Accelerate your workflow from local Python prototype to the cloud (Sponsor: Microsoft)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=KBYE53i7eGU"
+        }
+    ]
+}

pycon-us-2023/videos/an-overview-of-the-python-code-tool-landscape-2023.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Linters, type checkers, style formatters, package linters, security\nanalysis, dead code removers, docstring formatters, code complexity\nanalyzers: There is a wealth of static code analysis tools in the Python\necosystem. It's intimidating to start looking at them and easy to get\nlost. What's the difference between Pyflakes, flake8, and autoflake? Or\nbetween autopep8 and pep8-naming? This overview explains the different\nkinds of static code analysis tools, what tools are out there (as of\n2023), and how beginners can get started using these tools to write code\nlike pros. This talk also provides a beginner's introduction to type\nhints in Python and the type checker tools available. There are too many\ntools to describe in detail, but this talk does introduce the promising\nnewcomer Ruff, an extremely fast Python linter written in Rust.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/110/"
+        }
+    ],
+    "speakers": [
+        "Al Sweigart"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/knUGpULAmn4/maxresdefault.jpg",
+    "title": "An Overview of the Python Code Tool Landscape 2023",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=knUGpULAmn4"
+        }
+    ]
+}

pycon-us-2023/videos/approaches-to-fairness-and-bias-mitigation-in-natural-language-processing.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "With the advent of large pre-trained language models like GPT, BERT,\netc., and their usage in almost all natural language understanding and\ngeneration applications, it is important that we evaluate the fairness\nand mitigate biases of these models. Since these models are fed with\nhuman-generated data (mostly from the web), they are exposed to human\nbiases. Hence, they carry forward and also amplify these biases in their\nresults. In this talk, we will discuss the motivation for fairness and\nbias research in NLP and discuss different approaches used to detect and\nmitigate biases. We will also explore some available tools to include in\nyour models to ensure fairness.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/56/"
+        }
+    ],
+    "speakers": [
+        "Angana Borah"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/f0bEx1yT72o/maxresdefault.jpg",
+    "title": "Approaches to Fairness and Bias Mitigation in Natural Language Processing",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=f0bEx1yT72o"
+        }
+    ]
+}

pycon-us-2023/videos/argument-clinic-what-healthy-professional-conflict-looks-like.json

@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "What does healthy disagreement look like? Many of us have never\nexperienced healthy conflict at work, and so assume our only options are\nto either avoid conflict or have a nasty fight. But it doesn't have to\nbe that way: professional disagreement can be direct without being\nnasty. We want to show what that looks like.\n\nIn this model argument, presented as a play, watch two engineering\nmanagers disagree about something. How do they work through their\ndisagreement -- politely and effectively? Watch our the characters\nfigure out what they're really clashing about, learn about each other's\nperspectives, and come to a better decision than either could alone.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/10/"
+        }
+    ],
+    "speakers": [
+        "Sumana Harihareswara",
+        "Jacob Kaplan-Moss"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/l_AzIVnlim0/maxresdefault.jpg",
+    "title": "Argument Clinic: What Healthy Professional Conflict Looks Like",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=l_AzIVnlim0"
+        }
+    ]
+}

pycon-us-2023/videos/async-the-easy-way-scaling-structured-concurrency-with-static-and-dynamic-analysis.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Async python is a relatively recent addition to Python\u2019s longstanding\nconcurrency options of processes and threads - and offers a very\ndifferent programming experience. Where processes run independently and\nthreads switch at the whim of the kernel scheduler, async tasks take a\ndifferent tradeoff: managing shared state is as easy as in\nsingle-threaded synchronous Python, but it\u2019s on you to ensure that there\nare enough ``await``, ``async for``, and ``async with`` statements where\ntasks can switch to make steady progress.\n\nIn this talk, we\u2019ll explore the advantages of structured concurrency -\nespecially error handling, timeouts, cancellation, and readable code -\nand both convenient and reliable ways to mitigate the problems of\ncooperative concurrency (when one *uncooperative* slow task can bring\nyour whole program to a halt). I\u2019ll introduce you to static analysis\nwith flake8-trio and explain how to write your own AST-based tools, and\nshow how dynamic analysis can help us catch anything that slips past\nthat quick and convenient check.\n\nWith a system like this in place, you don\u2019t have to be an experienced or\nparanoid software engineer to write beautiful async code - to serve or\nscrape a website, control a bundle of processes, or write a game - it\njust reads like normal Python, and your tools will catch you if you\nfall.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/85/"
+        }
+    ],
+    "speakers": [
+        "Zac Hatfield-Dodds"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/FrpUb6OEbcc/maxresdefault.jpg",
+    "title": "Async the Easy Way: scaling structured concurrency with static and dynamic analysis",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=FrpUb6OEbcc"
+        }
+    ]
+}

pycon-us-2023/videos/best-practices-for-using-python-to-power-serverless-applications-sponsor-capital-one.json

@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Capital One uses Python to power a large number of serverless\napplications to improve developer experience and increase customer\nvalue. Because Python enables fast development cycles, engineers and\ndata scientists at Capital One have more time to focus on delighting our\ncustomers. Our Python development is also more potent on serverless as\nit eliminates multiple overhead requirements. In this talk, we will\ncover best practices we've learned along the way for using Python to\nbuild serverless solutions to enable a fast, intuitive and iterative\ndeveloper experience for:\n\n-  API calls\n-  Streaming data\n-  Machine learning inference\n\nAttendees will learn the techniques and tools available when using\nPython to build a production-grade serverless system complete with\nobservability and development practices baked in without ever\nprovisioning a server. The presentation will feature a demonstration of\nPython-based AWS Lambda functions-as-a-service.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/152/"
+        }
+    ],
+    "speakers": [
+        "Brian McNamara",
+        "Dan Furman"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/2SZ6Wks5iK4/maxresdefault.jpg",
+    "title": "Best Practices for Using Python to Power Serverless Applications (Sponsor: Capital One)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=2SZ6Wks5iK4"
+        }
+    ]
+}

pycon-us-2023/videos/biohacking-con-python-como-convertirse-en-el-senor-burns-fluorescente.json

@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "La charla abrir\u00e1 con una breve introducci\u00f3n al biohacking, seguida por\nuna mini clase (s\u00faper leve, lo prometo) de teor\u00eda gen\u00e9tica con el\nprop\u00f3sito de entender perfectamente la metodolog\u00eda del caso pr\u00e1ctico.\n\u00c9ste es el verdadero centro de la charla y consistir\u00e1 en editar nuestro\npropio ADN con CRISPR (una herramienta de corte y empalme biol\u00f3gico) y\nun script de Python (que dise\u00f1ar\u00e1 las secuencias gen\u00e9ticas necesarias\npara el experimento) para biohackearnos ciertos genes y convertirnos en\nel se\u00f1or Burns fluorescente. Todo esto nos servir\u00e1 para ver el tremendo\npotencial de la sinergia entre la ingenier\u00eda gen\u00e9tica y Python, no s\u00f3lo\nen ejemplos c\u00f3micos como el ya mencionado, sino tambi\u00e9n en el \u00e1mbito\nsanitario como tratamiento de enfermedades.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/14/"
+        }
+    ],
+    "speakers": [
+        "Marina Moro L\u00f3pez"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/4dGswVHGQlo/maxresdefault.jpg",
+    "title": "Biohacking con Python: c\u00f3mo convertirse en el se\u00f1or Burns fluorescente",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=4dGswVHGQlo"
+        }
+    ]
+}

pycon-us-2023/videos/breaking-away-from-the-empire-avoiding-the-evil-clutches-of-if-then-statements-sponsor-neo4j.json

@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Become a Rebel and learn how to create a hyperspace navigation app to\navoid Imperial patrols using the power of graphs in Python! Say goodbye\nto complex if-then statements and embrace a more elegant and flexible\napproach. In this talk we'll introduce graphs as a data structure, how\nto model this kind of data, and how to use them in place of more\ncomplicated logic code. Discover how graphs can simplify decision-making\nlogic in your code for improved readability and extensibility.\n\nJoin us on a journey to break free from the empire of if-then statements\nand unlock the full potential of your data. Expand your toolset and\nliberate your code!\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/143/"
+        }
+    ],
+    "speakers": [
+        "Jason Koo",
+        "Alison Cossette"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-VFPRdc0EZA/maxresdefault.jpg",
+    "title": "Breaking Away from the Empire: Avoiding the Evil Clutches of If-Then Statements (Sponsor: neo4j)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=-VFPRdc0EZA"
+        }
+    ]
+}

pycon-us-2023/videos/breaking-boundaries-advancements-in-high-performance-ai-ml-through-pytorch-s-python-compiler-sponsor-meta.json

@@ -0,0 +1,29 @@
+{
+    "copyright_text": "CC BY",
+    "description": "As GPUs continue to become faster, PyTorch, one of the most widely used\nframeworks in AI/ML has faced challenges keeping up with performance\ndemands. To mitigate this, parts of PyTorch have been moved into C++.\nThis approach goes against the original intent of PyTorch as a\nPython-based framework and complicates contributions from the community.\nThe PyTorch development team recognized the need to address these\nchallenges while maintaining PyTorch's Python roots and set ambitious\ngoals to improve performance, decrease memory usage, enable\nstate-of-the-art distributed capabilities, and ensure more PyTorch code\nis written in Python. To achieve these goals, they developed a Python\ncompiler. Attendees of this talk will get an inside look at how the\nPyTorch development team approached these challenges and implemented\ntheir innovative solution to achieve a 43% speedup in performance. We\nwill discuss the benefits and challenges of this approach, as well as\nthe techniques and technologies used to build the PyTorch Python\ncompiler. This talk will provide valuable insights into the development\nprocess of and offer attendees a deeper understanding of how PyTorch\ncontinues to evolve and innovate.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/155/"
+        }
+    ],
+    "speakers": [
+        "Justin Jeffress",
+        "Sam Gross",
+        "Suraj Subramanian"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/sKFwS0TEHHM/maxresdefault.jpg",
+    "title": "Breaking Boundaries: Advancements in High-Performance AI/ML through PyTorch's Python Compiler (Sponsor: Meta)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=sKFwS0TEHHM"
+        }
+    ]
+}