List of videos

In today's IDE-land, we've often overheard conversations between developers about new features being added to their editor-of-choice and how editor XYZ is better than ABC (vim vs emacs vs VSCode vs IntelliJ, we know the drill). This talk doesn't stoke fire to that debate in any direction (since different things work for different people). But, a very important tool that often powers most of the magical features that come with modern software development is the LSP server. The LSP server often keeps chugging in the background, tirelessly providing the user with diagnosis regarding the codes, autocompleting variables, and formatting the codebase to maintain prettiness. While various elements such as parsing, linting, and formatting have long existed, it is the LSP server that seamlessly unifies these features in an editor-agnostic manner. LSP servers are used everywhere, often installed individually by the user even, but there aren't many resources regarding how to actually build a functional server that can do more than send /"Hello Editor World!"/ messages to the editor. This talk aims to fill in that gap to provide a blueprint of steps that anyone who wants to implement an LSP server in Python can follow. Following this talk will provide a better understanding of the JSON-RPC protocol used by LSP servers to communicate with the client, diagnosis that a server can share with the user and pitfalls that one can fall into while implementing their own server. It will end with a live demonstration of a toy-LSP server that provides the basic functionalities to an editor client. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/29/2024-05-14T03%3A18%3A23.117527/LSP_Demystified_-_2.pdf

Binary extensions underlie much of the modern Python ecosystem, providing performance and access to a wealth of existing code. Packaging for these libraries is rapidly changing from thousands of lines of distutils and setuptools based hackery to build systems designed for binaries like scikit-build-core, meson-python, and maturin. NumPy, for example, went from around 13K to 2K lines of building related code by moving to Meson in NumPy 1.26. These build systems provide a much more integrated experience than was previously possible for compiled extensions. For example, CMake or Ninja are only required if the system doesn’t already provide an appropriate copy, which allows building with an external ninja/cmake on systems without binary wheels on PyPI like Pyodide, BSD, and Android. Modern editable installs are supported. Support for advanced features like ABI3 wheels or wheels that don’t call CPython is usually just a single configuration option. We will look at how easy it is now to set up a binary extension using CMake, Meson, or Maturin (Rust only). It can be done with only three files each containing only a handful of lines of code. Unlike the previous solutions, this covers cross-compilation,multithreaded builds, modern C++ standards, and other features that would each require custom code in a classic setup.py. Combined with cibuildwheel for building wheels and good support from modern binding tools like pybind11 and nanobind, the barrier for entry to reliable compiled extensions has dropped dramatically. We will also look at the challenges and solutions from some larger conversions to modern build systems, like NumPy’s and RAPIDS.ai. After this talk, you will know how to easily create compiled extensions to solve problems you encounter, and how to move existing projects to these modern build systems. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/112/2024-05-17T13%3A51%3A23.958689/PyCon_2024.pdf

The documentation for your Python package is already peppered with examples – what if users could run them in an interactive REPL, right inside the online documentation? With PyScript, developers can add an interactive Python session to any webpage, including integration with Sphinx, MkDocs, readthedocs, and GitHub Pages. Your documentation examples become an interactive learning session with zero backend or installation. In this talk, you will learn how to enhance your Python web documentation by making it interactive and runnable anywhere, in a fully serverless way.

Code coverage shows what lines or branches your tests are missing. If you maintain Python code, chances are you use coverage.py to measure it. You probably don't use it all the time, though, as it slows down your tests -- up to a whopping 2.6x. This talk introduces SlipCover, a new tool that brings this overhead down to only 5%. We look into what slows down coverage.py, and show how SlipCover is able to do better. For Python 3.12, SlipCover adopts the new Low Impact Monitoring API (PEP669); we discuss the advantages and challenges of integrating it into SlipCover. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/110/2024-05-14T18%3A33%3A26.308459/SlipCover-PyCon24.pdf

Given the results it can deliver (and its inherent complexity), geospatial data often takes center stage in projects it's incorporated into. Its star power and intimidating array of fellow-travelers (GDAL, et al) can make it easy to discount its value in simpler supporting roles or behind-the-scenes. Looking beyond the typical analysis and visualization toolchains--and their extreme learning curves--this talk demonstrates some comparatively low-lift patterns for leveraging geodata in a web application back end. We'll begin by briefly discussing how geospatial data differs from other data types, how it is commonly formatted and made available, and which aspects (spatial reference identifiers, e.g.) are crucial to maintaining data correctness. Having laid out a few fundamentals we will look at PostGIS, an open-source extension to PostgreSQL which enables support for spatial datatypes, functions, and indexes. Finally, we'll look at an example application based on the FastAPI web framework which uses features of Pydantic and SQLAlchemy + GeoAlchemy 2 to implement custom geospatial validations for inbound requests. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/97/2024-05-15T21%3A17%3A46.498628/Geospatial-Validations.pdf

While other language ecosystems have a streamlined workflow that involves a single tool like Rust's Cargo and JavaScript's npm, maintaining Python projects has historically involved learning and using an ever-growing set of tools: packaging: distutils, setuptools, flit dependency management: pip, pip-tools, poetry Python management: pyenv, Homebrew, Windows store environments: virtualenv, tox, nox versioning: pbr, setuptools_scm, bump2version, versioneer builds: pip, build publishing: twine ... This talk explains how Hatch can be that unified tool for Python. Audience Programmers at any level that wish to simplify their development experience. Level Any Objectives Attendees will learn how to manage the entire lifecycle of a project with Hatch from creation to publishing. Outline Intro (3 minutes) brief history why rewrite status/current users Project setup (2 minutes) installation porting setuptools-based projects creating new projects, with options Python management (1 minute) Packaging (6 minutes) briefly show pyproject.toml metadata build targets metadata hook plugins file inclusion defaults benefits vs setuptools config VCS support dev mode build hook plugins Dependencies (2 minutes) commands auto-sync workspaces, monorepos Environments (8 minutes) basic options philosophical difference between tox & nox scripts context formatting matrices overrides environment plugins Static analysis via Ruff (2 minutes) Testing via pytest (2 minutes) Versioning (2 minutes) source plugins bumping Publishing (1 minute) Future (1 minute) extension modules lock files Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/61/2024-05-16T00%3A00%3A40.871535/Hatch_-_The_only_tool_you_need.pptx

Full title: Talks: Seeing is Believing - Using Diagrams to Communicate Complex Ideas with Python This talk is about communicating with visuals to make complex ideas simple to understand. Over the years I have produced diagrams, charts, illustrations and other graphics to help people understand sophisticated project concepts. This includes project architecture, standard operating procedures, coding concepts, sprints and roadmaps. You will be guided through ways of how to make stylized examples of your project code and workflows in easy to follow examples. By using common software for illustrations along with some simple guidelines you too can make easy to follow visual content for your next project. Key Takeaways: Learn methods to visually communicate with your team including with color, shapes, images, gifs and even memes to help get a point across Understand how to make your technical documentation into visual graphics with diagram design style guides See examples of using libraries like Sphinx, Pydoc, and PlantUML to help make great diagrams Come away with an ability to execute a simple (or sophisticated) graphic with essential steps and key requirements Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/135/2024-05-17T12%3A19%3A14.148950/PYCON-2024-DIAGRAM-TADEH-HAKOPIAN-03.1.pdf

Debugging is one of the hardest parts of our jobs. Experienced developers shrug it off as an inevitability of life, but it's one of the biggest obstacles standing in the way of newcomers. While working as a mentor, the pain of this fact became ever so vivid for me. Inspired by Bret Victor's "Inventing on Principle" and Redux, I went on a quest to find out if time-travel debugging was possible. In my journey, I created a time-travel debugger for Python: Rewind. Rewind is a fork of CPython. It works by logging each state change to a file as the Python interpreter runs. Then, another program reads back the log file, recreates all historical states of the program and saves them to a database. A debugger GUI allows the user to step through the program line by line both forward and backward. Developing software using a time-travel debugger is a uniquely pleasant experience. It removes the anxiety of using a regular step debugger by allowing you to "undo". It's often more productive to start at the end where an error occurred, then step in reverse to go towards its cause. Moreover, omniscience - knowing all historical states of the program before hand - allows us to rethink what a debugger user interface can be. The talk will be fast paced. In addition to slides, I'll be voicing over some pre-recorded animations / videos in the style of YouTube documentaries. Demos are pre-recorded so there will be no risk of things going wrong live.

You might have encountered beautiful animations and data storytelling through many educators and experimentalists online and wondered if it’s only done in javascript or could also be done by Python. In this talk, the attendees will learn how to blend the 3D animation power of Blender with the 2D plotting capabilities from Python libraries like matplotlib, plotly, seaborn, etc. We will demonstrate some practical techniques to create immersive 3D models with Blender and enhance them with detailed 2D plots, providing a comprehensive narrative for data interpretation. By integrating these data-viz tools, devs and data enthusiasts will discover new & impactful ways to leverage Python to present and communicate their data insights from educational and work projects.