24 hours a day, 7 days a week, 365 days per year...

July 26, 2014

Month View for GTG’s Calendar Plugin

These past couple weeks I implemented a new view for the calendar plugin: the Month View.

Until now, the plugin only displayed a single week. Now the user can switch between views, using the drop-down menu, and select between ‘Week’ or ‘Month’.

This new view has very similar functionalities to the previous one, allowing a task to be dragged/dropped to change its dates, double clicking on it to change its content, and also allowing the creation and deletion of tasks.

Here is a preview of how things are going with the month view, even though it’s not working a 100% yet:month-view

I hope to finish the implementation and fix the issues with this new view soon, in order to be able to integrate it to GTG as well.

July 25, 2014

2014-07-25: Friday

  • Off to visit Bob, lovely home, took dogs for a walk, talked technology - into Waltham for a Boston steak & cheese sub, kindly dropped at Alewife. Into the Xamarin office - lovely place for a LibreOffice hack-fest tomorrow - lovely to catch up with Jo Shields, Miguel, Duncan, Jeff, Michael, Aaron and a lot of friendly new people. Waited for Joel and Robinson.

Not going to GUADEC

For the first time since I first started attending GUADEC in 2009, this year I am not going.
Strasbourg is very close to where I live (about four hours driving) but some factors just make it very difficult to attend the conference this year. We have a guest over and I didn’t want to go by myself because, even though Olivia is a very relaxed baby, I still notice how I am more tired than usual and it would be risky to drive all alone (besides, it’d leave all the responsibility of taking care of the baby to Helena). Taking everybody there could be an option but I could only go for the weekend anyway and, since we’re going for vacation a week after the event, logistics and timing are just not convenient.

I will surely miss having a beer with old friends.

Have a great GUADEC!


GSoC 2014 report 2

What an eventful month! Lots of code have been read, produced, reviewed and refused, several code designs have been proposed, but as everything was work in progress, I didn't fell it was exciting enough to blog about it at that time.

But here it is! The blog post that explains it all.

Multiple displays per machine

I mostly spent the third week trying to have multiple displays for a SPICE machine, which implied reading a lot virt-manager's code and some of spice-gtk's code.

I achieved to get the maximum number of displays available for a machine and, with Christophe Fergeau's help, to get some good results: we were able to have multiple displays each in its own window, but we were not able to open them up from Boxes yet (the session had to have them already opened).

Multiples machines

Jakub Steiner proposed a design focusing mainly on having multiple machines running side by side in different windows:
It settled what idea would be implemented, and a new bug report have been created to reflect that.

The window singleton

The main problem that have been encountered is that Boxes uses a static window instance that is accessed directly by a huge number of classes.

It is very problematic, as if you summon a second instance of this window's class, any action in the second window will have its reactions produced not on itself but on the static window instance, which is conceivably problematic who you want to implement a multi window feature.

Zeeshan proposed not to change the app's design to allow having multiple windows but to have multiple one window instances communicating via D-Bus.
It have its pros, as it would make Boxes more resistant to crashes, to slowdowns and to be be naturally more parallelized, but the design would most certainly have ended up being a gigantic mishmash.

This idea have been abandoned in favor of a code refactoring.

Getting rid of the window singleton

In Boxes' design, the app's controller is scattered over all the classes.
In my opinion it is problematic:
  • you can't use a class in any different way without changing the class' code
  • changing a simple behaviour may require modifying lots of classes
  • you can't have a good overview of the application's behaviour  which may confuse newcomers
I spent several weeks refactoring the app, trying to move the controller closer to the root of the composition tree by using signals to make the leaf classes dumber but more modular.
It worked preety well and Lasse, which reviewed my patches, and I  were preety proud of the newly produced code and design.

At the time when the code started to take shape, unfortunately, Zeeshan had harware failures which made him not able to check out our work.
Because of that, we knew quite lately that he preferred the code to stay as close as possible from the actual design, changing as less code as possible in the process.
It is pretty wise, as he haves to maintain the application, and so I started over with these considerations.

So far the last set of refactoring patches are well received, all they need is a little bit of polish to fully shine!

What's next

It's now the time of GUADEC, here I'll be able to chat with my colleagues and to meet other gnomes!
If everything go as planned, the patches will be merged during this period, and I'll be able to actually implement the multi window feature after that!

Maps BoF

I'm going to GUADEC again this year. Actually I should probably be packing since my flight leaves for Strasbourg in 4h. But first a quick announcement.

I'd like to announce my intention to hold a Maps BoF this GUADEC.
Maps is shaping up and after we've gotten the work from this years GSoC projects merged we are hopefully starting to look like a real world usable application.
Now would be a good time to look over what we've done and discuss where we're going with the larger GNOME community.
We want input and feedback on design, code and more. And we want help from you guys to decide what kind of an application we want Maps to become in the future.

So, if you're staying past the core days at GUADEC this year and are interested in Maps, please add yourself as an attendee here!

Regarding date and time, my suggestion is 14-19 on the 31st of July, but personally I'm flexible.

See you in Strasbourg!

July 24, 2014

L10n & Docs at GUADEC 2014

At this year’s GUADEC, there will be a number of sessions relevant to people interested in GNOME localization and documentation:

  • On Monday, Kat will give an update from the docs team called Documentation: state of the union. Her talk will detail what has happened in the documentation realm since GUADEC 2013, so be sure to attend.
  • Team Reports on Saturday will include localization and documentation.
  • There will be a screenshot automation BoF on July 30th. Vadim Rutkovsky from Red Hat’s Desktop QE has some sweet surprise for you, translators!
  • Finally, on July 30th and 3Ist, Daiki Ueno and Alexandre Franke are planning to organize an i18n hackfest to work on translation tools, spellcheckers, dictionaries, input methods, and related fields.

I’ll be arriving tomorrow evening with Christian Schaller and other desktop people from Red Hat Czech and leaving on the 31st – hope to see you all in Strasbourg!

sponsored-badge-shadow guadec-2014-badge-large


Open Help Conference 2014

This is a belated post on the Open Help Conference in Cincinnati, OH that I had the chance (thanks for sponsoring me, Red Hat!) to attend this year. It took place from June 14-15 at a nice venue provided by Garfield Suites Hotel. The Conference was followed by the GNOME Docs Sprint from June 16-18.

The Open Help Conference is much smaller in attendance than some of the large industry conferences for technical writers out there. This actually allows the attendees to actively participate in many talks and discussions, similarly to what you can usually experience at unconferences. It was the Conference’s primary focus on docs communities that made attending each of the sessions very relevant to those of us who work on open source documentation.

Cincinnati Skyline Cincinnati Skyline chili The venue The hackfest

Along with people representing other open source companies and communities (this included Eric Shepherd from Mozilla or Michael Downey from OpenMRS), there were also two fellow Red Hatters attending (Rich Bowen and David King). We had quite a few people from GNOME Docs, too. The Conference was organized by Shaun McCance who did a fantastic job running the whole event as he found time not only to take care of the venue and catering, but also of the social events on both conference days that took place in his lovely hometown of Cincinnati. Thanks again, Shaun!

You can check #openhelp and Michael Downey’s excellent notes to learn more about the different talks and sessions held at OH.

Open Help Conference 2014 Hackfest

The Open Help Conference 2014 Hackfest followed an unwritten tradition in the GNOME Documentation Project of having two GNOME docs hackfests or sprints annually. Unlike the sprint held earlier this year in Norwich, UK where the team worked mostly on updating the user help for the upcoming GNOME 3.12 release, the Cincinnati hackfest focused on finishing the GNOME System Administration Guide. We managed to completely rework the overall structure of the guide and redesigned the index page for the guide, following the earlier design mockups prepared for GNOME Help by Allan Day.

The restructured System Administration Guide now features the following main groups of topics:

  • User Settings (Lockdown, Pre-seed user defaults, Pre-seed email/calendar/groupware, Appearance, Setup)
  • Login Settings (Appearance, Session, Management)
  • Network (NetworkManager, etc.)
  • Software (Apps, Extensions, Management)
  • Troubleshooting / diagnosis

More details can be found on the Guide planning page.

Other things that caught my attention during the conference:

Duck Pages

Shaun’s plans for the future include an additional input format for Mallard-based documentation – so called Duck pages. A Duck page is essentially a plain text format based on Mallard XML that doesn’t use the often distracting XML syntax. Duck pages should make it easy to author single-sourced topic-based documentation with a Markdown or AsciiDoc-like syntax. Unlike Markdown and others, Duck pages aim to not only allow for quick creation of rich-formatted docs, but also to contain data necessary to integrate the document with the rest of your Mallard-based documents.


Shaun also presented another tool that he has been working on: Blip. It is a web application to monitor documentation projects that use SCM repositories. Some examples include:

Blip lets you not only browse through individual modules in your documentation project, but it also mines data to present information about contributors, their commit or mailing list activity, and much more.

  • An example of a project profile with complete data on branches, commits, authors, included documents, and more: Gnome User Documentation
  • An example of of a user profile with personal stats: Shaun McCance

2014-07-24: Thursday

  • Woken rather early by babes squabbling - presumably that means they're over their jet-lag. Off to work with Thomas to the Symetrica office, had a rather interesting tour, good to meet his colleagues Matt & Greg again from the wedding.
  • Worked through mail, out for a walk at lunch time around the lake and caught up with Matt, back to poke at a few silly bugs.
  • Amused by the circular: "Assume that my world-view is unique and yours is not: now look how amazing my unique world view is !" argument. Since I've only heard this hubris from (some) atheists, let me transpose it to a Christian perspective for fun: "there are, historically, millions of world views that do not include God's glorious grace, mercy and free forgiveness you believe in only one of these - and think that all 999,999 others are wrong. I just go one step further - why don't you ?" lazy stuff indeed; quite apart from the various interesting discussions as to some flavours of atheism eg. some forms of Bhuddism.

GSoC Report 4: Stalking your friends with GNOME

More than one month without a GSoC report? Luckily my mentors are so kind to get angry with me ;) . The truth is that I was really busy getting ready for some final exams, but that stuff is finished and I am really motivated to continue.

What was done?

Stalking your friend with GNOME

I started to like the word stalk since I started to play GTA V and got known about the Lifeinvader in-game social network, now this word is coming to GNOME Maps. I was working in a feature to display check-ins from user friends and from the user him/herself. This feature is going to be available only for Foursquare users that have a Foursquare account configured in GNOME Online Accounts. Since I was mostly working in the non-GUI part of the feature I don't have much to show you, just one screenshot:

No! I'm not using maximize and minimize buttons in my environment! that's happening to me with the latest version of Gtk+, dunno why :)

These are markers that Maps will show to represent a check-in (for the current user or for the user itself), obviously, if you press on that marker, a bubble with more information about the check-in will appear, I'm working with Andreas to get a nice mockup for that bubble. Maybe some GNOMErs remember me asking for help in IRC to get a photo with a circle shape, that was what I was trying to do :) .

Maybe you want to get involved in this feature since a have some usability worries that I explain in this Bugzilla comment, any feedback related to this will be appreciated.

Reviews, reviews and more reviews

Now I'm starting to getting some nice feedback from Dario and Rishi (GSoC students working on Maps) about the markers and bubbles I'm coding.

I hope when everything get merged, we will have a really nice maps app for GNOME.

What's next?

Showing check-ins in Maps is the last goal for my GSoC project, so the next tasks is to finish this and work hard to get everything merged before 3.14.


Sadly, I am not going to be in Strasbourg this weekend, not because I couldn't get sponsorship, but due personal stuff. I hope next year to be different, because I really wanted to be there, hacking with you :(

Week 2, 3 and 4: Implementing History View and Revamping the UI of Gnome-Calculator

Hi everybody,

Sorry for the late update on the project, was a little busy writing the code for this project.
Anyways let me give you a brief description of what I have been able to implement so far!
I have added padding to the buttons so that they are aligned in well sepearated rows and columns. We are planning to keep the color of the buttons nearly the same except the buttons for the operators would have a darker shade of grey and the result button would be blue in color. Improving the functionality of Undo buttons has already been implemented by another developer so I just fixed a bug associated with the same. I have also implemented History View which is the most important subtask of this project. The History View stores the expression entered by the user along with the corresponding answer into well defined rows of Gtk.ListBox.You can select and edit the expression in a row by double clicking the corresponding row.
Link to the patch for adding padding to the buttons:

Link to the patch for implementing history view :

Link to image of History View in Gnome-Calculator:

We have more plans for history view and the UI so stay tuned. I would be back with more updates on my project soon!

GUADEC 2014, here I am


I just arrived in Strasbourg where the 2014 edition of the GUADEC will take place.

The city is beautiful and have an interesting architecture full of half-timbered buildings and lush vegetation, which contrasts a lot with my home town of Montpellier.

The GUADEC and my participation to the GSoC for Boxes

During the last weeks, I worked a lot with Christophe Fergeau, Zeeshan Ali and Lasse Schuirmann, this GUADEC will be a great occasion to meet them in person and to enhance our collaboration on Boxes.
The GUADEC will also be a great occasion to work on Boxes by chatting about (and solving?) pending patches and to chat about Boxes' future during a BoF.

I'll also attend Lasse's proposed BoF on pointerless navigation (i.e. keybaord navigation), completing it with my interest on forsaken input devices such as gamepads. Don't hesitate to come and chat with us!

Have a nice trip and see you in Strasbourg!

Just two days to GUADEC

Tomorrow I'm going to leave for Strasbourg and starting the next day I will attend GUADEC '14.
As Gnome intern, I'm going to give a lightning talk on Sunday starting at 5pm (UTC/GMT +2 hours).

I would like to thank the Gnome Foundation for sponsor my accommodation.
Can't wait for meeting developers and having interesting lectures!

I’m also going!

I am going to GUADEC and it will be a first timer. GNOME Foundation has been kind enough to sponsor me and I’d like to thank them for doing so. It will be an adventure for me for sure!

What’s happening

I’ll let most things flow, but there is a few things I have in mind for GUADEC:

    • I’ll be volunteering as runner and session chair on at least Sunday, Monday and probably more.
    • I’ll be participating in Engagement’s Birds of a Feather session.
    • I plan to perform a lighting talk around these promotional videos I tinker with.

Most importantly I’ll be meeting a lot of people, both new and known. It will be interesting, inspiring and motivating. A nice learning opportunity I’d say.


Another year, another GUADEC

It’s 2014, and like previous years:


This time I won’t give any talk, just relax and enjoy talks from others, and hope Strasbourg.

And what is more important, meet those hackers you interact with frequently, and maybe share some beers.

So if you go there, and you want to have a nice chat with me, or talk about Grilo project, don’t hesitate to do it. Igalia, which is kindly sponsoring my attendance, will have a place there during the core days, so likely you could find me around or ask anyone there for me.


Continuous testing and Wayland

The GNOME-Continuous  continuous integration and delivery system has been helping us to keep the quality of the GNOME code base up for a while now.

It is doing a number of things:

  • Builds changed modules
  • Creates vm images that can be downloaded for local testing
  • Smoke-tests the installed image  by verifying that it boots up to the login screen
  • Runs  more than 400 tests against the installed image
  • Launches all the applications that are part of the moduleset and takes screenshots of them

All of this happens after every commit, or at least very close to that, and the results are available at the website.

You can learn more about GNOME-Continuous here.

As a member of the the GNOME release team I am really thankful for this service, it has made our job a lot easier – at release time everything just builds and works most of the time nowadays.

Earlier this year, we’ve made the smoke-testing aspect of gnome-continuous more useful by verifying not just GNOME, but also GNOME Classic and GNOME on Wayland.

Today, we’ve had a minor breakthrough: for the first time, the GNOME/Wayland smoke test succeeded all the way to taking a screenshot of the session.

GNOME/Wayland(of course, GNOME on Wayland looks just like GNOME under X11, so the screenshot is not very exciting by itself).

To get this far, we had to switch to the egl-drm branch of mesa, which adds support for running KMS+DRM GL applications with QXL.

July 23, 2014

Mono Performance Team

For many years a major focus of Mono has been to be compatible-enough with .NET and to support the popular features that developers use.

We have always believed that it is better to be slow and correct than to be fast and wrong.

That said, over the years we have embarked on some multi-year projects to address some of the major performance bottlenecks: from implementing a precise GC and fine tuning it for a number of different workloads to having implemented now four versions of the code generator as well as the LLVM backend for additional speed and things like Mono.SIMD.

But these optimizations have been mostly reactive: we wait for someone to identify or spot a problem, and then we start working on a solution.

We are now taking a proactive approach.

A few months ago, Mark Probst started the new Mono performance team. The goal of the team is to improve the performance of the Mono runtime and treat performance improvements as a feature that is continously being developed, fine-tuned and monitored.

The team is working both on ways to track performance of Mono over time, implemented support for getting better insights into what happens inside the runtime and has implemented several optimizations that have been landing into Mono for the last few months.

We are actively hiring for developers to join the Mono performance team (ideally in San Francisco, where Mark is based).

Most recently, the team added a new and sophisticated new stack for performance counters which allows us to monitor what is happening on the runtime, and we are now able to export to our profiler (a joint effort between our performance team and our feature team and implemented by Ludovic). We also unified both the runtime and user-defined performance counters and will soon be sharing a new profiler UI.

Watch out for DRI3 regressions

DRI3 has plenty of necessary fixes for and Wayland, but it's still young in its integration. It's been integrated in the upcoming Fedora 21, and recently in Arch as well.

If WebKitGTK+ applications hang or become unusably slow when an HTML5 video is supposed to be, you might be hitting this bug.

If Totem crashes on startup, it's likely this problem, reported against cogl for now.

Feel free to add a comment if you see other bugs related to DRI3, or have more information about those.

Update: Wayland is already perfect, and doesn't use DRI3. The "DRI2" structures in Mesa are just that, structures. With Wayland, the DRI2 protocol isn't actually used.

Sandboxed applications for GNOME, part 2

This is the second of two posts on application sandboxing for GNOME. In my previous post, I wrote about why application sandboxing is important, and the many positive impacts it could have. In this post, I’m going to concentrate on the user experience design of application sandboxing.

The problem

As I previously argued, application sandboxing has the potential to greatly improve user experience. Privacy features can make users feel more secure and in control, and performance can be improved, for example. At the same time, there is a risk involved with adding security layers: if a security framework is bothersome, or makes software more difficult to use, then it can degrade the user experience.

Sandboxing could be truly revolutionary, but it will fall flat on its face if no one wants to use it. If application sandboxing is going to be a success, it therefore needs to be designed in such a way that it doesn’t get in the way, and doesn’t add too many hurdles for users. This is one reason why effective design is an essential part of the application sandboxing initiative.

Some principles

Discussion about sandboxed applications has been happening in the GNOME project for some time. As these discussions have progressed, we’ve identified some principles that we want to follow in ensuring that sandboxed application provide a positive user experience. Before I get into the designs themselves, it’s useful to quickly go over these principles.

Avoid contracts

Sandboxed applications have limited access to system API and user data and, if they want more access, they have to ask the user for it. One way to allow apps to ask for these permissions is to present a set of application requirements that the user must agree to at install time. Anyone who uses Android will be familiar with this model.

Asking for blanket user permissions at install time is not something we are in favour of, for a number of reasons:

  • People have a tendency to agree to contracts without reading them, or without understanding their implications.
  • It often isn’t clear why the application wants access to the things it wants access to, nor is it clear when it will use them. There is little feedback about application behaviour.
  • There’s no opportunity to try the app before you decide what it gets access to. This is an issue because, prior to using the application, the user is not in a good position to evaluate what it should get access to.
  • Asking for permissions up front makes software updates difficult, since applications might change what they want access to.

It doesn’t have to look like security

All too often, security requests can be scary and intimating things, and they can feel far removed from what a user is actually trying to do. It doesn’t have to be this way, though: security questions don’t have to be expressed using scary security language. They don’t even have to look like security – the primary purpose of posing a security question is to ascertain that a piece of software is doing what the user wants it to do, and often, you can verify this without the user even realising that they are being asked a question for security purposes.

We can take this principle even further. The moment when you ask a security question can be an opportunity to present useful informations or controls – these moments can become a valuable, useful, and even enjoyable part of the experience.

Privacy is the interesting part

People tend to be interested in privacy far more than security. Generally speaking, they are concerned with who can see them and how they appear, rather than with abstract security threats. Thinking in terms of privacy rather than security therefore helps us to shift the user experience in a more human-orientated direction. It prompts us to think about social and presentational issues. It makes us think about people rather than technology.

Real-time feedback

A key part of any security framework is getting real-time feedback about what kinds of access are occurring at any one time. Providing real-time feedback makes the system much more transparent and, as a result, builds trust and understanding, as well as the opportunity to quickly respond when undesirable access occurs. We want to build this into the design, so that you get immediate feedback about which devices and services are being used by applications.

Audit and revocation

This is another key part of security, and follows on from real-time feedback. A vital area that needs to be addressed is the ability to see which services and data have been accessed in the past and which application accessed them. It should be possible to revoke access to individual services or devices based on your changing needs as a user, so that you have genuine control over what your applications get to see and do.

Key design elements

User-facing mechanisms for applications to request access to services and data are one obvious thing that needs to be designed for sandboxed applications. We also need to design how feedback will be given when services are being accessed, and so on.

At the same time, application sandboxing also requires that we design new, enabling features. By definition, sandboxed applications are isolated and can have limited permissions. This represents a challenge, since an isolated application must still be able to function and, as a part of this, it needs (mediated, secure) mechanisms for basic functions, like importing content, or passing content items to other apps. This is the positive aspect of the sandboxing user experience.


Here, sharing is the kind of functionality that is commonly found on mobile platforms. It is a framework which allows a user to pass content items (images, documents, contacts, etc) from one app to another (or to a system service). This is one of the positive, enabling pieces of functionality that we want to implement around application sandboxing.

Sharing is important for sandboxing because it provides a secure way to pass content between applications. It means that persistent access to the user’s files will be less important for many applications.


The sharing system is envisaged to work like many others – each application can provide a share action, which passes a content item to the sharing service. The system determines which applications and services are capable of receiving the content item, and presents these as a set of choices to the user.

In the example shown above, an image that is being viewed in Photos is being shared. Other applications that can use this image are then listed in a system-provided dialog window. Notice that online accounts are also able to act as share points in this system, as are system services, like Bluetooth, Device Send (using DLNA), or setting the wallpaper.

Content selection

Content selection plays a similar role to sharing, but in reverse: where sharing allows a user to pass content items from a sandboxed application, content selection is a mechanism that allows them to pull them in.

Content selection has traditionally occurred through the file chooser dialog. There are a number of obvious disadvantages with this approach, of course. First, content items have to be files: you can’t select a contact or a note or an appointment through the file chooser. Second, content items have to be local: content from the cloud cannot be selected.

The traditional file chooser isn’t well-suited to sandboxed applications. Sandboxing implies that applications might not be able to save content to a common location on disk: this means that we need a much more flexible content selection framework.


Content selection should enable content from a range of applications to be selected. Content can be filtered by source application, and it can include items that aren’t files and aren’t even stored locally.

System authorisation

Sharing and content selection are intended to provide (system mediated) mechanisms for opening or sending individual content items from sandboxed applications. When access is required to hardware devices (like cameras or microphones), or permanent access is required to the user’s files or data (such as contacts or the calendar), the system needs to check that access is authorised.

For cases like this, there is little option but to present the user with a direct check – the system needs to present a dialog which asks the user whether the application should have access to the things it wants to have access to. The advantage of posing a direct question at the time of access is that it provides real-time feedback about what an application is attempting to do.



In line with the principles I outlined above, we’re pushing to take the sting out of these dialogs, by phrasing them as relatively friendly/useful questions, rather than as scary security warnings. We’re also exploring ways to make them into useful parts of the user experience, as you can see with the camera example: in this case, the security dialog is also an opportunity to check which microphone the user wants to use, as well as to indicate the input level.

A key requirement for the design is that these access request dialogs feel like they are part of your natural workflow – they shouldn’t be too much of an interruption, and they should feel helpful. One technique we’ll need to use here is to restrict when system authorisation dialogs can be shown, since we don’t want them popping up uninvited. It certainly shouldn’t be possible for an application to pop up an access request while you are using a different application.

Real-time feedback, audit and revocation


As I said above, providing real-time feedback about when certain services are being used is one of the goals of the design. Here, we plan to extend the system status area to indicate when cameras, microphones, location and other services and devices are in use by applications.

We also have designs to extend GNOME’s privacy settings, so that you can see which services and content have been accessed by applications. You will be able to restrict access to these different services, and block individual applications from accessing them.

Pulling it all together

One of the things that I’ve tried to demonstrate in this post is that implementing application sandboxing isn’t just about adding security layers to desktop infrastructure. It also requires that we carefully think about what it will be like for people to use these applications, and that security frameworks be designed with user experience in mind.

We need to think beyond security to actually making sandboxing into a positive thing that users and developers want to use. For me, one of the most exciting things about sandxboxing is that it provides the opportunity to add new, powerful features to the GNOME application platform. It can be enabling rather than being a purely restrictive technology.

These designs also show that application sandboxing isn’t just about low-level infrastructure. Work needs to be done across the whole stack in order to make sandboxing a reality. This will require a combined effort that we can all participate in and contribute to. It’s the next step for the Free Software desktop, after all.

The designs that I’ve presented here are in the early stages of development. They will evolve as these initiatives progress, and everyone working in this area will have the opportunity to help develop them with us.

GUADEC 2014 Map

Want a custom map for GUADEC 2014?

Here’s a map I made that shows the venue, the suggested hotels, transit ports (airport/train station), vegetarian & veggie-friendly restaurants, and a few sights that look interesting.

I made this with Google Map Engine, exported to KML, and also changed to GeoJSON and GPX.

If you want an offline map on an Android phone, I suggest opening up the KML file with Maps.Me (proprietary OpenStreeMap-based app, but nice) or the GPX on OSMand (open source and powerful, but really clunky).

You can also use the Google Maps Engine version with Google Maps Engine on your Android phone, but it doesn’t really support offline mode all so well, so it’s frustratingly unreliable at best. (But it does have pretty icons!)

See you at GUADEC!

Making Evince “Behave” & GUADEC!

Evince_logo_newThis is probably going to be the shortest post I will be writing, but then it’s GUADEC time!

My latest component is Evince, the document viewer. I am building up on the same infrastructre as we did for Weather testing, and have put together some basic tests for the application. These can be found HERE

On the lighter side of things, I could do with a baggage zipper (much like a file zipper) at a click to take care of my packing, and mail me and my zipped luggage to save us from the gruesome travel :P

Apart from these, I am helping the team organize Volunteers, and I realize I love organizational tasks for GUADEC. (Should take up more of these in the future too :D)

Anyways, returning to the old way of packing now. (I promise the next blog will be better!)

Quick-start guide to gst-uninstalled for GStreamer 1.x

One of the first tools that you should get if you’re hacking with GStreamer or want to play with the latest version without doing evil things to your system is probably the gst-uninstalled script. It’s the equivalent of Python’s virtualenv for hacking on GStreamer. :)

The documentation around getting this set up is a bit frugal, though, so here’s my attempt to clarify things. I was going to put this on our wiki, but that’s a bit search-engine unfriendly, so probably easiest to just keep it here. The setup I outline below can probably be automated further, and comments/suggestions are welcome.

  • First, get build dependencies for GStreamer core and plugins on your distribution. Commands to do this on some popular distributions follow. This will install a lot of packages, but should mean that you won’t have to play find-the-plugin-dependency for your local build.

    • Fedora: $ sudo yum-builddep gstreamer1-*
    • Debian/Ubuntu: $ sudo apt-get build-dep gstreamer1.0-plugins-{base,good,bad,ugly}
    • Gentoo: having the GStreamer core and plugin packages should suffice
    • Others: drop me a note with the command for your favourite distro, and I’ll add it here
  • Next, check out the code (by default, it will turn up in ~/gst/master)

    • $ curl | sh
    • Ignore the pointers to documentation that you see — they’re currently defunct
  • Now put the gst-uninstalled script somewhere you can get to it easily:

    • $ ln -sf ~/gst/master/gstreamer/scripts/gst-uninstalled ~/bin/gst-master
    • (the -master suffix for the script is important to how the script works)
  • Enter the uninstalled environment:

    • $ ~/bin/gst-master
    • (this puts you in the directory with all the checkouts, and sets up a bunch of environment variables to use your uninstalled setup – check with echo $GST_PLUGIN_PATH)
  • Time to build

    • $ ./gstreamer/scripts/
  • Take it out for a spin

    • $ gst-inspect-1.0 filesrc
    • $ gst-launch-1.0 playbin uri=file:///path/to/some/file
    • $ gst-discoverer-1.0 /path/to/some/file
  • That’s it! Some tips:

    • Remember that you need to run ~/bin/gst-master to enter the environment for each new shell
    • If you start up a GStreamer app from your system in this environment, it will use your uninstalled libraries and plugins
    • You can and should periodically update you tree by rerunning the script
    • To run gdb on gst-launch, you need to do something like:
    • $ libtool --mode=execute gdb --args gstreamer/tools/gst-launch-1.0 videotestsrc ! videoconvert ! xvimagesink
    • I find it useful to run cscope on the top-level tree, and use that for quick code browsing

July 22, 2014


I’m going to GUADEC 2014! My flight would be 16 hours from now, so I’m currently packing my baggage.

I used up a lot of time applying for passport, applying for visa, looking for cheap plane and train tickets, buying things I need for my trip, waiting for the electricity to come back after a typhoon, and lots of other stuff, so I haven’t done much about my Google Summer of Code project. Seems like I have to code a lot during and after GUADEC to catch up :) .

Anyway, just found out yesterday that I have to participate in the lightning talks so I’m currently working on my slides too. I wonder where Yahoo put the announcement e-mail about it because it is not in my inbox nor GSoC folder.

Looking at the Zooniverse code

Recently I’ve been looking over the Zooniverse citizen science project and its  source code on github, partly because it’s interesting as a user and partly because I thought writing an Android app for Galaxy Zoo would be a good learning exercise and something useful to open source.

So far my Android app can’t do more than show images, but I thought I’d write up some notes already. I hesitate to implement the Android App further because the classification decision tree is so tied up in the web site’s code, as I describe below.

Hopefully this won’t feel like an attack from a clueless outsider. I’m just a science enthusiast who happens to have spent years developing open source software in various communities. I’ve seen the same mistakes over and over again and I’ve seen how to make things better.

Zooniverse is organised by the Citizen Science Alliance (CSA). Incidentally, though the CSA has an organizational structure, I can’t see it’s actual legal form. Is it a foundation or a company? The and domains are registered to Chris Lintott. Maybe it’s just a loose association of researchers with academic institutions assigning funds to work they care about, and maybe that’s normal in academia. The various Zooniverse employees actually seem to work for the member organisations such as the Adler Planetarium or the University of Oxford, though I guess some funding is for specific Zooniverse projects and some funding is for the overall Zooniverse development and hosting. That probably makes coordination difficult, like a big open source project.

Open Source

Since early 2013, the main Galaxy Zoo project has the code for it’s website on github along with the Zooniverse JavaScript library that it shares with other Zooniverse projects.

But most projects highlighted at (such as Planet Four, Asteroid Zoo, Moon Zoo, or Solar StormWatch) don’t yet have their website’s code on github. This looks like a worrying trend. It doesn’t look like open sourcing has become the default as planned.

The zooniverse github repositories list is a poor overview, particularly because most of the respositories have no github description whatsover. Github should make them mandatory, even though they’d need to be updated later. Most projects don’t even have a basic description in their either. Furthermore, I’d like to see a clear separation between front-ends, server-side code, and utilities (for processing data or for installing/maintaining servers.), maybe presented out on a github wiki page.

Also, they apparently have no plans to open source the server-side code (Ouroboros at that serves new subjects (such as galaxy images) to classify and receives classifications of these subjects. I think I’ve read that it’s a Ruby-On-Rails system. The client-side and server-side code is tightly bound, so this is a bit awkward. There is clearly room at least for some of the data structure and descriptions to be abstracted out and shared between the server, the client, and the analysis tools.

I can’t find any real documentation about the various Zooniverse code or APIs so there’s an awful chance of this blog post being the only introductory documentation that exists. I’d really welcome corrections and I’d gladly help. Neither can I find any place for public discussion of the software’s development, such as a mailing list. It’s hard for any open source project to mature without at least somewhere to discuss it.


Arfon Smith at Zooniverse wrote some blog entries about the Zooniverse Domain Model, Tools and Technologies, and Server-side logic (my title).  (Arfon has since left Zooniverse to work at Github). I also found some useful  documentation at the zooniverse page. But I had to look at the code and the network traffic to get a more complete picture.

Languages, Libraries, Frameworks

The zooniverse front-end web-sites generally seem to be written in CoffeeScript (a mostly nicer language on top of JavaScript), using the Spine framework, which seems to make it easier to separate data and code into an MVC structure and to write code that deals asynchronously with the server while caching some data locally.

Some Coffeescript is written inline with the HTML, in Eco (.eco) files.

The CSS is written in the Stylus syntax, as expected by hem, which they use to bundle the code up for deployment.

I’m no JavaScript expert, but these seem like fairly wise choices.

Zooniverse web sites communicate with the Ouroboros server using RESTful GET (get subjects to classify) and POST (return a classification of a subject) HTTP requests, using JSON syntax. I think the JSON syntax is generated/parsed by the base Spine.Module.  I don’t know of any implementation-independent documentation for this web API.

The website code uses the Zooniverse library  as a helper to communicate with the server, for instance to login, to get subjects, and to submit classifications, and to support the lists of recent and favourite subjetct. The Zooniverse library is also implemented in Coffescript. Strangely, the generated JavaScript is also checked into git. The Api class seems to be most interesting..

Questions and Answers

Let’s look at the Galaxy-Zoo website though its maybe the most complicated. It allows users to classify images of galaxies. Those images may be from one of several astronomical surveys, such as Sloan or UKIDSS. Each survey has an ID and a Workflow ID listed in (with much duplication of magic numbers). Each survey has a human-readable description and title in the list of English strings.

Each survey has a question/decision tree under app/lib, such as Galaxy-Zoo’s  I wonder if this generated or duplicated from somewhere in the server software.  Why are the long question titles duplicated and used as IDs for leadsTo instead of using short codes? Is this tree validated somehow during the build?

These IDs, Workflow IDs, and decision trees are listed in the Subject class.

Question IDs

The zero-based index of the questions in the decision trees are used as IDs when submitting the classification. For instance, a submitted classification POST might contain the following parameter to show that, when classifying a Sloan image, for the “Is there any sign of a spiral arm pattern” question (sloan-3, and the 4th question asked of me) I answered “Spiral” (a-0):

classification[annotations][4][sloan-3]: "a-0"

These implicit IDs, such as sloan-3, are also used in the translations,  and throughout the code. For instance, to reuse some translation strings, to decide if there should be a talk-page link. That i18n hack in particular belongs as an association in the decision tree.

These implicit IDs are also used in the CSS (via the Stylus .styl files) to identify the relevant icons. The icons are in one workflow.png file in order to use the CSS Sprites technique for performance). The various sub-parts of that image are selected by CSS in common.styl.

This seems very fragile. It would be safer if the icon files were stored separately and then the combined file was generated, along with that .styl CSS. I guess that the icons are already stored separately somewhere, maybe as SVG. One parent file could define the decision tree and all the associated descriptions and icon files.

Ideally much of this structure would be described in configuration files separately from the code. That generalisation would allow more code reuse between Zooniverse projects and could allow reuse by other front-ends such as iPhone and Android apps. Presumably it’s this fragility that has caused Galaxy Zoo to withdraw its previous mobile apps. Even with such an improvement, you’d still need a proper release process to coordinate development of interdependent software.

Subject and Classification

Galaxy-Zoo has a Subject class, as does the Operation War Diaries project. These usually derive from the base Subject class in the zooniverse library ,though the Snapshot Serengeti Subject class does not.

The Ouroboros server at at provides a list of subjects for each group (a group is a survey, I think) to be classified via JSON. Here is the list of subjects for Galaxy Zoo’s Sloan survey. And here is the subjects list for Snapshot Serengeti with a simpler URI because there is only one group/survey.

The surveyId (for the group) for Galaxy Zoo is chosen randomly, though it’s currently hard-coded to always choose the Sloan survey. This JSON message contains the URLs of images for each  subject, in the list of “locations”. The Subject’s fetch() method calls the Api.get() method from the Zooniverse library and then creates Subjects for each item that the JSON message mentions.

The Subject’s constructor seems to take theJSON fragment to populate its member fields using the default Spine.Model’s AJAX functionality.

Galaxy-Zoo has a Classification class, and Snapshot Serengeti has one too. There doesn’t seem to be any common base Classification class in the zooniverse library. The Classification’s send() method calls the Classification’s toJSON() method before POSTING the message to the server via the Zooniverse library’s method.

It’s hard to see any great commonality between the various projects.
For instance, a Galaxy Zoo classification is a series of answers to multiple-choice questions, with the questions being from a decision tree. I guess that Snapshot Serengeti’s animal classification is similar, though you can provide multiple sets of answers to the same questions about what animal it is and what it is doing, to identify multiple animals in each image. Moon Zoo and Planet Four ask you to draw specific shapes on an image and also classify each shape you’ve drawn, probably resulting in coordinates and identifications.

I wonder if the server-side code has any common model for these data structures or if the classifications just get fed into project-specific databases for project-specific data analysis later.


Looking behind my back, a very interesting part is done. Let me tell you what I did during this period and what is coming.

After the basis have been set the real work has started. GNOME Books is going to be a “two level” application, as it is going to use two different levels and languages, C for the core functionality and JavaScript as managed runtime. To make a bridge between those two worlds the code has to be written using GObject convention.  The application can be divided in two parts:

  1. A library for handling interaction with the WebKit WebView, which could be called GNOME Books Library,
  2. GNOME JS application.


To expose a common API from a C library to GJS the code had to be “introspected”. GObject introspection is a middleware layer between C libraries (using GObject) and language bindings, in this case JavaScript. The C library is being scanned at compile time, followed by the generation of a metadata file. At runtime, language bindings are reading metadata and automatically providing bindings to call into the C library.

The C library is exposing “controller” object with the methods which are calling into the WebKit WebView. WebKit View is then calling JS functions to execute the method.

The most challenging aspect was building the whole thing. The best supported build system is the autotools aka the GNU build system, with autoconfautomake and libtool.

The structure of the project at this point can be seen below.

├── src
│   ├── lib
│   │   ├── gb-webview.c
│   │   ├── gb-webview.h
│   │   ├── gb-resources.c
│   │   ├── gb-resources.xml
│   ├──
│   ├──
│   ├──
│   ├── application.js
│   ├── mainWindow.js
│   ├── main.js
│   └── webView.js


GJS Books application is based on GtkApplication class which handles aspects of GTK+ application. It exports actions and menus and manages a list of toplevel windows whose life-cycle is automatically tied to the life-cycle of the application.

By using introspected library application can load and render the book and present it in the window, with the WebKit WebView. Some extra functionality which is implemented is controlling the reading more.


The repository of the GNOME Books application can be found on github [1].


I am very glad to say that I’ll attend this years edition of GUADEC in Strasbourg, France. As a participant of Google Summer of Code I will give a short introduction of my application during the interns’ lightning talks session.



  • Add more functionality in the library to navigate the book
  • Integrate Books application with the document discovery part that Documents partly does

[1] github repository of the GNOME Books application:

GSoC Report #3 – Certificate Handing PKCS#11 Module

Journey to nowhere

Well, last time I posted the PKCS#11 module was not loading with modutil.

Looking up Evolution Data Server code to see what e_source_registry_new_sync() was up to, I found an interesting comment about a deadlock on e_source_registry_new_sync() that was occurring, the bug mentioned in the comment is a duplicate of a bug not marked as fixed.
Well, so I decided to try the asynchronous version, e_source_registry_new(), which calls a callback when done.
Changed the function flow, wrote the callback, tested. Nothing happened. I waited forever and the callback was  never called back.

After spending half a week trying to find out what was deadlocking the module,  I decided to test it in another machine. (Luckily I have two machines at my disposal). Settled up everything, modutil, and voila, loaded!
There is some kind of misconfig in the first machine causing the problem, which I don’t know what may be, since both run a Fedora 20 64-bit distro.

I decided put that problem aside and started coding on this new machine. But I will surely have to address this problem again, as someone else may get deadlocked too.

Edit: After all things described below were implemented  I tested it again, and magically it loads in that machine too.

Onward to fetching contacts!


Improving queries

When asking for contacts, I only have interest in contacts which have a X509 certificate. So, I changed all queries done to Evolution to query for contacts with an E_CONTACT_X509_CERT field. There are times the PKCS#11 module will ask Evo for contacts which have a specific email address and has a certificate field, and there are times the module will require all contacts which have a certificate, regardless of email address.
The two queries look like this:

(and (exists "x509Cert") (is "email" "") )
(and (exists "x509Cert") )

But every query asking for x509cert field returned nothing, as if there were no contacts with a X509 certificate. It turned out there was a little bug [0] in which only queries for existence of fields of type string returned correctly.
Thanks to Milan Crha it was fixed quickly, ;).

Stepping through contacts

The number of contacts returned when asking for all contacts’ certificates can be enormous. So I changed from e_book_client_get_contacts_sync(), which returns a list of contacts, to  e_book_client_get_cursor_sync(), which returns a cursor that can navigate through the contacts and fetch the required number of contacts.

Session management

PKCS#11 modules can serve a number of applications, or threads, concurrently. To separate context from one application to another, there are sessions.
I elaborated a small structure to store all info needed for an application, or thread context. For now, the module only know one session, every application that opens up a session will unknowingly share it with other applications. I wanted to avoid problems with data structures and sessions while implementing the main feature.
When the work is settled, the module can be expanded to be true multi-session.

Object management

Object management does need improvements. At first I believed that the module would be stateless, go to Evolution, get certificates, return and forget them.
Objects have an object handle assigned to them by the module. It can change from one session to another, or between two instances of sessions used one after another. But PKCS#11 API defines that objects are expected to have the same handle during a session’s life time.
So, the module needs to keep track of the objects and it’s handles. Currently the module assigns a new handle to every object found.
This is not a priority and will be implemented soon.

Certificate structure

The certificate received from Evolution is now converted and put in a CERTCertificate structure.
I tried to do it before but without success. This time I have figured out a way to convert the DER encoded certificate into the mentioned structure (no crashes or SECFailure’s).
The conversion is beneficial as many DER encodings fields become available right away, like the DER encoding of the certificate issuer or subject. It eliminated some auxiliary functions used to parse the DER certificate.
The contact’s certificate in a CERTCertificate may ease future work as well.

So, where are those certificates

As Evolution still was not capable of sending encrypted mail, guided by the logs generated by PKCS#11 Module Debugger [1], I started to answer other queries the module was receiving, which I was not responding to. For example NSS asks for certificates issued by a specif issuer during a search, and for some objects NSS would ask for the CKA_ID of the object, an identifier of the object used to bind corresponding certificate, public and private keys.

Issuer name search

The data received in the search template is a DER encoding of the issuer name, and the certificate returned from Evo is DER encoded. A simple comparison of the issuer name encoding was enough.

Get attribute CKA_ID

I spent a lot of time and effort on this one, and I couldn’t do it. NSS has lots of useful functions, but most of them are only available internally. They are not exported in their libraries. Or maybe I’m the one who couldn’t find them.
The only solution at sight was to parse the certificate and calculate the CKA_ID myself. But that would be too much time consuming and error prone, as the value differs by algorithm. RSA, DSA, ECDSA each one of them has a way to calculate CKA_ID.

Got lucky

Seeing no way to get out of the situation, and in a last effort, I started to search around randomly.

And by chance, navigating on the certificates list shown by Evolution in ‘Preferences’ menu, right clicking the certificate I found out that Evolution (or NSS) did not trust the contact’s certificate.
I marked it as trusted, and I could send a message encrypted, wohooo!

Receiving encrypted mail

You can’t see it, but this email was encrypted using a certificate retrieved  from Evolution addressbook by a PKCS#11 module.

Next steps

  • Take a look at this trust mechanism, and check if it is possible or secure to mark it as trusted from the module.
  • Refine the module
  • Start working on integration with Evolution

Well, time to pack my stuff cause




Slide embedding from Commons

A friend of a friend asked this morning:

I suggested Wikimedia Commons, but it turns out she wanted something like Slideshare’s embedding. So here’s a test of how that works (timely, since soon Wikimanians will be uploading dozens of slide decks!)

This is what happens when you use the default Commons “Use this file on the web -> HTML/BBCode” option on a slide deck pdf:

Wikimedia Legal overview 2014-03-19

Not the worst outcome – clicking gets you to a clickable deck. No controls inline in the embed, though. And importantly nothing to show that it is clickable :/

Compare with the same deck, uploaded to Slideshare:

Some work to be done if we want to encourage people to upload to Commons and share later.

Update: a commenter points me at viewer.js, which conveniently includes a wordpress plugin! The plugin is slightly busted (I had to move some files around to get it to work in my install) but here’s a demo:

Update2: bugs are fixed upstream and in an upcoming 0.5.2 release of the plugin. Hooray!

GUADEC Preparations

As I announced in previous blogposts, I will attend to GUADEC 2014. I see forward to meet so many gnomies and remeet some I got to know in Berlin. Here some information about my personal, little, efforts to make GUADEC a success.

Consistent Slides for GUADEC 2014

After I reveived the notification containing details about how to prepare my lightning talk I wondered why there is no slide design for GUADEC 2014. After some conversation with Marina Zhurakhinskaya I created some master slides specifically intended for use in GUADEC 2014.(And even got them reviewed by her, thanks for that!) I uploaded the master slides with some example contents for GSoC lightning talks here:

Maybe we can make our presentations a bit more consistent with that, maybe it saves some work for someone. Feel free to use, modify, … them for any purpose you want.


In the last month I got a bit interested in accessibility. In the last days I have made contact with some blind users and hope I can gain some information about how they use or would like to use a PC. In addition I’m trying to organize a discussion about how we can improve navigation without pointer devices in general on GUADEC. If you need more info about that or want to join, take a look at:


There is no visible progress since the last blog post from my project. I worked on many things, especially:

  • Patch reviewing
  • Bug filing/triaging
  • GUADEC related things mentioned above plus the usual preparations you do when giving even a short talk on your first open source conference

Im going to GUADEC


like many fellow GNOME developers I will be in Strasbourg for GUADEC 2014.

on Monday morning, I will give a talk on the GTK+ Scene Graph Tool Kit, or GSK for short, but you should make sure to attend the many interesting talks that we have planned for you this year.

see you at GUADEC!

GTK+ at GUADEC 2014

GUADEC is almost here. GTK+ will be presented with 3 talks:

  • GTK+, dialogs, the HIG and you  (by me)
  • GTK+ and CSS (by Benjamin)
  • The GTK+ scene graph toolkit (by Emmanuele)

All of these will be on Monday, the 28th. We will also have a GTK+ team meeting on the 31st.

I’ve made a small collage to summarize my talk:

Dialogs See you all there !

Red Hat Certifications

More than two years had been passed since I have met Red Hat in the GNOME Documentation Hackfest 2012.  After the event, I came back to my Perú and doors were opened to work as a system administrator in GMD. There, I gained skills in handling files, working with the command line and using system documentation, along with managing systems (boot-up, identifying processes, starting/stoping virtual machines, controlling systems), configuring storage partitions and logical volumes, and more…

After almost a year, IBM Perú gave me the opportunity to manage Red Hat servers, and I now I am pleased to announce that I got the best Red Hat certifications on May, 31th 2014: RHCSA and today, the most expected: RHCE.


I am still learning, unexpected situations can happens even if you have the best plan for servers maintenance.

Thanks to GOD, family, friends, GNOME, Fedora and everyone who supports my career and fun in the Linux world :)

Filed under: Education, GNOME Tagged:, Julita Inca, Julita Inca Chiroque, Perú, Red Hat, Red Hat Enterprise Linux 6.3, RHCE, RHCSA, RHSCA


I'll be heading to GUADEC in a couple of days, arriving Friday evening.

I have two talks this year. One will cover GOM, a GObject to SQLite bridge. One will cover Builder, a fun new project I've been working on.

I'm looking forward to seeing everyone soon!

July 21, 2014


So its that time of the year! GUADEC is always loads of fun and meeting all those the awesome GNOME contributors in person and listening to their exciting stories and ideas gives me a renewed sense of motivation.

I have two regular talks this year:
  • Boxes: All packed & ready to go?
  • Geo-aware OS: Are we there yet?
Apart from that I also intend to present a lightning talk titled "Examples to follow". This talk will present stories of few of our awesome GNOME contributors and what we all can learn from them.


I'm going to GUADEC 2014 badgeLeaving tomorrow, as I will be first at the Evince Hackfest


The 3 course lunch baffles me. Where’s my simple FOSDEM-french bread?!?

summing up 57

i am trying to build a jigsaw puzzle which has no lid and is missing half of the pieces. i am unable to show you what it will be, but i can show you some of the pieces and why they matter to me. if you are building a different puzzle, it is possible that these pieces won't mean much to you, maybe they won't fit or they won't fit yet. then again, these might just be the pieces you're looking for. this is summing up, please find previous editions here.

  • a critique of technocentrism in thinking about the school of the future, by seymour papert. so we are entering this computer future; but what will it be like? what sort of a world will it be? there is no shortage of experts, futurists, and prophets who are ready to tell us, but they don't agree. the utopians promise us a new millennium, a wonderful world in which the computer will solve all our problems. the computer critics warn us of the dehumanizing effect of too much exposure to machinery, and of disruption of employment in the workplace and the economy. who is right? well, both are wrong - because they are asking the wrong question. the question is not "what will the computer do to us?" the question is "what will we make of the computer?" the point is not to predict the computer future. the point is to make it. highly recommended
  • inside the mirrortocracy, if spam filters sorted messages the way silicon valley sorts people, you'd only get email from your college roommate. and you'd never suspect you were missing a thing. lest you get the wrong idea, i'm not making a moral case but a fairly amoral one. it's hard to argue against the fact that the valley is unfairly exclusionary. this implies that there is a large untapped talent pool to be developed. since the tech war boils down to a talent war, the company that figures out how to get over itself and tap that pool wins. highly recommended
  • programming languages, operating systems, despair and anger, it's pretty damn sad that something as limited and now ancient as bash represents some kind of optimum of productivity for many real-world "everyday programming" tasks - and yet fails so miserably for so many other everyday programming tasks due to lack of data abstraction and richness. 90% of the shit that gets written doesn't even involve anything as complicated as finding set partitions. really
  • we lost the war. welcome to the world of tomorrow, we need to assume that it will take a couple of decades before the pendulum will swing back into the freedom direction, barring a total breakdown of civilization as we know it. only when the oppression becomes to burdensome and open, there might be a chance to get back to overall progress of mankind earlier. if the powers that be are able to manage the system smoothly and skillfully, we cannot make any prediction as to when the new dark ages will be over
  • the gloaming, short film by niko nobrain

Photos - Picasa Web Integration: Add the miner to GNOME Photos

This update has been due for some time since I was away for the last week.

I have completed the code for integrating the Picasa Web miner into GNOME Photos. The patches[1][2] have been submitted for review. With this, a majority of the work for my GSoC project is complete. The rest of the time will be spent on following up with the review of my patches and working on other bugs.

Sadly, I am missing a great opportunity to meet up with the community at GUADEC 2014 due to other commitments. Maybe I will make it next year.

Happy hacking!

July 20, 2014

Business as usual.

No surprises:


Looking forward to part-time holidays, beautiful Strasbourg, and the usual bunch of great people.

OPW Report #6 – week 8-9

Following reviews – translations in Greek language have been completed the last two weeks within the OPW:
UI Translations:
network-manager-applet, tracker, zenity, anjuta, glade, Gtk+, gtksourceview, Gtk+ • Property Nicks, devhelp, gnome-sudoku, gnome-tetravex
gnome-mines, four-in-a-row, bijiben, lightsoff, quadrapassel, gnome-robots, gedit, anjuta, Evince Document Viewer

The files of past two weekswere larger in size and very demandingregarding the revision with many errors for correction.Fortunately the version3.14 is almostready! Only a few files have to be reviewed and some strings to be translated that have been added afterwards.

Going to Guadec

For the first time since 2008, when it was in Istanbul, I'm coming to Guadec. This time it is in Strasbourg, France. Thanks to a work week scheduled just before in Paris.

I won't present anything this year, but I hope to be able to catch up a bit more with the Gnome community. I was already at the summit last fall, as it was being held in Montréal, but Guadec participation is usually broader and wider.

Newcomers Workshop

The GNOME Newcomers Workshop might be coming to a conference near you this summer! Owen Taylor and I will be hosting one at GUADEC in Strasbourg, France on Saturday, July 26 and one at Flock in Prague, Czech Republic on Saturday, August 9. If you have never contributed a patch to GNOME before or even have never used GNOME, this workshop is for you! You’ll get a quick overview of the GNOME project, have a chance to install GNOME in a virtual machine, and learn the tools and the process of contributing a patch. If you plan to come to either workshop, please add yourself to the list of attendees.gnome-balloonIf you can’t attend one of the workshops, you can install the available image in a virtual machine and go through the newcomers tutorial used at the workshop on your own. You can ask any questions you have on IRC.

We would like to have one helper per three newcomers at the workshops. If you are an established contributor and will be available, please sign up now to help with the workshop at GUADEC or Flock, and then you can check the room in the beginning of the session to see if we need your help based on the attendance. I’d love to see more people running the Newcomers Workshop locally or at other events they attend. Helping out with one of these sessions would give you a chance to learn how it works.

In addition to hosting the Newcomers Workshop, I will be speaking about how to be an ally to women in tech at GUADEC and about the Outreach Program for Women at Flock.


And then I’m going to