GNU Hackers Meeting in Paris, 2011

Location: Paris, France, at IRILL (details, map), the Center for Research and Innovation on Free Software.

This GNU Hackers Meeting took place from Thursday 25th August to Sunday 28th August, 2011. Thanks to IRILL for hosting the event and video-recording it, to Inria for providing access to a conference room, and to the FSF for providing funding for the meeting.

IRILL is located 23 avenue d'Italie, on the third floor, in the same building as Inria main talks will take place at IRILL on the 3rd floor, room "algorithme". The entrance of IRILL and Inria is on the left of the building, to the left of the post office ("La Poste") entrance.


IRILL facilities are available all day from Thursday 25th to Sunday 28th.

Below is the schedule of talks. This year's main topic is extensibility.


The main topic of this year is extensibility.

The talks are listed below, usually with a summary, supporting slides, and a video recording of the talk. All videos and locally-hosted slides are published under the Creative Commons Attribution 3.0 Unported license, unless otherwise specified. Videos are in the Ogg format.

Introduction To The GNU Hackers' Meeting (Ludovic Courtes)


Lightning Talks


Goodbye World! The perils of relying on output streams in C (Jim Meyering)

(slides, video)

If you develop in C and want an application to detect and diagnose output errors reliably, then you do NOT want to use the standard stream output functions like putchar, fputs, fprintf, etc. If you must use them anyway, there is a whole raft of corner cases you'll have to worry about. Here, you'll see how to deal with the ugly reality, while retaining some semblance of maintainability.

Many programs write some or all of their output to stdout, the standard output stream. Yet, while most seasoned programmers realize the importance of closing (and diagnosing any failure therein) all files they open, few apply that discipline to stdout. The result is that many programs do not diagnose write errors. As you will see, although applications usually do not open stdout, it is often just as important to close it properly as it is to close any other output stream. I'll illustrate the problem and show how to avoid it in a maintainable and minimally intrusive manner. While handling stdout has some subtle twists, you'll see that using any output stream robustly requires great care, and in some cases it is next to impossible. In the end, you will be wondering why any developer who requires reliable output functions still uses C streams at all.

GNU epsilon, an Extensible Programming Language (Luca Saiu)

(slides, video)

Programming languages should be designed to be growable by users, built upon a very small language and a set of syntactic abstraction features aiming at rewriting complex programs into a combination of simple forms which are easy to analyse, reason upon and implement, according to a user-supplied specification directing syntax, control, static analysis and optimization.

This talk presents the advantages and challenges of such a reductionistic design philosophy and documents the experience of building upon one specific core language, starting from its neighbourhood and exploring much further.

A status report on the implementation will be provided.

Making Old Things New (Reuben Thomas)

(slides, video)

GNU has many long-established projects which remain central to the operation of GNU under the hood, and, in many cases, are still widely used directly by users. Programs such as the coreutils, grep and gcc fall into this category, as does Emacs.

Unfortunately, working on these programs is not widely seen as a fun or cool thing to do. This is a pity for two reasons: first, despite a resurgence of effort in the past few years, many of these programs are merely being maintained in a good state, not developed further as much as they could be; and secondly, programming with C and GNU autotools is widely perceived (in particular, outside GNU) as being dull, unproductive and old-fashioned. On the other hand, while there have been some remarkable advances in the GNU tools, this perception is still true to an unfortunately large degree.

This talk has two main aims: first, to showcase recent advances in the GNU tools, in particular the recently rapidly developing gnulib, that make programming in C more productive and fun than was the case for many years; secondly, to explore the remaining obstacles and make some suggestions for tackling them, using a mixture of existing proven tools, existing tools that are not widely used (and often that still need work), and one or two ideas that are yet unimplemented; and thirdly, to show that not only is there much necessary and valuable work to be done in "traditional UNIX" style programming, but there's a lot of fun to be had and perhaps most surprisingly to non-kernel programmers, that it can still be a framework for exciting innovation.

Recent Development Directions for makeinfo (Patrice Dumas)

(slides, video)

Texinfo is the official documentation format for the GNU project. However, the last release dates to 2008. This long period is due to many changes happening behind the scenes, first the merging of texi2html in Texinfo, to replace makeinfo, and then the replacement with a Parser transforming the Texinfo document into a tree further processed by Converters.

After detailing this recent (and not so recent) history, a brief presentation of the Parser will show what's next for makeinfo.

GNU/Hurd, aka. Extensibility from the Ground (Samuel Thibault)

(slides, video)

The Unix model usually strongly separates the "privileged" user from the non-privileged users. The former usually have all possible privileges, while the latter have very restricted privileges, limited to their own home directory, and at best sometimes allowance to mount removable media. One of the answers from userland has for instance been GVFS, which permits GNOME applications to transparently access not only what the system proposes, i.e. actually what the privileged user proposes, but also what userland-provided content, such as files from FTP, SMB, etc. Another interesting example is using SOCKS to access an intranet website. Some browsers natively support using a SOCKS proxy, and for those which don't, libsocks4 can be used to transparently make them do.

These approaches (embedding) are however limited and impede composition, since they mostly have to be explicited in the source code. What if a removable media is formated with a special filesystem? What if the intranet website can not be accessed through ssh, but only through a VPN? Why not being allowed to run a PPP tunnel over a serial port when one already has granted access to the serial port? These are usually not an issue on the desktop, where the unprivileged user is actually also the privileged user, and people have become used to tinkering something through sudo, FUSE, TAP, etc. but it's still tedious and potential security holes. On a freshly-installed system, can't one e.g. just run tar xf / to download and unpack a tarball in one go? Actually, on a GNU/Hurd system, one can.

Funnily enough, even if GNU is Not Unix, GNU/Hurd uses a very unixish approach to bring extensibility: files. By introducing the concept of translator, which is actually its real core, GNU/Hurd lets a user easily achieve a wide range of tasks which require particular privileges on usual Unix systems, examples include accessing the content of an iso image from a shell, chrooting, routing application network traffic through a VPN, IP translation…

This talk will present the notion of translator, and through some examples of translators which already work, show the range of power that it brings to "non-privileged" users (i.e. actually the #0 freedom) without breaking security, and how it compares with the Linux GVFS/FUSE/CUSE/etc. equivalents.

Introduction to the GNU MPFR library (Vincent Lefevre)

(slides, video)

This talk will be a general presentation of the GNU MPFR library for floating-point computation in arbitrary precision. I will explain the specific features of this library (correct rounding at the bit level, exceptions) and give examples. I will also explain how MPFR is tested to improve its reliability. Finally some simple applications using this library will be presented.

Introduction to the GNU MPC library (Andreas Enge)


The GNU MPC library is presented with its many similarities and some differences to the GNU MPFR library. We address representations of complex numbers and the main implemented features. Some algorithms chosen to yield efficient implementations and, at the same time, correct rounding are also discussed.

[undisclosed topic] (Jose E. Marchesi)


Org-mode is to Emacs what Emacs is to computers (Bastien Guerry)

(slides, video)

Org-mode is an Emacs mode for keeping notes, maintaining TODO lists, doing project planning and authoring with a fast and effective plain-text system.

In this talk, I'll go through existing core features (the organizer, the exporters, the Babel library) and present examples of real use. I will also list possible contributions (exporters, libraries to interact with online organizers, bug tracking tools, etc.) and mention hard problems to solve, the hardest one being to make Org suitable for collaborative project planning.

Finally, I'll give an overview of Org's history and community, with some ideas on how to sustain this great project.

Debian in context: distributions, upstreams, and downstreams (Stefano Zacchiroli, Debian Project Leader)

(slides, video)

Once upon a time, the work-flow of software distributions was rather straightforward (grab new upstream release, package it, profit) and the number of stakeholders relatively low (upstream authors, packagers, users). Nowadays, the context is getting more complex and the notion of upstream/downstream blurrier: derivative distributions are built on top of existing distributions, the software distribution pipeline is getting longer, … and (luckily) users are everywhere! What are the responsibilities of the various stakeholders in order to have a sustainable ecosystem that benefits not only individual projects, but rather Free Software as a whole?

Emacs XWidget Branch (Joakim Verona)

(slides, video)

Emacs Xwidgets is an experimental branch to enable embedding of GTK+ widgets inside an Emacs window. The Emacs abstraction is called an Xwidget, for eXternal widget, and also in reference to the XEmbed protocol.

Currently its possible to insert buttons, sliders, WebKit browsers, and XEmbed sockets in the buffer. It works similar to the support for images in Emacs. Adding more types of widgets should be fairly straightforward, but will require adapter code for each type.

A difference from images is that xwidgets live their own life. You create them with an API, get a reference, and tie them to a particular buffer with a display spec.

Each xwidget can have several views. In MVC terms, an xwidget is the model, and an xwidget-view is a view of the xwidget in a particular Emacs window.

The xwidget code attempts to keep the visual appearance of the views in sync with through an Observer pattern implementation.

Extensibility in GNUstep and Étoilé (Quentin Mathé)

(slides, video)

This talk will present the various interesting mechanisms to support extensibility in Objective-C, how GNUstep uses them as a Cocoa-compliant implementation, and how Étoilé leverages Objective-C and GNUstep to push flexibility even further on both the user and developer sides.

Objective-C comes with various abilities to extend classes from other libraries, introspect code at run-time, resolve methods lazily etc. We will discuss these and some less common ideas such as class transforms, which are used to implement Prototypes or Key-Value Observing (a way to observe arbitrary changes in other objects).

GNUstep uses Objective-C's dynamism to implement its drawing backends, theme support or features such as Key-Value Coding or Key-Value Observing more well-known from Cocoa developers. GNUstep AppKit and Foundation are based on various recurrent patterns such as class registration or class cluster to extend the built-in classes, so we will detail them and give some concrete examples such as NSImageRep.

On top of Objective-C and GNUstep, Étoilé builds a desktop environment, which is more or less a developer platform as it stands now. We will discuss LanguageKit that can be used to create dynamic languages that integrate seamlessly with Objective-C objects, and make possible to write methods that belongs to the same class in various languages. At a higher level, we will show the possibilites opened by EtoileUI, a UI toolkit where the User Interface is entirely modulalized into pluggable aspects (layouts, styles, tools, controllers etc.) in a way that allows to create new UI quickly or change the UI at run-time precisely and easily.

If I'm not out of time ;-) I'll try to present our latest experiments on CoreObject as an object-oriented database with revision control, or at least make a quick demo.

Extending GCC with MELT for Free Software (Basile Starynkevitch, Pierre Vittet)

(slides, video)

MELT is a high-level domain specific language (offering pattern matching, applicative/object/reflective programming styles) to extend GCC (the GNU Compiler Collection). MELT is free software (GPLv3 licensed, FSF copyrighted) available as a GCC [meta-] plugin (and also as a GCC experimental branch).

We give an overview of MELT through examples, and suggest specific extension (to be coded in MELT) ideas for GNU software.

Scilab: Extendability issues when dealing with non-IT people (Sylvestre Ledru)

(slides, video)

Scilab is major numerical computing software. Like many others (Python, R, Octave), Scilab provides some extension mechanisms to develop modules. However, especially since most of the users are not developers, it comes with a price.

During this presentation, the various common issues met by the Scilab team will be presented and discussed.

GNU Free Call—a healthnet of cars and cell phones (Haakon Meland Eriksen)

(slides, video)

GNU Free Call is a new project to develop and deploy secure self-organized communication services worldwide for private use and for public administration. The focus of this talk is the continuation of emergency medical services even when existing infrastructure is no longer available or has been deliberately disabled using GNU Free Call to create a healthnet of cars and cell phones.

The User in the Loop (Andy Wingo)

(slides, notes, video)

Extensibility is more than a mere nice-to-have feature: it helps our users feel fulfilled, and is a key component of Freedom 1. It also gives users the tools to make the transition to casual contributor, and possibly even to be your replacement as a maintainer. Extensibility helps users and builds GNU.

Beyond the argument for extensibility, this talk looks at the practical implications of the different approaches to extensibility: embedding, extension, and scripting. It also argues that Guile, the GNU extension language, supports all of these models. Guile is a capable, practical language implementation for extension that all GNU projects should use.

Emacs Lisp, Guile, JavaScript, A Hard Limit, and an Ethical Argument (Jim Blandy)

(We are sorry but the video of the talk is unavailable for technical reasons. Q&A video part 1, Q&A video part 2)

Extension languages are a powerful design pattern. However, the language you choose affects the audience you get, and supporting mixed languages fluently has turned out to be harder than many of us expected. I think the difficulty lies in the way we impute real-world meanings to the concrete behaviors of programs. This difficulty is fundamental to the act of programming, and cannot be solved. I will offer concrete examples to illustrate, draw some disappointing conclusions, and suggest a way forward.

News from the GNU Advisory Committee

Woodchuck: Improving Data Availability for Mobile Devices (Neal Walfield)

(slides, video)

Mobile devices should maximize data availability, the likelihood that data that a user wants is accessible. High-speed cellular connectivity is no silver bullet: wireless communication is energy intense; data transfer caps are increasingly common; and cellular coverage is not ubiquitous.

Woodchuck is a framework for scheduling the transfer of delay-tolerant content, such as blogs, podcasts, email, social network updates, weather reports, and calendaring data. Woodchuck saves battery power, manages data caps and hides poor network coverage by monitoring network conditions and user behavior and, when conditions are good, tells applications (starting them if necessary) to perform an update or a transfer. The challenge is to figure out how to manage these resources efficiently and to predict what the user likely needs.

In this talk, I will show some measurements of the potential improvements of prefetching. I will briefly discuss Woodchuck's design. I will present Woodchuck's API and the approach to scheduling I am exploring. Finally, I will discuss the user-study we are conducting so as to be able to evaluate the scheduling policy.

More information about Woodchuck, including the Woodchuck server, a C library and Python modules, can be found at:

Binary packages are also available for the N900.

GNU Data Language (Alain Coulais, Sylwester Arabas)

(We are sorry but the video of the talk is unavailable for technical reasons. slides)

GNU Data Language (GDL) is a free/libre/open source incremental compiler compatible with IDL and to some extent with PV-WAVE. Together with its library routines it serves as a tool for data analysis and visualization in such disciplines as astronomy, geosciences and medical imaging. GDL is free software licensed under the GPL. GDL depends on large number of other libraries, including: GCC, Readline, GSL, PLplot, ImageMagick, FFTw, …

From French to international (Alain Coulais, Cyprien Gay)

The "No More Racketware" action's aim is to obtain a possibility for a consumer not to pay pre-installed software during his/her computing purchase.

Guile-Emacs (BT Templeton)


Funding for free software in Europe (Karsten Gerloff - FSFE President)


Free Software and High Performance Computing (Juan Antonio Añel Cabanelas)


Free Software can be a hard choice when you are working with HPC infrastructures. When you work in an environment where time (and therefore computational performance) is hard money, and sometimes not so much as you would need, it is not easy to justify that you are "throwing down the drain" half of your funding. Moreover you could not have control about the code that you are running or the supercomputer that you are using, which makes much more complicated the problem. This talk will try to open a productive discussion on these issues during the GHM.

GNU Psychosynth (Juan Pedro Bolívar Puente)

GNU's participation in Google Summer of Code (Rodrigo Rodrigues da Silva)


GNU LibreDWG (Rodrigo Rodrigues da Silva)


  • Ludovic Courtès (GNU Guile)
  • Julien Danjou (GNU Emacs)
  • Jim Blandy (GDB, GNU Guile, Firefox, etc.)
  • Samuel Thibault (GNU Hurd)
  • Andy Wingo (GNU Guile)
  • Dodji Seketeli (GCC, Nemiver, GNOME)
  • Sylvestre Ledru (IRILL, Debian, Scilab)
  • Jose E. Marchesi (GNU PDF, GNU recutils)
  • Bastien Guerry (Org-Mode, GNU Emacs)
  • Neal Walfield (GNU Hurd)
  • Jim Meyering (GNU Coreutils, GNU Parted, Gnulib, etc.)
  • Andreas Enge (GNU MPC)
  • Albert Cohen (GCC, IRILL)
  • Vincent Lefevre (GNU MPFR)
  • Brian Gough (GNU Scientific Library, GNU Source Release Collection)
  • Quentin Mathé (GNUstep, Étoilé)
  • Luca Saiu (GNU epsilon)
  • Reuben Thomas (GNU Zile, GNU Hello)
  • Patrice Dumas (GNU Texinfo)
  • Simon Josefsson (GnuTLS, GNU Libidn, GNU Shishi, GNU SASL, etc.)
  • Juan A. Añel (GNU Spain, GNUticias)
  • Sylwester Arabas (Gnu Data Language)
  • Jérémie Koenig (GNU/Hurd)
  • Giuseppe Scrivano (GNU IceCat, GNU MyServer, GNU Wget, GNU Inetutils, etc.)
  • Alain Coulais (Gnu Data Language)
  • Stefano Zacchiroli (Debian, IRILL)
  • Richard Braun (GNU Hurd)
  • Rodrigo Rodrigues da Silva (GNU LibreDWG)
  • Haakon Meland Eriksen (GNU Free Call)
  • Roman Gopalan
  • Joakim Verona (GNU Emacs)
  • Ralf Wildenhues (GNU Automake, GNU Libtool, GNU Autoconf, Gnulib, etc.)
  • Basile Starynkevitch (GCC, MELT)
  • Francis Southern
  • Gaël Le Mignot (GNU Hurd)
  • Toby Dylan Hocking (GNU R)
  • Pierre Vittet (GCC, MELT)
  • Paolo Carlini (GCC)
  • Guillaume Smaha
  • Juan Pedro Bolívar Puente (GNU Psychosynth, GNU Jump)
  • Alexandre Lissy (GCC, MELT)
  • Arnaud Patard (Mageia distribution)
  • Arne Babenhauserheide (GNU Hurd)
  • Florent Popille (Univ. St Étienne - Research on free software development)
  • Bruno Haible (GNU gnulib, GNU libunistring)
  • Karsten Gerloff (FSFE President)
  • BT Templeton (GNU Guile, Guile-Emacs)
  • Steve White (GNU FreeFont)
  • Edlira Nano (INRA)
  • Laurent Guerby (GCC Compile Farm)
  • François Dumont (GCC)
  • Dimitri Fontaine (GNU Emacs, el-get)
  • Romain Tartière (FreeBSD)
  • Brice Lopez
  • Arnaud Gambonnet


Registration is over.

  • You make a small donation to support future GNU Hackers Meetings with Flattr:

All donations will be used to provide travel grants for those unable to attend otherwise.

Further information

There is no charge to attend the meeting but you will need to pay for your own travel / accommodation / meals. If you need financial support for travel or accommodation costs, please indicate this in your registration email with the minimum amount that would permit you to attend the conference.

Suggested accommodation options

Hotels close to IRILL:

Hotels further:




IRILL has a list of suggested restaurants. We will try to have group meals at noon and in the evening. Note that eating in IRILL's and Inria's offices is not permitted.

On Wednesday 24th, the dinner took place at 8pm at the Mussuwam, a Senegalese restaurant located 33 boulevard Arago, Paris (13th district), 1.3 km away from IRILL.

On Thursday 25th, the dinner took place at 8pm at Au P'tit Cahoua 39 Boulevard Saint-Marcel, 75013 Paris.

On Friday 26th, dinner took place at "Le temps des cerises", 18 rue Butte aux Cailles, 75013 Paris (01 45 89 69 48), 10 minutes walk from IRILL.


Ask on the mailing list at

Follow the GHM news feed feed16.png for updates.