PyVideo.org - Almar Klein

Let’s embrace WebAssembly!

2018-07-25T00:00:00+00:00

Description

WebAssembly (WASM) is an open, low level binary format designed to be compact and run at native speed, while being memory-safe. WASM is primarily intended to run code in browsers, but its by no means limited to this. This makes it an interesting intermediate language (IR); code that compiles to WASM will (in the future) run basically anywhere. In short: WASM is coming and its great!

Unsurprisingly, WASM is being embraced by many communities, such as C++, Rust, Lua, and .NET. Sadly, there does not seem to be a lot of enthusiasm from the Python community yet…

Perhaps this is because Python is interpreted and can therefore not (easily) use WASM as a compilation target. It should be possible to compile a Python interpreter (like CPython or Pypy) to WASM and thereby run Python code in a browser. But the result would be pretty heavy-weight, so it would arguably not be a very practical.

Within the PPCI project (a pure Python compiler infrastructure) tooling has been developed to load, inspect, compile and even run WASM modules. This allows combining WASM and Python in new ways. In this talk we discuss two approaches by which the Python community might embrace WASM.

Firstly, various projects already exist that compile Python functions to other languages (e.g. Numba, PScript), and we have type annotations. If Python functions would be compiled to WASM, the resulting code would run in any WASM runtime (e.g. the browser). This will be demonstrated with an example, for which the resulting code can be run either in a browser or inside Python itself. In either case, it’s pretty darn fast.

Secondly, rather than using WASM, it might be interesting for Python to function as a platform to run and bind WASM modules. Two of Python’s greater strengths are its rich ecosystem and its ability to glue things together. Let’s build on that! Imagine creating an application that consists of multiple WASM modules, perhaps compiled from different languages, and binding these together into a single Python app.

This will be demonstrated with a game, which is written in Rust, compiled to WASM, and running inside a Python process. The WASM module consumes a drawing API, which is in this case provided by Python, and Python feeds the WASM module with user input.

I hope that this talk inspires other Pythonistas to think about the advantages that WASM can bring to our ecosystem, and also about the role that Python can play in the growing WASM ecosystem.

Introducing Vispy's high level modules: easy, powerful visualization

2014-10-22T00:00:00+00:00

Description

Vispy is an OpenGL-based interactive visualization library in Python. Its goal is to make it easy to create beautiful and fast dynamic visualizations. For example, scientific plotting of tens of millions of points, interacting with complex polygonial models, and (dynamic) volume rendering.

Vispy is a young library and very actively developed. Until recently, a user would have to know OpenGL in order to work with Vispy. Now that the higher levels of the package take shape, this is no longer the case. When these layers are finalized, the number of people that can benefit from vispy will significantly increase.

We will give a brief overview of the Vispy package, and focus on the higher level modules that will make it easy to visualize images, lines, etc., and organize these object in a scene graph. Of course we will demonstrate this with several examples.

We will also talk about our progress in other areas, such as a browser backend and integration with the IPython notebook.

http://vispy.org/

A Pure Python GUI Tookit Based on Web Technology

2015-10-05T00:00:00+00:00

Description

This talk describes a cross-platform, pure Python toolkit for creating graphical user interfaces (GUI's), that uses web technology for its rendering. You can use it to create desktop applications, web apps, and add widgets to the IPython/Jupyter notebook.

Getting the hang of WASM

2017-08-31T00:00:00+00:00

Description

Web Assembly (WASM) is a new open standard developed by representatives from all major browsers. It is a low level binary format designed to be compact and run at native speed, while being memory-safe.

WASM is primarily intended to run code in browsers, but will also run in other environments like desktop, mobile and more. This makes it interesting to use as an intermediate language (IR); code that compiles to WASM will (in the future) run basically anywhere.

A proof of concept was released early this year and works out of the box in recent Firefox and Chrome browsers. In order to play with WASM myself, I wrote a tiny Python library that makes it relatively easy to generate WASM modules.

In this talk I will briefly explain what WASM is, describe the anatomy of a WASM module, how it fits in the host environment (e.g. JavaScript or a C++ program), and the kinds of opportunities that this provides. Via live coding in a notebook, I will first write a simple WASM program by hand, compile it to binary WASM, and execute it in the notebook itself. We will then move to higher levels (including a Mindfuck to WASM compiler) and end with compiling a simple Python program to WASM, which will find the 10001st prime much faster than Python does. As a side effect, this talk is also a crash course on how compilers work.

I expect WASM to have a major impact. Although it is currently in its early infancy, we can already play with it, and I hope to give a glimpse of the awesome things that it can do.

Running (snippets of) Python in the browser

2016-03-26T00:00:00+00:00

Description

PyData Amsterdam 2016

In this talk, we’ll start with an overview of solutions to run Python in the browser. Then we’ll explain how our solution (PyScript) works and what its advantages/disadvantages are. Next, we’ll demonstrate its use in a few real-world projects.

It is evident that “the web” is becoming an increasingly important place to publish research findings. Apart from the obvious advantage of being able to reach a wide audience at negligible cost, browser technology allows for increasingly sophisticated means to present your data and findings in various interactive ways.

Unfortunately, the language of the web (JavaScript) is a language that is notorious for its many flaws. It seems that Pythonistas are especially repelled by the language, since the number of projects that try to “run Python in the browser” is steadily growing.

In our approach (PyScript), we do not aim to run the full Python language in the browser. It’s rather a way to write JavaScript using a Python syntax, making it as Pythonic as we can. There are a few pitfalls, but these have been reduced over time, which makes writing PyScript feel almost like writing Python.

One advantage of our approach is that one can generate snippets of JavaScript code that can interact as-is with other JavaScript libraries. Combined with the fact that PyScript is valid Python, it allows for a natural way to define client-side reactivity inside common Python modules. Also, it makes PyScript faster than most other Python-in-the-browser solutions.

One of its use-cases is Bokeh’s new capability to define client-side callbacks in Python. There are plans to use a similar approach to allow users to define custom Bokeh models. The Flexx project is a pure Python widget toolkit, that renders in the browser. All widgets are implemented with PyScript (wrapping PhosphorJS for some layouts). In a project with Clinical Graphics, PyScript is used in a system that allows visualization and user-annotations of medical images, with plans for 3D visualizations.

Slides available here: https://docs.google.com/presentation/d/1X069udByOTw3d4-NVU14XwhTANCdECvjY0R7fDuXTpA/pub?start=false&loop=false&delayms=3000

Running Python Apps in the Browser

2016-07-14T00:00:00+00:00

Description

The web is becoming an increasingly important place to publish research findings, but JavaScript is a language that is broken by design, and Pythonistas seem particularly repelled by the language.

Flexx is a tool to create web apps, for which the client-side is completely implemented in Python and transpiled to JavaScript. It’s easy to extend Flexx’ functionality by writing Python classes, which will be demonstrated in this talk.