Extraordinary “Master On Free Software” enrollment period is open until October, the 1st.
Don’t forget that open sessions are going to be held in September and they are free.
Master on Libre Software has published its open sessions in September in A Coruña. They are open and free to public, but registration is required because capacity is limited.
September, the 3rd, Friday:
September, the 4th, Saturday:
September, the 10th, Friday:
September, the 11th, Saturday:
September, the 17th, Friday:
September, the 18th, Saturday:
More information in:
El Máster en Software Libre organiza en Septiembre unas jornadas abiertas al público. Estas jornadas están compuestas de las siguientes actividades:
Las Jornadas tendrán lugar en las sede de Igalia en Coruña en la dirección Calle Bugallal Marchesi 22, 1º. Para asistir registrese en el Formulario de Inscripción.
El programa de las jornadas es el siguiente:
Viernes 3 de Septiembre:
Sábado 4 de Septiembre:
Viernes 10 de Septiembre:
Sábado 11 de Septiembre:
Viernes 17 de Septiembre:
Sábado 18 de Septiembre:
Aunque la entrada es libre, se requiere inscripción previa para controlar el aforo. El aforo es limitado por lo que se procederá al registro por estricto orden de llegada. Además, es posible registrarse para cada una de las sesiones individualmente. El formulario de inscripción se encuentra disponible en la siguiente página.
I have been kindly invited to be in the Program Committee of the 2nd International Workshop on Empirical Software Engineering in Practice (IWESEP 2010), that will be held in the city of Nara (Japan) next December 7 and 8.
Also, there will be a tutorial about Mining Software Repositories, for the first time in Asia, with lectures by Ahmed E. Hassan (Queen's University), Sung Kim (Hong Kong University of Science and Technology) and Thomas Zimmermann (Microsoft Research and University of Calgary).
For more details, visit the website of the workshop, or download the Call for Papers.
The deadline for abstract submission is October 4, 2010 October 11, 2010,
and for paper and demo submissions October 11, 2010.
If you’re using Grilo from git, last patches enabled improved GObject Introspection so you can start using Python with PyGObject to develop your applications.
A Python clone of the grilo-test-ui is provided, and should give you an idea of what can be done with these new bindings: basically enjoy all the power in Grilo without needing to touch C code, and without us having to maintain manually created bindings.
If you’re a JavaScript user, then you need to watch bug #616961. As JavaScript doesn’t support GParamSpecs yet (#626047), you’ll need this patch which replaces GParamSpec annotations with uints. And now, time for unit testing with PyGObject!
Using Grilo bindings from Python console
grilo-test-ui using GObject Introspection bindings
Missing GParamSpec when accessing from JavaScript
“Érase una vez ….“. Así empiezan muchos de los cuentos que leímos. Donde aprendíamos que ir sólo por el bosque era peligroso o que las mentiras sufren de efecto boomerang. Porque de algún modo, las historias dan forma a nuestra visión de la vida, el universo … y todo lo demás.
Justo hoy he recibido un enlace a un video maravilloso sobre el poder de las historias (y del peligro que supone “the single story“):
Por eso me animo a hacer esta mínima recopilación de historias que han marcado mi -limitado- entendimiento de fenómenos tan dispares como el caldo de cultivo del integrismo islámico o la apertura china al capitalismo. Son radiografías noveladas de un momento estelar de la humanidad.
"I hear and I forget. I see and I remember. I do and I understand". That's a very well known quote by Confucius, that is usually mentioned by pedagogues. Basically, it says that most of the times the best way to learn is by doing.
Since the end of July, and thanks to the generous funding of the UAX, I am visiting the SAIL research group at Queen's University. As part of my visit, last week I went to Waterloo to visit the rest of the team that works over there. Jack and Ahmed took me around the campus of the University of Waterloo, and I noticed that there was more campus activity than at Queen's. They explained to me that it was because of the "coop" students. At first, I did not really catch what they meant. What is that "coop" thing? At Waterloo, students have teaching terms and "coop" terms, when they go to companies and work there for six months, as part of their learning experience. They work and attend classes, during all the scholar courses. There are different options, like working only during summer terms, or doing it alternate, which means that some students have to attend courses during summertime. Basically, there is always a teaching semester, even in summer. And both attending classes and working count as part of their studies. Interesting, huh?
According to Wikipedia, Waterloo has the largest "cooperative educational" program in the world. There is a full article in Wikipedia about cooperative education, full of interesting references and experiences about the topic. It seems that it started in the United States at the beginning of the 20th century, with the goal of improving the learning process of engineering students. They realized that those students who had to work to cover their expenses were achieving better academic results and more job opportunities.
Actually, last weekend, while hanging out in Kingston, I found a group of students with a "Formula 1"-like car, and they explained to me that they built the car themselves, as part of their undergraduate studies on Mechanical Engineering. They actually have created a racing and engineering team, and were ranked first in Canada in the competition. The car even had some telemetry systems, that they used to tweak the car to the different circuits where they have to compete. They car cost about 50,000 CAD to build, with most of the budget coming from Queen's, but also with funding coming from different sponsors. I was amazed that a bunch of guys in their early twenties could have built such a car, which was by all means equivalent to the cars that we see in the Formula 1 racing, and above all, that they did it with so many constraints. They start have the car at the beginning of the course, and in the same scholar course, they have to participate in the competition. If they do that for undergraduate studies, imagine what endeavors will those students will be able to manage in their professional future.
So far, I thought that it was better to delay contact with the real world while studying. If you start to work, it will distract you, you will not get grades as good as you could, and even though you gain in experience, you will loose in grades, that are important for some future options (like applying for a research grant, at least in Spain). But having known about these initiatives, I have changed my mind. Grades, for themselves, are useless, They are just a carrot in front of students that make them concentrate in getting better grades, they are not a learning instrument. In engineering studies (and probably in other studies), learning is achieved by doing, and everything that separate students from doing is wasting the time of professors and students. In my experience as student, and short experience yet as lecturer, those students that go to a company for some time while they are still pursuing their undergraduate studies have to face more difficulties to pass their courses, and some times even the lack of understanding by lecturers, that want them to attend their classes. In summary, the policies that we use for grading, teaching and student practices, discourage students from going to industry to gain experience, because that is usually reflected negatively in the rest of their curriculum.
Next time we face a case of a student who cannot attend classes because she is working (either as a part of the curriculum, or just to earn some money), instead of punishing her, we should think about the goal of their studies, and therefore as our goal as teachers. Is it their learning or our grading? Is it more important to attend our classes or to be part of the real world of the profession out there? And should we discourage or encourage that? Do we want them to hear and forget, see and remember, or do and understand?
El plazo ordinario de inscripción ha finalizado el pasado 31 de Julio. Desde el 1 de Agosto se abre el período extraordinario de matriculación hasta el Viernes 1 de Octubre.
Podéis revisar la información en esta web con las condiciones de matriculación durante el periodo extraordinario, ya que todavía podéis obtener descuentos por otras vías para el segundo plazo de inscripción.
Las solicitudes se aceptarán hasta el 1 de Octubre, por lo que si estáis pensando en presentar el proyecto fin de carrera, o lo habéis presentado este año, todavía podéis acceder al descuento por participar en el Premio al Mejor PFC con Software Libre
Por otra parte, estamos organizando unas sesiones informativas sobre Software Libre, el Máster y una serie de mesas redondas durante el mes de Septiembre. Estad atentos a la información que publicaremos en esta página.
Another quick one: if you want to watch/follow a product in (GNOME’s) bugzilla, it is explained here.
To watch an entire product, lookup the product in this page. This will show the default assignee (often productname-maint@gnome.bugs). Then add it your your watched users list.
An easy one, but as it took me a while to find it, I put it here as a reference.
Last weekend I’ve been giving the last lesson of the Web module at Master on Software Libre. In this lesson we’ve tried to advance as much as possible in the practice that the students are developing for this module, a web application using Java technologies: Maven, Hibernate, Jetty and ZK.
The last part of this practice has the aim to create web services around this web application based on REST standard. In order to properly explain how this goal could be achieved I’ve created a small example that could be useful for more people.
The Java API for RESTful Web Services is called JAX-RS (and it’s defined at JSR-311) and the reference implementation is Jersey. I’ve tried to find an example using Jersey, Jetty and Maven about how to add REST web services to a Java application, after failing in my search I decided to start my own example based in a post by Tim Reardon.
These kind of services are intended to import/export data from/to a web application, the most common formats are XML and JSON. For this example I decided to use XML, using JAXB standard to map Java classes to XML files.
The final result is a simple application implementing the different HTTP methods (GET, POST, PUT and DELETE) that could help to other developers as example. Along with several bash scripts to to test the web service, I’ve also added a basic client written in Java. You can find the example application uploaded to Gitorious and you can download the source code from there.
General Error.
General Input/Output Error.
by Nacho Uve (noreply@blogger.com) at July 29, 2010 03:16 AM
\e
\e [FILE]
\ef [FUNCTION_NAME]
#\ef dropgeometrycolumn
ERROR: more than one function named "dropgeometrycolumn"
# \df dropgeometrycolumn
Schema | Name | Result data type | Argument data types | Type
--------+--------------------+------------------+---------------------+--------------
public | dropgeometrycolumn | text | character varying, character varying | normal
public | dropgeometrycolumn | text | character varying, character varying, character varying| normal
public | dropgeometrycolumn | text | character varying, character varying, character varying, character varying | normal
(3 rows)
# \ef addgeometrycolumn(character varying, character varying, integer, character varying, integer)
by Nacho Uve (noreply@blogger.com) at July 29, 2010 02:54 AM
Tomorrow I’m leaving to GUADEC 2010. I’m goint to assist only on Thursday this time, when I’ll be doing this year GUADEC talk about Modest project.
This time the talk focus will be completely different, as I’ll be explaining the process towards Modest 4, where we’re focusing in intensive refactoring, with the goal of releasing a product quality in GNOME, Moblin and Hildon/Maemo5 platforms.
Also, I’ll talk about some differences between Maemo and GNOME platforms, and some bits I miss in GNOME platform:
I won’t ellaborate too much, but I’m trying to point some weak points in GNOME platform we could improve (just taking free software Maemo components, or improving GNOME platform components).
The talk will be on Thursday, at 14:45 in Seville room.
Aunque se haya acabado ya la 7ª Guadec-Hispana, para mí siempre será el principio: la primera vez que aporté algo (por humilde que haya sido) a una conferencia de Software Libre. Fue una experiencia muy agradable, a pesar de que hablar delante de tanto hacker produzca cierta intimidación 
. Afortunadamente, la (estupenda) cena del día anterior me sirvió para ir conociendo un poco a la gente, y ver que no mordían: es gente muy maja. Desde luego, es algo totalmente recomendado, tanto si tenéis la oportunidad de presentar algo como si acudís de oyentes.
Todas las charlas quedaron grabadas en vídeo, y la organización se encargó también de recoger las presentaciones, así que no creo que se tarde mucho en publicarlas en la página del evento: son todas muy recomendables. Y, para ir haciendo boca, aquí están las mías: en ellas se habla de Jamp, la aplicación desarrollada en el módulo de Desktop & Mobile del máster. ¡Que las disfrutéis!
I’ve just finished writing the slides for the JaMp‘s talk at the GUADEC-ES 
Maybe it’s still a bit longer than it should, but hey!
So, if you want to know those issues we faced with JaMp (GObject signals, D-Bus -from both C and Python sides-, and some notes about the Maemo port) come visit us to the Computer Science Faculty at A Coruña on 23rd July -next Friday- at 13:00. Grab the program here.
Se acaba de publicar el horario de las ponencias y talleres de la GUADEC Hispana que se celebrará el Jueves 22 y Viernes 23 de Julio en la Facultad de Informática de Coruña. Finalmente ha sido posible dar cabida a las ponencias presentadas con un horario muy compacto y exigente tanto para ponentes como asistentes.
No os olvideis de inscribiros en el registro antes de Domingo, 18 de Julio de 2010.
Los contenidos de la GUADEC Hispana van a ser eminentemente técnicos y van a abarcar temáticas relevantes para la comunidad de GNOME como son los retos que plantea la nueva versión de GNOME 3.0, la accesibilidad de la plataforma (a11y) y la incorporación de nuevos desarrolladores a la comunidad.
GUADEC tratará temas específicos de dispositivos móbiles como es el soporte de dispositivos mutitáctiles (multitouch), la adquisición de imágenes a partir de camaras (Gdigicam), la geolocalización (GeoClue) o la reproducción de objetos multimedia (Grilo).
También se presentarán una aplicaciones de OCR (OCRFeeder), una herramienta traducción de software (Gtranslator) , un reproductor de música por internet (JaMp) o las nuevas librerías y apliación para navegar en la web (Webkit y Epiphany).
Esta GUADEC Hispana también servirá para reflexionar sobre la GNOME Foundation y la evaluación del proyecto GNOME.
La Guadec Hispana es organizada por GPUL y GNOME HISPANO gracias a los patrocinadores Igalia y OpenShine con la colaboración de la Facultad de Informática de la UDC, la asociación GHANDALF y la Secretaría Xeral de Modernización e Innovación Tecnolóxica de la Xunta de Galicia a través de Mancomun y la Fundación para o Fomento da Calidade Industria e o Desenvolvemento Tecnolóxico de Galicia
Some quick notes (the list of things which would deserve a full blog entry for themselves just keeps growing…)
(Sure, there will be other issues as well, and I’ll set up the bugtracker as soon as possible)Ya están disponibles el programa y la inscripción de la VII GUADEC Hispana que se celebrará en la Facultad de Informática de A Coruña del 22 al 23 de de 2010..
La organización de la VII Guadec Hispana se complace en anunciar el programa de charlas, talleres, mesas redondas y actividades para los dos días de congreso. Este año contaremos con ponentes de España, Chile, Perú y Portugal.
Si quereis conocer las últimas novedades del proyecto GNOME, teneis una cita obligada en la Facultad de Informática de la Universidade da Coruña.
La inscripción está ya disponible a través de la aplicación de registro, y estará abierta hasta el 18 de julio, así que date prisa si quieres acudir, ya que las plazas son limitadas.
Guadec-Es es organizada por GPUL y GNOME HISPANO gracias a los patrocinadores Igalia y OpenShine con la colaboración de la Facultad de Informática de la UDC, la asociación GHANDALF y la Secretaría Xeral de Modernización e Innovación Tecnolóxica de la Xunta de Galicia a través de Mancomun y la Fundación para o Fomento da Calidade Industria e o Desenvolvemento Tecnolóxico de Galicia
El programa de este año incluye muchos temas interesantes para los asistenes que quieran conocer como empezar a participar en una comunidad de Software Libre como GNOME.
Pero también permite conocer las últimas novedades del proyecto GNOME en cuanto a su apliación a tecnologías móbiles, estudios de su comunidad, mejoras en accesibilidad, las implicaciones de los nuevos navegadores o el soporte de los sistemas Multitouch, entre muchos otros temas.
Esperamos contar contigo.
The application we’ve been developing at the Desktop & Mobile module in the Master has been accepted for a talk in the GUADEC-ES!
More info on that soon, but you can start by checking the program. Or even better: why don’t you register and visit us?
Igalia y la Universidad Rey Juan Carlos, promueven la IV edición del Máster en Software Libre en Galicia. Con sede en A Coruña, se realizará a partir de Octubre en sesiones de viernes tarde y sábado mañana. Se podrán enviar solicitudes de inscripción hasta el 31 de Julio.
El principal objetivo del Máster es continuar formando profesionales especializados en Software Libre, supliendo la elevada demanda dentro del sector TIC. Se orienta a recién titulados y profesionales que deseen mejorar sus capacidades para gestionar, analizar y colaborar en proyectos internacionales de Software Libre. Cuenta con un enfoque eminentemente práctico, fomentando el trabajo en grupo, y incluyendo como actividad del Master la asistencia a un congreso internacional. Durante el desarrollo de la docencia los alumnos podrán disfrutar de charlas magistrales de personajes relevantes en el entorno del Software Libre.
Accede al Master a partir de 2200€ gracias a la posibilidad de obtener becas y prácticas remuneradas en las empresas colaboradoras y de acogerse a los siguientes descuentos sobre el precio base:
Si además, participas en el Premio Fin de Carrera de Software Libre de Igalia contarás on otro 10% de descuento sobre el precio base. Consulta la política de precios. Entre los colectivos con descuentos se encuentran varios colegios profesionales, asociaciones de Software Libre, empresas asociadas a AGASOL o estudiantes recién titulados durante los últimos dos años.
Ya te puedes matricular en el Master de Software Libre 2010-2011 a través del formulario de inscripción.
Si deseas más información puedes enviarnos tu consulta a través del formulario de contacto.
Last week, Daniel Rodríguez (Information Engineering Research Unit, UAH) visited our department to talk about how to start to collaborate in the field Mining Software Repositories, where to get data, what topics we could do join works on. I prepared a set of slides with practical information about datasets, conferences and journals, to be used as a facilitator for discussion. The slides are available in SlideShare:
The presentation contains some links to datasets that can be easily used for empirical studies, and that makes it possible to conduct replicable studies. Also, there is paper at MSR 2010 that describes the data sources used for the MSR Challenge; the paper is entitled Mining Challenge 2010: FreeBSD, GNOME Desktop and Debian/Ubuntu and contains description of the FreeBSD repositories, of FLOSSMetrics data about GNOME and of the Ultimate Debian Database. If you use the paper for your research, please consider citing it (download the BibTeX citation as text file):
@InProceedings{challenge_msr2010, author = {Abram Hindle and Israel Herraiz and Emad Shihab and Zheng Ming Jiang}, title = {Mining {C}hallenge 2010: {F}ree{BSD}, {GNOME} {D}esktop and {D}ebian/{U}buntu}, booktitle = {Proceedings of the 7th IEEE International Working Conference on Mining Software Repositories}, pages = {82--85}, year = {2010}, publisher = {IEEE Computer Society}, }
As part of the course on Software Engineering that I teach at UAX, we engaged in a research review and debate about how can agile methods and architecture coexist, and which one is better for particular cases.
To prepare the debate, we read a set of papers, most of them from IEEE Software, about software architectures and agile methods. From the list of papers that I preselected, the students decided to read the following:
We also read a IEEE Spectrum's paper about the Virtual Case File, a (in)famous example of software project that failed, partly because of the lack of flexibility that agile methods foster:
The debate was quite intense, and we finally ended up concluding that there is no silver bullet, sometimes it is better to use agile methods, sometimes it is not, and it is always good to know that there are different approaches to software development, and that new projects should be faced without prejudices. I also tried to highlight that software development is a social activity, and that code, documentation, etc, are all important, but it is even more important to be open to the rest of people, and to communicate with the rest of the team.
I am very happy with the results, everybody enjoyed the activity, and I am very glad that they all read so many papers in English (being most of them Spanish, and one French), with a critical look, and using them as arguments for the debate. We also "discovered" the IEEE Software magazine, and other sources of information, that are available to anyone through the institutional suscription of the university, and that contain very useful practical information for the software professionals that they will soon become.
La organización de la VII GUADEC HISPANA anuncia que el 22 de junio es el plazo límite extendido para los miembros de la comunidad que deseen plantear ponencias, talleres o mesas redondas.
La organización de la VII Guadec-es, que tendrá lugar los próximos días 22 y 23 de julio en A Coruña, anuncia una extensión en el plazo para el envio de contribuciones (ponencias, talleres y mesas redondas). La fecna límite límite es el 22 de junio, tras lo cual se publicará el programa definitivo de la VII Guadec-es.
Desde la organización somos conscientes de que los plazos que se habían planteado eran bastante justos, y ante la petición de diversas personas queremos proporcionar a los miembros de la comunidad un poco más de tiempo para elaborar sus propuestas.
Las instrucciones para el envío se encuentran, como siempre, en la petición de contribuciones
Back in October, a friend and I started a project targeting Maemo. We had been thinking about programming for maemo for a lot of time (but for Diablo devices), and Fremantle‘s new UI, so appealing, almost got us buying a N900 (we ended up buying a HTC Tattoo, but that’s another story).
At that moment, I was going to the cinema maybe twice a month, and as some of my friends have the (sometimes annoying) habit of waiting after the credits to see if the movie has extra scenes or something, I thought it would be nice if I had an app in my phone which could tell me if it was worth waiting. A nice brainstorm started, and we added showtimes and other movie info to the app, so Maevies -from movies + maemo- was born. After that, it was “just” a matter of researching which web services could provide that info.
We got the backend “working” rather soon. We started using librest and synchronous calls, so the user would be blocked until we got a response from the web services. We wanted to have a basic backend functionality, and quickly focus on the UI but… we stopped there. We met a couple of times to get started with the UI, but didn’t get too far.
About a month ago I announced that we were starting the development module in the master and that, after having enjoyed an introduction to python, I was quite convinced to port Maevies to Python. Then, I commented in the same post that I wouldn’t port it, but mimic the architecture we’re using for the master app: C with GObject for the model, and Python at the view, connected using DBus. Soon I had all the old maevies backend adapted to use GObject, all the librest references removed and replaced with libsoup’s, and a basic prototype with PyMaemo, with a fake behaviour like the one I would expect from the actual app.
Today, I can announce a “functional” pre-alpha version of Maevies. I’ve created a page for it at this blog, and linked it from the maemo garage’s one, have taken some screenshots, and pushed the last commits (yeah, I also migrated from subversion to git, now that I’m feeling really comfortable with it).
So what’s going on with maevies?
And what are the next steps?
Welcome Window
Search Dialog
Search Results
Movie Info
Ya podemos confirmar la noticia de que la GUADEC Hispana se volverá a celebrar en su septima ocasión en Coruña. Volvemos a repetir tras el éxito de 2005.
La VII GUADEC-ES se organizará en la Facultade de Informática da Universidade da Coruña (España) los días 22 y 23 de julio de 2010.
Este año GUADEC-ES está organizada por GPUL y GNOME Hispano y contamos con la colaboración de GHANDALF.
Ahora mismo estamos buscando patrocinadores y colaboradores, así que si tu empresa, asociación o insitución está interesada en echar una mano no dudes en ponerte en contacto conmigo o a través del correo “chair (arroba) guadec (punto) es”
Aunque es una alegría que la comunidad GNOME vuelva a visitar Galicia nos habría gustado que finalmente GUADEC-ES se hubiera celebrado como estaba previsto, en Chile, pero la situación del país tras el terremoto ocurrido a principios de año ha oblicado a postponer el evento para mejores tiempos. Esperemos que GNOME CHILE nos pueda mostrar su país el año que viene.
Ya está abierta la petición de contribuciones hasta el 14 de junio de 2010. Así que enviar vuestras contribuciones lo antes posible que este año estamos contra reloj.
Una cosa importante para organizar el viaje, este año Coruña es un lugar ideal para enlazar vuestro viaje a La Haya para asitir a GUADEC. Desde Coruña hay vuelo directo a Amsterdam y el GUADEC-ES está encajada para que las frecuencias de aviones permitan venir A Coruña desde Amsterdam para la gente que salte el Atlántico o utilizar Coruña como base para los que salgan de España.
by Pedro A. González (noreply@blogger.com) at May 21, 2010 11:01 AM
My first idea about this entry was to write down some things I learnt about GObject signals, while comparing them to what I feel is a close relative: C# events. However, after the first draft I think it’s better to focus on GObject now, and leave the comparison for another day. Credit should go to Víctor Jáquez, from Igalia, who explained me those things needed to start off. Don’t blame him, however, for the mistakes or misconceptions I may have
There’s a design pattern, the Observer pattern, used to allow “subscribers” to track or follow state changes happening on an object, the “subject”. In C#, this is implemented via Events, in Java you have the Listeners, and in C, with GObject, you have signals. Going to the GObject implementation details:
enum {
END_OF_STREAM,
LAST_SIGNAL
};
static guint
jmp_mplayer_signals[LAST_SIGNAL] = { 0 };
The enum “tags” our signals. In this case, we just have one: END_OF_STREAM. LAST_SIGNAL is a convention: as it is in the last place, it will be always “our last real signal” + 1. And that’s used in the next line, when we declare an array storing those signals: it will have “LAST_SIGNAL” size. It doesn’t store the signal itself, but its identifier, but we’ll see that later.
jmp_mplayer_signals[END_OF_STREAM] =
g_signal_newv ("end-of-stream",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
NULL,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0,
NULL);
That is how the signal is created. It calls the gobject function g_signal_newv which creates the signal, and stores its identifier in the array position given. But, what means each of the params? Well, to be honest, I don’t know too much:
The first one is easy: “end-of-stream” is the signal name. The documentation sets some limitations to the characters it can contain, but that’s all.
The second one is “the type this signal pertains to”. The macro G_TYPE_FROM_CLASS gets the type from the class structure (klass).
The third one is composed by signal flags. They “specify detail of when the default handler is to be invoked”.
I don’t know about the next three params: documentation says class_closure, accumulator, and accu_data. As soon as I learn what they do, I’ll update this. Setting them to NULL worked fine for my needs.
The fourth one, called c_marshaller, sets the interface for the callbacks listening for our signals. So, in our example, g_cclosure_marshal_VOID__VOID means that we won’t require our callback functions to receive arguments. You can find more closures here.
G_TYPE_NONE defines the return type for our callback, so our callback (closure) signature would have this form:
void end_of_stream_callback (JmpMPlayer *self, gpointer user_data);
Our last two params are the length of param types, and an array of param types.
So, what is left? Well, our “subject” still has to notify (“emit”, in GObject) his subscribers. And those subscribers need to actually “subscribe” to the signal. Here we go:
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_EOS:
g_signal_emit (self, jmp_mplayer_signals[END_OF_STREAM], 0);
break;
g_signal_emit receives an instance the signal is being emitted on, the signal id (which we had previously stored in that array), and a detail. Quoting the documentation,
detail identifies the specific detail of the signal to invoke. A detail is a kind of magic token/argument which is passed around during signal emission and which is used by closures connected to the signal to filter out unwanted signal emissions. In most cases, you can safely set this value to zero. See the section called “The detail argument” for more details about this parameter.
And this closes the circle: subscribing to the signal.
g_signal_connect (jmplayer, "end-of-stream",
G_CALLBACK (end_of_stream_callback), loop);
g_signal_connect connects a given callback (G_CALLBACK (end_of_stream_callback), whose signature we saw before), with a signal in an instance (jmplayer), passing arguments (loop)
To write this entry, I’ve relied on two documents: API Reference’s Signals and The GObject messaging system’s Signals, and the (yet little) knowledge I acquired during this stage of Jamp implementation (which, itself, required Víctor‘s help and said documentation). Full code for this example is available at Gitorius, for both the “subject” and the “subscriber”.
This last weekend we had two very interesting sessions in the Destkop and Mobile development module. On Friday, it was an introduction to Python, followed by a PyGTK app. While the app was very simple, it covered the basics: using containers to add widgets, handling signals, setting callback functions. I liked it so much that I’m seriously considering porting maevies (the maemo app a friend and I are developing, stalled for some months) to PyGTK. After all, all we needed was libRest, and I’m confident that Python has something similar.
But that was on Friday. On Saturday, we started with the first workshop. During the module, we are going to develop a Gnome desktop application, which will be later ported / adapted to Maemo: a Jamendo client called Jamp. The application has ben designed / is being designed with that port in mind, so hopefully we won’t need too many changes to achieve it. We’ve been distributed between three teams: UI with PyGTK, web API connection with libsoup, and multimedia playback, with gstreamer. Wikipedia says
Jamendo is a music platform and community.
All music on Jamendo is free to download and licensed through one of several Creative Commons licenses or the Free Art License, making it legal to copy and share, as well as to modify and make commercial use of for some, depending on the license. Jamendo allows streaming of all of its thousands of albums in either Ogg Vorbis or MP3 format, and downloads through the BitTorrent and eDonkey networks.
So, while we learn, we’ll be contributing to a Good Thing™ . I’m very motivated about using git, doing a team development, submitting patches, and enjoying such a collaborative environment.
I’ll try to keep you updated
Some weeks ago we finished our administration and development module focused on networks and computers. This module is part of our Master on Free Software and I had the pleasure to take part in it again, together with other mates here in Igalia
While it is a module covering an extensive range of interesting topics; this year, I covered two broad topics: Networking and Linux Kernel
With regard to Networking, we saw relevant topics such as foundations, administration, tooling, design and security (attack and defense) in depth. All these topics included practical hands-on-lab sessions with selected questions and exercises in order to consolidate theory, doubts and continuous assessment.
Introducing the Kernel land is always a defiant task due to obvious reasons: you are touching hardware here! 
so crossing the border forward and backward between software and hardware is not the perfect place to newcomers and non very experienced developers. Fortunately, I always find passionate and skilled people in my classes and, this year, it was not an exception so introducing “bored” stuff about electricity and principles of digital computing with historic milestones was the previous needed stuff to follow the next technical topics. Finally, we surfed the Kernel internals and ran some configuration/compilation in order to see how the things are working currently.
This last topic closed our visit to three relevant OS in mainstream: FreeBSD, OpenSolaris and GNU/Linux (Debian).
You can check more about teachers, stuff, conferences and so on here!
El plazo de inscripción para el curso de desarrollo en entorno web está abierto hasta el 28 de Mayo.
El módulo, que se desarrollará en Coruña, tendrá lugar los viernes y sábados desde el 11 de Junio hasta el 31 de Julio. A lo largo de la docencia, los alumnos se familiarizarán con las tecnologías usadas en estos entornos así como con las herramientas y prácticas habituales en los proyectos de software libre.
Te interesará este curso si:
Destacados:
These months I’ve been collaborating in Libertexto development. Libertexto, a project coordinated by Rafael Ibáñez, will be a Firefox extension whose goal is to allow the user to do some text comprehension tasks (highlight, add annotations and create bookmarks) and concept mapping tasks (manage a tree of “lexias” or units with semantic content) on HTML and PDF documents.
Multiplatform
So far, I’ve mainly been involved in the task of integrating Evince into Firefox. The goal was not only to provide support for PDF document viewing, but also to adapt Evince to manage the communication with the Firefox extension and to provide the required functionalities and GUI interaction. The fact that Libertexto has to work both in Linux (Ubuntu Jaunty) and Windows made the task more challenging and had an important influence in the design decissions.
The plugin
The main idea was to write a plugin registered to visualize documents having the “application/pdf” mime type, using Evince for that, and interact with the XUL/Javascript code to coordinate everything. The npsimple example was very valuable to learn how to code a multiplatform basic plugin implementing the Netscape Plugin API (NPAPI). These first testings (with the help of Dependency walker) showed me that the plugin code would only load if compiled with the same compiler used to build Firefox. That means forgetting Cygwin, MinGW32 and other Windows platform free stuff and compile using Visual C++, getting the headers from the Mozilla SDK.
Communications: first try
Once I had a plugin that did nothing, I looked for ways to communicate it with Firefox. I tried some XPCOM examples and debug tools without much luck, so I finally decide to use alternative ways of communication when I needed to.
Compiler restrictions
At this point I focused in compiling Evince for Windows. I chose Evince 2.28.0 because it had been already compiled for Windows by Hib Eris. I found him in the #evince IRC channel and he pointed me to the Ubuntu PPA he had used to cross compile for Windows using MinGW32. He also confirmed to me that mixing MinGW32 compiled apps with MSVC compiled apps is a problem because MinGW32 compilations are dependant on msvcrt.dll, while recent MSVC compilations depend on msvcrt80.dll or msvcrt90.dll. That explains why I couldn’t compile the plugin with the MinGW32 toolchain from Windows. Forget also about converting Evince itself into a plugin (implementing NPAPI), because it won’t load. There’s currently no easy solution, but to compile everything with MSVC (not tried before) or keep applications split.
Embedding the window
After having compiled Evince and all its dependencies for both operating systems I modified the plugin to start Evince each time a new document was loaded. Next step was to find a way to embed Evince in Firefox, because having it as an independent window was not an option. The plugin was given a window ID (XID in X11, HWND in Windows), so I modified Evince to receive it as an extra parameter and use gtk_window_reparent() to “hijack” the window that Firefox provided. Of course, using Mozplugger is much easier, but it’s not supported in Windows, so I had to do it by hand. After some tweaking and having to disable DBUS support to get exactly one process per document (in Linux), it worked in both systems. In Windows I ended up with refresh and focus problems, but I didn’t go further.
Communications: second try
At this point, the key was to have a reliable communication system between Evince and the plugin. DBUS would have been good for Linux, but would bring too much problems in Windows (everything should be installed or work from the Firefox extension bundle and I’d need a way to use DBUS from javascript). Standard IPC methods (eg: shared memory) would be a problem too, because I hadn’t managed to successfully develop XPCOM components that could access low level C functions to use that IPC methods. However, there’s one thing that always work: plain old HTTP requests. They are supported in the Firefox side using XMLHttpRequest and in the Evince side using libsoup-2.4. I had experience using libsoup in Meiga, so it wasn’t difficult for me to set up a bidirectional realtime communication middleware using the AJAX paradigm.
The initial port handshake is a bit tricky, though. Remember that there’s no way for the Firefox extension, the plugin and Evince to talk to each other before this handshake. The process is as follows:
/usr/local/libertexto-0.0.5 yet, it triggers the install script and waits until the process is completed. Then continues.nplibertexto.dll/.so is installed (eg: /home/user/.mozilla/firefox/ky712h81.default/extensions/libertexto-0.0.5@libresoft.es/platform/Linux_x86-gcc3). From that path it gets the extension path (...libertexto-0.0.5@libresoft.es) and builds the xid directory path (...libertexto-0.0.5@libresoft.es/xid)evince --xid 0x6800001 --libertexto-path /home/user/.mozilla/firefox/ky712h81.default/extensions/libertexto-0.0.5@libresoft.es/xid /home/user/local_links.pdf.0x6800001 in the xid directory.children array for further use. Each time the children array changes, the file libertexto-0.0.5@libresoft.es/libertexto-docs is regenerated. That file has the URL MD5 sum and port, one line per document.resource://libertexto-docs/ to the Firefox extension and it’s monitored each 5 seconds using XMLHttpRequest (it can also read local files). That way, the extension keeps a table of open documents and their ports.http://127.0.0.1:53162/receive) and reads and attends any pending messages that Evince would like to communicate. If there are no more messages, just keeps waiting for one to come. When one comes, the network dispatcher in the Libertexto extension attends it, closes the connection and restarts it to wait again. Evince code just enqueues outgoing messages and writes them when the extension (re)opens the connection.http://127.0.0.1:53162/send?action=test¶m1=value1¶m2=value2). There’s also another network dispatcher in Evince that processes incoming messages and calls the corresponding function of EvApplication.0x6800001 xid file is removed and libertexto-docs is rebuilt.Packaging
It was time to polish a little bit the building and packaging environment. Different binary sets for different platforms can be provided using the platform directory in the Firefox extension package. In Windows, there’s no problem in relocating a GNOME app where you want, as there’s specific code to locate the data and config dirs, but in Linux it has to be installed in a fixed location, so I prepared a very basic installation script for that platform to be executed by the plugin the first time that the user opens a document.
Functionalities
With the infrastructure ready, I started to hack on Evince and implement the required functionalities (and the related middleware messages in both sides):
For some of them, specially those related to text highlighting and annotations, the advice from Carlos García Campos was very helpful. Shell, view, document and backend layers, the pixbuf cache, the jobs system… Evince is a big project and I needed some time to get used and understand it, but it has a lot of things to learn. I enjoyed very much this development stage. 
When all the PDF side functionalities were completed, I removed all the unneeded GUI options from Evince and adapted the Libertexto extension panel to produce and handle the required middleware messages needed to manage the user interaction.
The result
Although the project still lacks part of the control and HTML modules functionalities, I got Evince integration working in this nice prototype.
You can download it as: libertexto.xpi. Please note that this file will probably evolve, being overwritten with newer versions.
Until the whole project gets released, a shapshot of the Evince branch code is published in Gitorious for you to have a look.
by Pedro A. González (noreply@blogger.com) at April 15, 2010 07:02 AM
A few months ago, when I was trying to start developing for maemo, I discovered a project called ESbox. ESbox is “an Eclipse Ganymede-based product that helps programmers to develop applications for Maemo platform using Scratchbox Apophis”. It launches scratchbox transparently, includes wizards for different types of apps, lets you debug step by step and on device, and also uses C/C++ or Python plugins, so you can refactor code, jump to variable declarations, explore types, autocomplete…
I don’t know exactly when it was, but I once came to maemo IRC channel to ask a specific (maybe too specific) question about ESbox. I was surprised that nobody was using it: people there were using nano, vi, Emacs… I asked them about all the features a “full IDE” offers: what about code refactoring? what about autocompletion? debugging? While some said that you can get emacs to auto-complete from a given dictionary, the other questions remained unanswered. In fact, I almost felt like we weren’t talking the same language.
Our discussion wasn’t constructive at all: I don’t know if it was the language barrier, if it was me who said something inappropriate in the beginning, or if I met people too “Taliban”. The thing is that I had to listen things like “real programmers know the name of the functions / methods they need: autocompletion is for dumbs”. And no, it wasn’t a joke like “real programmers develop their own device drivers”. So I gave up and left the channel: I assumed that programmers would choose their IDEs according to the kind of development they were doing, so “hobbyists” would use nano, would copy & paste and wouldn’t care too much about extras, and “professionals” would use others, or at least would know and use the extras I wanted. And time went by.
As I was telling you in the last post, this Friday we’ve got our first session in the Desktop & Mobile development module of the master. After its presentation, we had a brainstorming to choose which app we will be developing during the workshops, and then… we started talking about IDEs. More specifically, Emacs.
That gave me the opportunity to confirm that there really was a difference between professional developers and non-professional, and that my worries were really shared by others. It was a really interesting chat, where we were explained the environment, from the basics (navigation a buffer, open, close, kill and yank…) to more complex things: debugger integration, syntax highlighting modules, autocompletion, macros…
After the session, I now can understand other people not using Eclipse or Netbeans, while still being productive. I’m not going to use Emacs, not yet, as it looked like some of the features that “just work” in Eclipse require some fiddling in Emacs; but at least I know that someone using Emacs and mastering it will be as efficient as an Eclipse user -or even more.
Still, when I think about the things I like to have working in Eclipse, the following comes:
I know that I can do all of the above using Eclipse, and since this Friday I know that some of them are also possible with Emacs, so now I’d like to have some feedback:
What do you expect in an IDE? Is your list similar to mine? What is your IDE of choice? Which special options of your IDE you use the most? Which options are you most proud of?
This week I’ve been working a bit more in the Clutter Grilo Player. And finally did release 0.1.1:
Thanks to Chris Lord for his patches in clutter code, and Iago Toral for his help improving YouTube speed.
As usual, I uploaded the packages to CGP Launchpad PPA. The code, in CGP gitorious.
This Friday we’re starting the Desktop/Mobile module on the Free Software Master. One of the reasons that brought me here was that one: I wanted to jump into GTK and Qt development, learn new programming languages, and, specifically, learn to develop for mobile devices. What I think now, which really gets me motivated, is the idea that considering how much I’ve enjoyed the previous modules which in advance didn’t look so great (to me), this one will be incredible.
But there’s also another point: more than a half of the course is over, now. Summarizing, we’ve gone through Introduction to Libre Software, where we learnt the most important people in this movement, learnt about Business Models or Licensing stuff among other things; Dynamics of Libre Software Communities, where we analyzed and studied several important communities and learnt the process to apply those analysis to other ones; and now, just before Easter Holidays, we’ve got Systems Integration with Libre Software. In this last module, even if it almost shares the name with a 5º course subject in Ingeniería Informática at UDC, we didn’t learn Web Technologies (there’s a module for that!): we’ve done security, systems administration, scripting, servers configuration and management, version control with git…
And, at this point, I’d like to share with you some of the things we’ve been doing here. Fortunately, my mates and I -as previous editions’ students did- are using a subversion repository hosted at Morfeo’s Forge, where all the practices and assignments were developed (in the open, as the master’s philosophy would suggest), so it’s very interesting to share all of this work with anyone interested.
I’m grouping them by subject -I won’t link my mates’ works, but they can do it in this post’s comments-. I’ll point out those mistakes I found after I handed out the works, and also all known limitations, some possible improvements or even things which are already outdated. Here it goes:
Introduction to Libre Software:
Dynamics of Libre Software Communities
Systems Integration with Libre Software
Of course, I’m missing lots of things. So if you want further info, you can browse the full repository to get my mates’ works or other years’, you can check the moodle for the theory, read the planet for other comments… Enjoy, and Happy Hacking!
As a part of the course on Software Engineering that I have started to teach at UAX, my students, some fellow lecturers and I will engage in a debate about the past, present and future of Software Engineering. In class, we have just finished learning about software architectures, and object oriented design, with all the heavyweight usual design process. In the next weeks, we will learn about agile methods, extreme programming, etc.
Last week we all read Code as design, a set of articles about how software design is bloated, and about using software code directly as design, without all the overhead documents produced while applying standard design and development processes.
In the next weeks, we will read some other papers, blog posts and other sources, that have dealt with this issue before. The paper by Tom DeMarco in IEEE Software Aug 2009 issue is worth noting. It triggered some comments about the death of Software Engineering, and how software design and development is rather craftsmanship than engineering, and wondering what's the point of Software Engineering.
Interestingly, this month's IEEE Software issue is entitled Architecture and agility, and it is about the coexistence of agile methods and architecture. I have not read the issue yet, but it looks like it advocates for a peaceful coexistence of both.
Most of the students have a strong opinion in this debate: they are on the side of heavyweight methodologies. I am probably a little biased about lightweight and agility, but don't get me wrong, this will not be a fight heavy vs. light methods. We will try to obtain a set of guidelines and recommendations about what methodologies are better in what cases, and how existing processes can be improved, taking in account existing successful experiences that would have been predicted as a failure using traditional engineering beliefs.
We will probably also add a grain of free software / open source software development, both on the side of heavy and lightweight methodologies, and also both for successful and failed projects.
We will add our conclusions and materials used during the debate to a wiki page, that will be published once we get finished (I will based part of my evaluations using the activity of that wiki, so it will not be public before finishing the course to avoid interferences).
If you want to help or collaborate, and know interesting examples to use for this debate, a enlightening paper or whatever, please add a comment to this post. Your help will be very much appreciated.
Last weeks I’ve been playing with Clutter and Mx libraries, with the idea of knowing them deeper while also trying to help a bit. Honestly, I believe that the best way to learn about such things is just creating something using them.
So, knowing the fantastic effort done by Grilo team at Igalia, to create a framework for accessing different multimedia sources across the internet, I came to the idea of creating a very simple media player that uses MX widgets, Gstreamer, and Grilo framework.
And here it is, the first release of Clutter Grilo Player. It’s still dirty, but the general idea of the interface is there. It supports browsing and searching some Grilo providers, including Youtube and others.
Some links:
A couple of days ago I created an Linkedin account. Rocío convinced me to do so, because apparently "everybody was there". I did not really think that I could find anybody there, but after importing all my GMail contacts, it turns out that everybody is actually there.
From a technical point of view, Linkedin does not seem to have any better technology than Facebook or other thematic social network sites like Mendeley (for research). For instance, when browsing the list of contacts of someone else, or when searching for a list of contacts, with the goal of cannibalizing her contacts, if you add someone, you will be redirected to a new page, and you will loose the list of contacts of the previous page (this is, it does not implements HTMLHttpRequest). In general, it lacks many Web 2.0 features.
However, it has become very popular among companies and professionals. Maybe because companies are very conservative and like obsolete technologies, so people feel like at home. Well, I know Linkedin targets professionals and companies, but it is surprising they are not trying to improve the user interface, and remain popular even with a so arcane web.
I am not sure whether it will be any advantage from a professional point of view, but just in case I added as many people as I could. I might probably have missed someone, so if I know you and you are in Linkedin, please let me know or just add me to your list of contacts. This is my public profile.
After some migration work, now we have Tinymail repository completely migrated to gitorious.org:
I’ve rescued all the branches available in our svn and tried to keep the proper authorship attributions.
So, from now on, the development should happen in gitorious, and, if you want to keep updated with the latest changes, this is the source to get the information.
I’ve also updated as much as possible the tinymail wiki with proper references to the gitorious.
I know I’ve just announced moving modest to gitorious, but modest was already in git. This time the change in tinymail is bigger as we’re also moving to git from svn! Big change, bigger benefits.
Una de las cuestiones centrales sobre la globalización y el capitalismo es cómo afectan ambos a la re-distribución de riqueza y, por lo tanto, al bienestar social. El paper “Who captures value in a global innovation network? The case of Apple’s iPod“, es una de esas joyitas que hechan luz sobre el asunto de un modo ameno y muy muy claro.
A través del análisis de la cadena de valor del iPod, los autores ponen sobre la mesa quién gana qué con el producto. En el momento del análisis, de los 300$ a los que se vendía el iPod, existía una gananciade unos 190$ sobre el coste de fabricación. El paper analiza cómo se reparte la tarta de beneficios, obteniendo la siguiente tabla:
Las cifras microeconómicas que nos muestra el caso del iPod no son distintas a las macroeconómicas que ya había publicado el Informe PNUD del 2001, dedicado al cambio tecnológico y que se puede resumir con el siguiente mapa de nodos de innovación tecnológica a nivel mundial:
Las conclusiones que uno saca luego de leer ambos informes son claras:
Así, si algo podemos aprender del análisis de la producción del iPod es que la aldea global, en la carrera por la especialización del trabajo a nivel mundial, va construyendo barrios ricos, pobres… y fuentes de futuros conflictos.
En Diciembre de 2009 recibí de la compañía para la que trabajaba un regalo de navidad: la nueva N900, la navaja suiza de los teléfonos que aspiran a ser computadoras portátiles. Desde entonces he notado cómo han cambiado mi actividad digital: consumo de noticias, leer/escribir correo, actividad en redes sociales, etc. Para muestra un botón:
El gráfico superior refleja los post que he enviado a twitter desde Noviembre de 2009 hasta Marzo de 2010. Como he dicho, he obtenido la N900 a finales de Diciembre. En enero, me he decidido a usar Mauku para leer y escribir en twitter e identi.ca.
Como se puede ver, en las últimas semanas mi actividad ha aumentado, tanto en número de posts por día, como en días que envío algún enlace a twitter/identi.ca. Mi sensación personal es se puede extrapolar este patrón a otras actividades (lectura/escritura de correo, consumo de noticias, etc).
Como conclusión, podría decir que lo que era tiempo muerto antes para mí ahora se convierte en momentos que invierto en interactuar con otros: ya no espero el bus mirando cómo pasan los coches sino que leo mi correo, ya no hago tiempo mientras llega la persona con la que he quedado sino que escribo una recomendación sobre la última película que he visto. En definitiva, la movilidad y el always connected que nos traen los dispositivos móviles de última generación, creo que favorecerá el aprovechamiento de esos tiempos muertos que todos tenemos. Y será una fuerza para la interacción con otros muy potente y todavía por explorar en toda su magnitud.
Notas a este post:
El próximo sábado 27 de marzo se cierra el plazo de inscripción para el segundo de los cursos de especialización que organiza Igalia: Desarrollo para dispositivos móviles y desktop con Software Libre. A lo largo de las 80 horas de docencia se tratarán contenidos como los siguientes:
Si te gusta programar sobre las últimas tecnologías y con Software Libre, éste es tu lugar! 
Más información:
El plazo de inscripción para el curso de desarrollo en entorno desktop/mobile está abierto hasta el 27 de Marzo.
El módulo, que se desarrollará en Coruña, tendrá lugar los viernes y sábados desde el 9 de Abril hasta el 06 de Junio. A lo largo de la docencia, los alumnos se familiarizarán con las tecnologías usadas en estos entornos así como con las herramientas y prácticas habituales en los proyectos de software libre.
Te interesará este curso si:
Destacados:
En los últimos días se está actualizado la sección de experiencias de ex-alumnos. Con esta sección se pretende mostrar la cara humana del máster más allá de los números de impacto y resultados del mismo.
Por el momento, se han publicado los perfiles de cinco de los alumnos de las dos primeras ediciones, donde se puede encontrar un perfil heterogéneo de personas, gente que desarrolla su trabajo en ambientes tan distintos como la Administración Pública, la Universidad o en la empresa privada. Todos ellos cuentan su experiencia en el Máster de Software Libre.
Aunque ya hemos blogueado sobre los resultados de las primeras ediciones del Máster en Software Libre, estos días estamos completando la sección de “Experiencias de ex-alumnos“.
Ellos son la cara humana del máster, los que dan sentido a lo que hacemos en cada edición. Y, la verdad, es una gozada leer lo que nos envían para la sección de la web: ésto, más que los números nos demuestra el gran impacto que está teniendo el máster entre sus participantes.
Os invitamos a leer las experiencias de los ex-alumnos, no tiene desperdicio.
A principios de mes, estuvo con nosotros Tomeu Vizoso, de SugarLabs, para contar su experiencia en el proyecto. La sesión se centró en 2 temas:
Estos últimos días hemos publicado on-line los videos de la sesión para que todo aquel que no pudo asitir pueda disfrutar de tomeu y de su experiencia. Esperamos que os guste!
Tomeu Vizoso – Sugar talk at Igalia (1/4)
Tomeu Vizoso – Sugar talk at Igalia (2/4)
Se acaban de poner disponible online los videos de la charla de Tomeu Vizoso de SugarLabs.
La sesión se llevó a cabo a principios de Febrero. Al principio de la sesión, Tomeu se centró en contar la historia, presente y retos futuros del proyecto Sugar. Finalmente, se hizo un repaso de cómo empezar a contribuir código a Sugar.
Tomeu Vizoso - Sugar talk at Igalia (1/4)
Tomeu Vizoso - Sugar talk at Igalia (2/4)
This week we’ve finally moved Modest to gitorious:
The repository itself is called modest:
http://gitorious.org/modest/modest/
git://gitorious.org/modest/modest.git
Reasons are basically that gitorious is faster and better providing git services. So I hope the change is for good.
All the other services will still be in garage: mailing lists, wiki, and project web.
Implementation guide
Last weeks we’ve also been writing some information about how Modest has been implemented, in the wiki. You can find them in Modest architecture documentation. There you’ll find:
Desde hoy por la mañana soporto OpenID en los comentarios, y desde hace casi dos meses está activado el soporte para dispositivos móviles. Respectivamente, se ven así:
Soporte de OpenID en los comentarios
Y así:
Versión móvil del sitio
Espero que os animéis algo más a comentar: si todo está correctamente configurado, los comentarios autenticados con OpenID se aceptan automáticamente.
Alberto García
Andres Maneiro
Andrés Estévez
Andrés Maneiro
Chema Casanova Crespo
Daniel Izquierdo
Enrique Ocaña
Israel Herraiz
Javi Vázquez
Javier Estévez
Javier Muñoz
José Dapena
Juan José Sanchez
Manuel Rego
Master Software Libre
Nacho Varela
Nacho Varela
Pablo Sanxiao
Pedro González
Premio PFC con Software Libre
Simón Pena
Xavier Castaño
Last updated:
September 06, 2010 02:30 AM
All times are UTC.
Powered by:
