«

FOSDEM 2014

The annual Free and Open Source Developers Meeting (better known as FOSDEM) took place in Brussels last weekend, and I had the privilege to go there and be a part of it. It was my second visit to this amazing conference, so I knew there was going to be beer, lots of interesting talks, and a huge crowd of developers and hackers interested in free software. This post is a summary of what I’ve seen there.

For those who don’t know this event, FOSDEM is probably the biggest free software oriented conference in Europe with more than 5000 people attending every year. It takes place at the Université Libre de Bruxelles early in February each year. It starts with a beer event in an epic place called Délirium Café on Friday and goes on with more than 400 talks spread over the weekend. In other words, it’s massive.

#Friday Beer Event As odd as it might sound, a conference full of free software hackers actually starts with a social event. The venue of choice for the evening was a large pub in the centre of Brussels called Délirium Café. It’s famous for their record-breaking selection of beers (offering over 2000 different types).

Delirium Café
Delirium Café in Brussels

The rules were set by a sign at one of the bars: “No, there really isn’t any Wi-Fi. You’ll have to talk to each other”. Surprisingly enough, it went quite well. The whole place was absolutely packed and a considerable number of people were waiting outside in the rain, trying to get in. Speaking of world records, at this time, Délirium Café probably becomes the place with the world’s biggest concentration of people who are able to write their own device drivers.

For us, it was a lovely evening overall. We had a couple of pints and met a few people. There were power and restroom failures during the night, but the beer selection was a nice compensation for all that.

#Saturday’s Talks The first talk I went to see on Saturday was Enlightenment as a Standalone Wayland Compositor by Stefan Schmidt and Chris Michael of Samsung. They are working on cleaning Enlightenment of any remaining X dependencies, so it can be used as a Wayland compositor.

Saturday's Schedule
The schedule for Saturday

From there, I moved to the Legal devroom to listen to Chris Aniszczyk, the Head of Open-Source at Twitter, to talk about how his company works with open-source. He talked about some of their open projects, their policy to encourage Twitter employees to contribute code upstream, and he also discussed his view of various open-source licenses. Talking in favour of non-copyleft licenses, such as MIT or BSD, he argued that GPL can be a barrier to adoption of your project.

The next one for me was State of the X.org Foundation by its board member Martin Peres. At the moment, the foundation consists of roughly 80 members and has raised enough money to be able to operate for at least 5 more years. I was a bit confused here by the fact they worked really hard to acquire a nonprofit corporate status and then got rid of it.

Next up was Manuel Bachmann offering insights on porting legacy X11/GL applications to Wayland. I was really looking forward to seeing this talk, because I would love to see Wayland run on the Raspberry Pi. Apparently, it’s not that simple. The functionality of X11 doesn’t match exactly the functionality of Wayland. Some things (such as window minimisation) can only be achieved through additional libraries (xkb in this case). The good news is that all the major toolkits (GTK+ 3.8 and higher, Qt5) already support Wayland. For GL, you’ll need to migrate from GLX to the EGL API.

Wolfgang Sang demonstrated how to add support for new hardware to the kernel by searching the Linux Kernel Driver Database for existing drivers and matching them to new devices of similar nature. I really like this kind of crowdsourcing. The developers ususally hobbyists and volunteers don’t always have all the devices available.

I stayed on the main track in Janson for the next talk by Red Hat’s Tom Tromey, who explained how can you extend and customise gdb using small scripts in Python. It looked really powerful. You can do all sorts of things with that, such as results filtering, pretty-printing, and probing. These are especially useful when debugging higher-level languages, such as C++, where the output of gdb is usually very hard to read and understand.

We went to check out the lighting talks track for a while where Jean-Michel Philippe introduced a distro specifically designed for children to learn about computers. That was really interesting for us, because we’re essentially trying to do the same thing in Kano. He showcased some really cool apps and projects for kids even as young as 2 years old. The goal of the project is to provide children with tools for their self-fulfilment and to show them what is possible to do with computers. I love that mission, because that is exactly what we’re trying to do. Tech-savviness is really hard to teach to others. You have to get them interested enough to teach themselves.

The last talk for Saturday was (again) about Wayland, this time about the status of GPU offloading by Axel Davy. I was really excited about that one as well, but I have to admit that I was really exhausted at this point that I could barely understand. You can find more information in the slides.

#Sunday’s Talks

The second day of the conference was packed with a massive number of talks, just as the first one. Unfortunately, I didn’t manage to get up before 9, so the first talk I went to see on Sunday was Considering the Future of Copyleft by Bradley Kuhn at the legal and policy issues devroom. He talked about the current trend of moving away from copyleft licenses, such as GPL, to the more permissive ones, e.g., MIT or BSD. GitHub is a big advocator of MIT. And in fact, Chris Aniszczyk was advocating permissive licenses from a perspective of Twitter in the same room on Saturday. It makes sense for companies and especially startups, but it means the user actually gets less freedom. LLVM could potentially become the an example of the permissive license abuse. The compiler is licensed under the UoI/NCSA license, which is quite similar to MIT. Apple has been a big contributor to it, however, there is no obligation for them to keep releasing their code. Although it doesn’t make much sense now, in a couple of years when (and if) LLVM sees wider adoption, they might start shipping proprietary premium extensions and additions to it. And there won’t be much we’ll be able to do about it.

Sunday's Schedule
The schedule for Sunday

Incidentally, the next talk I went to see was How to contribute to LLVM by Sylvestre Ledru. This one was a bit more practical; Sylvestre explained the tools and processes the community around LLVM uses. I was really surprised by the fact that they use subversion for such a big project. I hated it already after a month of using it for a project at the university. Apart from that they use Phabricator for code reviews.

Laurent Sansonetti, former Apple employee and a founder of HipByte, was talking about Statically compiling Ruby with LLVM short while after that. His company develops RubyMotion, a LLVM-based Ruby toolchain that allows writing native iOS and Mac apps in Ruby. Laurent is the original author of MacRuby, which is a AOT and JIT for Ruby on Mac. RubyMotion seems to be a continuation of the effort extended to iOS. They have some pretty impressive customers using their toolchain including 37Signals and Lines, the London Underground status app. The whole project has around 12.5k lines of C++ code and Laurent discussed some of the ways it utilises LLVM. I would love to try writing Ruby apps for iOS, but I can’t justify spending £125 for a weekend-hacking-fun toolchain at this point.

One floor down from the LLVM devroom was the Python one. Saying it was packed there would be a severe understatement. It was bloody mental, it was. We couldn’t get in for the talk about PSF and after queueing for an half an hour outside, we barely managed to squeeze in for Romain Guillebert’s How PyPy makes your code run fast. PyPy is an interpreter and just-in-time compiler for Python. PyPy is written in RPython, which is a restricted subset of the Python language compiled to C. The interpreter has much more flexibility to perform optimisations that cannot be done in AOT compilers, and produce much more efficient machine code. Romain showcased a real-time implementation of edge-detection on his webcam (using the Sobel’s algorithm) in both PyPy and CPython. The difference was huge. However, there are still some limitations. PyPy doesn’t work well with C extensions and there is only a partial support for GUI libraries.

After PyPy, I moved to the main track to listen to Ric Wheeler, the manager of the kernel storage team ad Red Hat, to talk about Persistent Memory. While in the past, memory was either slow and persistent, or fast but volatile, the technology now starts to bring the best of the two worlds together. There are persistent data storage devices already available that run on very high speeds that are here to stay. Starting with SSDs, DRAMs with a battery pack, DRAMs with flash memory attached, and even wilder ideas and approaches.

However, due to the speed of traditional disks, the kernel’s IO stack is full of optimisations that are specific to rotational drives that might become inefficient or even harmful to performance. Be it the 4k page size limit, the CFQ scheduler, or even individual file systems. Giving more options to developers will certainly come with a lot of challenges to be solved all the way through the IO stack.

Ric also mentioned SMR, which is a technology that seems to be coming to rotational drives. These drives work best with continuous read/writes rather than random accesses, so in order to get the benefits, we might need to bend the file system drivers quite a bit.

Torvald Riegel and Nuno Diegues talked about transactional memory in the same room. Transactional memory is a programming abstraction that aims to simplify concurrent programming, which is becoming much more ubiquitious. It is way of transparently guaranteeing the atomicity of operations in shared memory without having to worry about locking on the application level. The operations are grouped to transactions which are atomic. It is supported in the C11 standard and it was added to gcc in version 4.7.0. The presenters stressed that it is just a tool and not a magical solution to all problems with concurrency.

This brings me to the very last talk I had the chance to see at FOSDEM this year. We went back to the Python track to listen to Romain Guillebert again to talk about PyPy. This time, it was a very brief introduction of what it is and how it works. He was also answering lots of questions from the audience in the second part of his segment.

#Summary It was a pretty tiring but an awesome weekend. There are certainly not many conferences like FOSDEM. I learned so many new things, got up-to-date with the advances of many open projects and initiatives, and got lots of ideas as a result. We tried a few belgian beers, waffles and some chips. So if you’re wondering whether it’s worth going next year, it is (at least for the beer).

Anyway, if you couldn’t make it to Brussels this time, the video team started uploading the first recordings already and I’m sure all of them will be available for download shortly.