psc on board

PackageKit in Cheese

2012-02-01T14:36:00.000+01:00

As I already mentioned in one of my last posts, the sharing functionality in Cheese uses nautilus-sendto, which is a runtime dependency, and we wanted to do it our best to let the user/developer/maintainer know about it:

1. By checking the dependency at configure time.

2. By writing a comment in the README file.

3. By using PackageKit to install the package at runtime. If the package is not installed, and the user tries to use the sharing functionality, PackageKit will be used to install it at runtime.

The adventure

The PackageKit bit has been quite challenging for me, and I have to admit that it took me much longer than expected :(! I have learned a lot of new things though!

The first problem I had, was that I spent a few days working on dbus-glib, which I later discovered through Dave, that was deprecated. The source of the problem and biggest issue for me was, that both of the examples I followed in the PackageKit FAQ and the Vala tutorial, were obsolete and using dbus-glib. I have already talked with Richard Hughes about the first example and marked the second one as obsolete in the Vala tutorial wiki.

After this discovery, I started using the C API and the org.freedesktop.PackageKit.Transaction interface, which offers the InstallPackages method. I realised of course, that all the examples I looked at, used the org.freedesktop.PackageKit.Modify interface instead, but from my last experience, and since I did not see this interface documented anywhere in the API, I just went on working using the 'Transaction' interface. It also took me a long time to get it 'almost' working, but it never did completely. Another failure!

While I was in the middle of this frustrating process, Dave found out, that the 'Modify' interface was actually not obsolete, and pointed me to a very interesting link that took him some time to find and explained us why all the examples we saw, were using the 'Modify' interface. We both wondered why this was not documented and so hidden, and agreed that this should be somewhere more visible.

After making all the changes in the code again to use D-Bus and the 'Modify' interface instead, I talked to Richard Hughes regarding all these issues. He was really nice, and informed me that the reason why this was not documented in the API, was because the API is just documenting the 'system interface', since the 'session interface' isn't really part of the core PackageKit project but a reference implementation that both KDE and GNOME provide. He also pointed me to another very useful link and agreed on the need of a better entry in the PackageKit FAQ, to provide the users with all these information and documentation, something I will be helping with.

Gained knowledge
I could resume what I have learned about PackageKit in a few paragraphs, that I hope will be useful for you in the future.

There are two different levels of API in PackageKit:

- The system API: It is the 'Transaction' interface, which is more low level, but allows the developer to control everything, including things like GPG keys and EULAs. Everything is explained in the PackageKit reference manual.

- The session API: It is the 'Modify' and 'Query' interface, which allows the developer to install a package without taking care of the low level part. This is the one used in Cheese. The documentation in this case, is not so visible as I already mentioned before, but you can find what you need in the git.gnome.org repositories under the /src and /docs directories of gnome-packagekit.

Dave wrote a nice generic synchronous example of PackageKit usage in Vala, using the 'Modify' interface:

[DBus (name = "org.freedesktop.PackageKit.Modify")]
interface Packagekit : Object {
    public abstract void install_package_names (uint xid, string[] packages,
                                                                            string interaction) throws IOError;}

int main () {
    Packagekit pk;
    try {
        pk = Bus.get_proxy_sync (BusType.SESSION, "org.freedesktop.PackageKit",
                                                   "/org/freedesktop/PackageKit");
        string[] packages = {"nautilus-sendto" };
        var interaction = "hide-confirm-search,hide-finished,hide-warning";
        pk.install_package_names (0, packages, interaction);
    } catch (IOError error) {
        critical ("D-Bus error: %s", error.message);
        return 1;
    }
    return 0;
}

This is basically what you need to know if you want to install any package at runtime in your application using PackageKit, and do not want to bother with the details. I have used the asynchronous version of it for Cheese.

PackageKit in Cheese.

This has been a long post, but as you can see, it was quite an adventure to get here! I will write soon with more news!

How great would it be if...

2012-01-19T11:15:00.000+01:00

I have been constantly thinking about something in the last months. Unconsciously, it all started when I did my first contribution to GNOME, then I got addicted, and more and more contributions came, and together with that, more research, reference manuals I had to read, APIs I had to use, the GOPW (GNOME Outreach Program for Women)... and then there it was, a NEED!

How many of you did not feel that documentation was incomplete or non understandable at some point and were desperately looking for an example or source of inspiration?? In my case, I usually look in some project under git.gnome.org, and it helps in most of the cases. What about if we had some kind of 'Google Code Search' tool that would search in all the available code at git.gnome.org? Something like a 'GNOME Code Search'! How great would that be??

What do you guys think? Which approach would you take for doing something like this?

Add 'Share' functionality to Cheese - check!

2012-01-17T15:00:00.000+01:00

Great news! The sharing functionality I have been lately working on, have been merged into Cheese master! Now, users will be able to share pictures and videos within different technologies! This needs some improvement though.

First of all, nautilus-sendto needs a good check in the configure.ac file. We are talking here about a runtime dependency, and it would be really nice to have a hint for the user in the form of a message at configure time if nautilus-sendto is not installed on their system or they have the wrong version of it. I already tried something, but it is not completely working, and therefore had to be dropped from the patch for the merge:

# Check for nautilus-sendto runtime dependency.
NAUTILUS_SENDTO_DEP_MSG="This is a runtime dependency just needed for using the sharing functionality in Cheese."
NAUTILUS_SENDTO_REQUIRED=2.91.0

AC_PATH_PROGS([NAUTILUS_SENDTO], [nautilus-sendto], [notfound])
AS_IF([test "x$NAUTILUS_SENDTO" = "xnotfound"],

[AC_MSG_WARN([Unable to find nautilus-sendto >= $NAUTILUS_SENDTO_REQUIRED in the path. $NAUTILUS_SENDTO_DEP_MSG])],

   [NAUTILUS_SENDTO_SYSTEM=`nautilus-sendto --version | $SED 's/nautilus-sendto //g'`
    AS_VERSION_COMPARE([$NAUTILUS_SENDTO_SYSTEM], [$NAUTILUS_SENDTO_REQUIRED],
         [NS_VERSION_COMPARE=0],
         [NS_VERSION_COMPARE=1],
         [NS_VERSION_COMPARE=1])
    AS_IF([test $NS_VERSION_COMPARE = 0],
       [AC_MSG_WARN([Unable to check the version of nautilus-sendto, it is probably too old. At least $NAUTILUS_SENDTO_REQUIRED is required. $NAUTILUS_SENDTO_DEP_MSG])])])

The problem with this solution, is that it will only work for those versions of nautilus-sendto that include support for the --version argument, currently just nautilus-sendto master, since this is a feature I also worked on during the nautilus-sendto integration, and was merged about a week ago. This means, that old versions of nautilus-sendto will not recognize this argument, and therefore return an error message ("Could not parse command-line options: Unknown option --version"), that AS_VERSION_COMPARE will use, comparing a version number with a string, instead of a version number with another version number, which will of course make the check useless. In the meantime, while I work on finding an improved solution, the user will be informed in two ways in case they hit this problem: through the UI by an insensitive 'Share' action and through the README file.

There are other bits that also need some improvement. As I already explained a few blog posts ago, for accomplishing this task, I used nautilus-sendto, that internally uses libsocialweb, which needs to have some libsocialweb accounts first set up for working. Right now, the only way for setting those accounts up is using Bisho, that is also giving some problems. The idea now and next challenge, is to use GOA (GNOME Online Accounts) in libsocialweb instead, at least, and just for the moment, for the Google services, so my next tasks will be to focus on porting the current libsocialweb YouTube service to use GOA, and to fix all of those underlying bits that are not working correctly, to make the sharing functionality work really well!

As you can see, I do not get bored. I will be back soon with more news!

Avoid using busy-waiting or spinning technique

2012-01-03T18:27:00.000+01:00

Busy-waiting, or in other words, spinning, happens when a process repeatedly executes a loop of code to see if a condition is true, while waiting for an event to occur. This means, that the processor will be waiting for the task to be finished in order to go on executing other tasks, which means, that in general this technique should be avoided, since it consumes time of the processor that could be used, wasting it on useless activity. The solution would be to use an asynchronous approach.

Thinking in asynchronous terms is hard though, synchronous API is simpler in many ways, so most of us tend to use it. It is also usually a quicker hack, but not because of this reason it is the best option.

In order to let Cheese users launch several nautilus-sendto dialogs, to send several pictures each time, and change the form of the cursor from when Cheese was busy with nautilus-sendto to when it was not and all of these without blocking the UI, I needed to take an asynchronous approach. I do not have experience with it, so I of course did it the "easy way", spinning the loop (spin_event_loop()) and this was the result (please, take into account that I removed all the code that was not necessary for this explanation):

public void files_share() {

    try {
       main_window.set_busy_cursor();
       Pid child_pid;
       Process.spawn_async("/", argv, null SpawnFlags.SEARCH_PATH, null, out child_pid);
       main_window.set_normal_cursor();
    }

}

public void set_busy_cursor() {
get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.WATCH));

   spin_event_loop();
}
public void set_normal_cursor() {
   get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
   spin_event_loop();

} 
 public bool spin_event_loop() {

while (Gtk.events_pending()) // Busy-waiting
{...}

}

After submitting my first patch with this code, Dave was the one who made the review, and he suggested me to not use the spinning technique. Now it is obvious after reading the above mentioned reasons why :P. At first I was a little bit "afraid" of using asynchronous API. It looked completely akward to me, but then I also discovered through him, that GIO and GLib have some nice API to make asynchronous operations simpler. GIO offers GSimpleAsyncResult, which I personally did not find specially pretty, but still very useful. Sushi uses it and has some nice examples in its code. On the other hand, GLib has g_child_watch_add() (ChildWatch.add()), which sets a function to be called (child_finished()) when a child exits, and was the best approach for my case and the one I decided to replace the spinning technique with:

public void files_share () {

try {

Pid child_pid;

if (Process.spawn_async("/", argv, null,

SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,

null, out child_pid))

{

ChildWatch.add (child_pid, child_finished);

if (num_children == 1)

window.get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.WATCH));

}

}
void child_finished (Pid pid, int status) {

Process.close_pid(pid);

if (num_children == 0)

window.get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
}

All of these has been totally new for me and I am very happy I learned some bits of it. It definitely improved the code a lot!

Hopefully, all these changes will be merged to master very soon. I will keep you informed!

Integrating nautilus-sendto in Cheese

2011-12-24T18:50:00.000+01:00

Among other things, last week I have been very focused and working on the integration of nautilus-sendto in Cheese.

First, I spent some time playing around with nautilus-sendto, and during this process, I filed some bugs and made patches for them too. I first could not compile master during maintainer mode due to some deprecated symbols that I replaced at the end in the form of a patch. After that, I have been having problems with the libsocialweb plugin, which is loaded by nautilus-sendto. At run time, the nautilus-sendto dialog did not show any of the libsocialweb offered technolgies. After talking to Bastien about this issue, he informed me, that in order to show the above mentioned accounts in nautilus-sendto, it is necessary to create your own libsocialweb accounts with Bisho (MeeGo configuration tool for libsocialweb social network aggregator) first. Once the accounts have been created, nautilus-sendto should show those accounts in its dialog. I also filed a bug and submitted a patch updating the README file of nautilus-sendto with this information, which was not available anywhere and updated the diagram I used in my last post with the following one:

Sharing videos and images with Cheese.

The truth is, that even using Bisho now, nautilus-sendto is not showing the libsocialweb accounts for me, which is something I have to go on investigating.

Bisho is also not very stable. It is currently showing just 3 different account types: Facebook, Twitter and Flickr, and just Flickr is working. After what has happened with Meego and the integration of GNOME Online Accounts (GOA) in GNOME, it might be nice and wise to migrate from Bisho, to GOA, another thing I filed a bug about.

Bisho.

After getting familiar with nautilus-sendto, I started working on the integration itself and made a small wrapper in Cheese. Now we can say, that Cheese has the capacity to share images and videos through different technologies. Look that I just said the capacity, which does not mean that is completely working yet! For my changes, I have created a new "shareable-media" branch in Cheese that you are very welcome to test!

This is how it is currently looking in the UI:

Share images and videos Cheese option.

Integration of nautilus-sendto in Cheese.

I have also realised, that multiple selection of images and videos is not completely working on Cheese. A user is able to select several images and videos that are together one next to the other, but not different separate ones, which is something we will also try to fix.

This, improving the current code and fixing the different issues within nautilus-sendto and Bisho are the next points in my TODOs list. Lots of fun!! :))

I will write back soon with more updates! Thanks for reading!

GNOME Outreach Program for Women 2011: The goals

2011-12-14T00:00:00.000+01:00

As I already announced a few weeks ago, I had the honour to be selected as an intern for the GNOME Outreach Program for Women 2011 (GOPW)! I will be working on the Cheese project and mentored by David King.

My main goal, and proposed one, from the outset, was to provide Cheese with support for uploading recorded videos to YouTube. Analysing the problem, I decided that I would like to solve it in a way from the beginning, that would permit to extend this feature with other social sharing technologies for sharing images and videos in Cheese in the future. After talking about all of these ideas with Dave, he pointed me to libsocialweb. Later on, and talking to Bastien Nocera about what the plan was, he pointed me to nautilus-sendto, a convenience application to send files via email, bluetooth or instant messenger,which internally uses libsocialweb already and is what I am finally going to use for my purpose, extending my main goal a bit from sharing in Youtube, to sharing in general.

The following diagram should give you an overview of the whole general idea:

I am very excited to see all of this working already! I will try to keep you up to date with the whole process.

Thanks for reading!

Autotools Project Manager, part 5: [current status MERGED]

2011-11-30T16:30:00.000+01:00

After all the work, I can already announce and celebrate, that the plugin for giving Qt Creator support for autotools projects, has been merged today into Qt Creator! I could not have finished my time at Openismus GmbH and series of posts related to the plugin in a better way. I am very happy of the result and hope it will be helpful for those who love autotools. Enjoy and see you soon!

Cheese Architecture

2011-11-18T10:30:00.000+01:00

During the process of trying to understand the internals of Cheese and together with Dave, we created a diagram that I rewrote in dot language and which I think will be very useful for all of those who want to start contributing to the project or are simply curious about it. It took us some time to put the pieces together, but here is the result!

Created using Graphviz.

Did I mention before that I love Graphviz? It is so, but on this occasion it took me a while to get the layout and the legend the way that I wanted. In order to reorder the subgraphs (each of the external boxes: UI, libcheese, libcheese_gtk, System and Legend), I needed to create some transparent nodes and connections to lie to the rank system that dot uses. You can check out the code on my GitHub repository for more details.

The diagram will be available as part of the Cheese documentation for the next 3.3.2 release, coming out next Monday the 21st of November.

Enjoy!

Embracing the changes

2011-11-17T11:30:00.000+01:00

Right now I am writing from what is still my bedroom, and my bed. If you had a look around, you could see 7 boxes full of books, clothes, gadgets, things that I need, things that I do not need at all but I feel stupidly attached to. All of them sum up my almost 4 years abroad, not that I can put all the great people that I got to know along the way into my boxes. Those, I keep in my memories and my heart. I just ask myself, how much stuff is a person able to collect in such a short period of time??

These last years have been full of good, and also bad, moments and cherished people. I can say that I learnt something new every day, lived in 7 different places, learned a new language, worked in different companies… It was a great and long adventure, a precious piece of my life, also with big emotional costs, but still, just a part of the adventure. And like every good story, and as Freddie Mercury said, "the show must go on", and my show is just starting!

The destination of these 7 boxes is Gran Canaria; it is also mine. I am moving back home for now and I am really excited about all the new things that are awaiting me in the future. My time at Openismus has come to an end, and therefore, I will have time now to finish my studies—something I really wanted to do a long time ago. I also have the honour to say and re-announce, that I have been selected as one of the interns for the GNOME Outreach Program for Women! This means, that you will still keep on hearing from me! I have been very lucky, I must say, and will be mentored by David King to work on the Cheese project. I cannot wait to start!

Autotools Project Manager, part 4: Moving from Gitorious to Gerrit.

2011-11-10T18:50:00.012+01:00

After the first code review from the Qt Creator team, and due to the new Nokia changes related to open governance, this project has been migrated from Gitorious to Gerrit. This migration has blocked the development of the project more than expected, mainly due to the bureaucratic processes involved, but now things are back to normal, and after a second review it seems that we are closer to seeing the plugin become part of Qt Creator.

Also two great pieces of news. The first, is that the configure.ac file is now highlighted in the autotools project. Credit goes to Friedrich W. H. Kossebau, who pointed me to the right place and person in order to make this happen. The second, is that Mathias Hasselmann has come up with a great idea: a script for converting devhelp books into Qt help collections.

As you see, all good news! Now, let's go on making Qt Creator rock!

Update: Since there is no way to have even read access to Gerrit unless one has an account in their Qt Bug Tracker Jira system, I will go on keeping the Gitorious repository up to date with all the changes. Enjoy!

Autotools Project Manager, part 3: The Merge Request

2011-09-01T14:25:00.000+02:00

During the Desktop Summit 2011, I had the chance to meet some of the guys working on the Qt Creator (QTC) team. I took advantage of this opportunity and talked to them about the AutotoolsProjectManager plugin. After some discussion, among other things about the lack of available documentation and the intention of making a merge request (MR), I was invited to visit the Nokia office in Berlin. So, last week, I had a very interesting and productive evening there and got to talk to some of the developers, Tobias Hunger, Daniel Molkentin and Oswald Buddenhagen, as well as to Leena Miettinen (in charge of the Qt tools documentation), all of who I have to thank for their patience and the time they took to help me. After the visit and their great advice, I had some homework to do (fix some code style issues, add the documentation and code completion…) to get the plugin prepared for the MR. Now, it is finally available in gitorious, waiting to be reviewed by the QTC team! Let's keep fingers crossed!

Desktop Summit 2011: happy and proud.

2011-08-31T15:46:00.000+02:00

I know that it has been two weeks since the Desktop Summit 2011 Berlin came to an end, but I really wanted to write this post.

It is my desire to express loudly and publicly how happy and proud I am. Happy because everything worked better than good, because being a member of the organization has been one of the most gratifying (and also exhausting :-)) experiences this last year. As the volunteering coordinator, I could not be prouder of all the volunteers. You simply did a great job and made things happen. Thanks to the core team for being such a great one, to all the volunteers, also to all of you who volunteered at the last minute, and to all of the attendees for attending and for their understanding when things did not work right out of the box.

Working together with the KDE and GNOME community was a fantastic experience where I got to know lots of interesting people who I hope I will keep in touch with. I will miss all the KDE guys next year at GUADEC!

See you hopefully soon at any geeky conference!

Autotools Project Manager, part 2: The Plugin.

2011-08-05T17:14:00.001+02:00

During the last past weeks, as I already announced and as part of my trainee program at Openismus GmbH, I have been working on a plugin for autotools support to be used with Qt Creator. The project is still in an early state of development, but already offers some nice features and is ready for its first release.

What can the plugin do?

Load an autotools project and work with it in QTC.
Syntax highlighting for Makefile.am files.
Automatic project tree update if the Makefile.am or configure.ac file is changed.
Configuration of build steps (autogen, autoreconf, make and configure).
Build and run an autotools project from within QTC.
Automatic code completion.

Some ideas for the future:

Add syntax highlighting for the configure.ac file.
Detect whether autogen.sh runs configure, and allow the user to configure that, to avoid a second configure run.
Improve the parser. Autotools can generate several/different types of binares, libraries or other kind of targets. The current parser, checks for bin_PROGRAM binaries. If the output produces one of them, the parsing will be successful, if there are more, the parsing will not be successful. This should be changed to a more *Anjuta like* Makefile.am parsing style, which takes into account the existence of multiple outputs among other complex things. In the meantime, and as a suggestion of the Qt Creator's developers, I am using a ProjectExplorer::CustomExecutableRunConfiguration, which allows the user to choose which executable he/she wants to run, in case there is any.

How to use the plugin:

Download the project from gitorious.
Follow the README file for installation instructions.
See that the plugin is recognized and loaded by Qt-Creator, by selecting Help -> About Plugins in QTC. The AutotoolsProjectManager plugin should be listed as part of the Build System plugins.
Open an autotools project in Qt-Creator, using File -> Open File or Project... In the prompted dialog-box, select the Makefile.am from your project. This is the only way a user can use the autotools plugin. Thus, a Makefile.am must always exist before hand.
The first time an autotools project is opened with Qt-Creator, a dialog-box pops up and the user will be able to select the build directory. Qt-Creator then puts a .user file in the directory so it doesn't need to ask again. Only in-source building is working right now.
After clicking on the Finish button of the Autotools Wizard, Qt-Creator should show the project's tree structure at the left side hand. The root node should show the project name and all project files should be listed and editable from there.
At this point, building and running the application should work. This will execute autogen.sh or autoreconf, configure and make. The first time, when running the application, a dialog will ask you to choose the executable's location, then, QTC will remember it for the following times. Ideally, this will be changed in the future, to be done in a more automated way.
When selecting Projects->Build Settings from Qt-Creator on the left side bar, notice the typical autotools build steps (autogen.sh/autoreconf, configure, make). You may configure some parameters such as adding new configure parameters or changing the build directory (though, as I mentiond before, only in-source building is working at the moment).

As always, all comments and feedback is very welcome. Have fun!

Autotools Project Manager, part 1: Understanding QtCreator's Project Explorer

2011-07-28T12:27:00.001+02:00

It has already been more than one year since Peter Penz created a plugin for autotools support to be used with Qt Creator. In the meantime, Qt Creator developers have been busy, and having fun, rewriting several parts of the code, which, on the one hand, leads to nicer, improved interfaces, but on the other hand, to API breaks. So, it was time to "update" (redo) his work, and this is what I am currently working on.

For a trainee with a year’s experience, this is a more than challenging task: no experience developing for Qt Creator or with plugins, nor much experience with autotools, no documentation at all... In the beginning, I did not know how to start, nor if I could actually get something done at all, but then, with the help of the wisdom and patience of Peter Penz, David King and some of the Qt Creator guys, Tobias Hunger and Daniel Molkentin, things started to develop.

There is no documentation on how to develop a plugin for Qt Creator, so I had to spend a lot of time reading Qt Creator's code, in order to understand which bits I would need and how they were related. As I already said, this was very time consuming, so I have decided to write a series of posts, of which this is the first, to share what I learnt with you, and maybe save you some time in the future. As always, this is not meant to be a guide or tutorial; this is just what I did and how I understood it. I would be happy if this helps you deal with the huge monster that is Qt Creator, or even if I get some feedback on things which might be wrong :)).

Understanding some basics:
Qt Creator is a plugin loader and all its functionality is implemented in plugins. A very basic Qt Creator plugin has three different parts:

.pro file, which is the project file.
.pluginspec.in file, that provides some information about the plugin.
projectplugin files, with the implementation of the ExtensionSystem::IPlugin interface in a class.

Also, to give support for a new project type — in our case, the autotools project — we need to implement some interfaces in the ProjectExplorer plugin, which is what I am going to focus on in this post.

The ProjectExplorer plugin
The ProjectExplorer plugin is a set of classes and interfaces that make up the project management system in Qt Creator. Its architecture is detailed in the chart, and explained in the following lines:

The Project (ProjectExplorer::Project) is the whole project itself, and it is always associated with a MIME type (specified in an .mimetypes.xml file), which defines the kind of file the project will be indentifed by, when the project is opened in Qt Creator.

The ProjectExplorer::Project class loads the project and embeds it into the QtCreator project tree. Every project supports one or more Targets (ProjectExplorer::Target), which are the target environments for which the developer wants to build the project (desktop, Symbian devices and
MeeGo, among others).

A Target can have several BuildConfigurations (ProjectExplorer::BuildConfiguration), DeployConfigurations (ProjectExplorer::DeployConfiguration) and RunConfigurations (ProjectExplorer::RunConfigurations).

A BuildConfiguration (for example, release or debug) represents all that is needed to build the project for the target. Each BuildConfiguration currently has two BuildStepLists (ProjectExplorer::BuildStepList), which are a set of instructions to run. The first list is used to build, and the second one to clean up. The BuildStepLists contain BuildSteps (ProjectExplorer::BuildStep), which are the steps that need to be executed ("make", "make clean", etc.).

A DeployConfiguration contains a BuildStepList, and is used to deploy the aforementioned BuildConfiguration output into the right place for later execution by the RunConfiguration.

A RunConfiguration defines what needs to be run: usually the program that was built before. It could also be some set of unit tests, a script, some existing application which is used to test a library that was just built, etc.

You can also get an overview of what a generic plugin should implement by looking at the genericprojectmanager plugin example in the qt-creator/src/plugins/genericprojectmanager directory.

Have fun!

Remember, remember!

2011-07-06T23:21:00.000+02:00

Just 4 weeks left for the Desktop Summit in Berlin! Let's make it possible all together and sign up NOW as a volunteer! Deadline is July 18th!

Desktop Summit 2011 - Call for Volunteers

2011-06-23T16:55:00.001+02:00

This is the final count down and we need your help!

A community conference like Desktop Summit can only happen if you make it possible. It doesn't matter where you are from, how old you are, whether you have ever attended a Free Software conference... YOU can contribute as a volunteer.

Have a look to the official announcement now and join us!

See you there!

WHCH application icon!

2011-05-09T12:41:00.000+02:00

WHCH has a proper application icon now. All thanks to Kat and her great work. Thank you for making it possible!

WHCH v-0.2 is out!

2011-04-01T17:39:00.004+02:00

Working Hours Counter for Humans (WHCH) is growing step by step and little by little. I released the 0.1 version in January and it was already time for a 0.2 release with some new features.

What is new?

I made WHCH a single instance application. Every time the user tries to lunch a new instance, the window related to the current primary running instance will be displayed.

I added a desktop file and an icon image, so now the application is available from the desktop's menu. Regarding to the icon image, I am using a test one for the moment, taken from the Tango Desktop Project.

Now, each of the tasks available in the list of tasks, is followed by the client it is related to.

The start, end and duration time fields are exported into Mediawiki format in a more human-readable way and the total number of hours worked per week are calculated now too.

WHCH is now visible in and accessible from the notification area. If the user closes the window, the application will keep running in the system tray. When hovering the mouse over the tray's icon, a tooltip will display the time that has been spent on the task the user is currently working on.

What's coming next?
For the next release, I'm among other features, working on creating a 'History View'. As a consequence of this task I will need to rearrange some code and that is going to be a very interesting, and probably long, learning experience. Let's see what comes out of it!

If you are interested, you can find and follow the project on GitHub or download the tar.gz. As always, all comments are welcome, as are merge requests.

Thanks for reading!

Update:
I found and fixed a bug in WHCH regarding to the time counting displayed in the main view, and created therefore a tarball release for a new 0.2.1 version too.

Muktware.com interview.

2011-03-30T23:04:00.000+02:00

As I already wrote in my last post and as part of my trainee program, I have spent the last few weeks porting Cheese to GTK+3. In creating the new Cheese version, I collaborated, among others, with two other women developers: Luciana, who was responsible for the camerabin port and gobject introspection support, and Laura, who provided Cheese with SVG overlays support. It is already known that there are not many women involved in the development world yet, so seeing one of them might be considered kind of remarkable. Can you imagine the surprise when you find out that three of them are working in the same project? I think those were the thoughts that came across Swapnil Bhartiya mind when he decided to make us an interview for Muktware.com.

GApplication in Cheese.

2011-03-24T14:07:00.006+01:00

I have been working for the last few weeks on porting Cheese to GTK+3. I found some challenges along the way, and migrating from LibUnique to GApplication was definitely one of them, so I thought that this might deserve some special attention. New and more detailed documentation is now available, but I created a small flow chart just to have an overview of how GApplication works within a real application which is familiar to us.

Created using Graphviz (awesome tool!).

First of all, I want to make it clear that this does not meant to be a guide or tutorial, it is just what I did and understood. It worked and I am happy to share it with you and I will be happier if it helps you to deal with GApplication in the future or even if I get some feedback on things which might be wrong :)).

What problems did I face first?

GApplication is new, the documentation was not as detailed as it is nowadays and it was the first time that I had ever used it. I never worked with LibUnique before either, and the terms primary instance, remote instance and local instance were new to me. So, what was that?

With some reading and bothering David King for a while, I discovered how everything worked together and what those terms meant. If you are as confused as I was, this might help you:

Primary instance: The very first instance of the program, that means, the first instance you run. Example: Run firefox for the first time and there you have a primary instance.

Local instance: The very last instance you run from a program, this is the last one you started working with. Example: In our example, the firefox instance you started, would be at the same time primary and local. If you start a new firefox instance, then the first one would still be the primary, and the second one would be the local.

Remote instance: Every instance of the same application that is not the primary one. Example: In our example, the second instance of firefox that you run would be the remote one.

Cheese works as a single instance, and with a single window for that instance. Every time Cheese is called from a terminal with command line arguments, those are handled locally by the newly created instance, and here, GApplication::local_command_line() plays the main role. Every time g_application_run() is called, GApplication::local_command_line() is invoked. This function always runs in the local instance, which is the last instance you run.

By default, GApplication::local_command_line() tries to handle the command line in the primary instance, but since I wanted to be faithful to the original implementation, the purpose was to handle command line arguments locally, and for that, I needed to override the GApplication::local_command_line() function to make it return TRUE, and this is in essence what the diagram tries to explain.

This is how the main function looks like. (Cheese.Main inherits from GtkApplication which inherits from GApplication):

public int main (string[] args)

{

...

Cheese.Main app;

app = new Cheese.Main ("org.gnome.Cheese",ApplicationFlags.FLAGS_NONE);

app.activate.connect (app.on_app_activate);

int status = app.run (args);

return status;
}

I hope this is helpful, in some way, to somebody. As you can see, the diagram starts on the app.run(args) call. You can check out the source code on git.gnome.org, and for a more colourful version, in my GitHub repository.

I wanted to take the opportunity to thank David King for his infinite patience and help during my work migrating Cheese to GTK+3, Jürg Billeter for being so responsive and helpful in every single issue I had with Vala, and Carlos Garnacho for helping me out with some GtkStyleContext problems.

Thanks to all of them for the help and to you for reading!

Knock! Knock! on Planet GNOME.

2011-03-14T21:42:00.001+01:00

Hello, hola, ei je, hallo, shalom, kon-nichiwa, merhaba Planet!

I was very happy being part of this community, but now I am even happier having the chance to share my little knowledge and experience with all of you.

So, who are you? Well, as you might have figured out, I am the "new one". My name is Patricia Santana Cruz (patriciasc) and I come from the beautiful island of Gran Canaria, Spain, where I studied Computer Engineering at the University. After participating in a seven month Erasmus program in Germany, I decided to continue living and working in the country. And now, I am currently working as a trainee software developer in Berlin, at Openismus GmbH.

How have you contributed? All started at University, where I had the chance to do an internship as a Free Software Evangelist at our Free Software Office for one year. After that, and as a part of my trainee program, I had the chance to work on some small FOSS projects. My last contribution and the one I have been working on for the last weeks, was porting Cheese to GTK+3.

Something more to say? A lot! But I do not want to bore you, so if you want to know something more, do not hesitate to ask :). I will try to keep you informed in the meantime.

My Qt mini project: WHCH

2011-01-21T16:06:00.001+01:00

I have spent the last few weeks working on a new Qt mini project, WHCH ("Working Hours Counter for Humans"), an application for tracking the time spent on individual projects.

For this project I have used QtCreator 2.0.1 (with integrated QtDesigner), which has been a pleasant experience in almost all aspects, although there are two things I was not entirely happy with:

Its flexibility concerning to layouts in the design process. Murray wrote a good resume about this with some screen-shot examples.
Lack of in-depth documentation, in some cases. Although this was counterbalanced by the number of examples available.

I did not use autotools this time, but qmake, which was not such a frightening experience as I thought it would be. Again, the problem at this point was the documentation. At least there are some extra sources here and there to help with this!

What can you do with WHCH?.
- Keep track of the time spent on a task.

- Add new clients.
- Add new tasks related to clients.

- Add a detailed description for a task.
- Modify start/end time and description of a task.

- Export a list of tasks into Wikimedia format

obtaining the following result for the example in the screenshot:

There is still work to be done, as well as new features to be applied, and I already created a list of FIXMEs and TODOs to start with. Check it out and submit your new ideas if you fancy (-;.

You can find and follow the project on GitHub or download the tar.gz. All comments are welcome, as are merge requests.

Enjoy!

GNOME Development Documentation and Tools Hackfest 2010.

2010-12-07T10:51:00.000+01:00

I spent the last 4 days attending the Gnome Development Documentation and Tools Hackfest, which was held at Openismus offices in Berlin. The venue was just the most convenient for the event, since with such weather (-15ºC one of the days), the days turned to be very productive... no one wanted to spend much time outside!.

Almost all the attendees arrived during Wednesday evening and to compensate their (most of them) long journeys, we had a great dinner at the Massai's African restaurant (courtesy of Openismus). Hard work started the day after.

We spent almost one day trying to make an agenda with the topics we would like to cover during the hackfest and finally focused on two main themes, the "GNOME developer platform" and the "developer stories" or put another way, "who is going to use GNOME and what for?". After this, we did some brainstorming on the way we wanted to make this possible and some ideas came out.

First, we realized after some discussion, that most of the people find it difficult to know how to get started working on GNOME, so one of the agreement points from the very beginning, was that a platform overview needs to be done. Here, questions such as 'where is 'x'?' and 'what is 'x' for?', among others, would be answered. We also want to do this in a way that is attractive for getting developers involved and convince managers that GNOME makes the difference. After some more discussion and work, the idea took form and now you can already see the results in the form of a screenshot.

An other idea that we decided to put into practice, was the initiative of writing ten-minute introduction tutorials for various GNOME technologies (first in five target languages: C, C++, Python, Vala and Javascript) in order to show what kind of easy and amazing things one is able to do in a lunch break time period. I was involved in this team and my task was to create a very small simple image viewer GTK+ application in the C language (the tutorial is coming soon). For writing the documentation, we decided to use Mallard, so Schaun gave us a small and very useful introduction on it. You can see all the mini applications and some of the tutorials in the GNOME git repository. Please note that they haven’t been fully reviewed yet.

The hackfest went very nicely and the desire of being collaborative and helpful was present during the whole event. I am happy I was there and had the chance to meet all these people and be useful in a way. Thanks to everybody for comming, as well as to those who read in the planet GNOME that we were meeting, and just appeared by own iniciative in the office and joined us, like Konstantine or Clemens, which might join us at the Desktop Summit 2011 with some cool design thinking workshop again!!

MeeGo and The MeeGo Conference 2010.

2010-12-01T14:11:00.000+01:00

I was at the MeeGo Conference in Dublin. We were very busy from the first minute we arrived there until the last day we came back, and it was pretty productive.

But, what is MeeGo?
For those of you who do not know about MeeGo (taken from the Meego project Website):
"MeeGo is an open source, Linux project which brings together the Moblin project, headed up by Intel, and Maemo, by Nokia, into a single open source activity. MeeGo integrates the experience and skills of two significant development ecosystems, versed in communications and computing technologies. The MeeGo project believes these two pillars form the technical foundations for next generation platforms and usages in the mobile and device platforms space."

What was the conference about?
Sunday:
We arrived at the airport and went straight to the hotel, where we left all our stuff. Then, we decided to go for a walk to the center and try some Irish specialities. The center of Dublin is quite lovely!

Back to the hotel, we decided to go to the Aviva Stadium, where the conference was taking place (yes, in such an unusual and great location). There was a lot of work to be done before everything was prepared for the next day, so we helped a bit on this before we all went to bed.

Monday:
We started the day having a great Irish breakfast all together at the hotel and then went straight to the Stadium.

The whole morning was busy with Keynotes where AMD announced that it was joining the The Linux Foundation’s MeeGo project, and Intel announced that all Meego Conference's attendees would get a Lenovo s10-3t tablet netbook.

In the early evening I attended some different talks. I started with "Meego Infrastructure", where OBS (openSUSE build service) was introduced and followed with "Meego on BeagleBoard", which was interesting but I missed some practical or "in use" example. Afterwards, I went to some other talks about learning from past mistakes and designing Meego apps (which were not really focused on Meego).

In the evening, after a nice reception organized by Novell and doing some networking, the whole Openismus' crew went out together for dinner.

Tuesday:
We woke up very early to avoid the crowd and got tickets for the football match (Ireland vs. Norway) on Wednesday evening (courtesy of the organisation as well). We got those very easily but for the netbooks we had to stay in the queue a little bit longer. Once we got them , the organization gave us a pendrive with Meego OS on it, for a "do it yourself" installation·. I must admit, that I was kind of surprised when I turned the netbook on and saw that Windows 7 was installed on it... I would have expected some Open Source OS at least.

Some hours later, I got to know a Nokia representative who I talked with, about the new Qt mini project I am currently working on. Showing interest on it, he gave me an N900 in order to test on the device. What a day of presents!

I spent the rest of the day attending different talks. The ones I especially enjoyed were those based on designing apps for Meego devices and the ones focused on OBS, for instance, "Rolling your first package in the openSUSE Build Service (OBS)".

To finish the day, a party at the Guinness Storehouse was organized for the evening.

Wednesday:
This was an unconferenced day, so anybody who wanted to give a talk, could book his/her slot on a public board and just present it. The most interesting talk of the day was definitely LibreOffice's talk.

We spent the rest of the evening in the football match, well, I spent just the first part of the game watching it. Since I am not a football fan, I decided to spend the rest of the time inside chatting with some people. Norway won!

What did I learn and what are my impressions?
Although this is a very young project and there is still much work to be done, I had a good impression about the way it is developing and the whole infrastructure and organization behind it.

From the conference, I can say that there is a positive feeling and collaboratively-working community surrounding this new born and helping to make it grow strong. It fed more than enough attendees's curiosity concerning Qt Quick and OBS as well, the two star technologies in this project. Since MeeGo targets a wide variety of devices, they need very flexible developing technologies supporting them, and therefore, a large number of talks were focused on this two subjects.

I am very optimistic about this. Let's stay with our eyes wide open observing and contributing to make this baby grow up healthy!

Interesting links:
MeeGo Conference session videos.
MeeGo Conference 2011.

GHangtuxmm.

2010-11-08T15:01:00.000+01:00

As I wrote in one of my previous posts, I have been working on the conversion of GHangtux to GHangtuxmm, or in other words, on the conversion from C/GTK+ to C++/gtkmm.

For those of you who do not know about gtkmm (taken from the gtkmm project website):
"gtkmm is the official C++ interface for the popular GUI library GTK+. Highlights include typesafe callbacks, and a comprehensive set of widgets that are easily extensible via inheritance. You can create user interfaces either in code or with the Glade User Interface designer, using Gtk::Builder. There's extensive documentation, including API reference and a tutorial.

gtkmm is free software distributed under the GNU Library General Public License (LGPL).

gtkmm follows the official GNOME Platform Bindings release schedule. This guarantees API/ABI-stability and new releases on a predictable schedule, delivering C++ API for the underlying GTK+ and GNOME APIs as soon as possible." (from gtkmm project's website).

This has been fun again. Working on the project made me realize how laborious it can be to:
    - learn C++. What a monster!. This is all about experience, so my hope is that one day I will be the monster here, the C++ monster ;-).
    - convert an app that you have already developed into another language. The appropriate word here would actually be "rewrite" and not "convert", since you have to consider it as an entirely new project. Forget about what you did and focus on the new structure and libraries. This is a new project!
    - have a nice history in your repository... This takes practice, practice and more practice.

I am happy with the results so far although improvements are still being made. You can find and follow the project on GitHub where all comments and merge requests are welcome. Do not hesitate to do this.

Thanks for reading!

Back from "Qt Developer Days 2010".

2010-10-18T21:52:00.003+02:00

As I said in my previous post, I spent last week in Munich attending the "Qt Developer Days" and it was pretty interesting.

Monday:
Was focused on training, so as newbie in the Qt world that I am, I attended the Essential's track which gave me an overview on the topic and woke up my interest in the language even more. I just found Qt Creator a fascinating tool together with the integration of Qt Designer. Qt Assistant and its brilliant examples is not less in this family.

Tuesday and Wednesday:
I was able to attend the technical track. From all the talks, the ones that definitely captivated my attention, were those based on Qt Quick. Qt Quick (Qt User Interface Creation Kit) is a technology for creating UI's in a very fast way, using the declarative language QML, which allows the developer the usage of Javascript too. It is very useful for creating prototypes specially, although Mobile apps, and small desktop ones are a goal of this technology too. I am not sure if complex desktop applications are, but let's keep our eyes wide open...

Not all was learning and working. We managed to enjoy some food, beer and music from the area at Donisl's and on Wednesday evening, we managed to meet Murray for dinner and have a look to the Munich offices. Very nice!!

This week I will start my new mini-project on Qt and post about it very soon.

Thanks for reading!

Qt Developer Days 2010.

2010-10-06T17:11:00.000+02:00

Next week I will be in Munich for the "Qt Developer Days". I will be attending the "Qt Essentials" track and I presume it is going to be quite interesting and one of the best ways for doing my first steps in the Qt world. I am very happy that Murray asked us to go.

I will post again when I am back!.

Moving on to gtkmm

2010-09-01T16:12:00.000+02:00

I have spent the last weeks trying to improve some parts of GHangtux. One of the improvements (the more obvious and complicated one), came with the code restructuring.

BEFORE, all the code was divided in three different files:
- main.c: all code for the program except for the keyboard widget.
- keyboard.c/.h: keyboard widget code.

This structure made the code easy to read at the very beginning, but was obviously a bad idea for the long term. Actually, you should always divide your program in small modules although you think is going to be a very tiny one. It might be now, but who knows what is going to happen in the future. Also, you help to make this code reusable for other programs or programmers. So, mental note: always use modular code from the beginning!.

NOW, the code is divided in ten different files:
- ghangtux.c/.h: main program and definition of main structures.
- ghangtux_ui.c/.h: user interface.
- ghangtux_management.c/.h: functions for game management.
- ghangtux_utils.c/.h: auxiliary functions.
- ghangtux_keyboard.c/.h: keyboard widget.

After all the new code structure was ready, I decided to set up GTK-Doc to document GHangtux in a proper way (still need to finish commenting the functions), which brought me to the eternal discussion "recursive or non recursive Makefiles?". GTK-Doc documentation gave me the impression that I HAD to use recursive make with no explanation and no other chance. After some research and discussing about it with Dave, we found the way to do it "my way", that means: non recursive. You can read Peter Miller's excellent paper to learn why recursive make invocations are both slow and error-prone.

Happy with the results so far, I moved on to "convert GHangtux" to gtkmm, so now I am busy reading "Accelerated C++" and "Effective C++". Let's wait for the magic to happen soon ;).

Take care!

I was at GUADEC 2010

2010-08-18T14:13:00.000+02:00

This year was my first time at GUADEC, and it was just great. I have got to chat to people involved in the GNOME shell, usability and accessibility programs and got in touch with the members of the "Gnome Women" group as well. But not everything was chatting and socializing. I attended several interesting talks as well: clutter, state of union, GNOME shell... and joined a very handy workshop about "Design thinking" by the hand of the Invented Here guys. Pheeww, I am still trying to process all the new information!.

Back to chatting and socializing, more fun came at the evenings with the Canonical Party (first GUADEC where people danced I have heard), Collabora barbecue and the hackfest at Revelation Space.

Big news during GUADEC?
- The release of GNOME 3.0 have been pushed back to March 2011, but at the same time, The GNOME Project will ship GNOME 2.32 in September, along with a preview release of GNOME 3.0. Several distributions will ship GNOME 3.0 components that can be used for user previews or developer testing.
- An announcement was also made about the location for GUADEC 2011. Applause for Berlin this time!.

This year the Openismus crewed surprised all attendants with our new "Sommer/Autumn 2010 T-shirts collection". All thanks Kat.

I know..., envy is the word you are looking for ;). Hopefully I get the chance to go to GUADEC again next year.

GHangtux 1.0

2010-07-23T12:23:00.006+02:00

Wondering, what I have been doing the last few weeks?. GTK+ is the answer, GHangtux 1.0 the result, and since we all know that a picture is worth a thousand words I go just straight to the introductions: "World, this is GHangtux, GHangtux this is the world".

What is GHangtux?
GHangtux is a free program variation of the popular Hangman game. It has been designed for people of all ages and has a simple, easy-to-use interface.

It provides a keyboard and a sentence/word to guess, whose theme, the player is able to select. Current themes are: films, objects and persons.

During the game, a graphic sequence of tux images will be displayed, indicating the player how many attempts he/she has left.

How to "create life" from some code lines?
1. Getting familiar with GTK+. As I wrote in the last post, I spent my first weeks at Openismus learning GTK+ and to put this into practice, I worked in a very small but helpful project. "Foundations of GTK+ Development" was very useful in this learning process and gave me a good base.

2. Making and correcting mistakes. The next step was to learn about all those mistakes I made, to repeat them and to relearn from them again. This is part of every single step actually.

3. Testing the new knowledge. After the first two steps, it seemed that I was prepare to start my first simple GTK+ application which is the very early version of the game.

4. Creating a custom widget. After playing with GTK+ a few more weeks, I decided to create my own custom widget: the game's keyboard. For this step, I found Davyd Madeley's clock widget tutorial quite handy.

5. Integration of the custom widget in the early version of GHangtux. This is the last version of the game.

What is coming next?
- Internationalization with i18n.
- More themes.
- More image themes.
- Shortcuts for the menus.
- Others: clutter, desktop files...

"Side effects" of having developed GHangtux?
- Learning Git and discovering how powerful this tool is.
- Learning Autotools helped by Alexandre Duret-Lutz's tutorial, and some Openismus manuals.
- Practicing C.
- Practicing Glade.
- Programming style.
- Improving my communication skills.

You can follow the project under the repository in GitHub or download it in .tgz or .zip. All comments are welcome, as are merge requests.

Enjoy!

First weeks at Openismus

2010-06-14T12:26:00.003+02:00

Yay! Almost one month since the last time I wrote. I need to improve this :). There is a convincing excuse though. Since I started my job at Openismus, another evening full-time job came out: the search of my new apartment!. It seemed to be an easy task at the beginning, but now it just turned into a complicated competition. I have just realized that writing in your presentation e-mail that you have something to do with informatics may probably be not that popular. Being non-smoker seems to be another problem too.

At last, things at work could not be better. During the first week we dedicated our time to install Fedora 13 in our computers. Apart from some issues with our keyboards concerning to the language layouts, everything went fine. We learnt to know as well, how the "internal communication system" here works and joined some lists to be up to date with all project's news. Then we started with jhbuild!. That was definitive lots of fun: is there anybody that run it without having to fix at last 2000 errors? ;). Thanks God or whoever, Chris, David and Saint Google were there for support. We actually learnt a lot.

The second week started really good since we finished fixing the jhbuild's errors, and moved on to GTK+. I was busy with this till Thursday. On Friday and Saturday we went to the Linux Tag here in Berlin and attended a series of interesting talks about MeeGo, systemd, Google, Ubuntu and Gnome 3.0. The talks were interesting, but more business-orientated in general from my point of view. However, the best part of this kind of events are the "after-talk-times", where you get to know some people involved on different open source projects or people that work / worked in the same company you do and still did not know. Better chances of socialization came in the evenings with the barbecues at C-Base!.

Well, now it is time I stop writing here and go on learning some GTK+, since I have to present some legible code today.

See you soon!

CERN openlab summer students programme 2010

2010-05-19T22:38:00.012+02:00

I wake up and look through the window, the weather is OK, not that bad, not that good. I still do not have curtains because I moved for three months and did not have time to put them or had just better things to do (there are actually always better things to do than this). Next stop: the bathroom. There I wash my face. I go to the kitchen and start the kettle in order to make some tea for having breakfast. I turn on the radio to hear the news. I can not really hear the news with the noise of the kettle boiling the water. Water is ready and I prepare a cup of tea, for one, and to take away. I "take it away" back to my bedroom and turn my computer on in order to check my e-mails and read the news (I did not really pay attention to the ones on the radio, but I like to hear the sound on the background when I am at home, I love to listen to the radio). No remarkable news, no remarkable e-mails... wait.... what is this?. E-Mail topic: CERN openlab summer student programme 2010. I make click on the topic and a new screen shows the content of the e-mail:

"Dear Patricia,

We are pleased to inform you that you have been selected as an openlab summer student 2010 [...]"

More good news for this year, however, at this point I was looking in another direction. I am just looking forward to start my trainee at Openismus on the first June.

Count down... 21, 20, 19...

2010-05-11T23:34:00.006+02:00

The count down for moving to Berlin has just started, and the list of things needed to be resolved before doing it is getting bigger and bigger:

01. Bank account cancellation (done)
02. Cancell city hall registration (done)
03. Cancell Sportspass registration (done)
04. HVV Abokarte cancellation (done)
05. Finding someone new for my room (done)
06. Selling my room's furniture (done)
07. "Rent" a friend who will drive that car (done)
08. Rent a car for moving ( still in process)
09. Packing (still in process)
10. Goodbye parties (still in process)
11. Unemployment registration + fill in of N forms. N definitely tends to infinite (no way)
12. Others

It is not a bad recount. In the last weeks I have discovered without surprise that German bureaucracy is a lot of fun. Every time a went to the employment office, they gave me as a souvenir at last three different forms (poor trees!!) and had to go at last to three other different places in order to fill in the forms or collect information to complete them (plus side effects: annoying Murray and Kat. Sorry about that). That means, I have been going there every morning for the last week. It might be easier if I just live there for a while I guess.

Good news: my mother is finally visiting me!. After two years in Germany, it seems that it will happen. Well... just if Eyjafjallajökull does not get angry these days.

I am so excited about everything new that is coming!

Connecting dots till Openismus

2010-04-28T23:16:00.046+02:00

"[...] If I had never dropped out, I would have never dropped in on this calligraphy class, and personal computers might not have the wonderful typography that they do. Of course it was impossible to connect the dots looking forward when I was in college. But it was very, very clear looking backwards ten years later.

Again, you can't connect the dots looking forward; you can only connect them looking backwards. So you have to trust that the dots will somehow connect in your future. You have to trust in something — your gut, destiny, life, karma, whatever. This approach has never let me down, and it has made all the difference in my life. [...]"

Steve Jobs. 'You've got to find what you love'. Stanford Report, June 14, 2005.

One day you wake up and something important that makes a great difference in your life happens. You do not know, but if you look backwards connecting dots in your life, you will realize that in the last years, the whole universe was conspiring to make it happen: learning a new language, deciding to stay in a foreign country, skills...This happens just a few times in life (if you are lucky) and are moments marked with a mental big red cross reminding you where your past ends and the new beginning starts. Moments that have the ability to make you redo your life: new city, new flat, new life... For me, this moment has the name Openismus and here is where I am going to be doing a trainee program for the next year. [Here's Murray's announcement]

Joining the FSO in 2006, at the university where I did my studies , gave me the oportunity to introduce my self in a deepest way in the free software world. Since then, I had gotten interested in the dynamics of open source projects and now I am sure that I am in the rigth place for feeding this interest.

Welcome on board to the beginning of your new life Patri!