• 10:00 — introductory session
• 10:30 — Extending GCC with MELT for Free Software (Basile Starynkevitch, Pierre Vittet) (45 mn)
• 11:15 — Scilab: Extendability issues when dealing with non-IT people (Sylvestre Ledru) (30 mn)
• 12:30 — lunch
• 14:30 — Woodchuck: Improving Data Availability for Mobile Devices (Neal Walfield)
• 15:00 — Making Old Things New (Reuben Thomas) (45 mn)
• 16:00 — Funding for free software in Europe (Karsten Gerloff - FSFE President)
• 17:30 — visit of the Paris Observatory

• 10:00 — GNU/Hurd, aka. Extensibility from the Ground (Samuel Thibault) (45 mn)
• 10:45 — The User in the Loop (Andy Wingo)
• 11:30 — GNU epsilon, an Extensible Programming Language (Luca Saiu) (45 mn)
• 12:15 — lunch
• 14:30 — Extensibility in GNUstep and Étoilé (Quentin Mathé) (45 mn)
• 15:20 — Debian in context: distributions, upstreams, and downstreams (Stefano Zacchiroli, Debian Project Leader)
• 16:15 — key signing session
• 17:00 — lightning talks (15 mn each) - proposed topics
  • GNU LibreDWG (Rodrigo Rodrigues da Silva)
  • From French http://racketiciel.info/ to international http://racketware.info/index (Alain Coulais, Cyprien Gay)

• 10:00 — Goodbye World! The perils of relying on output streams in C (Jim Meyering) (45 mn)
• 10:45 — Org-mode is to Emacs what Emacs is to computers (Bastien Guerry) (45 mn)
• 11:30 — Emacs XWidget Branch (Joakim Verona) (30 mn)
• 12:00 — lunch
• 14:30 — GNU Free Call—a healthnet of cars and cell phones (Haakon Meland Eriksen)
• 15:00 — Emacs Lisp, Guile, JavaScript, A Hard Limit, and an Ethical Argument (Jim Blandy) (45 mn)
• 16:00 — lightning talks (15 mn each)
  • GNU's participation in Google Summer of Code (Rodrigo Rodrigues da Silva)
  • GNU in Latin America, or why should we hold a GHM in Brazil (Rodrigo Rodrigues da Silva)
  • Free Software and High Performance Computing (Juan Antonio Añel Cabanelas)
  • GNU Data Language (Alain Coulais, Sylwester Arabas)
  • GNU Psychosynth (Juan Pedro Bolívar Puente)

• 10:00 — Recent Development Directions for makeinfo (Patrice Dumas)
• 10:30 — Introduction to the GNU MPFR library (Vincent Lefevre)
• 11:15 — Introduction to the GNU MPC library (Andreas Enge)
• 12:30 — lunch
• 14:00 — News from the GNU Advisory Committee
• lightning talk (15 mn)
  • 16:30 — Guile-Emacs (BT Templeton)

(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.

(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.

(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.

(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.

(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 /ftp://ftp.gnu.org/pub/gnu/gcc/gcc-4.6.0/gcc-4.6.0.tar.bz2 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.

(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.

(slides)

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.

Canceled.

(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.

(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?

(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.

(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.

(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.

(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.

(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.

(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.

(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.

(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:

http://hssl.cs.jhu.edu/~neal/woodchuck/

Binary packages are also available for the N900.

(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, …

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.

(slides)

(slides)

(slides)

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.

(demo 1, demo 2, Master's thesis)

(video)

(incomplete video)

Hotels close to IRILL:

• Hôtel Manet, 300 m from IRILL, ~70 € per night (full as of June 13th)
• Hôtel Ibis, Porte d'Italie (Gentilly), 2 km from IRILL, ~70 € per night
• Jack's Hotel, 300 m from IRILL, ~80 € per night
• Hôtel Ibis, Italie/Tolbiac, 500 m from IRILL, ~80 € per night
• Hôtel Ibis, avenue d'Italie, next to IRILL, ~100 € per night
• Etap Hotel, Porte d'Italie est (Le Kremlin-Bicètre), ~1.7 km from IRILL, ~45 € per night
• Etap Hotel, Porte d'Italie ouest (Le Kremlin-Bicètre), ~2 km from IRILL, ~45 € per night
• Hôtel Minerve, 2 km from IRILL, ~100 € per night

Hotels further:

• Hôtel Ibis, la Vilette/Cité des Sciences, ~60 € per night, metro line 7, ~35 mn from IRILL.
• Hôtel Ibis, Porte d'Orléans, ~20 mn by metro, ~40 mn walking, ~65 € per night

Hostels:

• See hostelbookers.com.

Transportation:

• Schedules of the Parisian public transportation network (RATP)

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 ghm-discuss@gnu.org mailing list at http://lists.gnu.org/mailman/listinfo/ghm-discuss.

Follow the GHM news feed for updates.