Besides enjoying good beer, savouring delicious chocolate and snacking on tasty waffles, Igalians will be giving talks. Look for Igalians in the following sessions:

Guillaume Emont will explain how to take pictures of hippies from an aerial point of view with balloons and a bit of hacking in his lightning talk: Hacking in the real world: photography from above. Saturday 13.40 in room Ferrer.

Alejandro Piñeiro (API), one of our accessibility experts, will deliver a talk entitled GNOME 3.4 accessible: Status, news, future, in which he will explain the current status and future of accessibility in GNOME. Sunday at 9.15 in room H.1308 as part of the CrossDesktop Devroom.

Diego Pino, a long time hacker currently focused on the LibrePlan community, will deliver a lightning talk about LibrePlan on Sunday at 11.20, room Ferrer. Do not miss this opportunity to get to know more about a rising open alternative for project planning.

Mario Sánchez and Philippe Normand from our WebKit team will deliver a joint talk entitled: WebKitGTK+ status and roadmap to WebKit2. This will happen on Sunday at 15.00 in room H.1308 as part of the CrossDesktop Devroom.

Xan López, long time GNOME hacker, will conduct a talk entitled: Web Applications in GNOME. In which he will explain how to build applications with web technologies that will play well with the GNOME platform. Sunday at 16.20, also in room H.1308, CrossDesktop Devroom.

Apart from our speakers, many more Igalians are also travelling to FOSDEM to enjoy the event, meet friends and support the open source development community: Antía Puentes, Xabier Rodríguez, Joaquim Rocha, Adrián Pérez, Felipe Erias, Carlos López, Javier Muñoz and Andy Wingo, together with some students of our Master on Free Software, complete the Igalian expedition to FOSDEM 2012.

Be prepared for extreme cold and enjoy FOSDEM!

Friends, I am not a free man. Eval has been my companion of late, a hellhound on my hack-trail. I give you two instances.

the howl of the-environment, across the ages

As legend has it, in the olden days, Aubrey Jaffer, the duke of SCM, introduced low-level FEXPR-like macros into his Scheme implementation. These allowed users to capture the lexical environment:

(define the-environment
  (procedure->syntax
   (lambda (exp env)
     env)))

Tom Lord inherited this cursed bequest from Jaffer, when he established himself in the nearby earldom of Guile. It so affected him that he added <tt>local-eval</tt> to Guile, allowing the user to evaluate an expression within a captured local environment:

(define env (let ((x 10)) (the-environment)))
(local-eval 'x env)
=> 10
(local-eval '(set! x 42) env)
(local-eval 'x env)
=> 42

Since then, the tenants of the earldom of Guile have been haunted by this strange leakage of the state of the interpreter into the semantics of Guile.

When the Guile co-maintainer title devolved upon me, I had a plan to vanquish the hound: to compile Guile into fast bytecode. There would be no inefficient association-lists of bindings at run-time. Indeed, there would be no "environment object" to capture. I succeeded, and with Guile 2.0, <tt>local-eval</tt>, <tt>procedure->syntax</tt> and <tt>the-environment</tt> were no more.

But no. As Guile releases started to make it into distributions, and users started to update their code, there arose such a howling on the mailing lists as set my hair on end. The ghost of <tt>local-eval</tt> was calling: it would not be laid to rest.

I resisted fate, for as long as I could do so in good conscience. In the end, Guile hacker Mark Weaver led an expedition to the mailing list moor, and came back with a plan.

Mark's plan was to have the syntax expander recognize <tt>the-environment</tt>, and residualize a form that would capture the identities of all lexical bindings. Like this:

(let ((x 10)) (the-environment))
=>
(let ((x 10))
  (make-lexical-environment
   ;; Procedure to wrap captured environment around
   ;; an expression
   wrapper
   ;; Captured variables: only "x" in this case
   (list (capture x))))

I'm taking it a little slow because hey, this is some tricky macrology. Let's look at <tt>(capture x)</tt> first. How do you capture a variable? In Scheme, with a closure. Like this:

;; Capture a variable with a closure.
;;
(define-syntax-rule (capture var)
  (case-lambda
    ;; When called with no arguments, return the value
    ;; of VAR.
    (() var)
    ;; When called with one argument, set the VAR to the
    ;; new value.
    ((new-val) (set! var new-val))))

The trickier part is reinstating the environment, so that <tt>x</tt> in a local-eval'd expression results in the invocation of a closure. Identifier syntax to the rescue:

;; The wrapper from above: a procedure that wraps
;; an expression in a lexical environment containing x.
;;
(lambda (exp)
  #`(lambda (x*) ; x* is a fresh temporary var
      (let-syntax ((x (identifier-syntax
                        (_ (x*))
                        ((set! _ val) (x* val)))))
        #,exp)))

By now it's clear what <tt>local-eval</tt> does: it wraps an expression, using the wrapper procedure from the environment object, evaluates that expression, then calls the resulting procedure with the case-lambda closures that captured the lexical variable.

So it's a bit intricate and nasty in some places, but hey, it finally tames the ghostly hound with modern Scheme. We were able to build <tt>local-eval</tt> on top of Guile's procedural macros, once a couple of accessors were added to our expander to return the set of bound identifiers visible in an expression, and to query whether those bindings were regular lexicals, or macros, or pattern variables, or whatever.

"watson, your service revolver, please."

As that Guile discussion was winding down, I started to hear the howls from an unexpected quarter: JavaScript. You might have heard, perhaps, that JavaScript eval is crazy. Well, it is. But ES5 strict was meant to kill off its most egregious aspect, in which eval can introduce new local variables to a function.

Now I've been slowly hacking on implementing block-scoped <tt>let</tt> and <tt>const</tt> in JavaScriptCore, so that we can consider switching gnome-shell over to use JSC. Beyond standard ES5 supported in JSC, existing gnome-shell code uses <tt>let</tt>, <tt>const</tt>, destructuring binding, and modules, all of which are bound to be standardized in the upcoming ES6. So, off to the hack.

My initial approach was to produce a correct implementation, and then make it fast. But the JSC maintainers, inspired by the idea that "<tt>let</tt> is the new <tt>var</tt>", wanted to ensure that <tt>let</tt> was fast from the beginning, so that it doesn't get a bad name with developers. OK, fair enough!

Beyond that, though, it looks like TC39 folk are eager to get <tt>let</tt> and <tt>const</tt> into all parts of JavaScript, not just strict mode. Do you hear the hound? It rides again! Now we have to figure out how block scope interacts with non-strict eval. Awooooo!

Thankfully, there seems to be a developing consensus that <tt>eval("let x = 20")</tt> will not introduce a new block-scoped lexical. So, down boy. The hound is at bay, for now.

life with dogs

I'm making my peace with eval. Certainly in JavaScript it's quite a burden for an implementor, but the current ES6 drafts don't look like they're making the problem worse. And in Scheme, I'm very happy to provide the primitives needed so that local-eval can be implemented in terms of our existing machinery, without needing symbol tables at runtime. But if you are making a new language, as you value your life, don't go walking on the local-eval moors at night!

I know some people will probably disagree with me on this, but for me FOSDEM is one of the greatest events of this kind, and so I’m quite happy to go there this time, specially after not being able to attend last year due to some unexpected (and unavoidable) personal matters.

Opposite to other occasions, this time I’ll be there not only as an attendant but also as an speaker, talking about WebKitGTK+, its status and the roadmap of the project towards WebKit2 (the split process model “flavour” of WebKit), together with my mate Philippe, on Sunday afternoon. Thus, for the first time ever, nobody will be able to accuse me of going there just because of the beer event, which wouldn’t be true anyway.

For the impatient ones, the talk will be mainly about reporting on the work done during the last months in “WebKitGTK+ land“, as well as on the stuff that is already planned for the upcoming releases. Good examples of those would be, for instance, the ongoing effort to add support for Accelerated Compositing, or just the new features related to WebKit2GTK+ such as, of course, the solution for enabling accessibility support there. Ah! And of course, we’ll try to run some demos there too… fingers crossed!

Besides, I’m of course looking forward to meeting some people I haven’t seen for a while now (haven’t attended to the latest Desktop Summit either, due to very good reasons too), so if you see me around and want to chat and/or meet for a while, just let me know. I must look shy, but it’s usually a matter of minutes (seconds?) for my shyness to go away…

So that’s it. Just a final line to say “thanks” to my company for fully sponsoring this thing.

See you in Brussels!

Most of you might have heard about the sudden “death” of the airline Spanair. I had never known of an airline stopping its planes on the same day it announces it’s rupture.

Several colleagues of mine in Igalia were affected by the events and guess with whom some of us (mostly Igalians based at Coruña) were flying to Brussels? That’s right…

Fortunately yesterday we bought new flights and decided to try to get the reimbursement for the cancelled ones later.

This means that thanks to Igalia:

I had two presentations in each of the last two editions of FOSDEM but I didn’t really have something new to show in this year’s so I’m attending only as a participant which doesn’t make it less exciting for me.

I have already some arrangements planned, as in having a beer with some folks, and you’re invited too if you wanna talk about Igalia or the projects I’m involved in.

See you in Brussels.