Note that the slides are at : http://rzlab.ucr.edu/debian/debbugs_presentation_debconf10.pdf, and here, I’ll only mention most noteworthy elements I’ve noticed.

There’s a linear growth of number of bugs reported for several years, from the statistics made by Don.

In average, there’s same number of bugs filed / archived per day : Debian’s not losing ground against bugs

A new “affect” command has been added, for bugs present in a package affecting another package.

The “summary” command which can be used to quickly spot the summary of lengthy discussions deserves more love. Included “summary -1″ to send a new summary by email.

The new local-debbugs package : can mirror “your” bugs locally and allow to search, show, etc. even offline.

Lots of ideas for new features still in development (but lacking manpower).

Interesting idea about “action required sorting” which exhibits different interests for triager, maintainer, user, to maximize productivity. I guess this should be implemented in clients of the BTS also.

Interesting ideas about distributed bug tracking : sharing status with other bugtrackers (see other report), sideways syncing with other distributions, and making it available to upstream also. Note this was discussed in a subsequent BoF, which I’ve already blogged about.

Some elements taken from the Q&A :

• To my question about addition of RDfa, not currently on the TODO list… I guess I’ll have to do it myself ? … Need to provide more convincing hints on the usefulness.
• only 3 status in the BTS : Fixed / Found / Absent
• some other projects are using debbugs

Overall, a very interesting presentation. Well worth watching the video recording.

See also my report on the presentation by Christine Spang on Distributing bugtracking for Debian with SD which also discussed some debbugs things.

This is just some elements of report (some taken from the gobby edits, and written down by me after watching the video (unfortunately missing 2 mins of sound in the beginning of the video stream/recording)). This is not a full report of all the discussions, as some discussed elements weren’t of interest IMHO.

You’ll find here many ideas of mine, links and pointers (resulting of our work in the context of the Helios project on similar topics), so this is in no way a report of what was said exactly during the BOF.

Aspects of interest:

• for Debian bugs
  • Sharing state between upstream, downstream and sidestream
    • Forwarding upstream
  • Sharing comments between the same bugs
  • merging / conflict resolution (technically challenging, as well as in order to match people’s habits/process)
• Same problem in general
  • distributed bug tracking
    • working offline (modify locally, push, etc.)
  • but also distributed version/commit tracking : tracking bug presence or fix along the branches of commits in distributed VCSes
• Interop with other bugtrackers:
  • method to pass data back and forth between different bugtrackers
  • standard method / format / API : lack of standard widely used
  • visibility of issues known upstream (or elsewhere) to Debian users while using “reportbug”
  • scraping other trackers

Note that these topics may in principle be discussed on the Distributed bug trackers mailing list: http://kitenet.net/cgi-bin/mailman/listinfo/dist-bugs

Tools / implementation ideas :

• First, there’s a wiki resource about lots of software tools : http://dist-bugs.kitenet.net/software/
• SD (presented later by Christine Spang – see my other blog post about her great presentation)
• LaunchPad’s tracker already knows about lots of other bugs in other distros including Debian bugs (through “bug tasks”)
• bts-link watches links between bugs and status changes (mainly through scraping)
• Generic scraping tools could be used :
  • Scraperwiki (http://scraperwiki.com/)
  • or WebReformatter (http://code.google.com/p/webreformatter/
• Virtuoso spongers to perform on the fly conversion of bugs XML feeds to RDF to inject them in a RDF store (ex: search “bugzilla” inside http://www.openlinksw.com/dataspace/dav/wiki/Main/RDFMappersUseCases)

Storage of repositories / databases of remote bugs :

• Mail … lots of suggestions, but to be discarded IMHO
• in users’ Virtuoso RDF stores, eventually in an integrated way with the Semantic Desktop (KDE 4.4 / Tracker / Zeitgeist) which may be an option (integrating bugs in other desktop tools aware of the semantic desktop).
• through desktopcouch (as used by the bughugger client for LP tracker – see the bughugger presentation at RMLL/LSM 2010)

About such storage, and the RDF store option, here’s a prototype of ours that exposes UDD’s bug facts through a SPARQL interface, allowing to publish bug facts as RDF (setup in the frame of the Helios project). It includes both Debian and Ubuntu bugs, and allows interlinking them in a “standard” way (with Semantically described links in RDF). See http://testforge.int-evry.fr/d2r-server/resource/spackage/evolution for an example.

The problem is not how to distribute (distributed database systems exist), but the semantics of bug properties, and the different implementations of interfaces of different tools : which standard to implement, or how many converters are necessary if no standard ? We believe that navigation/referencing/tracking of external bugs would be much easier if bugs were LinkedData citizens, i.e. they would be exposed with (standard) formats like Semantic Web ontologies served with Semantic Web standards (like RDF).

The worst case is currently to have to perform web scraping on bugtracker interfaces. How to avoiding scraping ? A solution could be to publish RDFa / microformats using common standard semantics, directly from the bugtracker pages at bugs URLs (see my wishlist for debbugs on that subject : 590931: Would be great to integrate RDFa metadata into debbugs pages).

Now some pointers to historical details on the same subject and Debian (old posts by Lars Wirzenius) :

• “Distributed bug tracking”
• “Bug exchange format”

Overall, the discussion was quite interesting, but didn’t reach any sensitive progress regarding the state of the art. Much needs to be worked on, mainly on standardizing APIs, semantic descriptions of bugs, and implementation in tools like SD for instance. Stay tuned for more progress.

Hopefully, the slides are gonna be published soon, but in the meantime, you have them in the video recording (see link above) – EDIT: she has published here slides : see her blog post.

For those who don’t know SD, they may refer to a talk given by its author, Jesse Vincent, at the recent RMLL/LSM 2010 : Peer to peer issue tracking with SD and Prophet (video recording coming soon : EDIT: a premiere recording is available here).

She draws 2 main use cases in her speech, which is exactly the kind of features we’ve been thinking about for fetchbugs4.me :

• as a Debian maintainer : SD may be used to clone into your local SD repository all tickets related to your activity on your packages in debbugs.
• or as both a Debian maintainer and upstream developper, you’d combine bugs from Debian’s debbugs and upstream’s bugtracker in one same bug database.

What would be even better is to be able to link all of these bugs to each-other… but I’m not sure this is yet possible.

Christine started implementing debbugs (Debian’s bugtracker) support in SD. For reference, there’s a wishlist about it in 590156 : sd: Provide sync-ing with debbugs. The implementation is still in alpha state, in read-only mode only.

Christine has implemented a new method get_{machinereadablebuglog}() for debbugs’ SOAP interface. It seems to send some Perl Data::Dumper output, which is probably fine for SD as SD is written in Perl, like debbugs… but it may be better if it was some more generally accepted format, like JSON maybe.

Among the topics discussed, was the absence of any standard API to connect to bugtrackers, meaning that SD needs to include many different client code modules for each of the trackers different APIs over different kinds of protocols. I’ve raised (through my IRC comments, watching the presentation through the stream), that there’s a proposal for such a standard that exists : OSLC-CM. Still, it’s not widely implemented, in particular in Open Source tools (see another post of mine on the subject). I think it would be great if SD could be a client of OSLC-CM compatible trackers, hence I’ve filed a wishlist.

Also, I suggested that maybe it would be interesting to be able to browse the mail threads of comments on Debian bugs, much like with “bts –mbox show 12345″ command (which opens mutt on the bugs’ thread, for me), when in offline mode, with SD. Maybe the bts command could just use SD as a backend for all its operations.

Another very interesting feature may be to allow “transfering” a Debian bug to an upstream bugtracker, through SD. Dunno if that will be possible.

Finally the code may be found : in github.

I’m looking forward to testing it.

In his speech “PLF, the story of a third-party repository like no other for Mandriva“, Michael Scherer lead us to a historical trip in the story of the PLF repository. Entertaining, certainly. I’m not sure this would be of interest to many developers, but interesting for all wondering on how projects and communities start, evolve, and on some errors not to make.

Then there were two speeches illustrating how one may contribute to libre software projects and distributions, even with no development skills :

• “The illustrated guide to your first contribution to openSUSE” by Vincent Untz has run through all alphabet letters to tell the very many ways people can contribute to projects. For most items, they are not specific to openSUSE and apply to any project actually.
• “The translation of KDE into french” by Ludovic Grossard presented the workflow of translations submitted by volunteers so that they can become part of distribution packages. An essential task where lots of volunteers can participate. But even if some tasks are easy to do, the whole process is nevertheless quite structured and needs careful application.

Last, but not least, we enjoyed a presentation including a lot of demonstration, made by Vincent Untz on “The road to GNOME 3“. You may have heard that Gnome 3′s release has been shifted in time, but do you know the contents of this release? A must see for sure (when the videos are ready – EDIT: a preview video is available… see comments bellow).

Previous parts :

• (1/4) Report on programming languages and techniques in Development session of RMLL/LSM 2010 (1/4)
• (2/4)Report on ALM, QA and industrialization methods and tools presented in “development” track at RMLL 2010 (2/4)
• (3/4)Report about the forges track held under the Session ‘Development’ at the RMLL 2010 (3/4)

This part deals with the forges afternoon that took place on the 7th, co-authored with my colleague Madhumita Dhar (who’s also working on the COCLICO project).

The first forge to be presented by Sylvain Beucler was Savane, which is the software that runs the FSF’s forge Savannah. He spoke about the previous and future road-map of the Savane project. Breaking away from its legacy PHP code (sourcing from the old libre Sourceforge codebase in PHP), Savane is going in for a complete code rewrite. This is quite a bold decision and awaits a lot of work for everyone involved. However it also allows the choice for newer tools (Django), languages (Python), practices, and should provide a more modern, easy-to-wield forge at the end of the day. Main novelty should be in a new model of forge that would be decentralized (following recent trends ala git, and guidelines about freedom in the Cloud by Moglen and others), but I’ll blog on that topic later.

The second presentation was that of fusionforge, by Roland Mas. Like Savane, Fusionforge’s ancestry also started as a fork of the old Sourceforge. The path followed by them in recent times, interestingly however is quite different from Savane’s plans. Instead of building a new fusionforge, they are trying to make the current one better, providing more features and upgrades, through code clean-up and smooth refactoring. As Fusionforge has a good user-base (often as old heavily patched GForge 4.x deployments), the effort is also more to merge in the plugins/patches developed by its users and bring about more contributions (hence the fusion term). A considerable amount has aleady been done, with more on the way. It was also mentioned that as part of efforts conducted in the COCLICO project, there’s now some converging code (plugins, for instance) between Codendi and FusionForge to try and reduce implementation efforts (Codendi is another of the cousins of Savane and FusionForge forked-off from the Sourceforge base).
Beyond efforts on FusionForge, together with other COCLICO project participants, Roland and me initiated the PlanetForge initiative, that seeks for more discussion, interoperability and other experience exchange among forge implementers and users. It was discussed during the Q&A session, and we tried to clarify that the goal is not to make other forges merge to FusionForge (even if different forks of the same PHP codebase could benefit from merging together). The goal of PlanetForge is to create an interest community, so that each FLOSS forge project can continue to live its own life, but that, if possible, all can better share information, APIs specs and other interoperability means. In short, be different, while still interoperable to each-other.

The next presentation was about Launchpad, by Jonathan Lange. It was a general presentation, explaining how Lanchpad came to be developed, the current priorities, motivations of the people who are behind launchpad, its different features, and so on. There was some discussion afterwards on whether the goals of openness seeked by LaunchPad authors can be compatible with the technical difficulties in setting up LaunchPad instances for one’s own use.

The last presentation of the afternoon was on How to choose a forge for your needs by Joseph Roumier. A good talk outlining the why and how of the methodology used by his team at CETIC, to go about selecting a forge, for their specific needs. Any guesses for the winning forge ? You’ll have to watch the video, or read the slides.

Previous parts :

• (1/4) Report on programming languages and techniques in Development session of RMLL/LSM 2010 (1/4)
• (2/4)Report on ALM, QA and industrialization methods and tools presented in “development” track at RMLL 2010 (2/4)

Next parts:

• (4/4) Final part of the report on the Development track at RMLL/LSM 2010 (4/4)

Weaving a Semantic Web Across OSS Repositories: Unleashing a New Potential for Academia and Practice
(DOI: 10.4018/jossp.2010040103)
Authors: Olivier Berger (Institut Telecom, France); Valentin Vlasceanu (Institut Telecom, France); Christian Bac (Institut Telecom, France); Quang Vu Dang (Institut Telecom, France); Stéphane Lauriere (Mandriva, France)
in International Journal of Open Source Software & Processes (IJOSSP) Volume: 2, Issue: 2 (2010), Pages: 29-40 pp.

Here’s the abstract:

Several public repositories and archives of “facts” about libre software projects, maintained either by open source communities or by research communities, have been flourishing over the Web in recent years. These have enabled new analysis and support for new quality assurance tasks.
This paper presents some complementary existing tools, projects and models proposed both by OSS actors or research initiatives that are likely to lead to useful future developments in terms of study of the FLOSS phenomenon, and also to the very practitioners in the FLOSS development projects.
A goal of the research conducted within the HELIOS project is to address bugs traceability issues. In this regard, the authors investigate the potential of using Semantic Web technologies in navigating between many different bugtracker systems scattered all over the open source ecosystem.
By using Semantic Web techniques, it is possible to interconnect the databases containing data about open-source software projects development, which enables OSS partakers to identify resources, annotate them, and further interlink those using dedicated properties and collectively designing a distributed semantic graph.

Keywords : RDF, forge, archive, bug, semantic, semantic Web, ontology, database, repository of repositories,
interoperability, bugtracker, OSLC-CM, Debian.

The journal is published as closed content on paid access, but you may ask us, should you need to read a draft version.

This is an extended version of an earlier position paper presented at WOPDASD 2009.

This work was conducted in the frame of the “System@tic Paris-Region” cluster (http://www.systematic-paris-region.org/), with funding of the Paris Region council.

• Java development Industrialization using a technical base (by Stephane Traumat – slides: FR / speech: FR) which presented the tools and methods used by Scub (and released as open source as “scub foundation”) to conduct clients’ industrial projects in a Java environment.
• Industrialization & agility : the HELIOS project (by Laurent Laudinet – slides: EN / speech: FR) which presented the open source ALM platform developped by our partners in the Helios project, and insisted (too much maybe, to my own flavour ) on the challenges of industrialization in big industry.
• Bee Build management tool (by Michel Casabianca – slides: FR / speech: FR) a short presentation which introduced a smart object-oriented build management tool named Bee.
• Extending the GCC compiler with MELT to suit your needs (by Basile Starynkevitch – slides: EN / speech: FR) an amazing speech about the internals of GCC, and how it would be interesting for big projects to extend it with the MELT scripting solution in order to adapt GCC to the particular QA constraints of these projects. Quite technical, but very interesting : GCC is a world in itself, it seems.
• Agile development with IceScrum (by Vincent Barrier – slides: EN / speech: FR) nice presentation including lots of demo of the Scrum methodology and the IceScrum tool, that may be used to support it in distributed development teams. Worth attending if agile methods seem interesting to you.

Then we had 2 more talks on the subject of bug tracking (in the frame of an all-english afternoon):

• Peer to peer issue tracking with SD and Prophet (by Jesse Vincent – slides: EN / speech: EN) : great presentation about SD, a “universal” bugtracker client / mirroring tool using a distributed database, which allows to work on bug offline, or in a distributed team synchronization. I’m looking forward to playing with it. Would be great if it could sync with Debbugs. EDIT: a premiere recording of the speech is available here.
• Client to deal with great amount of bug for Launchpad: BugHugger (by Didier Roche – slides: EN / speech: EN) short presentation about bughugger, a graphical desktop client for Launchpad’s bugtracker aimed at developers who need to manage lots of bugs. I wonder if bughugger could be used as a frontend to SD…. It already uses desktopcouch AFAIR, so why not prophet also ?

During the last days of RMLL, we had planed to hold a PlanetForge gathering to discuss forges interoperability. Unfortunately, the outcome is not so good, as it was difficult to gather people at the same time due to giant (mess) distributed nature of RMLL (too many tracks in parallel ?), and for me, as I was chairing the session in another room. We’ll try to prepare a report of what happened anyway, including discussions on forges interoperability, fusionforge bugs fixing, or topics like bug tracking at a large scale (Fetchbugs4.me).

See also the forges “session” on similar forges related subjects (next part of the report, stay tuned).

Please tell us what you thought about this session (including links to other reports), and any suggestions for next year (use comments in this post).

Previous parts :

• (1/4) Report on programming languages and techniques in Development session of RMLL/LSM 2010

Next parts:

• (3/4) Report about the forges track held under the Session ‘Development’ at the RMLL 2010
• (4/4) Final part of the report on the Development track at RMLL/LSM 2010 (4/4)

• PHP development industrialization (by Jean-Marc Fontaine – slides: FR / speech : FR), which was actually more general than strictly about PHP, giving some hints on how to organize the development process in a company
• PHP code audits (by Damien Seguy – slides: FR / speech : FR) : Excellent (too) short presentation giving an introduction to security audits and PHP secure programming. A must view for any PHP programmer, IMHO.
• Listen to your PHP code (by Gabriele Santini – slides: EN / speech : FR), which was a quite technical and very rich presentation of various analysis tools that can be used to analyze PHP code in order to improve its quality. A must view for advanced PHP programmers for sure.
• SOAP and RESTful webservices with Symfony (by Hugo Hamon – slides: FR / speech: FR) a speech explaining how to implement web services in PHP applications (SOAP and REST APIs) with the help of modern frameworks like symfony or Zend framework.

After such presentations, we can conclude that PHP development is now something that can be very professional, with lots of tools helping to understand how PHP internal work and how to manage security concerns. On the same hand, here it’s not all about tools and technology, and great care has to be put in procedures, process and methodology, to be able to develop in a professional way in a PHP environment. Actually, some good old guidelines apply as for any other technology/language (see also the other industrialization talks bellow).

Many people came to attend these PHP presentations: maybe a dedicated PHP development sub-track may be organized next year ?

Then we have had some other great programming language-related presentations (in the frame of the global “full english” transversal track). First some technical ones :

• Go: A new systems programming language (by Uriel – slides: EN / speech : EN) : clear and interesting general presentation of the language.
• How I learned to Stop Worrying and Love Static Typing (by Alexander Heussner – slides: EN / speech: EN) : quite theoretical, yet very enjoyable presentation about typing systems and the merits of their implementation in different languages, explaining how one may choose different languages depending on the context/constraints of a particular program (particular mention for the graphical slides ).
• Quick introduction to Ruby 1.9 (by Bruno Michel – slides: EN / speech: EN) : short presentation about ruby 1.9′s novelties

and then a less technical one :

• Perl 5.12 (by Jesse Vincent – slides: EN / speech : EN) : excellent (“american style”) presentation of the Perl language history and release process, more than a technical description of the contents of Perl 5.12. Excellent to understand how such venerable open source project can sustain development. EDIT: a preview video recording is visible here (until full conference videos are released on RMLL site)

After these, and to conclude about the programming aspects of the development track, there have been some presentations about programming techniques. First some general application development talks like :

• Accelerated development with Quickly (by Didier Roche – slides: EN / speech: FR) : great demonstration-oriented presentation about the quickly development environment which helps to quickly generate almost instantly almost full-fledged Python desktop applications. A must see for those wanting to develop on the Linux desktop.
• How to make applications accessible? (by Samuel Thibault – slides: EN / speech: EN) : great lecture on how to think about accessibility of (mainly non-web) applications to help impaired (there are far more than you’d think: for instance color-blind people) users. Definitely worth attending (or watching).
• NoSql databases access in python (by Youenn Boussard – slides: FR / speech: FR) : great introduction to no-sql databases and overview of different such DB programs, with a few pythonic snippets.
• Introduction to libre “fulltext” technology (by Robert Viseur – slides: EN / speech: FR) : great overview of several open source technologies available to process full-text search in databases.

That concludes this first part of the report. Stay tuned for new episodes.

Please tell us what you thought about this session (including links to other reports), and any suggestions for next year (use comments in this post).

Next parts :

• (2/4) Report on ALM, QA and industrialization methods and tools presented in “development” track at RMLL 2010 (2/4)
• (3/4) Report about the forges track held under the Session ‘Development’ at the RMLL 2010 (3/4)
• (4/4) Final part of the report on the Development track at RMLL/LSM 2010 (4/4)

Steve Speicher at IBM/Rational has blogged about OSLC reference implementations and test suites.

He’s been kind to link to our implementation, which uses Zend framework in PHP, and will provide an Open Source OSLC-CM V1 server component for the Open Source Mantis bugtracker (and later for FusionForge trackers too).

I hope people can learn how OSLC-CM V1 works, by testing with a Mantis 1.2 installation plus our server add-on, and by looking at our server’s code (and maybe, then decide to use it in production too, of course).

…

More at https://sourceforge.net/apps/wordpress/heliosplatform/2010/06/17/open-source-oslc-cm-implementations-in-php/

• SOAP and RESTful webservices with Symfony (Hugo Hamon)
• PHP development industrialization (Jean-Marc Fontaine)
• Listen to your PHP code (Gabriele Santini)
• PHP code audits (Damien Seguy)

On build and compilation tools:

• Bee Build management tool (Michel Casabianca)
• Extending the GCC compiler with MELT to suit your needs (Basile Starynkevitch)

On industrialisation, ALM and agile methods:

• Java development Industrialization using a technical base (Stephane Traumat)
• Industrialization & agility : the HELIOS project (Laurent Laudinet)
• Agile development with IceScrum (Vincent Barrier)

On bugtracking (english track):

• Peer to peer issue tracking with SD and Prophet (Jesse Vincent)
• Client to deal with great amount of bug for Launchpad: BugHugger (Didier Roche)

On software forges (english track):

• A new Savane (Sylvain Beucler)
• FusionForge, one year and a half later (Roland Mas)
• The Launchpad collaboration platform (Jonathan Lange)
• Choosing a software forge (Joseph Roumier)

On programming languages (english track):

• Go: A new systems programming language (Uriel)
• Perl 5.12 (Jesse Vincent)
• How I learned to Stop Worrying and Love Static Typing (Alexander Heussner)
• Quick introduction to Ruby 1.9 (Bruno Michel)

On development techniques:

• NoSql databases access in python (Youenn Boussard)
• Introduction to libre “fulltext” technology (Robert Viseur)
• Accelerated development with Quickly (Didier Roche)

and also several other aspects of libre software projects and distributions:

• How to make applications accessible? (Samuel Thibault)
• The translation of KDE into french (Ludovic Grossard)
• The road to GNOME 3 (Vincent Untz)
• The illustrated guide to your first contribution to openSUSE (Vincent Untz)
• PLF, the story of a third-party repository like no other for Mandriva (Michael Scherer)

There should be plenty of oportunities to learn and discover interesting tools, techniques or methods. We’re looking forward to welcoming you in Bordeaux. And as usual, LSM is free entrance, and organized by volunteers, so join and enjoy.