Planet XMMS2

Gearing up for Summer of Code 2010

2010-03-08T04:02:24+00:00

We want to participate in the Summer of Code program 2010! There is a lot of things to do, write the application, propose projects, become a mentor! Please join us at the XMMS2 Summer of Code 2010 portal and contribute!

Y ahora en Planet Python México

2010-02-28T06:39:41+00:00

…pues eso, que ya no solo pertenezco a Planet Linux México, o Planet XMMS2 si no que recién iniciado el Planet Python México me integre y me siento muy contento de pertenecer a Planetas donde cubran temas que son de mi completo interés y les agradezco a todos por tomar en cuenta mi humilde blog.

Enlaces:

Planet Linux México
Planet XMMS2
Planet Python México

Desde codeplasticlesthack les digo GRACIAS !!!

XMMS2Con

2010-02-21T12:30:41+00:00

I am on my train back to Gothenburg from Malmö where I spent the weekend with the cool XMMS2 people. I think everything went very smooth and it was very very productive. We got a lot of things done and a lot of code merged. I will outline some of the highlights in this post, as I am certain that other participants also will do in their blogs.

First of all, 0.7 DrNo was released. This was the first thing we did, even before the Con started. It was way overdue, it actually was almost a year since we did the 0.6 DrMattDestruction release. There are a lot of reasons for this very delayed release. I think most of the people in the team are starting to feel the effects of their "real life". Some have become fathers, others has been busy with work, school and other activities that has to take precedence. But as always, when we get together and get to it, we get a lot of work done. I think I am not the only one to feel a bit energized and have a lot of ideas that would be cool to realize, let's see how long that lasts this time :-)

The most discussed topic on the Saturday was GenIPC. What is GenIPC you might ask yourself? Well if you have been around and tried to write any XMMS2 bindings at any point you know that it involves a lot of manual labour for wrapping all the functions the server implements. GenIPC is the answer to that. Our plan is to have the IPC definition in a XML file, which then can be used to generate the code for each binding. One of the benefits of this is that it will be easier to add new functions to all bindings, the other great benefit is that it will be easier to implement native bindings for all languages, since you only need to write the serialization and the code generator and the rest will be taken care of for you. Tilman have done some great work with GenIPC and the server side of it was merged directly after the DrNo request. On Saturday Tilman, Anders and Henrik discussed a lot of improvements for GenIPC in order to allow for function overloading and default arguments. This work is now well under way and I hope to see it in the master branch pretty soon, since I want to convert native Qt4 bindings to GenIPC and also finish my Objective-C bindings.

Next big project that Seb and Daniel looked at was S4. S4 is our homegrown database backend that is supposed to replace the SQLite backend we have now. The rational behind this is that we horribly misuse the SQL part of SQLite and forces our datamodel it. This leads to bad performance, lot of code overhead and so on. S4 solves this by introducing a datamodel that fits our use case a lot better. Preliminary tests shows that S4 is a lot faster when you have a lot of entries in the database, in fact the only time it's slower is when you do advanced queries that uses regex matching and that's slow almost everywhere :-) This will probably be reworked so that we don't use regex, but rather globbing as we had with SQLite. I hope to see S4 merged soon.

We did have some talk about workflow and how to improve the visibility of the topic branches and we have started to try out Gitorious, I hope that everyone will be satisfied with it. I think that workflow discussions warrants it's own blog posts so I will try to write it up later in the week. In the meantime you can checkout our Gitorious team page. And if you want to get in on the action, just tell me or Anders.

Next big step which also warrants it own blog post will be about our information reorganization, redesign of wiki and move to xmms2.org instead of xmms2.xmms.se. Stay tuned.

Oh, and thanks to everyone that came out, I had a great time organizing it and I am more than willing to do it again. I also want to make sure to thank Purple Scout AB for hosting us, if you attended and liked it, drop a line to twitter or on your blog to thank Purple Scout as well.

XMMS2 team is trying out Gitorious

2010-02-20T14:39:38+00:00

During the XMMS2Con (which is awesome by the way) we discussed how to improve the workflow, one thing we talked about was to improve the merge tools we have. We ended up trying gitorious instead. You can check out the XMMS2 team page on gitorious here and if you are a developer, please register and notify Tobias or Anders and they can add you to the group. Also leave feedback on how gitorious is working out for you.

XMMS2 0.7 DrNo release and XMMS2Con

2010-02-20T01:39:28+00:00

Yesterday we released DrNo, download at sourceforge. This is the first release in almost a year. We hope that we will get to it. Also today is the first day of XMMS2Con, it's hold at Purple Scout offices in Malmö, Sweden. About 10 of us will hopefully bring some new XMMS2 awesomeness during the weekend. If you are close to Malmö just pop by Purple Scout :)

X2T beta (XMMS2 + Twitter)

2010-02-07T07:42:34+00:00

Bien, pues he decidido liberar una versión beta de este proyecto que en el post anterior había mencionado. Se que la aplicación no es novedosa y que la idea de “twittear lo que escucho” a primer instancia suena interesante pero con el paso del tiempo se vuelve hasta cierto punto fastidiosa.

Sin embargo, he considerado que ha sido una buena forma de entretenerme aplicando algunos conocimientos hasta ahora estancados por cosas del trabajo y escuela. Me he divertido de lo lindo; aprendí muchas cosas que solo tenía en concepto, pero, que no había tenido la molestia de sentarme a practicarlas.

Y sacandole un poco de jugo a esta sencilla aplicación decidí darle algunos toques mas:

Sería una aplicación sencilla con 3 Tabs.
- About: Sencilla descripción del App.
- Connection: Conexión a Twitter (usuario y password)
- Preferences: Anexe un Grid para parámetros que en un futuro podrían añadirse a los actuales que son.
  - Filter: Formato del texto a mandar a Twitter.
  - Active: Si deseamos logearnos en Twitter al iniciar la App
  - Mode: El modo que bien puede ser “Twittea todas las canciones” o “Twittea solo las que te digo”
TaskBarIcon: Un icono en la barra de tareas el cual me permitirá esconder o visualizar la App, y mostrará un menú con algunas acciones.
FileConfig: El cual me pertira salvar la ultima configuración hecha por el usuario.

De entre las cosas que estuve aprendiendo (y que aun lo estoy por que es constante) fue el uso de las librerías gráficas wx para las GUI’s sobre python, y ya que heredan mucho de C, la cosa pues puede parecer tan fácil o complicado según se vea.

Como muchos desarrolladores me valí de wxGlade para el diseño de las interfaces que poco después se pueden mejorar en rendimiento codificando a mano (gracias a mi querido gEdit + plugins) y que puede ahorrarnos mucho tiempo.

En cuanto a la programación pues verán, el uso del middleware python-xmmsclient es básicamente sencillo, salvo claro que para capturar los cambios en el reproductor (cambio de canción) fue necesario implementar llamadas asíncronas con el servidor para después darles salida a twitter.

Otro aspecto que me pareció interesante manejar fue el uso de archivos de configuración, y ya que python cuenta con algunas librerías que nos facilitan el trabajo, no dude en usarlas. ConfigPaser es una librería que me permite editar los archivos de configuración de manera natural, sin rodeos pues y de la que recomiendo le den una checada.

Y por último pero sin dejar de lado, el uso de la clase TaskBarIcon de wx para implementar un icono en la barra de tareas el cual al dar doble click me permite visualizar la app, o click derecho para un Menú con algunas acciones como las que podemos ver en las imágenes.

Pongo a disposición de ustedes el código, ya sea para su uso, desarrollo, o simplemente por curiosidad de ver lo que ya detrás del desarrollo con Python, wx, XMMS2 y Twitter.

Código Fuente

svn checkout http://x2t.googlecode.com/svn/trunk/ x2t-read-only

Actualización: 9 de Febrero del 2010

Parametros:

Filter:

%artist
%title
%album
%url
%sample_format
%mime

Active:

0: Logearte al iniciar al aplicación
1: Logearte solo al dar conectar.

Mode:

0: Twittea todas las canciones.
1: Twittea solo las que yo indique en “Tweet this song”

x2t Proyect (XMMS2 + Twitter)

2010-02-02T07:01:28+00:00

En algunas ocasiones se me ha ocurrido “quiero twittear lo que estoy escuchando”, y me refiero a algo automático para que no tenga que escribirlo yo mismo.

Así que decidí programar una pequeña aplicación que lo haga, que tenga la bondad de darme a elegir si esta activa o inactiva, o bien establecer el formato en el que deseo que aparezca en twitter; así que hice manos a la obra y comencé a programarlo.

La elección del lenguaje como muchos ya se podrán imaginar es Python, por lo que usare el middleware de python-xmmsclient.

La instalación obviamente involucra al servidor XMMS2 y xmmsclient así que podriamos hacerlo simplemente así.

# apt-get install xmms2 python-xmmsclient

Lo interesante aquí es el desarrollo de un cliente XMMS2, eficazmente sencillo, aunque encontrar información acerca de la librería puede resultar un poco complicado y al hacerlo es posible que para nuestra elección de lenguaje venga muy incompleta.

Pero esto no significa que no logremos adaptarnos fácilmente, es la ventaja de las api’s estandarizadas, así que nuestro primer paso será hacer conexión con el servidor.

Una conexión básica con el servidor sería:

#!/usr/bin/env python
import xmmsclient
import os
import sys
 
xmms = xmmsclient.XMMS("miCliente")
 
try:
	xmms.connect(os.getenv("XMMS_PATH"))
except IOError, detail:
	print "Conexión fallida:", detail
	sys.exit(1)
 
result = xmms.playback_start()
result.wait()
 
if result.iserror():
	print "Error al reproducir, %s" % result.get_error()
else:
	sys.exit(0)

Como nos podemos dar cuenta, la conexión resulta muy sencilla, os.getenv(“XMMS_PATH”) nos devuelve el valor de la variable de entorno, y así nos permite saber si el servidor esta activo o no ya que al no estar corriendo, la variable no existe.

Por otro lado, una vez establecida la conexión podemos acceder a las acciones directamente del objeto xmms que creamos al iniciar el script, por ello, al ejecutar xmms.playback_start() le damos la orden al server de reproducir lo que tenga en cola, aunque no se ejecutará si no hasta haber llamado a xmms.wait().

Si por algún motivo no es posible reproducir algo, el objeto xmms arroja los errores (result.iserror()) que ocurrieron y así nosotros podemos controlarlos.

Podemos encontrar mas información sobre el desarrollo de clientes XMMS2 aqui por si estas interesado en ir mas a fondo, por mi parte trataré de ir con calma documentando lo que estoy desarrollando.

Una sugerencia podría ser desarrollar un pequeño engine de nuestro cliente, y así, hacernos la vida mas fácil para próximos desarrollos.

Hasta esta parte, todo ha ido claro me parece, aun no he tocado el tema de twitter así que ahora veremos algo al respecto.

Existen muchas librerías que podemos usar para nuestra aplicación, pero la que me sedujo fácilmente fue python-twitter (chales, eso fue un capumm). Python-Twitter es un proyecto que vienen desarrollando un grupo de developers, y resulta tan intuitiva que usarla será cosa de risa.

La librería viene incluida al igual que python-xmmsclient en los repos de Debian Lenny.

# apt-get install python-twitter

Y su uso es tan sencillo que el siguiente script resultará muy explicativo.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import twitter
 
mytwitter = twitter.Api("miusuario","mipassword")
 
status = mytwitter.PostUpdate('probando python-twitter')
print status.text
 
statuses = mytwitter.GetUserTimeline()
 
for s in statuses:
	print s.text

Así es, importamos librería, creamos objeto, hacemos una publicación con el texto “probando python-twitter”, imprimimos lo que enviamos, pedimos el Timeline y lo iteramos imprimiendo los textos. Sencillo no ?

La documentación completa la podemos ver aquí.

Con esta información será posible el desarrollo del cliente x2t que tengo en mente, de hecho, he diseñado una pequeña interfaz que solo ocupara un mínimo de opciones como establecer nombre y password de twitter, un filtro el cual me permitirá definir el formato de mis tweets, y si esta activo o no el servicio.

Está es por ahora la propuesta.

Y por lo pronto esto es todo lo que puedo comentar, estaré trabando en este pequeño proyectito por las noches y espero no tardar demasiado en anunciar como ha quedado.

Now in Planet XMMS2

2010-01-29T00:59:32+00:00

Today, i want to thanks the guys of Planet XMMS2 by add my feed. You know that i’m interested in developing for XMMS2 clients, and therefore i’m developing XMMS2 Client called Angel. Althought is developing even.

Thanks guys.

Multi-scrobbling at last!

2009-12-30T17:15:24+00:00

New XMMS2-Scrobbler release. Better than ever: multi-scrobbling is supported now. libre.fm users rejoice! See README for the details.

Mobilblogg for the iPhone.

2009-12-27T21:22:19+00:00

For a long time I haven't been able to develop anything constructive. It's been a severe code block that has been lasting for years. That's why it so fun to now announce some of my recent projects!

I decided to really learn Objective-C back in November. At work a customer requested a iPhone application and I was the only one that knew anything about Objective-C, so I was asked to join in a customer meeting telling them that I really knew Objective-C and iPhone development. So instead of lying my ass off I sat down and tried to get some coding done.

Eventually the customer didn't want to pay for the application so the project was never started, but I really learned Objective-C. And it resulted in my first iPhone application! It's a dedicated client to the MobilBlogg community. Together with Henrik Öhman of MobilBlogg (who did the API) an application to browse, upload and comment on photos was created. The application is submitted to Apple, who knows when it's going to be accepted :-)

The application is Open Sourced under the GPL license and you can check out the sources here.

The application could never had been made without other brilliant open source code: Three20 and JSon Framework. If you want example of using these frameworks, checkout my code.

To view screenshots and photos uploaded with the application head over to my mobilblogg!

Internet Explorer strips leading whitespaces in text nodes

2009-11-07T17:13:07+00:00

For some mysterious reason, Internet Explorer (tested in IE7 and IE8) strips leading spaces in text nodes preceded by an empty element, such as this:

[code lang="html"]

foo

[/code]

While innoccuous in static pages, it becomes problematic when DOM nodes get updated after a delay by some Javascript, as the separating whitespace has disappeared, hence ruining the layout of your text.

Surprisingly, I haven’t found any reference to this IE bug (not that there is a shortage of complaints about other IE idiosyncrasies), so I thought I’d share the problem and the solution I have found here. It’s all demonstrated in the following example:

[code lang="html"]
!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

world

[/code]

In the first case, the whitespace gets stripped, thus resulting in “Helloworld”. In the second example, the non-breaking space prevents IE from stripping the whitespace, so that when the span is filled by Javascript, the text reads “Hello world” as expected.

If you know other solutions or whether it’s considered a bug that will be fixed, please post in the comments!

“XMMS2 Collections” presentation at Metaweb

2009-11-07T16:46:27+00:00

On my way to the Google Summer of Code Mentor Summit 2009, I accepted DraX’s invitation to give a 1-hour talk about XMMS2 Collections at his work, i.e. Metaweb, in San Francisco.

The topic was somewhat relevant for them as it’s reminiscent of MQL, the query language they developed for Freebase. It’s worth noting that although both share a pool of buzzwords such as “graph”, “loosely-structured”, “querying”, etc, they are not quite the same:

Freebase is essentially a giant graph-database, which you query with MQL to retrieve graph fragments.
The XMMS2 database is a flat denormalized store, which you query with graph-structured Collections to retrieve a list of entries.

Note: Collections 2.0 should however allow fancier querying to retrieve tree-shaped structures.

About 10-20 people showed up and listened to me blurbing about the concept of Collections, the rationale behind them, the API, Collections 2.0, possible UI uses, what it represents for the user, pointers to S4, etc.

It’s all in those over-engineered slides that I have no choice but to put online, under Creative Commons Attribution-Share Alike 2.5 License, for them to live on forever on the internets. And yes, it’s still either in evil Keynote format (source), or in PDF.

Oh and Metaweb, thanks for the food!

XMMS2 Conference 2010 announced

2009-09-23T05:27:36+00:00

We are planning to do a XMMS2 Con next year. Please visit this page to announce your interest: http://wiki.xmms2.xmms.se/wiki/XMMS2Con2010

Parameterized Roles with MooseX::Declare

2009-08-19T08:27:25+00:00

You've probably already heard of Sartak's awesome MooseX::Role::Parameterized.

As of version 0.25, MooseX::Declare provides some nice sugar for that. This is what it looks like:

use MooseX::Declare;

role Counter (Str :$name) {
  has $name => (is => 'rw', isa => 'Int', default => 0);

  method "increment_${name}" {
    $self->$name( $self->$name + 1 );
  }

  method "reset_${name}" {
    $self->$name(0);
  }
}

class MyGame::Weapon {
  with Counter => { name => 'enchantment' };
}

class MyGame::Wand {
  with Counter => { name => 'zapped' };
}

Just thought I'd let you know, since i haven't gotten around to actually document this. In case you like it, have some spare tuits, and want to help out, the repository is right here :-)

Software engineering is.. dead?

2009-07-20T17:22:36+00:00

IEEE Software recently published an opinion piece from Tom DeMarco titled â€˜Software Engineering: An Idea Whose Time Has Come and Gone?â€™ in which DeMarco appears to declare the death of â€˜Software Engineeringâ€™ as a discipline. Unsurprisingly, this is generating some waves in the tech blogging community, with pieces such as â€˜Software Engineering: Dead?â€™ from Jeff Atwoodâ€™s Coding Horror, and Myles Eftosâ€™s â€˜Yep, Software Engineering is deadâ€™.

From reading DeMarcoâ€™s article, it is apparent that what he is addressing is the emphasis placed on â€˜controlâ€™ on software projects - that â€˜software engineeringâ€™ is often taken to mean that itâ€™s a means of controlling the outcomes of developing a software project. It should be obvious that DeMarcoâ€™s stance is one of reflecting upon his previous work and making some comments about how his work has been perceived in the software industry over the years. Aside from some â€œAw shucks, I wish my younger self had been wiserâ€ style reflection, DeMarco laments the fact that his work has been used over the years to justify the creeping bureaucratisation of the software development process. From that point, DeMarco goes on to prescribe that, rather than controlling minutiae, those in charge of software development should be treating their projects (by way of analogy) as unruly teenagers - by attempting to instil a sense of moral values and principles, rather than by being overbearing and all-controlling.

Unfortunately, Jeff & Myles appear to either be sensationalising, or reacting to a rather superficial reading of DeMarcoâ€™s opinion. Straight off the bat, Jeff points out DeMarcoâ€™s gravitas in his field, to hammer home the point that â€˜yes, this is a big dealâ€™. From there, however, Jeff switches to his usual agenda of elevating the romantic notion of â€˜software craftsmanshipâ€™. Not that Iâ€™m averse to this position - au contraire, Iâ€™m a big fan of Jeffâ€™s frequent expounding on matters of software development principles. What I disagree with, however, is the utter sensationalism with which this is being made here. At least, I am heartened that Jeff appears to have grasped the main point of DeMarcoâ€™s analogy: â€œIf you want to move your project forward, the only reliable way to do that is to cultivate a deep sense of software craftsmanship and professionalism around it.â€

I have no idea what has been said about either DeMarcoâ€™s piece or Jeffâ€™s blog post on the 220 mailing list, though reading through Mylesâ€™ blog post left me slightly incensed at certain points. The analogy between building a bridge and building software is somewhat tired. Compared to building bridges, building â€˜softwareâ€™ encompasses a vastly larger scope. That much we agree on. You might as well be comparing building software with building anything made of materials sourced from the ground. From here, however, it seems that Myles launches into a tirade about his least favourite academic subjects, or at least the ones that he found â€˜stupidâ€™. What I fail to grasp at this point is the relevance to DeMarcoâ€™s piece… But Iâ€™ll play along anyway.

Yes, formal proofs are arduous, and can be rather silly for trivial programming tasks, but it should be obvious that such techniques arenâ€™t applicable to all software development contexts. Would you apply formal proof methods to a small dynamic website youâ€™ve just built? Hell no. Would you apply formal proof methods to mission-critical software that could potentially lead to injuries, fatalities or serious damage to the environment or property, if anything were to go wrong? Hell yes. (Well, some variant of a formal method, anyway) Itâ€™s a simple cost-benefit (or risk analysis) scenario: which costs less - the development process, or the consequences of something going seriously wrong? Iâ€™d further argue that formal proof exercises done in an undergraduate academic setting would be more geared towards teaching and learning the process of doing the proofs than anything else. This is undergrad CS that weâ€™re talking about, with its endless assortment of silly assignments that require students to produce little of value beyond the end of their courses. I might also add that, even with a â€˜simpleâ€™ program having 9 lines of code, this degree of simplicity may be afforded by a myriad of much more complex underlying supporting systems - the degree of simplicity of a program may simply be a matter of perspective, or from where youâ€™re standing to look at the code.

What I find most troubling about Mylesâ€™ post, however, is the complete denigration of UML. Yes, Iâ€™ll admit that Iâ€™m a big proponent of UML. There may be a point about UML working really well with the waterfall model of software development, but to then imply that UML is almost completely useless - by association with the inadequacy of the waterfall model to address â€˜realâ€™ problems - seems a lot like missing the point of what UML is actually about. Yes, UML may superficially look like â€˜architectural drawings or flow diagrams or somethingâ€™. More importantly, UML is a standard notation to communicate about elements of software design. Beyond the ability of expensive software to create specky, neat and professional looking UML diagrams, UML itself is a tool for software developers to use when thinking about, crafting and communicating about the systems theyâ€™re building. By analogy, I would say that an ability to work with UML is like an ability to work with words and sentences and paragraphs. That is probably the reason why IT recruitment agents started using â€˜Object Oriented Analysis & Design Skillsâ€™ and â€˜Sound understanding of UMLâ€™ in their job ads - those *are* fundamentally useful skills to have.

As a programmer, I can have a conception of something that is a â€˜classâ€™ or an â€˜objectâ€™ and be able to express the idea in a diagram, say on a whiteboard, while talking with fellow programmers, and still be able to more or less directly translate this concept into code using Java or Python. Using UML, I can model relationships between such classes and talk about such relationships - beyond mere representation, UML can be a valuable tool for solving software design problems, especially in team environments. [And the good news is that there are tools nowadays to automate parts of the translation between UML and code, so you donâ€™t have to â€˜go and update hundreds of UML documents every time a minor change was requiredâ€™] None of this is really dependent upon the specific project management methodology being used. The real problem, as far as IT recruitment is concerned - at least in this region anyway - is that there is often a disconnect between what software development shops need and what their recruitment agents end up publishing. Given that IT recruitment agents are often more experienced in HR and marketing, they end up developing formulas for easily pushing job ads out there seemingly without much consideration for what is really required. That is how you end up with a litany of job ads that look like the same stuff rehashed over and over again. Thanks to all this, graduates who do have such skills end up in jobs which are advertised as requiring their skillset, yet never use them in any useful capacity.

Getting back to the main article, however - the point that DeMarco is trying to make here is rather subtle, one which can best be understood in the very context of his analogy. Developing software, in general, applies to a vast field of human knowledge and applications. As such, decisions about how software should be developed necessarily need to vary based upon the context and constraints within which such development is occurring. By way of analogy, humans, as they grow into adults, cannot be robotically programmed to gracefully handle every possible situation they might encounter. (Or, at least, one could imagine that this approach could fail rather disastrously if tried) Given these limitations, it is far better to learn about core principles and knowing how and when to apply them to produce generally favourable results. DeMarcoâ€™s point is that, as this applies to humans, that may be the real way forward for software development.

p.s. Some interesting and relevant articles relating to this topic:
- â€œIs Software Engineering Engineering?â€ - Peter J. Denning, Richard D. Riehle
- “Software Engineering â‰ Computer Science” - Chuck Connell

Good discussions about copyright control

2009-07-16T16:56:46+00:00

Over at The Digitalist blog there is a very good discussion about eBook DRM. Cory is excellent as usual but the highlight must be Clay Shirky's quote:

You say “I’m a strong believer in the rights of creative artists to control the distribution of their copyrighted content.” Sure, why not? And while we’re at it, we can be strong believers in breathing under water, or living to 130. Those ideas are similar to the idea of controlling distribution, in that there are a whole bunch of people who think they would be really really great. They’re all similar in another way too. Can you guess what it is?

Calypso

2009-07-12T16:44:42+00:00

What’s calypso? The new official xmms2 gui client.

I could talk about why the name calypso is a good name, what it means, etc. But I won’t, I’ll write about technical and implementation details.

Based on theefer’s post about extensability and some talks we have, we get to the conclusion that the client should be extensible, based on this I implemented the prototype of a framework to be used during this GSoC and hope that it will be useful in the final client.

The framework is composed of modules, there are two types of modules, I will call them the core and the extension modules. As you have thought the core modules contain core features and serve as the base for the construction of other modules. The core modules are responsible of communication with xmms2 daemon: to control playback, retrieve information, change configuration values, etc. They’re responsible for maintain caches of retrieved data and provide interface to this functionality to other modules. Actually if you look in the code tree you will see three (partially implemented) core modules: playlist, playback and collection.

Let’s talk about the more interesting, extension modules. In this category falls all modules that does not interact directly with the xmms2d daemon or provide basic functionality to the other modules, normally modules in this category have some related UI, for instance, a playlist viewer, collection browser, playback controller, and what else you can think. I’ll post about the ones I implement.

Another difference is related to implementation, core modules are supposed to be implement in some predefined default client language (C++), while extension modules could be implemented not only in the default language but also in some high level extension language (we’ve been trying QtScript).

The current state is the following: there are core modules for controlling playback, playlist and colllection management. In the extension modules field there are a simple playback controller, a playlist viewer, collection browser and the calypso-bar (this one deserves a specific post, but basically, it’s a cli-like controller for all modules).

In terms of Qt naming (I haven’t mentioned but the current prototypes are being developed int python+qt) models classes are normally provided by core modules while the extension modules are viewers and controllers (obviously it’s not a rule, for instance, there can be a lyrics fetcher extension module that’s a model). Related to the UI a module is responsible for providing his own interface (if have one) and there are no restrictions in how it’s created (manually in code, loading an .ui file) it just have to follow some naming rules so it can be used in the main interface.

I think that is it what I wanted to talk in this post, the next ones will be about some specific modules, in the queue there are already the calypso-bar and collection bins.

The tree is in git://git.xmms.se/xmms2/calypso.git you can try it, but be warned for now it’s just prototyping, have lots of bugs and partially implemented things. If you try anyway, please comment.

EuroPython 2009 - What happened?

2009-07-08T18:39:11+00:00

Last week I attended EuroPython 2009 in Birmingham, both as a speaker and as an attendee. This post won't reflect on my talks (one was not good, one was actually very good, I might do more posting about that later) but rather something interesting that I observed during the conference this year.

EuroPython have always been a very nerdy conference, no surprise there, so it struck me as very odd that several talks and seminars this year didn't include that much technology at all! They talked about politics and freedom.

First out was Cory Doctorows keynote "The Copyright Wars" which I unfortunately missed, but Reinout van Rees have a excellent summary here. Hopefully the audio recording of that keynote will posted soon. It does bring up a very important point about the future of open source software in a world controlled by paranoid content makers.

During the lightning talks (which was hugely entertaining at whole) two talks had the topic of politics.

First out was Holger Krekel who talked about the internet and how the information about us could be used for mass surveillance and the need to do something about it. He touched on the very recent problems we have seen in Iran, how the state has been filtering the access to the internet. Holger went on and suggested that there are two ways to attack the problem.

The first involves political activism ("We know it works, because we stopped the software patents"), he mentioned the Pirate Party (which makes me very happy) and that he considered joining it (Holger: You are very very welcome!). We need to start talking to the politicians and convince them that internet needs to be free!

The second option for people that have a more technical approach to things (almost everyone at the conference!) is the need for new technologies that can't be filtered as easy as a centralized system for passing messages. Holger encouraged people to develop other ways to distribute information and getting around filtering equipment. My colleague and me was very inspired by this and started to scribble some notes on how a system like that would look like. I might blog about this later.

All in all I really liked Holgers lightning talk, it was very inspirational and well delivered, thank you.

The second lightning speaker that had politics as a topic was Jacob Hallen. Jacob strikes me as a very soft spoken and timid man (I actually talked to him right before his speech), which is why his talk really surprised me. He delivered a very passionate (improvised?) speech about how big content are using methods that are really scary and he drew a direct parallel to "men in high boots, abducting people in the middle of the night". Thanks Jacob, it was inspiring!

For me it was very inspiring to hear this types of talks and speeches in a area so technology heavy (nerdy?), because this means that we are many that cares. Now we need to transform that care into action!

First post

2009-06-27T14:40:43+00:00

Hey, this is the first post in this blog, so I’ll describe what’s the blog intentions:

keep track of my Google Summer of Code 2009 (GSoC) work.
post ideas of features to be implemented in the client.
receive feedback form what have been done.

I am working in the XMMS2 official gui client mentored by Sébastien Cevey (theefer). If you don’t know XMMS2 click here, and for cool posts of what an awesome client should be look at theefer’s Star Wars posts.

Batteries and Apple

2009-06-24T07:08:10+00:00

In 2006 my girlfriend bought herself a MacBook, one of those white ones, pretty, easy to use, and all was well. About two years later the laptop started acting weird. I shut down even though there was still a lot of charge left in the battery and other strange symptoms. A call to Apple and a quick battery check in the store and she got a new battery thanks to the battery exchange program they had running back then, almost no questions asked, and all was well again.

A while ago the battery started acting up again. We came home from a short vacation and the battery icon had a cross over it and the battery didn’t charge. I got on the phone with Apple and they of course answered that I was SOL, but after refusing to accept that they told me to go to an Apple Support store to test if the battery was depleted, or defect. Needless to say it was defect, it had gone from acceptable performance to no performance in the blink of an eye.

Ok, so with the blessing of an Apple technician I called Apple again and now things started to get strange. The support now told me batteries were something you used up and that this battery too was used up even though the technician said otherwise. After a while I had the support guy accept that Apple didn’t manufacture their batteries to suddenly die after a years usage, but rather become less and less able to hold the charge. Based on this acceptance I tried pointing out that Konsumentköplagen (law to protect consumers here in Sweden) protected me from manufactoring errors, and as we both agreed that the battery was incorrectly manufactured, as determined by their party, this would give me the right, and according to me, right to a new battery.

This convincing had taken a while and the support guy was definatly not interested in Konsumentköplagen nor talking with me, so he redirected me up one level after he had explained the case to the next guy.

The next guy had been told by his managers that batteries were something you used up, and thus the Konsumentköplagen didn’t apply, but when asking for a legal reference to his statement that batteries was specifically not covered by the Konsumentköplagen he got a bit defensive, specially after me pointing out that the first hit on Google has the title ”Apple doesn’t care about Konsumentköpslagen”. After a short battle he sent me one step up to something he explained to be their office for more law-related questions.

This time a Danish girl answered and the conversation continued in english and she didn’t seem to have ever heared of the Konsumentköplagen, but was kind enough to give me a 30% discount code on a new battery from Apple Store. I accepted this as the alternative according to her was to talk to their lawyers, and that seemed like a too big effort considering the price of a new battery.

I’m still not completly sure who was right in this case, they never explicitly said that I was wrong. The Konsumentköplagen says that’s it up to the consumer to prove the manufactoring error, but as their technician had determined this already I belive that I was right, and I have still not found any explaination to the relation between Konsumentköplagen and batteries.

Not really a secret

2009-05-27T16:42:18+00:00

I have already voted for Piratpartiet in the Swedish EU elections. For people who know me that can hardly come as a surprise. I just wanted to briefly talk about why I went with PP instead of MP (that I usually vote for), when they actually have the same opinions about integrity and the future of Internet. I think it can be summed up in: I wanted to make a statement. There you have it. I want people in "power" to understand that it's not OK to ignore these questions (internet, freedom, integrity), it's not OK to push through new laws (FRA, IPRED) without consequences.

I might be naive, thinking that voting for PP is a "consequence" for the sitting parties. At least it seems like most politicians seems to understand that they have to tackle this question these days, that's a start.

Let's keep internet FREE, as in speech.

XMMS2-Scrobbler 0.3.0 released

2009-05-10T12:15:05+00:00

So here’s an XMMS2-Scrobbler release that will work with the recently released DrMattDestruction. This new version is witten in C instead of Ruby (so it’s much less memory hungry) and includes support for last.fm’s now-playing notifications.

XMMS2's GSoC '09: 3 exciting projects!

2009-05-09T10:56:48+00:00

Flowers blossom, birds sing and the sun is starting to shine higher and brighter and later every day. You know what it means: time to go out and find a nice spot in the shade, unfold your laptop and start hacking for it's summer — Summer of Code!

This year again, we were lucky to be accepted as an organization for the Google Summer of Code. Due to some logistic and organizational hazards, we're only running 3 slots this year, but it's more like a concentrate of amazing projects!

See for yourself:

cippo will tackle the almost mythical New Medialib Backend (AKA S4) project (GSoC entry), which aims at replacing our SQLite backend with a more suitable solution adapted to what we use it for, namely a key-value store for media (see the wikipage). Our very own and very bearded anders will be his mentor to make sure it all turns out even smarter than we expected.

Although the latest iteration of collections has seen a lot of performance optimizations, we still hope that this could bring even better performance. However, we're also interested in improving the memory footprint (incl. reducing duplicate data), alleviate locking problems (BUSY EVENT!), allow smart/dynamic hierarchy of metadata (e.g. attach a cover image to the album entity rather than each individual media) and wrap it all together using collections as a query mechanism. It's all very new and experimental, and that's why it's so cool!

Our second student, CaffineeHacker, will work on Cross Fade (GSoC entry), by making the xform chain persistent. A refactoring of the xform infrastructure is indeed needed to carry effects across song changes; optionally, the rework might allow "xforms to transmit data in the frequency domain instead of having each xform that uses frequency domain do an FFT". The project has been around for a while and we're happy to run it this year, mentored by rafl!

Finally, we're happy to get greafine back for another round of GSoC this year. He'd done a great job on nycli last year (freshly released in DrMattDestruction!), and his application left no doubt that he was The Man to work on a very exciting, long-awaited project: a grand new GUI client for XMMS2 (GSoC entry)!

The basic idea is, quite simply, to build the most awesome music player known to mankind, and while it might not be suitable for everyone, we're committed to make it follow a strong and original vision aligned with that of XMMS2. You can read more about that on the Planet, and more specifically on tru's and theefer's blogs. Incidentally, theefer will be mentoring this project.

We look forward to working with the students on all those great projects!

And meanwhile, works continue to merge nesciens' Collections 2.0 for the next release, and get GenIPC and Service Clients in as well!

MongoDB on CPAN

2009-05-08T22:53:28+00:00

I've been doing some contracting work for 10gen recently. They have that rather cool open source document database called MongoDB and they wanted me to write a module to use that from Perl. I did that and the code is now available on CPAN and github.

Writing that was fun, and I'm already looking forward to be able to use MongoDB as a backend for KiokuDB. I started writing code for that and put it on github, but isn't passing all the tests just yet.

In related news, after finishing the MongoDB module, I'm available for other things again. So if you're looking for a Perl telecommuter, let me know.

Apple: Be more transparent!

2009-05-04T23:20:25+00:00

Apple is a very secrative organization, they value their secrecy because it builds up a hype around the products. I love Apple products, I am what most people call a Apple fan-boy. But I think recent events regarding the App Store aproval process must be addressed in a negative fashion.

I love the fact that Apple have created great development tools for the iPhone and they have done so for free. This have given the iPhone eco-system a great boost and in less than a year they have succeeded in creating a development community that it’s competitors haven’t succeeded with yet.

I really believe that the App Store is a big reason for the success, all applications gathered and easy to browse / search. But the App Store is also the big sign of weakness in the iPhone eco-system. As you might already know, Apple is the gatekeeper for everything going into the App Store to make sure that “malicious” and “offensive” applications stay far away from the iPhone. While this makes sense (you don’t want viruses spreading via the App Store) in some ways the big problem is actually that Apple have so far refused to share any details on the approval process.

This creates big problems, not only because it’s hard for developers to know if their application will ultimately be accepted or not, but also because currently it seems like the process is very random, some of them have gotten a lot of attention. The latest application that have gotten the metaphorical cold hand was Nine Inch Nail own application. The application was actually first accepted (and put on the “featured” page in App Store), when NIN then submitted a minor update it was rejected because of “objectionable content”.

Probably this occurred because different people reviewed the first submission and the update. This really makes the flaw in the process really apparent, the developer can never trust the Apple approval process. If this continues I wouldn’t be surprised if small indie developers think twice before they start develop iPhone applications and that would really be a shame, because it will in the long run kill the community.

I think that Apple have to be more transparent, really post the guidelines that are used for the approval process or even better, small developers should be able to “test drive” their idea and get a pre-aproval. That would make it easier for the small developer to justify the investment they need to do to create a iPhone application.

Maybe another solution would be to “do a Maemo”. Maemo have a staging area called the “garage” where third party developers can upload basically anything they want, users needs to manually install them. This would allow Apple to review applications for the App Store, but applications that are deemed “offensive” can still be installed on willing users iPhones.

Please Apple, don’t destroy a good thing you have going on here, a free SDK was a great idea, the App Store was a super idea as well but your approval process can throw it all overboard. Be transparent, let the developers in on the secrets in this case.

Running tests that require an X server

2009-04-29T15:22:37+00:00

Lots of CPAN distributions require some kind of graphical environment. Some of them even pop up windows, which not only very annoying, but also sometimes fails if you're using a tiled window manager.

To test such distributions on a machine where no graphical environment is available or on your desktop while you're working and don't want to get annoyed to death you can use a fake X server, like Xvfb.

The easiest way to do that is to run

$ xvfb-run -a make test

instead of a plain make test. That'll automatically create a fake xserver, set up DISPLAY and run make test in that environment.

That works well for manually installing modules. When installing using CPAN.pm you can make things easier by writing a distropref.

First, tell cpan where your distroprefs are. I use ~/.cpan/prefs:

$ cpan
cpan[1]> o conf init prefs_dir
[...]
<prefs_dir>
Directory where to store default options/environment/dialogs for
building modules that need some customization? [] /home/rafl/.cpan/prefs
cpan[3]> o conf commit
commit: wrote '/home/rafl/.cpan/CPAN/MyConfig.pm'

Now write a distropref for the modules that need an X server and put it into your prefs dir as X11.yml

---
match:
  distribution: |
    /(?x:Wx
      |Gtk2
      |Gnome2
      |... other modules requiring an X server
    )-\d|
test:
  commandline: "xvfb-run -a make test"

Now the tests for Wx, Gtk2, Gnome2 and all other distributions you list in that regex will be executed with a fake X server.

I have yet to figure out how to write a distropref that just prepends to the test commandline instead of replacing it so I won't need to have another pref for all modules using Module::Build.

Implementing Typed Lexical Variables

2009-04-28T06:20:16+00:00

For quite some time perl provided a form of my declarations that includes a type name, like this:

my Str $x = 'foo';

However, that didn't do anything useful, until Vincent Pit came along and wrote the excellent Lexical::Types module, which allows you to extend the semantics of typed lexicals and actually make them do something useful. For that, it simply invokes a callback for every my declaration with a type in the scopes it is loaded. Within that callback you get the variable that is being declared as well as the name of the type used in the declaration.

We also have Moose type constraints and the great MooseX::Types module, that allows us to define our own type libraries and import the type constraints into other modules.

Let's glue those modules together. Consider this code:

use MooseX::Types::Moose qw/Int/;
use Lexical::Types;
my Int $x = 42;

The first problem is that the perl compiler expects a package with the name of the type used in my to exist. If there's no such package compilation will fail.

Creating top-level namespaces for all the types we want to use would obviously suck. Luckily the compiler will also try to look for a function with the name of the type in the current scope. If that exists and is inlineable, it will call that function and use the return value as a package name.

In the above code snippet an Int function already exists. We imported that from MooseX::Types::Moose. Unfortunately it isn't inlineable. Even if it were, compilation would still fail, because it would return a Moose::Meta::TypeConstraint instead of a valid package name.

To fix that, let's rewrite the code to this:

use MooseX::Types::Moose qw/Int/;
use MooseX::Lexical::Types qw/Int/;
my Int $x = 42;

Let's also write a MooseX::Lexical::Types module that replaces existing imported type exports with something that can be inlined and returns an existing package name based on the type constraint's name.

package MooseX::Lexical::Types;

use Class::MOP;
use MooseX::Types::Util qw/has_available_type_export/;
use namespace::autoclean;

sub import {
    my ($class, @args) = @_;
    my $caller = caller();

    my $meta = Class::MOP::class_of($caller) || Class::MOP::Class->initialize($caller);

    for my $type_name (@args) {
        # get the type constraint by introspecting the caller
        my $type_constraint = has_available_type_export($caller, $type_name);

        my $package = 'MooseX::Lexical::Types::TYPE::' . $type_constraint->name;
        Class::MOP::Class->create($package);
        $meta->add_package_symbol('&'.$type_name => sub () { $package });
    }

    Lexical::Types->import; # enable Lexical::Types for the caller
}

1;

With that the example code now compiles. Unfortunately it breaks every other usecase of MooseX::Types. The export will still need to return a Moose::Meta::TypeConstraint at run time so this will continue to work:

has some_attribute => (is => 'ro', isa => Int);

So instead of returning a plain package name from our exported function we will return an object that delegates all method calls to the actual type constraint, but evaluates to our special package name when used as a string:

my $decorator = MooseX::Lexical::Types::TypeDecorator->new($type_constraint);
$meta->add_package_symbol('&'.$type_name => sub () { $decorator });

and:

package MooseX::Lexical::Types::TypeDecorator;
use Moose;
use namespace::autoclean;

# MooseX::Types happens to already have a class that doesn't do much
# more than delegating to a real type constraint!
extends 'MooseX::Types::TypeDecorator';

use overload '""' => sub {
    'MooseX::Lexical::Types::TYPE::' . $_[0]->__type_constraint->name
};

1;

Now we're able to use Int as usual and have Lexical::Types invoke its callback on MooseX::Lexical::Types::TYPE::Int. Within that callback we will need the real type constraint again, but as it is invoked as a class method with no good way to pass in additional arguments, we will need to store the type constraint somewhere. I choose to simply add a method to the type class we create when constructing our export. After that, all we need is to implement our Lexical::Types callback. We will put that in a class all our type classes will inherit from:

Class::MOP::Class->create(
    $package => (
        superclasses => ['MooseX::Lexical::Types::TypedScalar'],
        methods      => {
            get_type_constraint => sub { $type_constraint },
        },
    ),
);

The Lexical::Types callback will now need to tie things together by modifying the declared variable so it will automatically validate values against the type constraint when being assigned to. There are several ways of doing this. Using tie on the declared variable would probable be the easiest thing to do. However, I decided to use Variable::Magic (also written by Vincent Pit - did I mention he's awesome?), because it's mostly invisible at the perl level and also performs rather well (not that it'd matter, given that validation itself is relatively slow):

package MooseX::Lexical::Types::TypedScalar;

use Carp qw/confess/;
use Variable::Magic qw/wizard cast/;
use namespace::autoclean;

my $wiz = wizard
    # store the type constraint in the data attached to the magic
    data => sub { $_[1]->get_type_constraint },
    # when assigning to the variable, fail if we can't validate the
    # new value ($_[0]) against the type constraint ($_[1])
    set  => sub {
        if (defined (my $msg = $_[1]->validate(${ $_[0] }))) {
            confess $msg;
        }
        ();
    };

sub TYPEDSCALAR {
    # cast $wiz on the variable in $_[1]. pass the type package name
    # in $_[0] to the wizard's data construction callback.
    cast $_[1], $wiz, $_[0];
    ();
}

1;

With this, our example code now works. If someone wants to assign, say, 'foo' to the variable declared as my Int $x our magic callback will be invoked, try to validate the value against the type constraint and fail loudly. WIN!

The code for all this is available github and should also be on CPAN shortly.

You might notice warnings about mismatching prototypes. Those are caused by Class::MOP and fixed in the git version of it, so they'll go away with the next release.

There's still a couple of caveats, but please see the documentation for that.

Declaring Catalyst Actions

2009-04-26T09:14:50+00:00

For a long time the Catalyst Framework has been using code attributes to allow users to declare actions that certain URLs get dispatched to. That looks something like this:

sub base    : Chained('/')    PathPart('') CaptureArgs(0) { ... }
sub index   : Chained('base') PathPart('') Args(0)        { ... }
sub default : Chained('base') PathPart('') Args           { ... }

It's a nice and clean syntax that keeps all important information right next to the method it belongs to.

However, attributes in perl have a couple of limitations. For one, the interface the perl core provides to use them is horrible and doesn't provide nearly enough information to do a lot of things, but most importantly attributes are just plain strings. That means you will need to parse something like "Chained('base')" into (Chained => 'base') yourself to make proper use of them.

While that's easy for the above example, it can be very hard in the general case because only perl can parse Perl. It's one of the reasons you can't use Catalyst::Controller::ActionRole to apply parameterized roles to your action instances, because parsing parameters out of things like Does(SomeRole => { names => [qw/affe tiger/], answer_re => qr/42/ }) would be awful and wrong.

With Catalyst 5.8 most of the attribute related code has been removed from the internals. It's now using MooseX::MethodAttributes to do all the heavy lifting. Also the internals of how actions are registered have been refactored to make it easier to implement alternate ways without changing the Catalyst core.

As a proof of concept for this I implemented a new way of declaring actions that's very similar to how Moose provides it's sugar functions. You can get it from github.

With that, the above example looks like this:

action base    => (Chained => '/',    PathPart => '', CaptureArgs => 0) => sub { ... };
action index   => (Chained => 'base', PathPart => '', Args    => 0    ) => sub { ... };
action default => (Chained => 'base', PathPart => '', Args    => undef) => sub { ... };

It also moves method declaration from compiletime to runtime, making this possible:

for my $action (qw/foo bar baz/) {
    action $action => (Chained => 'somewhere', Args => 0) => sub {
        my ($self, $ctx) = @_;
        $ctx->stash->{ $action } = $ctx->model('Foo')->get_stuff($action);
    };
}

Admittedly, that's all very ugly, but illustrates well what kind of things we're able to do now. But it doesn't need to be ugly. With Devel::Declare we have a great tool to add our own awesome syntax to perl, similar to how things like MooseX::Method::Signatures, MooseX::MultiMethods and MooseX::Declare do.

So how would a declarative syntax for Catalyst controllers look like? I don't know. Ideas include something like this:

under /some/where, action foo ('foo', $id) { ... }

to mean:

sub foo : Chained('/some/where') PathPart('foo') CaptureArgs(1) { ... }

Adding Moose type constraints to this would be interesting, too, and make validation of captures and arguments a lot easier. Multi dispatch similar to MooseX::MultiMethods could be handy as well:

under /some/where {
    action ('foo', Int $id) {
        # find and stash an item by id
    }
    action ('foo', Str $name) {
        # search items using $name
    }
    action ('foo', Any $thing) {
        # display error page
    }
}

So you see there are a lot of possibilities that should be explored. Unfortunately I have no idea what kind of syntax and features people would like to have, so your feedback on this would be much appreciated. :-)

DrMattDestruction released

2009-04-23T03:47:33+00:00

Slightly delayed, but...

After XMMS2 Team's tussles in Brussels; Here we go again!

XMMS2 Team is proud to present a new release, as late as always. This time there has been huge changes "under the hook" with the new "xmmsv".

You can obtain XMMS2 here:
Release notes:
http://wiki.xmms2.xmms.se/index.php/Release:DrMattDestruction
Source:
http://sourceforge.net/projects/xmms2

The XMMS2 Team would like to extend a big THANK YOU to all who have helped out with this release, and an extra thanks to especially to those 10 persons that made the AUTHORS file grow

Open Source Community Eduaction

2009-04-17T19:14:53+00:00

Purple Scout was contracted to do a Open Source Education a while back. The customer wanted a education that gave them the history, business and legal aspects, but they also wanted a section with some "real life" stories, from someone that have worked in a Open Source community already. While both my bosses handled the business and legal aspects I tackled the community section.

After almost a month of preparation, we held the pilot in front of a smaller group today. I was a bit nervous at the start but managed to hold a very engaging talk about the different inner workings of a community and a generalization of what drives open source hackers. It was a fun and interactive group that I managed to provoke a couple of times :-)

I would love to share the slides I did, but unfortunately they contain some information that I can't spread, therefore I will try to blog a bit about the conclusions that I managed to draw from all of this.

Also a question: What do you people think is the driving factor for participating in open source communities as a company, i.e. not for you personally, but what would drive your company to work with open source?

Open Source is about Participation

2009-04-17T19:14:33+00:00

As I have talked about earlier I am holding an education for company management about Open Source Communities. Since I can't release the slides directly I am going to blog a bit about what these slides contain.

One of the things I am trying to get across the table is that getting involved in a Open Source Community as a company is hard work and often counter-intuitive to old business practices. To illustrate this I have created some case studies about companies that have tried to involve them-self in the community and the different outcomes of that. In my examples I use Nokia, Apple, Google and Sun as examples (and some more of them), all these companies are interacting with the Open Source community in different ways. All of these companies have both succeeded and failed with their interactions (I won't comment on the individual cases in this blog post, but I am still interested in your feedback, what do you think about the companies listed above and do you have other examples of companies failing or succeeding with Open Source?).

While I was researching these different companies (most of my research was based on google searches like "opensource at X") I ran across Sun's Open Source webpage, this page states that 'Open Source is about Participation'. I think that is one of the most accurate one-liners about Open Source I have ever heard. In order to be able to accepted and successful with a Open Source Community you must show that you can participate, create code and work together with the community with it rules.

I think very few Open Source Communities would accept companies that tries to 'buy' their way into gaining influence over a certain project. But companies that can send relevant, well written patches that implements a feature or fixes a bug in a project they are using can succeed. Many nerds just care about code and that is the way it should be.

Interacting with a Open Source Community is not like interacting with business partner, few communities will implement features that they don't like just because your company needs it. Many community volunteers have a lot of pride invested in their projects and will place code-style and technical aspects before the needs of their end-users. This is very different from how a company works, because companies needs to see to the user needs before the technical aspects of the actual code (this might actually explain why most proprietary code is such a mess - "We need this now, or else!").

This means that companies have to care about things like this when they are contributing to Open Source projects, otherwise they might never get their patches merged.

So to sum up, if you want to gain the trust of a Open Source Community, participate and show them the code!

Code commenting - the myth

2009-04-05T12:08:52+00:00

I have lately been embroiled in a debate about the importance of commenting in code. While I donâ€™t yet believe that comments are completely unnecessary, I tend to think that they are largely unnecessary. Almost two years ago, I wrote â€˜Software development without mapsâ€™ in which I extolled the virtues of â€˜documentationâ€™. While it can be easy to confuse â€˜documentationâ€™ with â€˜commentingâ€™ and jump to the conclusion that Iâ€™m now contradicting myself, Iâ€™d like to draw the distinction between the two. Commenting is only a specific type of documentation - a kind of documentation that is so narrow in scope that it only applies to code. [Sidenote: In general, commenting will end up covering the ‘mechanisms’ expressed by code, and very little of the ‘policies’ and justifications - which would be best covered by higher level documentation anyway.]

In essence, I see programming as an activity where one devises and manipulates abstract models. Writing code is merely a process of expression of such models. What I was trying to get at, in my previous blog post, was that the same models can be viewed at different levels of abstraction. The â€˜documentsâ€™ encompass knowledge about the models at a higher abstraction level than the code. Documents, being UML diagrams, specifications, or other suitable representations. Comments, on the other hand, are at the same level as code. While it may be useful to sketch out a program using comments before the real code is written, I believe that such â€˜scaffoldingâ€™ should eventually fade away. Like faint construction lines in a technical drawing, such comments are there to provide an initial framework for laying out the real lines and curves. Like faint and rough sketches on canvas, or a block of stone or wood, the comments become unnecessary as the system is painted, or moulded into shape.

As a software system takes shape and matures, the most reliable indicator of what it is doing is the code itself, not any superfluous comments. Indeed, there are various dangers associated with using and maintaining comments beyond the initial stages of coding:

comment maintenance overhead
As code is modified for various reasons - bug fixes, feature additions, refactoring for reuse - extra time is required to verify not only the proper operation of the code (which can be automated), but also to review existing comments and rewriting the â€˜comment narrativeâ€™ in a way that fits the reshaped code. I consider this to be a special case of duplication of logic - in the presence of comments that attempt to explain the program logic, one needs to maintain not only the actual program logic expressed in the code, but also those comments that â€˜pretendâ€™ to be saying whatâ€™s happening. Such a task becomes especially daunting in a team of non-trivial size, as various people end up writing and rewriting chunks of this narrative - which all ends up devolving into an incoherent and unreliable mess. There are ways of managing, verifying and testing program code - and enforcing program coding style conventions - written in a diverse environment, but there is no reliable way of getting people to write a natural language in a consistent, non-monotonous way. The best we can do is introduce the editor model - should we then have a â€˜comment editorâ€™ on every programming team, to ensure that all the comments flow clearly and adopt the right style and tone?
matching comments with code
On the other hand, if programmers do not take the required amount of time to fully review and rewrite comments as they implement changes, we end up in a situation where the comments do not accurately reflect the sequence of events expressed in the code. As this compounds, over time, programmers who are introduced to the system later on bear the considerable risk of being lead astray while attempting to trace defects. The end result is code of poor quality, at the significant expense of time - time wasted following misleading comments.

Looking at the issue from another perspective, what about the usefulness of comments? The machine does not care about comments in the code. Comments do not affect the compiler. Comments do not affect whatever is going to be interpreting the code, or some processed version of the code. That is, indeed, the point of comments. Comments wonâ€™t make programs run faster, or in a more stable manner. Comments wonâ€™t eliminate bugs. If guns donâ€™t kill people and people kill people, then comments donâ€™t eliminate bugs - people eliminate bugs.

As far as I can tell, the importance of commenting code is 1) seemingly over-emphasised by Computer Science departments, and 2) an unfounded myth perpetuated in programming shops. OK, after a quick trip through IEEEXplore, I found several papers seemingly extolling the virtues of code commenting. However, they all seem to cite the same paper when doing so. A paper written in 1988. A paper about a study based on PL/I and Pascal. Enough said. Clearly, there has been some research done on the topic, but a lot of it seems outdated, especially in the face of more modern concepts such as Object Oriented languages, etc. I shall delve more into this and possibly post a follow-up to this.

In any case, even I was to assume that comments are useful and will bring about world peace, I cannot find any qualitative documentation on the subject. Itâ€™s all well and good to say things like â€œYour code should be 20% commentedâ€ or â€œYou need to have comments describing each functionâ€ or â€œComment about why, not necessarily what, the code is doingâ€, but no one ever seems to have good examples of such. Such vagueness simply serves to exacerbate the problem - anyone can write practically anything they like in comment blocks and get away with it. â€œWhaddya mean, I wrote comments! See!â€ A more practical way of posing this question would be: Given that I have a programming task, how do I write good quality comments that will remain useful to future programmers, given what I know about the problem domain, and how I anticipate it to change? Is there an example of this story and how it pans out?

Taking a step back, letâ€™s look at the real problem that commenting pretends to solve.

As I mentioned earlier, programming involves the manipulation of abstract models and expressing them in code. It therefore follows that one gains more by learning how to more effectively express programming code than by decorating code with comments. Programming code is the ultimate middle ground - it is something understandable both by the programmer and by the machine (at some level). The programmer who can write prose in comments does not hold a candle to the programmer who can get the machine to execute exactly what he wants to get done. There are two main reasons for the existence of comments in code: 1) making up for the lack of higher level documentation, and 2) attempting to mask complexity by â€˜explaining it in englishâ€™.

The first case is symptomatic of a poor development process, where intentions articulated at the business level arenâ€™t properly captured and architected into solutions at various levels of abstraction. In the absence of UML and other such higher level program models, developers are supposed to resort to code comments to explain â€˜whyâ€™ certain things are being done, even though higher level descriptions would be more accessible to various stakeholders. (This is a variant of the â€œexplain why youâ€™re doing thisâ€ style of commenting) Comments used in such a manner simply mask a lack of traceability between what a particular client wants, what possible solutions are presented and approved, and what ends up getting implemented. The valuable historical record of the back-and-forth discussions detailing what happened and when particular decisions were made, is simply lost. Coupled with an environment where developers are added to and removed from a project in a piecemeal fashion, this is simply a recipe for a fragmented disaster, as few of those involved have a complete memory of the sequence of events.

On the other hand, masking complexity by â€˜explaining in englishâ€™ is plainly disproven by decades of development on programming languages. Concepts such as functions, classes, methods, packages and libraries were developed for the specific purpose of managing complexity by breaking down code into smaller, safer, more tractable and more manageable chunks. Those allow for the implementation of layerable and composable solution patterns, as well as enabling reuse - all techniques well known to help improve the long term reliability and maintainability of software systems. If it werenâ€™t for those, weâ€™d still be writing long epics in FORTRAN.. if we could even get that far.. The fact that classes and methods can be given meaningful names dispels a lot of the reason for using inline comments. Got a function doing lots of things? Break it up into smaller functions that have descriptive names. The code is then easier to follow at a higher abstraction level. Want to zoom in on a specific step? Just go into that function. Easy. Up and down the abstraction ladder.

Despite the various reasons for writing comments, it all boils down to managing complexity: the complexity of stakeholdersâ€™ requirements, the complexity of the solution at hand. What Iâ€™ve been trying to say is that all of this relates to the management of the development process. By building maps and models of stakeholdersâ€™ requirements, a better understanding of the problem domain can be achieved. The process of building such maps and models also helps in the discovery and resolution of conflicting requirements and essential priorities. From there, developers can devise subsystems that - when coupled together - should aim to meet the set of requirements. Such subsystems can then be defined in terms of their interfaces and interactions with each other - all at a higher abstraction level. From there, the team can then zoom in further into each subsystem and attempt to refine the implementation further. This same process can be repeated down to applications, services, packages, classes and methods. The whole â€˜stackâ€™ describes the abstraction ladder in a consistent manner, and moving up and down this stack constitutes the â€˜zoomingâ€™ action. Explaining the process in such a way presents a simple concept that can be applied by various people involved in the process. Stakeholders talk to architects and account managers to produce documents and customer-facing models, while architects present the same documents and models to developers for further refinement and evaluation. The end product of this process is a whole collection of inter-related artifacts that document the history of the project and its various aspects from different perspectives - all of which is much more useful and accessible then comments buried deep in the code.

Another way of looking at the commenting problem is one of situational awareness. Piles of comments (or code, for that matter) are essentially worthless to a programmer until he reads them. (And when he does read them, the code will provide a more accurate picture of whatâ€™s happening, rather than the comments) A programmer (A) who writes some code has implicit knowledge of what the code does and why itâ€™s doing what it does. A programmer (B) who simply reads comments written by someone else has explicit knowledge of what the code is doing, but not necessarily any implicit knowledge. A programmer (C) who reads some code written by someone else internalises a more accurate mental model of what the code is doing. Simply put, programmer A devises a mental model and expresses it in code, while programmer C is doing the reverse process by reading the code and building a mental model. While programmer B has some chance of success at building a model, he might end up doing so â€˜fasterâ€™ than programmer C, but at the expense of an inaccurate - possibly even out of date - model. This whole construction and deconstruction of mental models is exactly why the â€˜abstraction ladderâ€™ development process is powerful - it provides models of varying detail at various levels to enable almost anyone to more easily conceptualise any part of the solution and work with it.

Sony Reader PRS-700

2009-04-03T22:20:26+00:00

I got myself a Sony Reader PRS-700 the other day. Imported from the USA of course, since we can't get fancy things like that here in Europe. Actually I am evaluating this unit for some friends and co-workers so they know what Reader to buy later.

So far I must say that I am impressed. I have been using it on my weekly trips back and forth to Malmö and more or less left all my books at home. The built-in light is pretty slick, I can actually read books in bed without disturbing my lovely fiance.

A word about the display, a lot of people hate it because it "glares", my guess is that these are the same people that "can't" use a glossy macbook either. I on the other hand have never had any problems with it. So I will continue to read my books digital going forward, no more big books that weigh a ton in my backpack.

Google Summer of Code 2009

2009-03-19T09:30:06+00:00

XMMS2 got the good news again! It feels awesome, not only because we get to participate in this fantastic program once again, but also the prospect of going to a mentor summit later this year is awesome :-) Thanks Leslie, you know we love you! ;)

But, I heard someone whispering that our proposed projects was less interesting this year! Let's do something about that! Do you have a good idea? File it at our wiki, TODAY! :-)

Accepted ... again!

2009-03-19T01:26:05+00:00

Good news! We have been accepted into this 2009's Google Summer of Code! Head over to the GSoC page at Google and apply as mentors / students.

Official XMMS2 client should be written in Qt!

2009-03-18T18:44:00+00:00

I read the that theefer did the other day and I just wanted to voice out my opinion about the Official client. I don't doubt that all people in the XMMS2 community probably already know my position about this, but I wanted to make it perfectly clear!

I think the official XMMS2 client should be written in the Qt toolkit and these are my reasons for it:

Qt works natively on all the platforms that XMMS2 runs on. More important, it actually looks good on all the platforms that XMMS2 runs on. It even looks good under GNOME these days.
The Qt API is very clean and easy to use.
You can write Qt applications in C++, Python or Ruby (see my language discussion further down).
Qt bundles with QtScript, which is a ECMA compliant language, which means that we can extend the official client in QtScript. This means a very low entry-level for people that want to add functionality to our client. QtScript is (IMHO) not fast enough to be the sole language we should use, but that might change soon.
Upcoming features like QtKientic will bring awesomeness to our client.

I also think that the base client should be written in C++, but supported by QtScript. First we had the idea that we should write the whole client in QtScript, just have a small C++ loader. I have researched this possibility but I don't think QtScript is ready for that. QtScript is slow, and you need the qtscriptbindings to bind the full Qt API to QtScript, that takes 2 hours to compile on my master macbook pro.

Writing the application in Python or Ruby would probably be more rapid than writing it in C++, but it will be a bigger pain to deploy. Qt/C++ is easiest to deploy because all the tools are already there and users don't have to install yet-another-lib. My second choice would be Python, mostly because I know Python, I don't know Ruby :)

How about xmmsclient bindings?

The last thing I would like to touch is about xmmsclient bindings. Right now I have Qt4 bindings that are native, that means that it doesn't use libxmmsclient beneath, they are not merged into the mainline, but could be found here. I think these bindings could be a good candidate to use in the client, but we would need to make it complete and merge it into XMMS2 first.

See this post as a material for discussion, I would love to hear your opinion. Let the flames rain!

Health related

2009-03-11T11:02:09+00:00

So this post is totally non-technical.

The last month I have been on a new diet. The reason for this is that I realized that I was simply getting way over-weight and unhealthy, so I decided to try something that worked good for my mother. I haven't blogged about this before because it's not something fun to talk about. But now, after four weeks on the diet and increased physical activities I have lost 14 kilos (about 30 pounds) and I am starting to feel light, full of energy and a lot more healthy.

I have also decided to participate in midnattsloppet this year. It's a 10 km run throughout Göteborg in the end of August. Want to join? :)

GSoC 2009 and other tidbits.

2009-03-11T10:56:25+00:00

I am on vacation this week, we where supposed to be in Sälen the whole week for some skiing, but due to some mandatory classes that Lisa had to attend, that didn't happen. We will leave for Sälen today instead and get 3 days in the slopes, that will be perfectly fine as well, I am actually looking forward to it a lot.

Also two days of vacation at home haven't been unwelcome at all. I have had time to reinstall my Eee 901, this time with easy peasy. I like it a lot, it really makes the most of the small screen and I didn't have to worry about drivers and X11 configuration etc, etc.

I have also submitted XMMS2 GSoC 2009 application. With some great help of theefer and wanders we finialized all the texts and got it sent away. I have a good feeling about this year, I am more motivated to be the admin and we have learned a lot. I just hope that Google gives us the chance this year as well.

On a XMMS2 releated note DrM has finaly entered testing period. This is waay overdue and we hope that we can wrap it up before the start of the GSoC, so that students can work against that version and not some unreleased one.

Google Summer of Code 2009

2009-03-11T02:47:40+00:00

We have just applied for Google Summer of Code 2009. Hopefully we will be included in the program for the fourth year in a row. Get involved in our ideas and community now! See our GSoC 2009 portal here!

Dollhouse - redux

2009-02-24T19:23:35+00:00

Episode 2 was a lot better! Actually, I suspect that this was the episode that they where aiming for showing as the Pilot from the beginning. It explains a lot of the backstory and is less "ordinary" than the first episode. I just miss the trademarked whedon humor, please give!

XMMS2, the vision

2009-02-16T16:18:22+00:00

I think itâ€™s a great thing for people to finally be stepping up to think of a way forward for XMMS2, especially after a period of relative stagnation. However, I have a few bones to pick with the current shape of things.

Given the direction that the â€˜XMMS2 Visionâ€™ is taking, I Iâ€™ll say this: I think software freedom is overrated. Weâ€™re in 2009, an era where Open Source is practically mainstream - computer manufacturers such as Dell and ASUS are selling desktop and laptop computers with Linux (typically Ubuntu, or some other Debian derivative) pre-installed. ASUSâ€™s Linux-powered eee PC helped launch the netbook revolution, with many observing that the netbook was an ideal application of the low cost benefits of a Linux-based OS. After a decade of people wishing to see Linux as a relatively mainstream desktop OS, it is practically there - any moderately computer literate average Joe can easily grab an Ubuntu Live CD and be on his way.

Thatâ€™s not to say that freedom is not important, but simply chanting â€˜freedom, freedom, freedomâ€™ does not build a thriving community of passionate users. Well, actually, it does, but thatâ€™s a kind of community that borders on blind faith, religious dogma and rabid zealotry when it comes to â€˜freedomâ€™ - e.g. the cult of GNU. Passionate, indeed, but is this what you see for the future of the XMMS2 project?

When I think about the XMMS2 project, I tend to take the â€˜freedomâ€™ aspect for granted, given that XMMS2 has been an open source project for most of its time in existence. Itâ€™s a given that XMMS2 is released under an open source licence, and that the small community of loyal developers, users and other fans has been built upon this foundation - I don’t think that is likely to change. When looking for a future vision for the XMMS2 project, Iâ€™d say that it would be more useful to search for more practical goals than to get lost in navel gazing about freedom. In the end, what people care about is code that works.

I recognise that putting together this vision is a good opportunity to examine the values that are important to the XMMS2 project. More importantly, however, I think whatâ€™s needed is a sharper focus on achieving certain goals. Without a drive towards such goals, weâ€™re pretty much left where we currently are, simply nibbling at ideas that we think are good at the time, without making much progress towards something more coherent.

Iâ€™d like to present my own vision for XMMS2 - by no means a definitive attempt, but merely my opinion - and comment on what has been said/written so far.

First of all: XMMS2, what is it? We use the term â€˜XMMS2â€™ in many contexts, with multiple meanings. I feel that, without a clear idea of how to define the term, weâ€™re likely to be left floundering, especially since this is at the very core of what weâ€™re trying to do. XMMS2 is many things:

A music player. (Or â€˜audioâ€™ player? Weâ€™ll get back to this..)
A framework for building custom â€˜jukeboxesâ€™?
A community of people who study, use, develop or otherwise contribute to a common codebase.
A project - to produce a music player - encompassing the community effort.

Personally, over the years Iâ€™ve been involved with XMMS2, it has been all this and more:

An opportunity to participate in an Open Source project and understand what itâ€™s about - especially the ability to do so from firsthand experience rather than being an outsider looking in.
An opportunity to put my software development skills into practice - and learn more about development in multiple languages, algorithms, software development processes.
An opportunity to discover more interesting kinds of music than I knew of - music thatâ€™s almost non-existent on local radio stations and music shops.
An opportunity to virtually meet and interact with strange people from all over the globe.

When I was first introduced to the XMMS2 project, I was merely a university student tinkering with something I found interesting at the time. What I learned from the subsequent experience, however, tremendously increased my development skills and practical knowledge of how software can be developed. I can say with some amount of gratefulness that being involved with the XMMS2 project is one of the major things that has shaped my career as a software developer so far - what I learned from Andersâ€™ engineering skills is still something that has an influence on how I build software today.

Perhaps, then, one might consider â€˜educationâ€™ as one of the values of the XMMS2 project. Indeed, XMMS2 has been a mentoring organisation in Googleâ€™s Summer of Code program for a number of years now - something which I believe has been quite instructive for both the students and the mentors involved. Iâ€™d like to think that there are others who might be interested in learning a thing or two about â€˜realâ€™ software development to join the community. Granted that code produced by the XMMS2 project is far from perfect, and far from being an academic example of great software engineering, I believe that there is much one can learn by being involved in the community and studying the code. (And no, the XMMS2 project isnâ€™t unique in this respect - many other open source projects also fit the bill)

Beyond what XMMS2 means to each community member, we need to look at where the project is headed. The way I see it, there are two main points to make about this: 1) building the code (or system, or framework - technical excellence), and 2) building the community (community excellence). In this process, we must bear in mind that weâ€™re trying to appeal to certain relatively distinct groups of people:

Users
Developers

Both groups view technical and community excellence differently.

In general, as far as users are concerned, if the product works, theyâ€™re (mostly) happy. (If theyâ€™re really happy, they might even tell their friends) As far as community is concerned, users are happy to occasionally rely on the community for support when things go wrong (Why canâ€™t I play my music, etc). A userâ€™s experience in both respects will dictate how long the user will remain loyal. For example, if XMMS2 canâ€™t easily play a particular file, the user will seek an alternative solution and likely switch to a different player. If the user cannot get the community to resolve a particular problem, or finds the community relatively unfriendly, he will likely gravitate towards a more friendly community.

As far as developers are concerned, technical excellence is about producing interesting code in particular ways - a more efficient algorithm, a more flexible plugin system, a library with a clean API, a seriously cool feature thatâ€™s not available anywhere else. The cornerstone, however, is the existing developer community around the project - these existing developers are the gatekeepers to the existing codebase, the ones with inside-out knowledge of how the existing system works, the ones who share the history of the project and dictate where it is going. The interface between contributing developers and core developers is exactly where the value of â€˜open sourceâ€™ comes into play. On one hand, contributing developers are attracted by how easy it is for them to modify existing code to introduce new features or fix defects, and on the other hand, core developers must have processes in place to ensure that code of relatively high quality is accepted - while encouraging the better contributors to remain interested.

Somewhere in the middle, thereâ€™s an intersection between the set of users and the set of developers. This typically takes the form of passionate users with certain skills moving towards becoming developers by contributing code to the project. In general, I think that this should be encouraged, as it grows the base of community members available to support users and induct new developers.

OK, so I’ve talked a bit about what I think is important for XMMS2 as a community. I’ll post some more later about users, developers and XMMS2 as the product.

XMMS2 vision

2009-02-15T22:38:20+00:00

Following up on my post from FOSDEM I have now started the process together with the XMMS2 community to define our Vision. We are working on getting a version of this vision that everyone feels ok with. You can see our work (and chip in if you want) at the following wiki page.

Dollhouse

2009-02-15T22:28:53+00:00

First episode of the much talked about Dollhouse was aired the other day. I got my hand on a digital copy and I watched it with a lot of anticipation. Aaaand it didn't let me down completely, but it didn't wow me either.. I like the concept, it's pure close-future sci/fi with the whole download/upload of memory concept well in place, Elizas performance was solid, but still something was missing. I am not giving up on this yet, I have faith in you Joss Weadon! But I hope we will see more weadon-esque humor and cleaver twists in the coming episodes.

android + last.fm = best thing since sliced bread!

2009-02-11T04:39:04+00:00

Installed the Last.FM player on my Android yesterday and I suddenly knew that I had just taken a leap into the future.

The days of myPod’s and other digital music players are reaching their end. I realise that while writing this, millions of people sit in front of their computers pushing music into their little gadgets before heading out in the street or whatever, and you know what…

<blink>THEY’RE DOING IT WRONG!</blink>

What they should do is to get themselves an Android or iPhone, install the Last.FM app, just head outside and click the ”xxxx’s Library” station and enjoy song after song they probably just want to hear right now, for free! The whole world of music instantly available from that Internet enabled device in their pocket.

<blink>THIS IS THE FUTURE! IT’S HERE!</blink>

It’s has also revolutionized my use of Last.FM. As I’m using it on the go I’m not really doing anything other than listening to music so it brings me closer to the music in a whole new way.

If I hear a song it’s really easy to just pick up the phone from my pocket and press the <3 button, maybe skip to the next song if the current one doesn’t fit my mood, or if the song reminds me of someone, the share button is just a click away, both share to email from the android contacts list, or to my friends at Last.FM.

I haven’t been this excited about a piece of software since I first started using Xbox Media Center, this IS the best thing since sliced bread (or XBMC in this case).

XMMS2 Developers at FOSDEM 09

2009-02-09T12:03:14+00:00

We had a blast at FOSDEM as usual. Here is the obligatory group-photo:

From the left: Erik Massop, Alexander Botero-Lowry, Auke Schrijnen, Daniel Svensson, Tilman Sauerbeck, Tobias Rundström, Sébastien Cevey, Kate and Sebastian Noack.

Update: Fixed spelling of Tilman's name, Sebastian's name and changed "from the right" to "from the left".

First vision, then hack.

2009-02-08T12:48:58+00:00

I am currently sitting in one of the Hacker Rooms at FOSDEM in Brussels. I have spent my last two days together with a great group of XMMS2 developers, just as last year. I really enjoy these events where you have the possibility to actually meet the people you spend a lot of your spare time with.

The discussions this year was very different than last years topics. This year people was more concerned about how to organize the distributed team and work on the "right stuff". I find it pretty funny since this is just the things I have started to do at Purple Scout recently.

I have decided to give it a go for the XMMS2 community as well. I am sure that I can leverage on some of the things I have learned recently, but I also know that it will be very different since the developers of the XMMS2 community are not working on XMMS2, just doing it for the kicks (and possibly the chicks, but I think that is just a big misunderstanding).

One of the talks that inspired the discussion was Bdale Garbee's keynote about the Debian community. He said that you shouldn't underestimate the values of values. Basically you'll need to share common values and goals within a community in order to get everyone aligned. Debian has a Social Contract that outlines the vision for the Debian project.

My plan is to establish a similar document for the XMMS2 project. It will be a document that is created by the community for the community and will hopefully allow us to align better towards the ultimate world domination goal.

After this document is done I will move on and establishing our "Code of Conduct" or "Development Guidelines", this document will outline how we work together as a group and what processes we follow.

So the current plan for world domination is:

Establish the XMMS2 vision document
Establish the XMMS2 code of conduct document
Get everyone super-hyped about XMMS2 development
Hack!
????
World Domination! (Or at least 'Ready to amaRock').

GTD with Things

2009-02-02T08:32:27+00:00

Wow, it really took a long time to write this entry. I have now been working at Purple Scout for around two weeks and it has been really good. I have a fantastic team to work with and I have already done some good work (in my own humble opinion). I have also had the chance to really start using GTD in my daily life (it's hard to organize your life when you only play video games, which was what I did during my vacation). So far I am very pleased with it, but the test of time will really show if it reduces my stress and improves my efficiency.

I am using Things from Cultured Code as my organizer software. It's a very clean software that implements the basic lists from GTD (Inbox, Next, Someday, Scheduled, etc). It also have a very flexible tags system that I use for a number of things and most important it has iPhone synchronization.

I use the iPhone application as my on-the-go collector. Most things I have to do pops up in my head when I am taking a walk or sitting in a meeting, in true GTD style my brain is stupid as well, so I just flick up my iPhone and scribble a few words in there. I concentrate to get a reminder mostly in the iPhone because it doesn't take that long to do that way and then expand on it when I sync it to my desktop client.

Collection with the desktop client is also very good, when I identify a task I just press my globally recognized shortcut (meta+ctrl+space) and it brings up a dialog where I can enter my task.

Things has the concept of Areas of Responsibility and Projects. I use the Areas as "larger projects" that can have several sub-projects. For example is 'Home' one of my areas, in there I can have projects like 'Redecorate the room' which in turn can contain specific tasks. Another area is "Work" but I also have a area for one of the bigger customers we are working with, since we are running ~8 projects together with this customer. Important to note is that tasks that are organized into a project can not be scheduled, they can only be 'next' or 'someday' as far as I understand it, but tasks that belong to the area directly can be scheduled. I am not really sure why this is, or if it's a bug.

When I get to my organization phase I first scan items that should be put into projects and put them there and then areas. I don't have item outside any area. Tasks that goes into projects get the tags of the project so usually I don't have to apply any extra tags to these tasks, but since areas doesn't have tags I have to apply them to these posts. The most common tags for me is "work" and "home" because when I head over to the "do stuff" phase I can filter my things based on tags, which removes a lot of distraction "now I am at work and can only see things I should do at work" works great for me.

Things isn't without flaw, the things that annoys me most are:

Pressing the icon in the dock doesn't bring up the minimized Things window.
Synchronization with iPhone only works over wifi and you have to be on the same network. Also if your firewall/router/switch for some reason filters bonjour (mDNS) it will not work (I had to fight the system administrator at work for this).

I hope these issues will be addressed in future updates of things.

That's it for today, next entry will probably be about SCRUM, since we just implemented this at work.

Programando un cliente xmms2 [1]

2009-01-11T08:17:07+00:00

Antes de comenzar a programar un cliente para el xmms2 tendremos que investigar como funciona, como es que logra comunicarse con un o muchos clientes al mismo tiempo.

Para interactuar con el servicio xmms2d es necesario hacerlo por medio de un intermediario (middleware) que llevara la comunicación entre el servidor y el cliente.

Es decir, el demonio xmms2d se ejecuta a la espera de peticiones, mismas que le serán pedidas por el intermediario; en la imagen superior vemos a dos objetos de tipo libxmmsipc quienes son los que están enlazados y pueden comunicarse en el mismo lenguaje, empero, el de la izquierda se entiende con el demonio, y el de la derecha con el cliente. A estos dos en conjunto les llamamos Middleware.

Afortunadamente existe una libreria en python que ayudara a actuar como intermediario entre el demonio y nuestro cliente. Esta libreria es llamada python-xmmsclient.

Los desarrolladores de xmms2 nos proponen algunas reglas de deberemos seguir para tener un buen funcionamiento entre nuestro cliente y el servidor, y no afectemos configuraciones que todos los clientes utilizan.

Entre ellas, respetar la variable de entorno XMMS_PATH, o si nuestro cliente guarda configuraciones podremos hacerlo dentro del directorio apuntado por $XDG_CONFIG_HOME. Así como algunas otras mas (para mas información aquí).

Los desarrolladores nos han facilitado tanto el trabajo que disponemos de Medialib, que es una función que parsea la información Tag de un archivo de audio, poniéndola en una tabla que fácilmente podremos manipular.

Existen dos modos de comunicaciones básicamente, un modo síncrono y uno asíncrono, cada uno con su respectiva función para determinados casos. Vamos, que si desarrollamos un cliente en modo texto plano para consola, podremos usar un modo síncrono sin ningún problema, pero si nuestra aplicación será algo mas sofisticado y gráfico, lo mas recomendable es usar una comunicación asíncrona.

¿Por que asíncrona? Bien, para que me puedas entender mejor voy a tratar de explicar algunas funciones que se llevan a cabo en la comunicación cliente-servidor.

Pongámoslo fácil, cuando nosotros ponemos play, estamos ejecutando un comando, y este comando envía una señal al demonio que interpreta y regresa un resultado, mismo que el cliente puede interpretar a como le de la gana. Pero, supongamos que abrimos 2 clientes, ambos saben que existe una lista de reproducción cargada, en el primer cliente se nos ocurre borrar esta lista, entonces el segundo seguirá teniendo la lista completa sin sufrir ningún efecto y esto podría causarle problemas, por lo tanto, este debía ser avisado (por medio de una emisión del demonio) del cambio y tener la misma información que el primero, por ello que la comunicación debería ser asíncrona.

Por ahora todo ha ido perfecto, en los próximos post’s tratare de mostrarles como hacer una conexión con un sencillo script en python.

Enlaces:

Writing Xmms2 Clients

Python y xmms2

2009-01-08T15:54:12+00:00

En el post anterior hable de este misterioso reproductor de audio para sistemas operativos de tipo unix, y debido a la falta de interfaces gráficas (Clientes) que satisfagan mis necesidades como usuario he decidido programarme uno.

El lenguaje que elegí eventualmente es python usando la librería wx; ya que quiero probar mi suerte en diseños de GUI y ver que tan adaptables pueden ser.

Bien, algunas características que quiero implementar.

Panel de Control
- Controles de Next, Back, Play, Stop, Pause, etc.
Panel de reproducción.
- Donde mostrará información del track en reproducción (tiempo, artista, titulo, etc).
Playlist
- Lista de reproducción.
  - Mostrando Artista y Titulo de la pista.
- Opciones para añadir o quitar archivos de audio, así como salvar o abrir listas de reproducción al estilo del xmms en su primera versión.
- Opción de Búsqueda. xmms disponía de la opción de búsqueda rápida (esto se hacia presionando la tecla J) que es lo que quiero lograr.

Por el momento he diseñado una interfaz que me agrada (un poco parecida a esperanza), aunque probablemente pueda cambiar en algún momento y quiero usar mi blog para dar a conocer el seguimiento que le estoy dando.

Afortunadamente existe una librería para python (python-xmmsclient) que me facilitará el trabajo, pero de ello hablare un poco después. Aquí muestro el interfaz que he diseñado.

El proyecto llevará por nombre Angel, aunque no es el definitivo, y el motivo, bueno, este si es personal. Y si alguién se anima a contribuir al proyecto hagamelo saber, toda ayuda es bienvenida.

Introducing GTD - Inbox Zero

2009-01-04T22:38:04+00:00

As you might or might know I resigned from my position at Procera Networks in the end of 2008. My new position will be at a company called Purple Scout, where I will lead a small team of developers and develop processes and infrastructure for in-house development work. Between my two positions I have managed to scrape together almost a month of spare time. While most of this time has been spent with family for holiday celebrations I have also spent quite some time researching GTD (Getting Things Done). I have decided to decided to try to implement this full out at my new position.

I will spend some posts in the blog about my way to implement this methodology. I will not try to explain all the finer details about GTD, this is explained in numerous sites around the internet. I will just described my attempts on implementing it. So far I haven't really implemented it fully, but this is the steps I have done so far.

I read the book and I don't think there is a short cut around that, just read it. Also listen to the 43 folders podcast with David Allen interviews. They give you a lot of practical tips.

I have been using Things for a long time, both for my Mac and for my iPhone, but I have never really got around to learn how to use it correctly, the pieces was falling in to place when I started to read the Getting things done book, more about that one later.

First thing I really implemented was the Inbox Zero mail handling. I have two mail accounts, one for my work and one personal GMail account.

I read my work email with Mail.app and I started off by changing the settings for getting emails in Mail.app, instead of polling email every 5th minute it's now polling every hour. I also turned of "Badge" notification (i.e. showing in the icon how many new emails you have) and disabled Growl Mail. I think these things are essential, because the whole point with GTD is that you should have specific slots for collecting and processing data, if you get interrupted when you actually do work this could really hurt the process. Secondly I downloaded and configured MailActOn to handle three different keyboard shortcuts: Ctrl-A will move the email to the Mail Archive folder, Ctrl-T will move the email to the To Do mail folder and Ctrl-R will move the email to the Read folder.

This makes it very easy to sort the email when they arrive. If it's a item that I can't do anything about and I don't want to save it: I delete it, if it's a email I can't do anything about but I want to save it for future reference I press Ctrl-A and get it out of my INBOX. If the email contains something I want to read, but is not a direct action I press Ctrl-R and revisit it later when I have some spare time. Now if there is a action in the email, something I need to reply to or do in any other way, then I press Ctrl-T. The emails that ends up in the To Do folder are collected and categorized in the "process" phase. When collected and categorized I will archive it. This is not optimal, my goal would be to get the To Do emails filed in my Things INBOX so that I have just one way to collect actions.

GMail is actually pretty well prepared for GTD. It has the concept of "archive" that just get's things out of my INBOX and into a search able index. It also have the possibility to put a Star on emails with keyboard shortcuts. I use it the following way: press 'e' and archive emails that I can't do anything about, star the email and archive it if it's something I want to read or to do anything about, then collect and categorize the starred messages later in my collection phase.

Instead of writing a monster post for everything I have done so far I will stop here and write another post later in the week about how I use Things and my data collection. I also have a lot of ideas on how to work with GTD in my future team, more about that will also come later.

Music of 2008.

2008-12-22T21:46:08+00:00

End of the year, let's summarize how the electronic music scene looked like in 2008? Generally there was a lot of talk about how the "synth" genre is dead, no-one innovates and so on. Well, I for one tend to disagree, there was a lot of really interesting releases this year, as you can see below.

5. Negative Format - Gradients

Negative Format returns with yet another release that is both trance, EBM and dreamy sound scapes. The track Hues of Grey is probably one of the best tracks NF ever did. Looking forward to even more tracks from NF in the future.

4. Ayria - Hearts for Bullets

Ayria or Jennifer Parker released a very very good record 2008. She describes her music as "Tit-zerEbb" style, greasy bass-lines, great hooks and hard beats. Together with Jennifer's voice this makes for a very very pleasant musical journey. Best tracks include "Girl on the Floor" and "Invincible".

3. Informatik - Beyond

This release really came as a surprise for me, I have heard Informatik before but I have never really gotten into their music. Beyond on the other hand really blew me away! Catchy synth-pop tunes with a powerful voice and awesome hooks. Listen to the tracks "Nothing Greater" and "Don't be Afraid" and be amazed!

2. Standeg - Ultra High Tech Violet

Another surprise! By mid 2008 Standeg released a free digital EP called "Rushing Pictures", after listening to this EP day out and day in they finally released "Ultra High Tech Violet". This is innovative release mixing trance sounds, intriguing melodies and very fine details. This is one of those releases where the more you listen to it, the more details you notice. The music is like a futuristic sound track for a sci/fi future. Best tracks are "25 hours", "Homes & Gardens 3.0" and "Image in motion". Haven't you bought it yet?

1. KieTheVez - Non-Binary

I have been talking about innovations and complex music for a futuristic world. But sometimes plain old beautiful will just work! KieTheVez is a Swedish synth-pop band from Gothenburg, they released a couple of records during the 90ies but have been silent for 11 years before they released "Non-Binary". This is pure synth-pop bliss! Haunting, beautiful and with great sing-along values. This might not be innovating or complex, but it's still great and it tops my last.fm list for the year! Smash hit is "One world for the next" but the disc is filled with awesome tracks.

Worth to mention as well is that the best gig of the year was Interlace at electriXmas, they have just released two new songs "istatue" and "nemesis" that can be found at their myspace page. If the new material will be anything like these two songs then it's going to be one of the strongest releases they ever made.

This years disappointment is Imperative Reaction's "Minus All" which is pretty dull record compared to the rest of their material. To bad, they used to be one of my top groups.

Now I am looking forward to 2009 with up-coming releases by Interlace, Combichrist, Depeche Mode, In Strict Confidence and hopefully a new Headscan release.

Long overdue post

2008-12-16T18:05:03+00:00

2008 was a crazy year...

This is the reason I haven't been posting stuff to my blog that often. I really hope that I can get back into it during 2009. So much of my creativity was lost into my day job, so much of the fun was stripped away. This is why I have resigned from my post at Procera Networks.

From the 12th of January I will start my new job at Purple Scout. I have been hired to structure their newly founded development group, to create processes and infrastructure for in-house development projects.

Purple Scout is a workplace where I think I can find my creativity again. Hopefully this will mark my return to open source and XMMS2, which I miss so much. In light of my new position I will also try to blog a bit more about driving a development team and development processes which has been inspired by both GTD and my work with the XMMS2 community.

Also watch out for more blog posts about this years best music and books later on.

Some pictures from FOSDEM

2008-12-11T19:39:58+00:00

Above you see Auke, me, tilman and anders in some discussions about S4 and friends.

And above a here you see rafl, wose, theefer and nesciens listening to ramblings.

Nice tshirts for everyone!

This is me on stage, doing my thing.

From left to right starting at the top: me, theefer, anders, auke, wose, rafl, walluint
From left to right starting on the second row: nano, tilman, nesciens

It's Over!

2008-08-19T14:15:33+00:00

Well, it's not really over, but yesterday, the 18^th, was the last day of coding for Google Summer of Code students. Service clients are 90% done as of this writing, and it shouldn't be hard to get the other 10% done in a day or two, plus some bugfixes. But deadline or no deadline, service clients are a sugary-sweet feature that XMMS2 really needs, and I will be hacking on them for a long time to come.

SoC certainly solidified a few lessons about the real world for me. Most importantly, in my humble opinion, is that money changes things. When you're coding for money, you're coding under a deadline, and it's incredibly easy to fall behind. The result/value split code that service clients depended on was supposed to be completed and merged before SoC even began. It's only now that SoC is over that the result/value split is "done" and it's still unmerged. The API for my project changed half a dozen times before I wrote a line of its code. And a myriad of personal issues took days and days of quality hacking time away from me. Lucky for me my mentor(s) were great in helping me sort out issues with the design and code, and reestablishing goals to fit the program into the summer. Thank you, nano and theefer!

A sure bonus is I now have a jumpstart on understanding the result/value split code and all that it brings. Since it is a pervasive change to both the client library and server-side, there's no getting anywhere without knowing how to work with it. Plus, as a member of the XMMS2 team, I'll be there after SoC to help merge, document, and answer questions.

Now with the finish line in sight, the thought of the upcoming mergefest and eventually, users using service clients has me more motivated than ever before. And I'm filled with a sense of great pride that I stuck it out through the summer and created something I feel is worth being proud of. But for now, I'm going to play a quick round of DDR with my little sister and get back to work.

Next on the Agenda...

2008-07-23T23:40:35+00:00

Well, the client-side of things is mostly done for now, so it's time I turned my attention to the remaining items. The server side of things needs to be updated/fixed and the service client manager (SCM) needs updating. The server is fairly straightforward, but I have some concerns about the SCM.

Does the SCM record clients in its configuration when they are run? Probably not. How would it record the executable path, for example? We should find a way to make this more automatic.

Provide methods to read/write SCM configuration.

service_client --register #registers its configuration using above methods

The above command can be called by waf during build to eliminate user intervention. The clients are already registered and ready for use upon installation!

Can we rename the SCM's shutdown function to "kill" (and perhaps redefine its functionality) or something that can't be confused with xmmsc_service_shutdown?

Can we change the default value of the "monitor" option (to check the configuration directory for updates) to true? This seems to cooperate much better with user expectations.

Can we get rid of the "timeout" option (to wait before killing a service client after a shutdown request is received)? If we rename the method to "kill" its intentions will be a lot more obvious--take down the client now.

Visions of Grandeur, Llamas, and API

2008-07-20T06:19:41+00:00

I've been really bad about updating this blog, I just noticed. So here's some fresh, tasty meat to dangle in front of your snapping jaws. The past several weeks were met with real life issues and coding issues, but not a lot of real code. But very recently I started working on the new API, and it's looking exciting!

Here's the vision so far. A service client (SC) creates a new service, stored in a service_t. The SC then can add methods by giving it a name, description, and arguments, each with a name and type. There is a variadic version of this which lets one add a method at a time, and a more primitive version to add a method, then one argument at a time. This makes it easy for C programmers and binding authors alike.

Here's what the data structures look like:

service_t:
 char *name;
 char *desc;
 uint32_t major;
 uint32_t minor;
 x_list_t *methods;

 uint32_t ref;

service_method_t
 char *name;
 char *desc;
 void *udata;
 xmmsc_service_notifier_t func;
 xmmsc_user_data_free_func_t ufree;
 xmms_value_type_t rettype;
 xmms_value_t *args;

The data is held in value_ts whenever possible because these are the new universal type being introduced with the result/value split code. A value_t can contain any of several basic types and can be serialized and deserialized automatically. Its representation and usage is effectively the same on the client and server. Because a service_method_t must contain function pointers and user data, it has to be a struct. (How could you send a function pointer over IPC?)

The next step is for the SC to call service_register and register its service with the server. Internally, service_register handles the conversion from service_t and service_method_t to representative value_ts, then sends them off to the server.

A client can request any information about the service from the server using service_describe. Since the data is already conveniently encapsulated in value_t form, it is just shipped off to the client. The client can then see everything except the actual function pointers, udata, and refcount (why would it want these anyway?).

Said client can use this data to figure out, say, the version of the service is within its own supported range. So the client queries a method. Let's make this more interesting with an example. We'll make a client LlamaGUI that implements support for counting llamas using the LlamaCount service.


void llamagui_llama_count_get (connection_t *xc)
{
  value_t *farms = list_new("llama_farm_a", "llama_farm_b");
  value_t *args = dict_new("farmlist", farms);

  res = service_query(xc, "LlamaCount", "count_get", args);
  service_notifier_set(xc, res, llamagui_llama_count_callback);
}

This request is sent to the server using the provided connection xc. The server simply looks up the "LlamaCount" service and shoves the request right along to the sc. Back in the sc, the request is checked for well-formedness. Are all the required arguments there? Are they the correct types? If not, a value_t containing an error is sent back through the server to the requesting client. If so, the notifier method is called, processing the request:


value_t *llamacount_get (connection_t *xc, service_method_t *method, value_t *args, void *udata)
{
  int count = 0;
  value_t *farmlist;

  farmlist = value_dict_get (args, "farmlist");
  for(; value_list_valid(farmlist); value_list_next(farmlist)) {
    count += llama_farm_count (value_int_get (farmlist));
  }

  return value_new_int(count);
}

This starts the return trip through the server and back to the requesting client. There is one more check performed to see that the return type indeed matches the type given at registration. A service method may always send back a value_t containing an error. If the types do not match, however, an error will be returned instead of the original value_t.


void llamagui_llama_count_callback (value_t *ret)
{
  if (value_type(ret) == VALUE_TYPE_ERROR) {
    llamagui_error_set("Oh no! A llamacaust occurred. Error %s", value_error_get(ret));
    return;
  }

  llamagui_llama_count_set(value_int_get(ret));
}

The LlamaGUI user gets her llama count right next to the XMMS2 playback controls and playlist of llama-friendly songs. Everyone is happy.

DrLecter escaped!

2008-06-15T11:49:18+00:00

Good evening, Clarice.

Finally a new XMMS2 release has arrived. This time it contains even finer meat, such as a whole bunch of new plugins and support for ruby 1.9. The XMMS2 Team would like to extend a big THANK YOU to all who have helped out with this release. Hope you will have as good time eating it as we had cooking it!

You can obtain XMMS2 here:
Release notes: http://wiki.xmms2.xmms.se/wiki/Release:DrLecter
Source: http://sourceforge.net/projects/xmms2

It Begins

2008-06-13T21:07:03+00:00

Summer of Code 2008 officially kicked off on May 26. Within two days, I had about 1500 lines of C written for the result/value split needed for service clients to have a clean API. I started out by writing a patch that was just enough to split xmmsc_result_t into xmmsc_result_t and xmmsc_result_value_t. Then I got the suggestion to create common implementations of all the types used by XMMS2's IPC and encapsulate them in an xmmsc_value_t. That accounted for about 1400 of the 1500 lines of code. :)

As it turned out, all that work wasn't necessary and only the original patch was needed. Fellow XMMS2ers theefer (Sébastien Cevey) and nesciens (Erik Massop) took over from where the patch left off, completely separating the two structures and even converting the CLI code to use the new value_t. So now, service clients will be able to pass arguments and return values around conveniently as xmmsc_value_ts.

Now the big question in my mind is how do I merge this beast? Somehow, I need to get service client code on top of the result/value split code. Do I simply rebase the code and resolve every conflict I can see as I go? Do I squash the service client code down to a few commits? What about authorship in both cases? One thing is certain; it's going to be very hard to visualize everything that needs changing to use the new value_t. But I guess this is just another lesson in how developers do things in the real world and why small, incremental commits are so useful in preventing this situation.

So I suppose there is really only one option: to rebase and pray that it's not impossible to fix. But that's the biggest obstacle in the way of getting service clients into the next release. Anything for the t-shirt!

Service Clients Redux

2008-05-23T17:03:53+00:00

It's that time again. People are walking around in flip-flops, getting tan(ner), and licking ice cream from cones. It's summer (or it's close enough, anyway), and this summer I'll be getting my tan from the computer monitor and my ice cream from the freezer. It'll be a basement-dweller's summer for me as I'm coding on XMMS2 in this year's Google Summer of Code.

I'll be working on service clients, a continuation of last year's unmerged work. The concept is to provide so-called "service" clients which perform a service (surprise!) that can be re-used by other clients so client authors aren't reinventing wheels all the time. It's just another way XMMS2 eases music player development to the point where making your own interface is a weekend project instead of a thesis project.

What Service Clients Are

The client-server nature of XMMS2 is a constant issue when trying to add new features or fix bugs. What was trivial to accomplish in a monolithic music player is not so trivial in XMMS2, and vice-versa. Service clients are a way to provide the same whipped-cream-and-cherry features you'd find in a monolithic client, but in a reusable, modular, and extensible form. It's cleaner than adding new stuff straight to the daemon, but still fairly simple and straightforward to use.

Service clients work by registering themselves and their callable methods with the XMMS2 daemon. Regular clients (or even service clients, as they're regular clients, too) request a service client from the daemon and call its methods appropriately and get back data. It's that simple. Album art lookup, tag lookup, last.fm submissions, and FreeDB lookup are all easily written as service clients and their functionality is very easily included in any client by use of a few methods. Services are even browseable so, with a little user intervention, a new service client could be used from a client that has no idea how to use the service, at least in theory.

What This SoC Will Bring

Service clients were part of last year's Summer of Code program, completed by student Ning "zeegeek" Shi under the direction of mentor Sébastien "theefer" Cevey. The API works and there are a couple service clients floating around, but zeegeek's codebase was never merged with the main XMMS2 tree. The code needs a full review and some questions about remaining oddities answered. A little bitrot has accumulated since last summer, too. My job will be to clean up the code and get it merged, first.

Later I'll also be writing the first language bindings in Ruby. This, too will be followed by a merge. Too often, Summer of Code projects are completed but remain unmerged for months, creating lots of work later. This summer, I'm including merges as part of the project goals. Once the service client API and Ruby bindings are completed and merged, it's time to take service clients' virginity. It won't be just a framework anymore, but I'll implement some useful clients, starting with a port of xmms2-scrobbler. And of course, this'll be followed by a merge as well.

Then more cool clients will follow. The next generation of collections, (Collections 2.0) also being implemented this summer, will probably implement the collections parser and a more flexible party shuffle as service clients. This is an exciting collaboration opportunity. Other possibilities include a medialib-updater styled service, taglib client, FreeDB/musicbrainz lookup, and album art lookup. I'm outlining way more service clients than I can handle this summer in the hopes that I can pick out an important and doable few and get those few done and merged by the end of SoC. They'll also be indispensable means of clearing up remaining kinks and bugs in the code while establishing some good example code and helping me write documentation.

Working on service clients this summer is exciting and I'm overjoyed that this is my first SoC. This is an excellent project with an excellent team during an excellent summer, so I've little doubt that all this year's projects will be successful. I'm hyped, and you should be, too! Stay tuned for when I finally settle down with a six-pack and start exercising my fingers.

Google Summer of Code™- students accepted

2008-04-22T00:48:12+00:00

Google was kind enough to allocate 6 (yes six!) slots to XMMS2 for this year's Summer of Code. We received many high quality applications and the selection was harder than ever.

The selected projects are all very exciting and span all over the xmms2 codebase: from deep down the medialib, with an experimental new database backend (S4), through an upgraded iteration of collections (Coll 2.0), all the way up to service clients. In the realm of clients, we will see a new powerful command-line interface (nycli) and an innovative GUI client focused on social metadata (Cloudstream). On top of that, the last project will revolutionarize our IPC layer (GenIPC).

Note that most of the projects build on top of last year's GSoC. See the full list of accepted projects (and students) if you want all the details!

So, to the accepted students: congratulations and may there be lots of good code written!