Blog

Despite its name, WebAssembly is not limited to the browser. In fact,
it's potential outside of the browser is at least as interesting. In
this post I talk about some experimental work that we have done in
combining WebAssembly with Python.

Historically, languages are either easy to use *or* fast. Julia has
shown us that we can have both. I argue that in this day and age, we
may *also* aspire a language to run on the web and mobile devices. I'll
explain how I think that Web Assembly will bring us closer to this goal.

In this post I discuss an approach for writing code in Python 3,
and still support Python 2.7. I've recently used this approach in one
of my own projects. Most projects should get away with only minor
modifications and an automatic translation step during package-build.
However, there are some pitfalls (bytes/str) that might need special
attention.

We have a rich ecosystem of visualization libraries, each with their
own API. By splitting our libraries in a user-facing part and a
rendering backend, and defining a standard to allow all these to
connect, we can have a rich visualization ecosystem while users only
have to learn one API.

Bokeh and VisPy are both awesome projects. However, I wonder
whether we need to change where things are currently going. While Bokeh
is great at 2D and the browser, 3D is not supported. While Vispy is
super-fast and good at 3D and custom visualizations, it's support for
the browser is poor. I don't want to tell scientists that they need two
or three visualization libraries. I want it all in one library.

Rendering a set of 100.000 vertices with OpenGL is very fast. However,
rendering 100 sets of 1000 vertices is significantly slower (even though
the total number of vertices is the same). Therefore, in visualization
libraries, collecting multiple objects in a single buffer can help
increase performance. In this post I try to get a grip on how much this
really matters. Result: it depends.

This post describes a small experiment that compares a few methods for
doing a box-layout in HTML. On a variety of browsers the result was
validated, and performance measured. The results show that the CSS
``display: flex`` method is the way to go.

We recently added volume rendering to [Vispy](http://vispy.org). In
this post I'll describe the method that is used, what the advantages
of this method are, and possible future additions. I tried to be gentle
and explain the method without giving too much boring details. Plus
there is some fancy footage to demonstrate the new functionality.

Like many people, I use todo lists to organize my tasks. I’ve tried
different todo-list solutions and even made a few apps myself. In this
post I try to explain what I learned from these tools, why organizing
knowledge and ideas may be more important than organizing tasks, and
why I like [Trello](http://trello.com) so much.

Dynamic programming languages provide great advantages due to
their interactive workflow, especially in science where algorithms are
complex and take many iterations to get right. Developer time is more
important than CPU time; writing all your code in a static language is
(often) a bad case of premature optimization.
This post is a story about how I learned the importance of dynamic
languages the hard way. I am sharing it here so that others might learn
from it too. It also touches on some of the benefits of Python compared
to Matlab.

Post-mortem debugging refers to the concept of entering debug mode
*after* something has broken. There is no setting of breakpoints
involved, so it's very quick and you *can* inspect the full stack
trace, making it an effective way of tracing errors.
This post explains some of the benefits and how it can be used from
IEP and other environments.

For the first post in this blog I wanted to write something that really
matters. At least to me. I tried to get at the core drivers behind what
I do: what are the fundamental reasons why I love open source software
so much?
Here's why I think that open source is *necessary* to improve/fix the
current scientific system and to guarantee our freedom to seek knowledge.