From f258947ecc5fbbb52183193fe3908786fa986814 Mon Sep 17 00:00:00 2001 From: Amethyst Reese Date: Wed, 7 Aug 2024 22:16:10 -0700 Subject: [PATCH] Talks for PyCascades 2024 Issue #1181 --- pycascades-2024/category.json | 3 ++ ...g-graphql-microservices-using-fastapi.json | 30 +++++++++++++++++ ...fting-better-and-efficient-containers.json | 29 +++++++++++++++++ ...-wirelessly-programming-circuitpython.json | 29 +++++++++++++++++ ...dly-cli-for-api-driven-infrastructure.json | 29 +++++++++++++++++ ...p-between-machine-learning-and-devops.json | 29 +++++++++++++++++ ...producibility-with-and-without-docker.json | 29 +++++++++++++++++ .../videos/intro-to-introspection.json | 29 +++++++++++++++++ ...s-and-friends-to-play-with-the-colors.json | 29 +++++++++++++++++ pycascades-2024/videos/lightning-talks.json | 27 ++++++++++++++++ ...vel-python-applications-with-pyscript.json | 29 +++++++++++++++++ ...g-of-jupyter-notebook-inaccessibility.json | 29 +++++++++++++++++ ...-methods-you-can-make-by-dunder-seuss.json | 29 +++++++++++++++++ ...periences-and-roles-within-the-python.json | 32 +++++++++++++++++++ ...orlds-with-python-in-game-development.json | 29 +++++++++++++++++ ...rest-deploy-notebooks-as-web-services.json | 29 +++++++++++++++++ .../testing-your-web-app-with-playwright.json | 29 +++++++++++++++++ ...t-language-to-write-python-in-is-rust.json | 29 +++++++++++++++++ pycascades-2024/videos/the-rising-sea.json | 29 +++++++++++++++++ ...the-stories-of-the-most-infamous-bugs.json | 29 +++++++++++++++++ .../videos/types-in-my-python.json | 29 +++++++++++++++++ 21 files changed, 585 insertions(+) create mode 100644 pycascades-2024/category.json create mode 100644 pycascades-2024/videos/building-graphql-microservices-using-fastapi.json create mode 100644 pycascades-2024/videos/containerizing-python-crafting-better-and-efficient-containers.json create mode 100644 pycascades-2024/videos/cutting-the-usb-cord-wirelessly-programming-circuitpython.json create mode 100644 pycascades-2024/videos/designing-a-human-friendly-cli-for-api-driven-infrastructure.json create mode 100644 pycascades-2024/videos/embracing-mlops-bridging-the-gap-between-machine-learning-and-devops.json create mode 100644 pycascades-2024/videos/i-declare-an-environment-reproducibility-with-and-without-docker.json create mode 100644 pycascades-2024/videos/intro-to-introspection.json create mode 100644 pycascades-2024/videos/kandinsky-using-kmeans-and-friends-to-play-with-the-colors.json create mode 100644 pycascades-2024/videos/lightning-talks.json create mode 100644 pycascades-2024/videos/next-level-python-applications-with-pyscript.json create mode 100644 pycascades-2024/videos/notably-inaccessible-data-driven-understanding-of-jupyter-notebook-inaccessibility.json create mode 100644 pycascades-2024/videos/oh-the-methods-you-can-make-by-dunder-seuss.json create mode 100644 pycascades-2024/videos/pyladies-panel-talking-about-experiences-and-roles-within-the-python.json create mode 100644 pycascades-2024/videos/pythonic-play-crafting-interactive-worlds-with-python-in-game-development.json create mode 100644 pycascades-2024/videos/rest-easy-with-jupyrest-deploy-notebooks-as-web-services.json create mode 100644 pycascades-2024/videos/testing-your-web-app-with-playwright.json create mode 100644 pycascades-2024/videos/the-best-language-to-write-python-in-is-rust.json create mode 100644 pycascades-2024/videos/the-rising-sea.json create mode 100644 pycascades-2024/videos/the-stories-of-the-most-infamous-bugs.json create mode 100644 pycascades-2024/videos/types-in-my-python.json diff --git a/pycascades-2024/category.json b/pycascades-2024/category.json new file mode 100644 index 000000000..5f6748d82 --- /dev/null +++ b/pycascades-2024/category.json @@ -0,0 +1,3 @@ +{ + "title": "PyCascades 2024" +} diff --git a/pycascades-2024/videos/building-graphql-microservices-using-fastapi.json b/pycascades-2024/videos/building-graphql-microservices-using-fastapi.json new file mode 100644 index 000000000..e22b23135 --- /dev/null +++ b/pycascades-2024/videos/building-graphql-microservices-using-fastapi.json @@ -0,0 +1,30 @@ +{ + "copyright_text": "", + "description": "FastAPI is a Python web framework built on top of the ASGI standard. The fusion of GraphQL and FastAPI emerges as a pivotal approach for constructing agile and scalable microservices. This talk delves into the symbiotic relationship between GraphQL's query flexibility and FastAPI's high-performance capabilities. Attendees will gain insights into seamless integration techniques, leveraging FastAPI's asynchronous framework, dependency injection, and GraphQL's expressive querying.", + "duration": 1422, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Aby M Joseph", + "Thameem Karakkoth" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/keiaOBCfWNE/maxresdefault.jpg", + "title": "Building GraphQL microservices using FastAPI", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=keiaOBCfWNE" + } + ] +} diff --git a/pycascades-2024/videos/containerizing-python-crafting-better-and-efficient-containers.json b/pycascades-2024/videos/containerizing-python-crafting-better-and-efficient-containers.json new file mode 100644 index 000000000..9e4a20e65 --- /dev/null +++ b/pycascades-2024/videos/containerizing-python-crafting-better-and-efficient-containers.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Containerization, particularly with tools like Docker, has become a cornerstone in deploying applications efficiently. Building a Docker image for Python applications is generally uncomplicated, yet optimizing these images requires extra work. Notably, many of these optimizations are uniquely tailored to Python.\n\nThis talk focuses on techniques and best practices to build more efficient Docker images for Python in order to generate reproducible and quicker builds while reducing the image sizes at the same time.", + "duration": 1652, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Avik Basu" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/MMUjFzcyIWs/maxresdefault.jpg", + "title": "Containerizing Python: Crafting Better and Efficient Containers", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=MMUjFzcyIWs" + } + ] +} diff --git a/pycascades-2024/videos/cutting-the-usb-cord-wirelessly-programming-circuitpython.json b/pycascades-2024/videos/cutting-the-usb-cord-wirelessly-programming-circuitpython.json new file mode 100644 index 000000000..07833252c --- /dev/null +++ b/pycascades-2024/videos/cutting-the-usb-cord-wirelessly-programming-circuitpython.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Come learn how to program CircuitPython wirelessly over Bluetooth and WiFi. CircuitPython is a version of Python designed for small computers used in electronics projects called microcontrollers. Bluetooth is great for connecting devices to a phone or tablet on the go. At home, WiFi simplifies connecting to a multitude of devices without needing to plug into them directly. Both are also great for devices that are hard to access.", + "duration": 1278, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Scott Shawcroft" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/eiQ9RIt-cNM/maxresdefault.jpg", + "title": "Cutting the USB cord: wirelessly programming CircuitPython", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=eiQ9RIt-cNM" + } + ] +} diff --git a/pycascades-2024/videos/designing-a-human-friendly-cli-for-api-driven-infrastructure.json b/pycascades-2024/videos/designing-a-human-friendly-cli-for-api-driven-infrastructure.json new file mode 100644 index 000000000..891d09087 --- /dev/null +++ b/pycascades-2024/videos/designing-a-human-friendly-cli-for-api-driven-infrastructure.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "As Bloomberg\u2019s infrastructure grows and evolves, the tools we use to manage it are becoming increasingly important. To streamline infrastructure management, our team set out to design a REST API and constituent CLI (Command Line Interface) that would comprise a single interface for both programmatic and human interaction with our infrastructure. Traditionally, building a CLI that is tightly coupled to an API requires maintaining a separate codebase, which is tedious and error-prone. Instead, we designed a CLI that dynamically generates commands based on the OpenAPI JSON documentation. However, since APIs are designed for computer interaction, we designed our API to include the information needed to implement a human-friendly CLI. Leveraging Python, FastAPI, and numerous other open source projects, we built a stable, extensible tool that greatly improves how we interact with our infrastructure.", + "duration": 1392, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Oliver Rew" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/LZQCLsqxVKI/sddefault.jpg", + "title": "Designing a Human-Friendly CLI for API-Driven Infrastructure", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=LZQCLsqxVKI" + } + ] +} diff --git a/pycascades-2024/videos/embracing-mlops-bridging-the-gap-between-machine-learning-and-devops.json b/pycascades-2024/videos/embracing-mlops-bridging-the-gap-between-machine-learning-and-devops.json new file mode 100644 index 000000000..a7185985f --- /dev/null +++ b/pycascades-2024/videos/embracing-mlops-bridging-the-gap-between-machine-learning-and-devops.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "In the dynamic field of machine learning, MLOps (Machine Learning Operations) has emerged as a crucial discipline combining aspects of machine learning, data science and operations. This talk aims to demystify MLOps differentiating it from traditional DevOps practices and highlighting its growing importance.", + "duration": 1398, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Mayank Jindal" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/wRnKcWIZEvk/maxresdefault.jpg", + "title": "Embracing MLOps: Bridging the Gap Between Machine Learning and DevOps", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=wRnKcWIZEvk" + } + ] +} diff --git a/pycascades-2024/videos/i-declare-an-environment-reproducibility-with-and-without-docker.json b/pycascades-2024/videos/i-declare-an-environment-reproducibility-with-and-without-docker.json new file mode 100644 index 000000000..60ea7acb9 --- /dev/null +++ b/pycascades-2024/videos/i-declare-an-environment-reproducibility-with-and-without-docker.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "A software project being called \"reproducible\" can mean a lot of things, but usually includes a description of how and where the code in your project can be run. Often this means including Python virtual environment, a Conda environment, or even a Docker container to help others replicate your work. In this talk I will introduce some of the most common ways the scientific Python community approaches reproducibility, and what are the advantages and disadvantages of the approaches. I will also share a new way that you can make not only your Python code but your development machine reproducible without Docker containers with a tool called Nix. I will also show an example of using a Nix defined operating system (NixOS) with Docker containers to run my home lab.", + "duration": 1591, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Sarah Kaiser" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/acGazOBPpeo/maxresdefault.jpg", + "title": "I declare an environment! - Reproducibility with and without Docker", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=acGazOBPpeo" + } + ] +} diff --git a/pycascades-2024/videos/intro-to-introspection.json b/pycascades-2024/videos/intro-to-introspection.json new file mode 100644 index 000000000..937564f42 --- /dev/null +++ b/pycascades-2024/videos/intro-to-introspection.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Python holds no secrets about your code; except perhaps how to access that information. in this talk you'll find out how to discover almost any information about running python code.", + "duration": 1307, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Jeremiah Paige" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/bCIDqS1sY5c/sddefault.jpg", + "title": "Intro to Introspection", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=bCIDqS1sY5c" + } + ] +} diff --git a/pycascades-2024/videos/kandinsky-using-kmeans-and-friends-to-play-with-the-colors.json b/pycascades-2024/videos/kandinsky-using-kmeans-and-friends-to-play-with-the-colors.json new file mode 100644 index 000000000..2ffa666a3 --- /dev/null +++ b/pycascades-2024/videos/kandinsky-using-kmeans-and-friends-to-play-with-the-colors.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Clustering is tricky yet absolutely essential for many a Machine Learning initiative. The what, the how and the why confound each time we look at the data, whether it is customer segmentation (or cohort) analysis or it is finding centers of influence or breaking down a population into groups to build different models for each.\n\nStudying clustering algorithms like KMeans using toy datasets is insufficient (and often tedious) because it does not let you experience real-world problems. For e.g. the problem when the centroids don't settle, or situations where we have too many or too few clusters. Which distance measure to use and when? How to prepare (normalize? standardize?) the dataset for clustering?\n\nAlso, not too many real-world scenarios are \"visual\", unless we plot a graph or two, and that fails when we deal with higher dimensions.\n\nWhat if we could use a non-trivial but visual data source? Like the colors and pixels of a photograph, where we could see the data that went in and the resultant output clusters?\n\nThe obvious **takeaways of this talk**, in my experience, are that *Data Science and Data Engineering practitioners* gain a deeper understanding of what's going on in the clustering algorithms in a fun, very \"visual\" and engaging manner; and also build a better intuition about the best approach to take for solving a problem.", + "duration": 1513, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Shaurya Agarwal" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/3v876L6_ay4/maxresdefault.jpg", + "title": "Kandinsky: Using KMeans (and friends) to play with the colors of photograph(s)", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=3v876L6_ay4" + } + ] +} diff --git a/pycascades-2024/videos/lightning-talks.json b/pycascades-2024/videos/lightning-talks.json new file mode 100644 index 000000000..de9af2963 --- /dev/null +++ b/pycascades-2024/videos/lightning-talks.json @@ -0,0 +1,27 @@ +{ + "copyright_text": "", + "description": "", + "duration": 2042, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/mtfu_D3pAlo/sddefault.jpg", + "title": "Lightning Talks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=mtfu_D3pAlo" + } + ] +} diff --git a/pycascades-2024/videos/next-level-python-applications-with-pyscript.json b/pycascades-2024/videos/next-level-python-applications-with-pyscript.json new file mode 100644 index 000000000..711558a38 --- /dev/null +++ b/pycascades-2024/videos/next-level-python-applications-with-pyscript.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Zero Installation, massive scalability, mobile support and more. This talk is going to cover the super powers of running Python in the Browser and how to best use PyScript.", + "duration": 1522, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Fabio Pliger" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/btEFmI633Pg/maxresdefault.jpg", + "title": "Next Level Python Applications with PyScript", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=btEFmI633Pg" + } + ] +} diff --git a/pycascades-2024/videos/notably-inaccessible-data-driven-understanding-of-jupyter-notebook-inaccessibility.json b/pycascades-2024/videos/notably-inaccessible-data-driven-understanding-of-jupyter-notebook-inaccessibility.json new file mode 100644 index 000000000..0b1089d02 --- /dev/null +++ b/pycascades-2024/videos/notably-inaccessible-data-driven-understanding-of-jupyter-notebook-inaccessibility.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Speaker: Venkatesh Potluri\n\nJupyter notebooks are versatile tools that open up rich storytelling possibilities by providing the means to interleave code, data and text together. Notebooks are widely adopted in a variety of expert domains such as data science, machine learning, and astronomy making the ability to create and consume them a critical requirement to participate in these professional domains. Notebooks and notebook software (tools and infrastructure to create and share notebooks) however are inaccessible resulting in barriers preventing blind or visually impaired (BVI) experts from participating in these professions.\n\nIn this talk, I will draw from our systematic large scale analysis on 100000 Jupyter notebooks and provide a broad understanding of why these notebooks are inaccessible, and exactly how inaccessible these notebooks really are. I will close with recommendations to infrastructures that drive the notebook pipeline and authoring practices to create and share truly accessible notebooks. It is imperative that we contribute to accessible notebook artifacts and software to make high-skilled work accessible!", + "duration": 1023, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Venkatesh P" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/vQS8bKCt6Hw/maxresdefault.jpg", + "title": "Notably Inaccessible -- Data Driven Understanding of Jupyter Notebook Inaccessibility", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=vQS8bKCt6Hw" + } + ] +} diff --git a/pycascades-2024/videos/oh-the-methods-you-can-make-by-dunder-seuss.json b/pycascades-2024/videos/oh-the-methods-you-can-make-by-dunder-seuss.json new file mode 100644 index 000000000..3e461fc42 --- /dev/null +++ b/pycascades-2024/videos/oh-the-methods-you-can-make-by-dunder-seuss.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "You can make many methods\n\nOver 100 to be exact\n\nThat start with two underscores\n\nWhat do you think of that?\n\nThe runtime, it calls these\n\nAt points A or B\n\nTo do special magic\n\nAt runtime, you see.\n\nYou may have seen `__getattr__` or `__init__`\n\nBut `__rfloordiv__`? What\u2019s the point of it?", + "duration": 1205, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Joshua Cannon" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/JiWhOHzho8o/maxresdefault.jpg", + "title": "Oh the (Methods) You Can (Make): By Dunder Seuss", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=JiWhOHzho8o" + } + ] +} diff --git a/pycascades-2024/videos/pyladies-panel-talking-about-experiences-and-roles-within-the-python.json b/pycascades-2024/videos/pyladies-panel-talking-about-experiences-and-roles-within-the-python.json new file mode 100644 index 000000000..4a82b8edf --- /dev/null +++ b/pycascades-2024/videos/pyladies-panel-talking-about-experiences-and-roles-within-the-python.json @@ -0,0 +1,32 @@ +{ + "copyright_text": "", + "description": "Panelists: Christy Heaton, Mariatta, Lynn Root, Luciana Abud", + "duration": 2621, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Lynn Root", + "Mariatta", + "Christy Heaton", + "Luciana Abud" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/whXlOKFk4Js/sddefault.jpg", + "title": "PyLadies Panel: Talking about experiences and roles within the Python community", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=whXlOKFk4Js" + } + ] +} diff --git a/pycascades-2024/videos/pythonic-play-crafting-interactive-worlds-with-python-in-game-development.json b/pycascades-2024/videos/pythonic-play-crafting-interactive-worlds-with-python-in-game-development.json new file mode 100644 index 000000000..d1f5d1f53 --- /dev/null +++ b/pycascades-2024/videos/pythonic-play-crafting-interactive-worlds-with-python-in-game-development.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Embark on a thrilling journey into the realm of game development where the elegance of Python meets the excitement of interactive experiences! In this talk, I will unravel the captivating world of Python game development, exploring the tools, techniques, and creative possibilities that make Python a formidable language for crafting immersive games.", + "duration": 1472, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Drishti Jain" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/ZEK-oYqhKlU/sddefault.jpg", + "title": "Pythonic Play: Crafting Interactive Worlds with Python in Game Development", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=ZEK-oYqhKlU" + } + ] +} diff --git a/pycascades-2024/videos/rest-easy-with-jupyrest-deploy-notebooks-as-web-services.json b/pycascades-2024/videos/rest-easy-with-jupyrest-deploy-notebooks-as-web-services.json new file mode 100644 index 000000000..2b488a970 --- /dev/null +++ b/pycascades-2024/videos/rest-easy-with-jupyrest-deploy-notebooks-as-web-services.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Jupyter notebooks are awesome! However, a notebook on its own is not a product or a service. Bridging this gap usually involves a complete rewrite into a web service that leaves behind all the awesome-ness of the notebook. What if we didn't have to do this? That's where Jupyrest comes in! Jupyrest is a library I created to solve this exact problem for my team at Microsoft. In this talk I'll show you how you can turn your Jupyter notebooks into a web service without any modifications to it. Jupyrest is being used at Microsoft by data scientists to deploy hundreds of microservices.", + "duration": 859, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Koushik Krishnan" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/CQVrwghjjFY/maxresdefault.jpg", + "title": "Rest Easy with Jupyrest: Deploy notebooks as web services", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=CQVrwghjjFY" + } + ] +} diff --git a/pycascades-2024/videos/testing-your-web-app-with-playwright.json b/pycascades-2024/videos/testing-your-web-app-with-playwright.json new file mode 100644 index 000000000..205db4589 --- /dev/null +++ b/pycascades-2024/videos/testing-your-web-app-with-playwright.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Once upon a time, if you wanted a truly modern web frontend experience for your Python web app you would have limited options in how to pull it off. A lot of people would reach for heavy frontend tools and frameworks such as React, Vue or one of their many, many competitors. And those tools generally have their recommendations around testing.\n\nThings are shifting a bit - tools like HTMX and AlpineJS are taking Python Web dev by storm and simplifying the creation of modern frontends. A Python web app can now take on the full responsibility of producing a modern frontend. So it would be good to test them in Python as well.\n\nThis is where Playwright comes in. It promises to enable reliable end-to-end testing for modern web apps. And it has Python bindings. *swoon*\n\nIn this talk, I'll give you a little tour of Playwright and how to use it in your app. I'll demo some workflows, patterns, tips, and tricks.", + "duration": 1183, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Sheena O'Connell" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/rrliP18nIig/maxresdefault.jpg", + "title": "Testing your web app with Playwright", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=rrliP18nIig" + } + ] +} diff --git a/pycascades-2024/videos/the-best-language-to-write-python-in-is-rust.json b/pycascades-2024/videos/the-best-language-to-write-python-in-is-rust.json new file mode 100644 index 000000000..22f172fce --- /dev/null +++ b/pycascades-2024/videos/the-best-language-to-write-python-in-is-rust.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Python is an excellent language, in part because of how accessible it is. This accessibility means that professionals in finance, science, marketing, etc, often can make use of it for their goals. This also means that for programmers who write tools for these users, Rust can make an excellent language to deliver a fast, stable experience. In this talk we'll discuss more about why you might consider augmenting your Python code with Rust and walk through a case study for how to achieve it.", + "duration": 1628, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Trent H" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/HkfVaZZAGLI/maxresdefault.jpg", + "title": "The Best Language to Write Python In Is Rust", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=HkfVaZZAGLI" + } + ] +} diff --git a/pycascades-2024/videos/the-rising-sea.json b/pycascades-2024/videos/the-rising-sea.json new file mode 100644 index 000000000..def81bd5e --- /dev/null +++ b/pycascades-2024/videos/the-rising-sea.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "We discuss the pleasure of problem solving by dissolution.", + "duration": 1341, + "language": "eng", + "recorded": "2024-04-07", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Matthew Drury" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/AkBWb1fK6R8/sddefault.jpg", + "title": "The Rising Sea", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=AkBWb1fK6R8" + } + ] +} diff --git a/pycascades-2024/videos/the-stories-of-the-most-infamous-bugs.json b/pycascades-2024/videos/the-stories-of-the-most-infamous-bugs.json new file mode 100644 index 000000000..9891f98e6 --- /dev/null +++ b/pycascades-2024/videos/the-stories-of-the-most-infamous-bugs.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "Whenever we write code we eventually make mistakes and have \u201cbugs\u201d. We employ many techniques including testing and reviews to avoid them but some mistakes still make it into production. But what are the most famous \"bugs\"? How they happened and is there something common we can learn from them?", + "duration": 1505, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Ian Zelikman" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/OOfefO9SHW0/sddefault.jpg", + "title": "The Stories Of the Most Infamous Bugs", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=OOfefO9SHW0" + } + ] +} diff --git a/pycascades-2024/videos/types-in-my-python.json b/pycascades-2024/videos/types-in-my-python.json new file mode 100644 index 000000000..86b44622d --- /dev/null +++ b/pycascades-2024/videos/types-in-my-python.json @@ -0,0 +1,29 @@ +{ + "copyright_text": "", + "description": "It's more likely than you think!\n\nTypes, In My Python? is an analysis of Python's unique relationship to typing systems.\n\nI will start by examining Python's strange dual nature:\n\nA dynamically typed scripting language that more or less works as expected.\n\nA strongly typed language with strict limits on what you can do with an object,\n\nand now able to statically analyze your usages to make sure you're doing things right.\n\nFollowing that, I will examine some of the concepts we talk about as a community in more detail.\n\nWhat do we mean by \"duck typing\", and how does it apply in light of Python's dual nature?\n\nWhy is it static analysis, and not static typing?\n\nTo end, I will make a proposal regarding the best method to use both sides of Python's type system.\n\nThe goal is to accelerate your development and reduce tedium.\n\nIs there a happy middle ground between strict static typing and a dynamic free-for-all?", + "duration": 1478, + "language": "eng", + "recorded": "2024-04-06", + "related_urls": [ + { + "label": "Conference schedule", + "url": "https://2024.pycascades.com/program/schedule/" + }, + { + "label": "Full playlist", + "url": "https://www.youtube.com/playlist?list=PLcNrB7gPa-Ne6QknxKayJaEBsKfkmA72l" + } + ], + "speakers": [ + "Piper Thunstrom" + ], + "tags": [], + "thumbnail_url": "https://i.ytimg.com/vi/aOap9C3AfAA/maxresdefault.jpg", + "title": "Types, In My Python?!", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=aOap9C3AfAA" + } + ] +}