Blog entries

  • Semantic Roundup - infos glan√©es au NextMediaCamp

    2008/11/12 by Arthur Lutz

    Par manque de temps voici les infos en brut glanées jeudi soir dernier au NextMediaBarCamp :

    Un BarCamp c'est assez rigolo, un peu trop de jeune cadres dynamiques en cravate √† mon go√Ľt, mais bon. Parmi les trois mini-conf√©rences auxquelles j'ai particip√©, il y avait une sur le web s√©mantique. Anim√©e en partie par Fabrice Epelboin qui √©crit pour la version fran√ßaise de ReadWriteWeb, j'ai appris des choses. Pour r√©sumer ce que j'y ai compris : le web s√©mantique il y a deux approches :

    1. soit on pompe le contenu existant et on le transforme en contenu lisible par les machines avec des algorithmes de la mort, comme opencalais le fait (top-down)
    2. soit on écrit nous même en web sémantique avec des microformats ensuite les machines liront de plus en plus le web (bottom-up)

    Dans le deuxième cas la difficulté est de faciliter la tache des rédacteurs du web pour qu'ils puissent facilement publier du contenu en web sémantique. Pour cela ces outils sont mentionnés : Zemanta, Glue (de la société AdaptiveBlue).

    Tout ça m'a fait penser au fait que si CubicWeb publie déjà en microformats, il lui manque une interface d'édition à la hauteur des enjeux. Par exemple lorsque l'on tape un article et que l'application a les coordonnées d'une personne metionnée, il fait automagiquement une relation à cet élément. A creuser...

    Sinon sur les autres confs et le futur des m√©dias, selon les personnes pr√©sentes, c'est assez glauque : des medias publicitaires, custom-made pour le bonheur de l'individu, o√Ļ l'on met des sous dans les agr√©gateurs de contenu plut√īt sur des journalistes de terrain. Pour ceux que √ßa int√©resse, j'ai aussi d√©couvert lors de ce BarCamp un petit film "rigolo" qui traite ce sujet pr√©occupant.

  • DBpedia 3.2 released

    2008/11/19 by Nicolas Chauvat

    For those interested in the Semantic Web as much as we are at Logilab, the announce of the new DBpedia release is very good news. Version 3.2 is extracted from the October 2008 Wikipedia dumps and provides three mayor improvements: the DBpedia Schema which is a restricted vocabulary extracted from the Wikipedia infoboxes ; RDF links from DBpedia to Freebase, the open-license database providing about a million of things from various domains ; cleaner abstracts without the traces of Wikipedia markup that made them difficult to reuse.

    DBpedia can be downloaded, queried with SPARQL or linked to via the Linked Data interface. See the about page for details.

    It is important to note that ontologies are usually more of a common language for data exchange, meant for broad re-use, which means that they can not enforce too many restrictions. On the opposite, database schemas are more restrictive and allow for more interesting inferences. For example, a database schema may enforce that the Publisher of a Document is a Person, whereas a more general ontology will have to allow for Publisher to be a Person or a Company.

    DBpedia provides its schema and moves forward by adding a mapping from that schema to actual ontologies like UMBEL, OpenCyc and Yago. This enables DBpedia users to infer from facts fetched from different databases, like DBpedia + Freebase + OpenCyc. Moreover 'checking' DBpedia's data against ontologies will help detect mistakes or weirdnesses in Wikipedia's pages. For example, if data extracted from Wikipedia's infoboxes states that "Paris was_born_in New_York", reasoning and consistency checking tools will be able to point out that a person may be born in a city, but not a city, hence the above fact is probably an error and should be reviewed.

    With CubicWeb, one can easily define a schema specific to his domain, then quickly set up a web application and easily publish the content of its database as RDF for a known ontology. In other words, CubicWeb makes almost no difference between a web application and a database accessible thru the web.

  • Release of CubicWeb 3.0

    2009/01/05 by Nicolas Chauvat

    As some readers of this blog may be aware of, Logilab has been developing its own framework since 2001. It evolved over the years trying to reach the main goal (managing and publishing data with style) and to incorporate the goods ideas seen in other Python frameworks Logilab developers had used. Now, companies other than Logilab have started providing services for this framework and it is stable enough for the core team to be confident in recommending it to third parties willing to build on it without suffering from the tasmanian devil syndrom.

    CubicWeb version 3.0 was released on the last day of 2008. That's 7 years of research and development and (at least) three rewrites that were needed to get this in shape. Enjoy it at !

  • Rencontre francophone autour des forges


    Logilab sera présent le Mercredi 21 janvier à la rencontre francophone autour des forges. Les présentations et les discussions porteront sur :

    • √©change de donn√©es entre forges, interop√©rabilit√©
    • d√©finition d‚Äôun mod√®le d‚Äôint√©gration ouvert
    • recherche multi-forges
    • gestion des permissions et partage d‚Äôidentit√©s
    • interaction entre la forge et le poste client

    Logilab espère ainsi bénéficier de l'expérience de chacun et des pistes d'évolutions pour, à terme, les intégrer dans son projet de forge basé sur CubicWeb.

    Toutes les informations de l'événement sont disponibles ici.

    photo par StormyDog sous licence Creative Commons.

  • Apycot big version change

    2009/01/26 by Arthur Lutz

    The version convention that we use is pretty straight forward and standard : it's composed of 3 numbers separated by dots. What are the rules to incrementing each on of these numbers ?

    • The last number is a incremented when bugs are corrected
    • The middle number is incremented when stories (functionalities) are implemented to the software
    • The first number is incremented when we have a major change of technology

    Well... if you've been paying attention, apycot just turned 1.0.0, the major change of technology is that it is now integrated to CubicWeb (instead of just generating html files). So for a project in your forge, you describe the apycot configuration for it, and the tests for quality assurance are launched on a regular basis. We're still in the process of stabilizing it (latest right now it 1.0.5), but it already runs on the CubicWeb projects, see the screenshot below :

    You should also know that now apycot has two components : the apycotbot which runs the tests and an cubicweb-apycot which displays the results in cubicweb (download cubicweb-apycot-1.0.5.tar.gz and apycotbot-1.0.5.tar.gz).

  • R√©sum√© de la rencontre francophone autour des forges du 21 janvier 2009


    Définition d'une forge

    Je vous propose tout d'abord une définition assez complète d'une forge logicielle.

    ¬ę Une forge ou plate-forme d'h√©bergement de projets logiciels est un ensemble r√©unissant les technologies du travail coop√©ratif et du g√©nie logiciel pour permettre le d√©veloppement coordonn√© de logiciels en √©quipe. Les services de base d'une telle plate-forme sont ax√©s sur le partage de fichiers (code source, donn√©es et ex√©cutables) et l'animation du groupe. Ils permettent la r√©daction et la programmation collaborative, et facilitent la communication dans le groupe gr√Ęce √† des outils associ√©s aux projets tels que des gestionnaires de listes de messagerie, des logiciels de suivi des t√Ęches et de gestion des rapports d'anomalies. L'utilisation d'une plate-forme de ce type am√©liore la qualit√© des r√©alisations en acc√©l√©rant les processus d'√©change entre d√©veloppeurs et les cycles de version des logiciels, tout en facilitant l'implication des utilisateurs dans la d√©tection des erreurs ou la mise en lumi√®re des fonctionnalit√©s pertinentes des logiciels.¬Ľ

    Tir√©e de (licence Art Libre, cr√©ateur initial Beno√ģt Sibaud, diffusable sous LAL, CC By, CC By-SA et GFDL).


    Problèmes recensés

    image by under creative commons

    Je liste ici quelques problèmes qui m'ont semblé émerger pendant les discussions de la journée.

    • forks nombreux du projet GForge avec peu de collaboration entre les projets
    • p√©rim√®tre technique souvent impos√© dans le d√©bat; ce qui g√™ne la d√©finition fonctionnelle d'une forge
    • forte hi√©rarchie des responsabilit√©s avec un r√īle 'd√©veloppeur' limit√© au profit de celui du 'chef de projet'
    • tr√®s orient√© web avec une strat√©gie d'int√©gration de produits tiers; d'o√Ļ une situation d√©licate pour l'homog√©n√©it√© des solutions √† cause des limitations du protocole HTTP
    • la m√©thodologie de conception des logiciels n'est pas √©voqu√©e dans le choix d'une solution (et pas d'approche Agile en g√©n√©ral).


    ALM, cycle de vie des logiciels et poste client

    Projet NovaForge

    Forge tr√®s aboutie o√Ļ une approche MDA a √©t√© mise en oeuvre pour la g√©n√©ration de cas de tests √† partir des cas d'utilisation d√©crits en UML.

    Intégration continue

    Plusieurs outils ont été nommés. J'ai placé la liste sur la page du wiki dédiée.

    Interopérabilité sémantique

    Projet xfmigration

    Ce projet vise à migrer le contenu d'une forge (BerliOS) vers GForge sans passer par le backend SGBD. L'idée est alors d'utiliser différentes ontologies pour 'mapper' les concepts des 2 forges.

    Cross-Forge Migration Tool is a concept for facilitating the migration process of project metadata between forge platforms. It uses SWRL rules for mapping and OWL-S standard for exporting mapping results.


    Projet HELIOS

    L'exposé présentait un cas d'utilisation du web sémantique pour la recherche et le tri de rapport d'anomalies sur des forges séparées. L'exemple utilisé a été de pouvoir rapatrier; puis sélectionner des tickets relatifs au projet Konqueror à travers le bugzilla de Debian et celui du projet lui-même. Il est ainsi possible de détecter certains doublons ou incohérences de versions.
    Projet CubicWeb forge

    J'ai pu pr√©senter le framework CubicWeb et son architecture de composants. La pr√©sentation n'√©tant pas pr√©vue initialement mais j'ai p√Ľ faire une d√©monstration √† partir de la forge publique de Logilab.

    À partir d'un schéma enrichi des composants installés, il est possible de faire des requêtes RQL (similaire à SPARQL) sur des entités et des sources distantes (Base de données, LDAP, subversion, ...). Logilab travaille aujourd'hui à l'ajout d'ontologies dans la manipulation de ce schéma.


    Je remercie les organisateurs de cette rencontre édition 2009 ainsi que l'ensemble des intervenants propices à l'échange de points de vue.

  • Fetching book descriptions and covers

    2009/05/11 by Nicolas Chauvat

    We recently added the book cube to our intranet in order for books available in our library to show up in the search results. Entering a couple books using the default HTML form, even with the help of copy/paste from Google Book or Amazon, is boring enough to make one seek out other options.

    As a Python and Debian user, I put the python-gdata package on my list of options, but quickly realized that the version in Debian is not current and that the books service is not yet accessible with the python gdata client. Both problems could be easily overcome since I could update Debian's version from 1.1.1 to the latest 1.3.1 and patch it with the book search support that will be included in the next release, but I went on exploring other options.

    Amazon is the first answer that comes to mind when speaking of books on the net and pyAWS looks like a nice wrapper around the Amazon Web Service. The quickstart example on the home page does almost exactly what I was looking for. Trying to find a Debian package of pyAWS, I only came accross boto which appears to be general purpose.

    Registering with Amazon and Google to get a key and use their web services is doable, but one wonders why something as common as books and public libraries would have to be accessed through private companies. It turns out Wikipedia knows of many book catalogs on the net, but I was looking for a site publishing data as RDF or part of the Linked Open Data initiative. I ended up with almost exactly what I needed.

    The Open Library features millions of books and covers, publicly accessible as JSON using its API. There is even a dump of the database. End of search, be happy.

    Next step is to use this service to enhance the cubicweb-book cube by allowing a user to add a new book to its collection by simply entering a ISBN. All data about the book can be fetched from the OpenLibrary, including the cover and information about the author. You can expect such a new version soon... and we will probably get a new demo of CubicWeb online in the process, since all that data available as a dump is screaming for reuse as others have already found out by making it available as RDF on AppEngine!

  • Nous allons √† PyConFr 2009

    2009/05/25 by Arthur Lutz

    Le 30 et 31 mai prochain (samedi et dimanche prochain) nous allons être présents à PyConFr édition 2009, nous sommes partenaire de l'évènement et allons y parler de CubicWeb. Pour être plus précis, Nicolas Chauvat y présentera "CubicWeb pour publier DBpedia et OpenLibrary". Il avait déjà évoqué ces sujets sur ce site : Fetching book descriptions and covers et DBpedia 3.2 released.

    Si vous comptez y aller, n'hésitez pas à venir nous dire bonjour.

  • Semantic web technology conference 2009

    2009/06/17 by Sandrine Ribeau
    The semantic web technology conference is taking place every year in San Jose, California. It is meant to be the world's symposium on the business of semantic technologies. Essentially here we discuss about semantic search, how to improve access to the data and how we make sense of structured, but mainly unstructured content. Some exhibitors were more NLP oriented, concepts extraction (such as SemanticV), others were more focused on providing a scalable storage (essentially RDF storage). Most of the solutions includes a data aggregator/unifier in order to combine multi-sources data into a single storage from which ontologies could be defined. Then on top of that is the enhanced search engine. They concentrate on internal data within the enterprise and not that much about using the Web as a resource. For those who built a web application on top of the data, they choosed Flex as their framework (Metatomix).
    From all the exhibitors, the ones that kept my attention were The Anzo suite (open source project), ORDI and Allegrograph RDF store.
    Developped by Cambridge Semantics, in Java, Anzo suite, especially, Anzo on the web and Anzo collaboration server, is the closest tools to CubicWeb, providing a multi source data server and an AJAX/HTML interface to develop semantic web applications, customize views of the data using a templating language. It is available in open source. The feature that I think was interesting is an assistant to load data into their application that then helps the users define the data model based on that data. The internal representation of the content is totally transparent to the user, types are inferred by the application, as well as relations.
    RDF Resource Description Framework IconI did not get a demo of ORDI, but it was just mentionned to me as an open source equivalent to CubicWeb, which I am not too sure about after looking at their web site. It does data integration into RDF.
    Allegrograph RDF store is a potential candidate for another source type in CubicWeb . It is already supported by Jena and Sesame framework. They developped a Python client API to attract pythonist in the Java world.
    They all agreed on one thing : the use of SPARQL should be the standard query language. I quickly heard about Knowledge Interface Format (KIF) which seems to be an interesting representation of knowledge used for multi-lingual applications. If there was one buzz word to recall from the conference, I would choose ontology :)

  • EuroPython 2009

    2009/07/06 by Nicolas Chauvat

    Once again Logilab sponsored the EuroPython conference. We would like to thank the organization team (especially John Pinner and Laura Creighton) for their hard work. The Conservatoire is a very central location in Birmingham and walking around the city center and along the canals was nice. The website was helpful when preparing the trip and made it easy to find places where to eat and stay. The conference program was full of talks about interesting topics.

    I presented CubicWeb and spent a large part of my talk explaining what is the semantic web and what features we need in the tools we will use to be part of that web of data. I insisted on the fact that CubicWeb is made of two parts, the web engine and the data repository, and that the repository can be used without the web engine. I demonstrated this with a TurboGears application that used the CubicWeb repository as its persistence layer. RQL in TurboGears! See my slides and Reinout Van Rees' write-up.

    Christian Tismer took over the development of Psyco a few months ago. He said he recently removed some bugs that were show stoppers, including one that was generating way too many recompilations. His new version looks very promising. Performance improved, long numbers are supported, 64bit support may become possible, generators work... and Stackless is about to be rebuilt on top of Psyco! Psyco 2.0 should be out today.

    I had a nice chat with Cosmin Basca about the Semantic Web. He suggested using Mako as a templating language for CubicWeb. Cosmin is doing his PhD at DERI and develops SurfRDF which is an Object-RDF mapper that wraps a SPARQL endpoint to provide "discoverable" objects. See his slides and Reinout Van Rees' summary of his talk.

    I saw a lightning talk about the Nagare framework which refuses to use templating languages, for the same reason we do not use them in CubicWeb. Is their h.something the right way of doing things? The example reminds me of the C++ concatenation operator. I am not really convinced with the continuation idea since I have been for years a happy user of the reactor model that's implemented in frameworks liked Twisted. Read the blog and documentation for more information.

    I had a chat with Jasper Op de Coul about Infrae's OAI Server and the work he did to manage RDF data in Subversion and a relational database before publishing it within a web app based on YUI. We commented code that handles books and library catalogs. Part of my CubicWeb demo was about books in DBpedia and cubicweb-book. He gave me a nice link to the WorldCat API.

    Souheil Chelfouh showed me his work on Dolmen and Menhir. For several design problems and framework architecture issues, we compared the solutions offered by the Zope Toolkit library with the ones found by CubicWeb. I will have to read more about Martian and Grok to make sure I understand the details of that component architecture.

    I had a chat with Martijn Faassen about packaging Python modules. A one sentence summary would be that the Python community should agree on a meta-data format that describes packages and their dependencies, then let everyone use the tool he likes most to manage the installation and removal of software on his system. I hope the work done during the last PyConUS and led by Tarek Ziadé arrived at the same conclusion. Read David Cournapeau's blog entry about Python Packaging for a detailed explanation of why the meta-data format is the way to go. By the way, Martijn is the lead developer of Grok and Martian.

    Godefroid Chapelle and I talked a lot about Zope Toolkit (ZTK) and CubicWeb. We compared the way the two frameworks deal with pluggable components. ZTK has adapters and a registry. CubicWeb does not use adapters as ZTK does, but has a view selection mechanism that required a registry with more features than the one used in ZTK. The ZTK registry only has to match a tuple (Interface, Class) when looking for an adapter, whereas CubicWeb's registry has to find the views that can be applied to a result set by checking various properties:

    • interfaces: all items of first column implement the Calendar Interface,
    • dimensions: more than one line, more than two columns,
    • types: items of first column are numbers or dates,
    • form: form contains key XYZ that has a value lower than 10,
    • session: user is authenticated,
    • etc.

    As for Grok and Martian, I will have to look into the details to make sure nothing evil is hinding there. I should also find time to compare zope.schema and yams and write about it on this blog.

    And if you want more information about the conference:

  • Logilab at OSCON 2009

    2009/07/27 by Sandrine Ribeau

    OSCON, Open Source CONvention, takes place every year and promotes Open Source for technology. It is one of the meeting hubs for the growing open source community. This was the occasion for us to learn about new projects and to present CubicWeb during a BAYPIGgies meeting hosted by OSCON.

    I had the chance to talk with some of the folks working at OpenLina where they presented LINA. LINA is a thin virtual layer that enables developers to write and compile code using ordinary Linux tools, then package that code into a single executable that runs on a variety of operating systems. LINA runs invisibly in the background, enabling the user to install and run LINAfied Linux applications as if they were native to that user's operating system. They were curious about CubicWeb and took as a challenge to package it with LINA... maybe soon on LINA's applications list.

    Two open sources projects catched my attention as potential semantic data publishers. The first one is Family search where they provide a tool to search for family history and genealogy. Also they are working to define a standard format to exchange citation with Open Library. Democracy Lab provide an application to collect votes and build geographic statitics based on political interests. They will at some point publish data semantically so that their application data could be consumed.

    It also was for us the occasion of introducing CubicWeb to the BayPIGgies folks. The same presentation as the one held at Europython 2009. I'd like to take the opportunity to answer a question I did not manage to answer at that time. The question was: how different is CubicWeb from Freebase Parallax in terms of interface and views filters? Before answering this question let's detail what Freebase Parallax is.

    Freebase Parallax provides a new way to browse and explore data in Freebase. It allows to browse data from a set of data to a related set of data. This interface enables to aggregate visualization. For instance, given the set of US presidents, different types of views could be applied, such as a timeline view, where the user could set up which start and end date to use to draw the timeline. So generic views (which applies to any data) are customizable by the user.

    The search powered by Parallax is very similar to CubicWeb faceted search, except that Parallax provides the user with a list of suggested filters to add in addition to the default one, the user can even remove a filter. That is something we could think about for CubicWeb: provide a generated faceted search so that the user could decide which filters to choose.

    Parallax also provides related topics to the current data set which ease navigation between sets of data. The main difference I could see with the view filter offered by Parallax and CubicWeb is that Parallax provides the same views to any type of data whereas CubicWeb has specific views depending on the data type and generic views that applies to any type of data. This is a nice Web interface to browse data and it could be a good source of inspiration for CubicWeb.

    During this talk, I mentionned that CubicWeb now understands SPARQL queries thanks to the fyzz parser.

  • You can now register on our sites

    2009/09/03 by Arthur Lutz

    With the new version of CubicWeb deployed on our "public" sites, we would like to welcome a new (much awaited) functionality : you can now register directly on our websites. Getting an account with give you access to a bunch of functionalities :
    • registering to a project's activity with get you automated email reports of what is happening on that project
    • you can directly add tickets on projects instead of talking about it on the mailing lists
    • you can bookmark content
    • tag stuff
    • and much more...

    This is also a way of testing out the CubicWeb framework (in this case the forge cube) which you can take home and host yourself (debian recommended). Just click on the "register" link on the top right, or here.

    Photo by wa7son under creative commons.

  • Now publishing blog entries under creative commons

    2010/03/15 by Arthur Lutz

    Logilab is proud to announce that the blog entries published on the blogs of and are now licensed under a Creative Commons Attribution-Share Alike 2.0 License (check out the footer).

    We often use creative commons licensed photographs to illustrate this blog, and felt that being developers of open source software it was quite logical that some of our content should be published under a similar license. Some of the documentation that we release also uses this license, for example the "Building Salome" documentation. This license footer has been integrated to the cubicweb-blog package that is used to publish our sites (as part of cubicweb-forge).

  • Sprint CubicWeb chez Logilab - annonce de derni√®re minute

    2010/04/29 by Arthur Lutz

    Logilab est en ce moment en train d'acceuillir un sprint autour de la plateforme CubicWeb. L'objectif principal de ce sprint de 5 jours est d'améliorer l'usage de javascript et des css dans CubicWeb :
    • avoir une API javascript propre, test√©e et document√©e
    • pouvoir facilement changer le style d'une application cubicweb
    • gestion de bundle pour javascript et CSS
    • une documentation sur les standards d'√©criture des fichiers JS et CSS pour cubicweb

    Ce sprint aura lieu du jeudi 29 avril 2010 au 5 mai 2010 (weekend exlus - les bureaux seront fermés). Vous êtes les bienvenus pour contribuer, filer un coup de main, faire du pair programming... ou simplement rencontrer des développeurs cubicweb. Vous pouvez même venir une après-midi ou une seule journée. Pour ceux avec des portables, il y aura du réseau disponible pour être connecté.

    Adresse : 104 Boulevard Auguste-Blanqui, Paris. Sonnez à "Logilab".

    Métro : St Jacques or Corvisart (Glacière est la station la plus proche mais sera fermée à partir de lundi)

    Contact :

    Dates : du 29/04/2010 au 30/04/2010 et du 03/05/2010 au 05/05/2010

  • AgileFrance 2010: retour d'exp√©rience sur la gestion agile du projet Pylos


    J'ai présenté au printemps dernier à l'occasion de la conférence AgileFrance2010 un retour d'expérience sur la gestion agile du projet Pylos. Mon "client" m'a fait la gentillesse de participer à l'élaboration de cette présentation et de venir co-présenter.

    Après avoir longtemps tardé, voici le support de la présentation (le texte se trouve à la fin, avec les notes pour les orateurs). Bonne lecture.

    Merci à Christine, et aux organisateurs de la conférence.

  • Rencontre Open Data √† Nantes: Enjeux et opportunit√©s pour le secteur culturel

    2011/11/17 by Arthur Lutz

    Nous étions présents à l'évenement organisé par Stereolux et Libertic consacré à l'OpenData dans le domaine de la culture à Nantes. Voici un court compte rendu des points que nous avons retenus de ces présentations.

    Présentation générale de l'OpenData par Libertic

    Il existe sur la toile assez d'articles sur l'Opendata pour qu'il ne nous semble pas nécessaire d'en donner une description, mais nous tenons à souligner que l'OpenData n'est pas simplement une mise à disposition des informations. Pour que des données puissent être qualifiées d'ouvertes, il faut qu'elles respectent une dizaine de principes parmi lesquels l'accessiblité, l'exploitabilité (données brutes), et la la réutilisablitié (licence).

    Claire Gallon a cité plusieurs exemples d'OpenData dans le domaine culturel :

    • la mise √† disposition de donn√©es sur la fr√©quentation d'un mus√©e permet de d√©velopper un service qui donnera la meilleure heure pour visiter ce mus√©e. Voir When Should I visit Tate Modern
    • Marseille-Provence 2013 (capitale culturelle europ√©enne) ouvre ses donn√©es et attend que les acteurs √©crivent des applications (mobiles notamment).

    Un idée importante est que le service public doit s'adresser au plus grand nombre et ne peut pas consacrer ses ressources à la mise en place de services de niche. La mise à disposition des données permet à des tiers d'occuper ces niches.

    En conclusion, Claire Gallon insiste sur la nécessité d'inclure la gestion de la communauté dans les démarches d'ouverture des données. La prochaine priorité des acteurs de l'OpenData sera la coproduction, à la fois pour l'écriture des applications et pour l'amélioration des données.

    Présentation du projet par Romain Wenz

    Romain Wenz de la Biblioth√®que nationale de France a pr√©sent√© sous l'angle de l'ouverture : l'ouverture √† un public diff√©rent, l'ouverture √† un mode de recherche diff√©rent (on cherche sur internet avant d'aller en biblioth√®que) et l'ouverture sur les reseaux sociaux o√Ļ le public partage des r√©f√©rences √† des contenus qu'il appr√©cie (twitter, facebook, etc.). Cette ouverture passe forc√©ment par un web indexable, o√Ļ l'on peut communiquer facilement une URL d'un contenu (exit les portails de recherche avec des sessions et variable http). Si un site n'est pas indexable, son contenu pourra √™tre trouv√© en s'y connectant directement, mais celui-ci restera dans le web "invisible" ou "profond".

    Romain Wenz a insisté sur l'Importance des technologies utilisées : d'un coté les strandards ouverts et formalisés par le W3C, notamment en terme de web sémantique (RDF, RDFa, opengraph,, etc.) et de l'autre l'utilité de s'appuyer sur du logiciel libre. Dans le cas de il s'agit de CubicWeb.

    Présentation des collaborations entre Wikimedia France et des institutions publiques à Toulouse

    La transition entre la BnF et Wikimedia est facile : Wikisource (bibliothèque de livres libres de droits) a signé un partenariat avec Gallica qui lui a fourni des numérisations de livres tombés dans le domaine public.

    Wikimedia France a présenté deux projets réussis en coproduction avec des institutions Toulousaines :

    • le projet Phoebus a donn√© acc√®s aux archives du Mus√©um de Toulouse √† des b√©n√©voles
    • la communaut√© Wikimedia Commons a particip√© √† l'enrichissement des metadonn√©es du fond consacr√© au photographe Eug√®ne Trutat.

    Présentation OpenData par la mairie de Nantes Métropole

    Frédéric Vasse a briévement présenté la démarche de la Ville de Nantes en matière d'OpenData. Le lancement de la plateforme aura lieu lundi prochain à la Cantine Numérique de Nantes. Selon lui, l'objectif de Nantes est de réussir la coproduction avec les acteurs du territoire.

    Conclusion et ouverture sur un projet concret d'OpenData pour les acteurs culturels

    Libertic a conclu en proposant aux acteurs culturels un projet d'aggrégateur d'informations sur les événements culturels à Nantes. Nous espérons pouvoir vous donner prochainement plus d'informations sur ce projet.

    Autre compte rendu (prises de notes) :

  • OpenData √† Nantes: agr√©gateur des √©v√©nements culturels

    2011/12/12 by Arthur Lutz

    Jeudi 8 décembre 2011 nous avons participé à la réunion de travail sur l'ouverture des données événementielles.

    Problématique des licences

    Un premier problème est que la licence proposée par LiberTIC est la CreativeCommons CC-BY, alors que les producteurs de données n'ont souvent pas les droits sur toutes les données qu'ils diffusent (par exemple la photo d'illustration d'un concert). Ils auront donc du mal à les publier en totalité sous licence CC-BY. Espérons que la licence Creative Commons rentre dans les habitudes et que cela ne va pas trop freiner le projet.

    Aujourd'hui, l'utilisation ressemble à du Fair Use: on tolère la ré-utilisation de contenus protégés par le droit d'auteur car cela sert la diffusion de l'information.

    Nous nous sommes demandé s'il est possible de mélanger deux licences dans un flux de données ou s'il faut faire deux flux séparés mais liés.

    Problématique d'utilisation

    Un deuxième problème est que les réutilisateurs ne seront pas intéréssés si les données sont trop pauvres et qu'elles n'incluent pas d'image ou de vidéo. Il faut donc trouver un socle commun qui satisfasse les producteurs et les réutilisateurs.

    Import ou gros formulaires qui t√Ęchent ?

    Vu la complexité du modèle de données qui a émergé des discussions (beaucoup de cas particuliers), il a été proposé de fournir un formulaire de saisie d'un événement. A notre avis, la saisie "manuelle" doit rester un cas exceptionnel (un acteur culturel n'ayant pas de site pour publier par exemple), au risque de n'être pour les producteurs qu'un enième site à renseigner lors de la publication de son agenda.

    Un exemple de bonnes pratiques est le très populaire GoodRelations qui offre un formulaire pour qu'un utilisateur qui n'a pas intégré le format à sa boutique en ligne puisse facilement générer son fichier et l'héberger chez lui, favorisant ainsi un modèle décentralisé calqué sur celui des moteurs de recherche.


    Il nous semble donc important de se concentrer sur les formats standards qui pourraient être importés et exportés par la plateforme.

    En voici une liste non exhaustive:

    Lectures supplémentaires

    Cherchant à combiner des vocabulaires existants (afin de ne pas réinventer un format qui devra être traduit dans un autre vocabulaire pour être réutilisable) nous sommes tombés sur les articles suivants :


    Il nous para√ģt important de ne pas se tromper dans les orientations choisies:

    • utiliser des formats standards et combiner l'utilisation de namespaces existants plut√īt que d'inventer un nouveau format
    • proposer plusieurs formats d'export pour diff√©rentes utilisations (json, ical, etc) quitte √† ne pas inclure tout le contenu disponible si le format ne s'y pr√™te pas
    • ne pas cr√©er une API de plus et choisir de privil√©gier les standards du web s√©mantique en publiant du RDF et si possible en fournissant un acc√®s SPARQL
    • pr√©f√©rer la publication distribu√©e des donn√©es par leurs producteurs et leur agr√©gation par la plate-forme plut√īt que d'attendre des producteurs qu'ils remplissent un formulaire de plus.

    Nous attendons avec impatience la suite des travaux. Selon LiberTIC la plateforme sera developpée en logiciel libre avec des outils collaboratifs pour piloter le projet.

    CubicWeb est une plateforme disponible en logiciel libre qui a déjà fait ses preuves et a été conçue pour développer des applications du type de l'aggrégateur décrit ci-dessus: import et export des données sous différents formats, utilisation des technologies standards du web sémantique. Nous espérons que ceux qui auront à réaliser l'agrégateur choisiront CubicWeb comme base technique pour ce projet.

  • R√©seau social ouvert et distribu√© avec CubicWeb

    2012/07/18 by Nicolas Chauvat

    Qu'est-ce qu'un réseau social ?

    • descriptions de personnes (profil, histoire, etc)
    • liens avec les autres membres (carnet adresses, etc)
    • cr√©ation de groupes
    • partage de contenu (photos, vid√©os, pr√©sentations, etc)
    • discussion (blog, commentaires, forums, messages, microblog)
    • mise en relation (boulot, ludo, dodo, etc)
    • recommandation (lien, livre, achat, film, music, etc)
    • pr√©sence (fait quoi, avec qui, o√Ļ, etc)

    Et l'interopérabilité ?

    • nombreuses applications / plate-formes
    • en majorit√© centralis√©es et ferm√©es
    • ouverture progressive: protocoles et API en cours de d√©v
    • r√©seaux ouverts et distribu√©s: appleseed, diaspora, onesocialweb, etc.
    • pourrait-on faire autrement ?

    API: openstack

    • d√©couverte / discovery = xrd
    • identit√© / identity = openid
    • contr√īle d'acc√®s / access control = oauth
    • activit√©s / streams = activity streams
    • personnes / people = portable contacts
    • applications = opensocial

    Et en utilisant les standards du Web ?

    Architecture ouverte et distribuée

    • vocabulaires RDF et protocole HTTP + REST
    • chacun son serveur
    • GET et √©ventuellement copie locale
    • abonnement si n√©cessaire (pubsub, xmpp, atom ?)
    • permissions g√©r√©es localement

    => social semantic network

    Pourquoi CubicWeb ?

    • plate-forme pour web s√©mantique (semantic web framework)
    • con√ßu pour avoir composants √† assembler
    • chacun peut d√©finir son application sur mesure
    • fait pour publier html et rdf en parall√®le
    • fait pour exporter et importer donn√©es
    • d√©j√† foaf, skos, sioc, doap, rss, atom, etc.


    • (micro)blog + book + link + file
    • pourrait ajouter: musique, photos, etc.
    • mais aussi: journal, recherche appartement, etc.

    Et ensuite ?

    Il y a bien longtemps...

    • d√©couverte = who et cat /etc/passwd | cut -d: -f1
    • identit√© = login
    • contr√īle acc√®s = chmod, chgrp, su
    • activit√©s = .plan
    • personnes = .addressbook
    • applications = vim ~/public_html/me.html


    Ce texte a √©t√© pr√©sent√© en ao√Ľt 2010, lors de la conf√©rence fran√ßaise des utilisateurs de Python (PyCon-Fr 2010)

  • Retour Agile Tour Nantes 2012 - pr√©sentation et pistes √† explorer

    2012/12/04 by Arthur Lutz

    Nous utilisons les méthodes agiles depuis la création de Logilab. Nous avons parfois pris des libertés avec le formalisme des méthodes connues, en adaptant nos pratiques à nos clients et nos particularités. Nous avons en chemin développé nos propres outils orientés vers notre activité de développement logiciel (gestion de version, processus sur les tickets, intégration continue, etc).

    Il est parfois bon de se replonger dans la théorie et d'échanger les bonnes pratiques en terme d'agilité. C'est pour cette raison que nous avons participé à l'étape nantaise de l'Agile Tour.

    Logiciels libres et agilité

    Plut√īt que d'√™tre simples spectateurs, nous avons pr√©sent√© nos pratiques agiles, fortement li√©es au logiciel libre, dont un avantage ind√©niable est la possibilit√© offerte √† chacun de le modifier pour l'adapter √† ses besoins.

    Premi√®rement, en utilisant la plate-forme web CubicWeb, nous avons pu construire une forge dont nous contr√īlons le mod√®le de donn√©es. Les processus de gestion peuvent donc √™tre sp√©cifiques et les donn√©es des applications peuvent √™tre √©troitement int√©gr√©es. Par exemple, bien que la base logicielle soit la m√™me, le circuit de validation des tickets sur l'extranet n'est pas identique √† celui de nos forges publiques. Autre exemple, les versions livr√©es sur l'extranet apparaissent directement dans l'outil intranet de suivi des affaires et de d√©compte du temps (CRM/ERP).

    Deuxièmement, nous avons choisi mercurial (hg) en grande partie car il est écrit en python ce qui nous a permis de l'intégrer à nos autres outils, mais aussi d'y contribuer (cf evolve).

    Notre présentation est visible sur slideshare :

    ou à télécharger en PDF.

    Behaviour Driven Development

    Le BDD (Behaviour Driven Development) se combine avec des tests fonctionnels haut niveau qui peuvent √™tre d√©crits gr√Ęce √† un formalisme syntaxique souvent associ√© au langage Gherkin. Ces sc√©narios de test peuvent ensuite √™tre convertis en code et ex√©cut√©s. Cot√© Python, nous avons trouv√© behave et lettuce. De mani√®re similaire √† Selenium (sc√©narios de test de navigation Web), la difficult√© de ce genre de tests est plut√īt leur maintenance que l'√©criture initiale.

    Ce langage haut niveau peut néanmoins être un canal de communication avec un client écrivant des tests. À ce jour, nous avons eu plusieurs clients prenant le temps de faire des fiches de tests que nous "traduisons" ensuite en tests unitaires. Si le client n'est pas forcément prêt à apprendre le Python et leurs tests unitaires, il serait peut-être prêt à écrire des tests selon ce formalisme.

  • Nazca is out !

    2012/12/21 by Simon Chabot

    What is it for ?

    Nazca is a python library aiming to help you to align data. But, what does ‚Äúalign data‚Ä̬†mean? For instance, you have a list of cities, described by their name and their country and you would like to find their URI on dbpedia to have more information about them, as the longitude and the latitude. If you have two or three cities, it can be done with bare hands, but it could not if there are hundreds or thousands cities. Nazca provides you all the stuff we need to do it.

    This blog post aims to introduce you how this library works and can be used. Once you have understood the main concepts behind this library, don't hesitate to try Nazca online !


    The alignment process is divided into three main steps:

    1. Gather and format the data we want to align. In this step, we define two sets called the alignset and the targetset. The alignset contains our data, and the targetset contains the data on which we would like to make the links.
    2. Compute the similarity between the items gathered. We compute a distance matrix between the two sets according to a given distance.
    3. Find the items having a high similarity thanks to the distance matrix.

    Simple case

    1. Let's define alignset and targetset as simple python lists.
    alignset = ['Victor Hugo', 'Albert Camus']
    targetset = ['Albert Camus', 'Guillaume Apollinaire', 'Victor Hugo']
    1. Now, we have to compute the similarity between each items. For that purpose, the Levenshtein distance [1], which is well accurate to compute the distance between few words, is used. Such a function is provided in the nazca.distance module.

      The next step is to compute the distance matrix according to the Levenshtein distance. The result is given in the following table.

        Albert Camus Guillaume Apollinaire Victor Hugo
      Victor Hugo 6 9 0
      Albert Camus 0 8 6
    2. The alignment process is ended by reading the matrix and saying items having a value inferior to a given threshold are identical.

    [1]Also called the edit distance, because the distance between two words is equal to the number of single-character edits required to change one word into the other.

    A more complex one

    The previous case was simple, because we had only one attribute to align (the name), but it is frequent to have a lot of attributes to align, such as the name and the birth date and the birth city. The steps remain the same, except that three distance matrices will be computed, and items will be represented as nested lists. See the following example:

    alignset = [['Paul Dupont', '14-08-1991', 'Paris'],
                ['Jacques Dupuis', '06-01-1999', 'Bressuire'],
                ['Michel Edouard', '18-04-1881', 'Nantes']]
    targetset = [['Dupond Paul', '14/08/1991', 'Paris'],
                 ['Edouard Michel', '18/04/1881', 'Nantes'],
                 ['Dupuis Jacques ', '06/01/1999', 'Bressuire'],
                 ['Dupont Paul', '01-12-2012', 'Paris']]

    In such a case, two distance functions are used, the Levenshtein one for the name and the city and a temporal one for the birth date [2].

    The cdist function of nazca.distances enables us to compute those matrices :

    • For the names:
    >>> nazca.matrix.cdist([a[0] for a in alignset], [t[0] for t in targetset],
    >>>                    'levenshtein', matrix_normalized=False)
    array([[ 1.,  6.,  5.,  0.],
           [ 5.,  6.,  0.,  5.],
           [ 6.,  0.,  6.,  6.]], dtype=float32)
      Dupond Paul Edouard Michel Dupuis Jacques Dupont Paul
    Paul Dupont 1 6 5 0
    Jacques Dupuis 5 6 0 5
    Edouard Michel 6 0 6 6
    • For the birthdates:
    >>> nazca.matrix.cdist([a[1] for a in alignset], [t[1] for t in targetset],
    >>>                    'temporal', matrix_normalized=False)
    array([[     0.,  40294.,   2702.,   7780.],
           [  2702.,  42996.,      0.,   5078.],
           [ 40294.,      0.,  42996.,  48074.]], dtype=float32)
      14/08/1991 18/04/1881 06/01/1999 01-12-2012
    14-08-1991 0 40294 2702 7780
    06-01-1999 2702 42996 0 5078
    18-04-1881 40294 0 42996 48074
    • For the birthplaces:
    >>> nazca.matrix.cdist([a[2] for a in alignset], [t[2] for t in targetset],
    >>>                    'levenshtein', matrix_normalized=False)
    array([[ 0.,  4.,  8.,  0.],
           [ 8.,  9.,  0.,  8.],
           [ 4.,  0.,  9.,  4.]], dtype=float32)
      Paris Nantes Bressuire Paris
    Paris 0 4 8 0
    Bressuire 8 9 0 8
    Nantes 4 0 9 4

    The next step is gathering those three matrices into a global one, called the global alignment matrix. Thus we have :

      0 1 2 3
    0 1 40304 2715 7780
    1 2715 43011 0 5091
    2 40304 0 43011 48084

    Allowing some misspelling mistakes (for example Dupont and Dupond are very closed), the matching threshold can be set to 1 or 2. Thus we can see that the item 0 in our alignset is the same that the item 0 in the targetset, the 1 in the alignset and the 2 of the targetset too : the links can be done !

    It's important to notice that even if the item 0 of the alignset and the 3 of the targetset have the same name and the same birthplace they are unlikely identical because of their very different birth date.

    You may have noticed that working with matrices as I did for the example is a little bit boring. The good news is that Nazca makes all this job for you. You just have to give the sets and distance functions and that's all. An other good news is the project comes with the needed functions to build the sets !

    [2]Provided in the nazca.distances module.

    Real applications

    Just before we start, we will assume the following imports have been done:

    from nazca import dataio as aldio   #Functions for input and output data
    from nazca import distances as ald  #Functions to compute the distances
    from nazca import normalize as aln  #Functions to normalize data
    from nazca import aligner as ala    #Functions to align data

    The Goncourt prize

    On wikipedia, we can find the Goncourt prize winners, and we would like to establish a link between the winners and their URI on dbpedia (Let's imagine the Goncourt prize winners category does not exist in dbpedia)

    We simply copy/paste the winners list of wikipedia into a file and replace all the separators (- and ,) by #. So, the beginning of our file is :

    1903#John-Antoine Nau#Force ennemie (Plume)
    1904#Léon Frapié#La Maternelle (Albin Michel)
    1905#Claude Farrère#Les Civilisés (Paul Ollendorff)
    1906#J√©r√īme et Jean Tharaud#Dingley, l'illustre √©crivain (Cahiers de la Quinzaine)

    When using the high-level functions of this library, each item must have at least two elements: an identifier (the name, or the URI) and the attribute to compare. With the previous file, we will use the name (so the column number 1) as identifier (we don't have an URI here as identifier) and attribute to align. This is told to python thanks to the following code:

    alignset = aldio.parsefile('prixgoncourt', indexes=[1, 1], delimiter='#')

    So, the beginning of our alignset is:

    >>> alignset[:3]
    [[u'John-Antoine Nau', u'John-Antoine Nau'],
     [u'Léon Frapié', u'Léon, Frapié'],
     [u'Claude Farrère', u'Claude Farrère']]

    Now, let's build the targetset thanks to a sparql query and the dbpedia end-point. We ask for the list of the French novelists, described by their URI and their name in French:

    query = """
         SELECT ?writer, ?name WHERE {
           ?writer  <> <>.
           ?writer rdfs:label ?name.
           FILTER(lang(?name) = 'fr')
     targetset = aldio.sparqlquery('', query)

    Both functions return nested lists as presented before. Now, we have to define the distance function to be used for the alignment. This is done thanks to a python dictionary where the keys are the columns to work on, and the values are the treatments to apply.

    treatments = {1: {'metric': ald.levenshtein}} # Use a levenshtein on the name
                                                  # (column 1)

    Finally, the last thing we have to do, is to call the alignall function:

    alignments = ala.alignall(alignset, targetset,
                           0.4, #This is the matching threshold
                           mode=None,#We'll discuss about that later
                           uniq=True #Get the best results only

    This function returns an iterator over the different alignments done. You can see the results thanks to the following code :

    for a, t in alignments:
        print '%s has been aligned onto %s' % (a, t)

    It may be important to apply some pre-treatment on the data to align. For instance, names can be written with lower or upper characters, with extra characters as punctuation or unwanted information in parenthesis and so on. That is why we provide some functions to normalize your data. The most useful may be the simplify() function (see the docstring for more information). So the treatments list can be given as follow:

    def remove_after(string, sub):
        """ Remove the text after ``sub`` in ``string``
            >>> remove_after('I like cats and dogs', 'and')
            'I like cats'
            >>> remove_after('I like cats and dogs', '(')
            'I like cats and dogs'
            return string[:string.lower().index(sub.lower())].strip()
        except ValueError:
            return string
    treatments = {1: {'normalization': [lambda x:remove_after(x, '('),
                      'metric': ald.levenshtein

    Cities alignment

    The previous case with the Goncourt prize winners was pretty simply because the number of items was small, and the computation fast. But in a more real use case, the number of items to align may be huge (some thousands or millions…). In such a case it's unthinkable to build the global alignment matrix because it would be too big and it would take (at least...) fews days to achieve the computation. So the idea is to make small groups of possible similar data to compute smaller matrices (i.e. a divide and conquer approach). For this purpose, we provide some functions to group/cluster data. We have functions to group text and numerical data.

    This is the code used, we will explain it:

    targetset = aldio.rqlquery('',
                               """Any U, N, LONG, LAT WHERE X is Location, X name
                                  N, X country C, C name "France", X longitude
                                  LONG, X latitude LAT, X population > 1000, X
                                  feature_class "P", X cwuri U""",
                               indexes=[0, 1, (2, 3)])
    alignset = aldio.sparqlquery('',
                                 """prefix db-owl: <>
                                 prefix db-prop: <>
                                 select ?ville, ?name, ?long, ?lat where {
                                  ?ville db-owl:country <> .
                                  ?ville rdf:type db-owl:PopulatedPlace .
                                  ?ville db-owl:populationTotal ?population .
                                  ?ville foaf:name ?name .
                                  ?ville db-prop:longitude ?long .
                                  ?ville db-prop:latitude ?lat .
                                  FILTER (?population > 1000)
                                 indexes=[0, 1, (2, 3)])
    treatments = {1: {'normalization': [aln.simply],
                      'metric': ald.levenshtein,
                      'matrix_normalized': False
    results = ala.alignall(alignset, targetset, 3, treatments=treatments, #As before
                           indexes=(2, 2), #On which data build the kdtree
                           mode='kdtree',  #The mode to use
                           uniq=True) #Return only the best results

    Let's explain the code. We have two files, containing a list of cities we want to align, the first column is the identifier, and the second is the name of the city and the last one is location of the city (longitude and latitude), gathered into a single tuple.

    In this example, we want to build a kdtree on the couple (longitude, latitude) to divide our data in few candidates. This clustering is coarse, and is only used to reduce the potential candidats without loosing any more refined possible matchs.

    So, in the next step, we define the treatments to apply. It is the same as before, but we ask for a non-normalized matrix (ie: the real output of the levenshtein distance). Thus, we call the alignall function. indexes is a tuple saying the position of the point on which the kdtree must be built, mode is the mode used to find neighbours [3].

    Finally, uniq ask to the function to return the best candidate (ie: the one having the shortest distance below the given threshold)

    The function outputs a generator yielding tuples where the first element is the identifier of the alignset item and the second is the targetset one (It may take some time before yielding the first tuples, because all the computation must be done…)

    [3]The available modes are kdtree, kmeans and minibatch for numerical data and minhashing for text one.

    Try it online !

    We have also made this little application of Nazca, using Cubicweb. This application provides a user interface for Nazca, helping you to choose what you want to align. You can use sparql or rql queries, as in the previous example, or import your own cvs file [4]. Once you have choosen what you want to align, you can click the Next step button to customize the treatments you want to apply, just as you did before in python ! Once done, by clicking the Next step, you start the alignment process. Wait a little bit, and you can either download the results in a csv or rdf file, or directly see the results online choosing the html output.

    [4]Your csv file must be tab-separated for the moment…

  • LMGC90 Sprint at Logilab in March 2013

    2013/03/28 by Vladimir Popescu

    LMGC90 Sprint at Logilab

    At the end of March 2013, Logilab hosted a sprint on the LMGC90 simulation code in Paris.

    LMGC90 is an open-source software developed at the LMGC ("Laboratoire de Mécanique et Génie Civil" -- "Mechanics and Civil Engineering Laboratory") of the CNRS, in Montpellier, France. LMGC90 is devoted to contact mechanics and is, thus, able to model large collections of deformable or undeformable physical objects of various shapes, with numerous interaction laws. LMGC90 also allows for multiphysics coupling.

    Sprint Participants

    More than ten hackers joined in from:

    • the LMGC, which leads LMCG90 development and aims at constantly improving its architecture and usability;
    • the Innovation and Research Department of the SNCF (the French state-owned railway company), which uses LMGC90 to study railway mechanics, and more specifically, the ballast;
    • the LaMSID ("Laboratoire de M√©canique des Structures Industrielles Durables", "Laboratory for the Mechanics of Ageing Industrial Structures") laboratory of the EDF / CNRS / CEA¬†, which has an strong expertise on Code_ASTER and LMGC90;
    • Logilab, as the developer, for the SNCF, of a CubicWeb-based platform dedicated to the simulation data and knowledge management.

    After a great introduction to LMGC90 by Frédéric Dubois and some preliminary discussions, teams were quickly constituted around the common areas of interest.

    Enhancing LMGC90's Python API to build core objects

    As of the sprint date, LMGC90 is mainly developed in Fortran, but also contains Python code for two purposes:

    • Exposing the Fortran functions and subroutines in the LMGC90 core to Python; this is achieved using Fortran 2003's ISO_C_BINDING module and Swig. These Python bindings are grouped in a module called ChiPy.
    • Making it easy to generate input data (so called "DATBOX" files) using Python. This is done through a module called Pre_LMGC.

    The main drawback of this approach is the double modelling of data that this architecture implies: once in the core and once in Pre_LMGC.

    It was decided to build a unique user-level Python layer on top of ChiPy, that would be able to build the computational problem description and write the DATBOX input files (currently achieved by using Pre_LMGC), as well as to drive the simulation and read the OUTBOX result files (currently by using direct ChiPy calls).

    This task has been met with success, since, in the short time span available (half a day, basically), the team managed to build some object types using ChiPy calls and save them into a DATBOX.

    Using the Python API to feed a computation data store

    This topic involved importing LMGC90 DATBOX data into the numerical platform developed by Logilab for the SNCF.

    This was achieved using ChiPy as a Python API to the Fortran core to get:

    • the bodies involved in the computation, along with their materials, behaviour laws (with their associated parameters), geometries (expressed in terms of zones);
    • the interactions between these bodies, along with their interaction laws (and associated parameters, e.g. friction coefficient) and body pair (each interaction is defined between two bodies);
    • the interaction groups, which contain interactions that have the same interaction law.

    There is still a lot of work to be done (notably regarding the charges applied to the bodies), but this is already a great achievement. This could only have occured in a sprint, were every needed expertise is available:

    • the SNCF experts were there to clarify the import needs and check the overall direction;

    • Logilab implemented a data model based on CubicWeb, and imported the data using the ChiPy bindings developed on-demand by the LMGC core developer team, using the usual-for-them ISO_C_BINDING/ Swig Fortran wrapping dance.
    • Logilab undertook the data import; to this end, it asked the LMGC how the relevant information from LMGC90 can be exposed to Python via the ChiPy API.

    Using HDF5 as a data storage backend for LMGC90

    The main point of this topic was to replace the in-house DATBOX/OUTBOX textual format used by LMGC90 to store input and output data, with an open, standard and efficient format.

    Several formats have been considered, like HDF5, MED and NetCDF4.

    MED has been ruled out for the moment, because it lacks the support for storing body contact information. HDF5 was chosen at last because of the quality of its Python libraries, h5py and pytables, and the ease of use tools like h5fs provide.

    Alain Leufroy from Logilab quickly presented h5py and h5fs usage, and the team started its work, measuring the performance impact of the storage pattern of LMGC90 data. This was quickly achieved, as the LMGC experts made it easy to setup tests of various sizes, and as the Logilab developers managed to understand the concepts and implement the required code in a fast and agile way.

    Debian / Ubuntu Packaging of LMGC90

    This topic turned out to be more difficult than initially assessed, mainly because LMGC90 has dependencies to non-packaged external libraries, which thus had to be packaged first:

    • the Matlib linear algebra library, written in C,
    • the Lapack95 library, which is a Fortran95 interface to the Lapack library.

    Logilab kept working on this after the sprint and produced packages that are currently being tested by the LMGC team. Some changes are expected (for instance, Python modules should be prefixed with a proper namespace) before the packages can be submitted for inclusion into Debian. The expertise of Logilab regarding Debian packaging was of great help for this task. This will hopefully help to spread the use of LMGC90.

    Distributed Version Control System for LMGC90

    As you may know, Logilab is really fond of Mercurial as a DVCS. Our company invested a lot into the development of the great evolve extension, which makes Mercurial a very powerful tool to efficiently manage the team development of software in a clean fashion.

    This is why Logilab presented Mercurial's features and advantages over the current VCS used to manage LMGC90 sources, namely svn, to the other participants of the Sprint. This was appreciated and will hopefully benefit to LMGC90 ease of development and spread among the Open Source community.


    All in all, this two-day sprint on LMGC90, involving participants from several industrial and academic institutions has been a great success. A lot of code has been written but, more importantly, several stepping stones have been laid, such as:

    • the general LMGC90 data access architecture, with the Python layer on top of the LMGC90 core;
    • the data storage format, namely HDF5.

    Colaterally somehow, several other results have also been achieved:

    • partial LMGC90 data import into the SNCF CubicWeb-based numerical platform,
    • Debian / Ubuntu packaging of LMGC90 and dependencies.

    On a final note, one would say that we greatly appreciated the cooperation between the participants, which we found pleasant and efficient. We look forward to finding more occasions to work together.

  • Open Legislative Data Conference 2014

    2014/06/10 by Nicolas Chauvat

    I was at the Open Legislative Data Conference on may 28 2014 in Paris, to present a simple demo I worked on since the same event that happened two years ago.

    The demo was called "Law is Code Rebooted with CubicWeb". It featured the use of the cubicweb-vcreview component to display the amendments of the hospital law ("loi hospitalière") gathered into a version control system (namely Mercurial).

    The basic idea is to compare writing code and writing law, for both are collaborative and distributed writing processes. Could we reuse for the second one the tools developed for the first?

    Here are the slides and a few screenshots.

    Statistics with queries embedded in report page.

    List of amendments.

    User comment on an amendment.

    While attending the conference, I enjoyed several interesting talks and chats with other participants, including:

    1. the study of co-sponsorship of proposals in the french parliament
    2. announcing their use of PostgreSQL and JSON.
    3. and last but not least, the great work done by RegardsCitoyens and SciencesPo MediaLab on visualizing the law making process.

    Thanks to the organisation team and the other speakers. Hope to see you again!

  • PyconFR 2014 : jour 1, frameworks web et gestion de source

    2014/11/04 by Arthur Lutz

    Suite de pyconfr 2014 jour 1 épisode 1.

    Performance des frameworks web : Python vs the world

    Ronan Amicel nous a présenté le travail de benchmark publié par TechEmpower. Ces tests et résultats sont forcement faux et biaisés, mais le code source des tests est publié en libre et il est donc possible d'apporter des corrections via le projet sur github

    Pour l'instant, Python3 serait plus lent que Python2, mais on peut espérer que Python3 rattrape son retard, puisqu'il est toujours développé. La comparaison avec pypy est surprenante, celui-ci est bien plus lent, l'hypothèse étant qu'il est ralenti lorsqu'il parle au driver mysql. En revanche, pour le test pypy + tornado, les performances peuvent être meilleures que nodejs car tornado est écrit en pur python il peut être optimisé par pypy.

    Dans le comparatif entre python et php, un acteur surprenant est phalcon qui a pris le parti de tout coder en C (plut√īt qu'une partie seulement comme on peut le trouver dans nombre de projets python).

    Support de présentation :

    CubicWeb - Vos données ont du sens

    Nous attendions avec impatience cette présentation, et Christophe de Vienne a très bien présenté CubicWeb, le framework web dont Logilab est à l'origine.

    Après une courte introduction aux concepts du web sémantique (les URIS, les relations, le Linked Data), il a appuyé sur la nécéssité de donner du sens aux données que l'on stoque dans nos applications. Il a expliqué la finesse des réglages dans le moteur de permissions de CubicWeb.

    Il a expliqué certaines fonctionnalités intéressantes selon lui dans Cubicweb :

    • les hooks: √©quivalent des proc√©dures stock√©es d√©clench√©es par des triggers, ils sont √©crits en Python et permettent de modifier des donn√©es en cascades, impl√©menter des r√®gle de gestion ou g√©n√©rer des notifications.
    • les adaptateurs : permettent de maximiser la r√©utilisation de code en adaptant une entit√© √† une nouvelle interface

    Selon Christophe, CubicWeb permet de développer une "base de donnée métier" strictement structurée, mais restant souple. Il a expliqué que l'interface par défaut n'est pas très sexy, mais qu'elle est néanmoins fonctionnelle comme backend d'édition.

    Une petite introduction aux cubes qui sont les "plugins" ou les "extensions" dans le monde CubicWeb, ils contiennent :

    • un sch√©ma
    • du code m√©tier
    • des vues
    • des contr√īleurs

    Pour manipuler les données, CubicWeb utilise RQL, qui a été inventé avant SPARQL (langage de requête du web sémantique) et est plus pragmatique et lisible. Une fonctionnalité notable de RQL : plus besoin d'écrire des jointures SQL !

    Finalement Christophe a conclu en présentant le mariage de Pyramid et Cubicweb. Selon lui, en regardant dedans, ils ont des philosophies communes. Le code permettant de développer une application Pyramid sur une base CubicWeb est publié sur la forge de CubicWeb. Christophe a aussi expliqué qu'il pousse des modifications pour que CubicWeb soit plus accessible aux développeurs habitués aux modes de développement "à la python".

    Support de présentation :

    La gestion de version, ce problème tellement simple…

    Pierre-Yves David (marmoute) nous a concocté un petit panorama des problèmes traités par les gestionnaires de source, avec des anecdotes de problèmes non-triviaux et quelques rappels historiques sur notre "science" informatique (merci les encodages!) Pierre-Yves s'est concentré sur les systèmes de gestion de version de "nouvelle génération", les outils décentralisés (hg, git, bzr). Forcément, étant donné qu'il travaille sur mercurial (et oui, celui écrit en python) il s'est concentré sur celui-là.

    Quand il travaillait chez Logilab, Pierre-Yves a notamment rajouté à Mercurial la notion de changeset obsolete et de phase pour faciliter la revue de code et le travail en équipe.

    Manipuler son code python avec RedBaron

    baron et RedBaron sont des projets assez prometteurs (et assez dingues) de manipulation de code en utilisant du code (plut√īt que des √©diteurs).

    Laurent Peuch est revenu sur les outils historiques du domaine : rope qui a pris la suite de bicycle repair man. Il y a aussi pyfmt par le même auteur, et autopep8 écrit par d'autres.

    Un exemple qui m'a parlé : ajouter @profile sur toutes les fonctions d'un script devient faisable en 3 lignes de python, et inversement pour les enlever. À suivre...

    Support de présentation :

    Prochain épisode

    Prochain épisode: jour 1, bus de communication, packaging et fin

  • BestOfWeb 2015

    2015/06/11 by Adrien Di Mascio

    Nous étions à la journée BestOfWeb 2015 vendredi. Au programme, quelques unes des présentations jugées les plus intéressantes qui avaient été faites lors de différents meetups orientés "web" ces derniers mois.

    Même si j'aurais pu me passer des nombreuses interventions des sponsors et si toutes les présentations n'ont pas retenu mon attention, j'ai dans l'ensemble bien apprécié la journée. Voilà en particulier ce que je retiens :

    • angular n'a plus beaucoup de d√©fenseurs, ou alors ils crient moins fort que les autres. De notre c√īt√©, apr√®s l'avoir utilis√© pour construire quelques applications, la mauvaise documentation, la difficult√© √† conserver l'application maintenable et le fait qu'angular 2 ‚ÄĒ qui aura certainement plein de qualit√©s ‚ÄĒ ne laisse pas de perspective de migration simple du code nous ont amen√©s √† pr√©f√©rer des biblioth√®ques plus simples comme Backbone¬†;

    • Microsoft continue √† contribuer du code libre et poursuit sa reconqu√™te des d√©veloppeurs perdus¬†;

    • j'aurais bien aim√© voir Hydra mentionn√© dans la pr√©sentation REST,

    • j'√©tais rest√© sur l'utilisation de Accept-Ranges et Range dans le cadre de contenus binaires et je d√©couvre (!) que √ßa semble √™tre une pratique courante de les utiliser pour la pagination dans les API REST. √Ä utiliser dans CubicWeb¬†?

    • CSS Grid Layout n'a pas l'air parti pour √™tre utilisable avant un petit moment¬†;

    • l'an dernier, dans le cadre d'une collaboration avec l'itemm, nous avions fait de l'acquisition audio dans le navigateur. Nous testions la justesse d'instruments √† vents et affichions les instruments en 3D dans le navigateur. Je me souviens qu'il fallait utiliser les nightly builds de chrome pour que √ßa fonctionne. Mais la pr√©sentation de l'ircam a montr√© que l'api Web Audio d√©collait vraiment. Ils ont fait des d√©monstrations de mixage en direct et on est pass√© √† deux doigts de faire faire du sound painting √† l'assembl√©e √† coups de t√©l√©phones portables et websockets. Leur d√©p√īt GitHub vaut le d√©tour¬†;

    • RxJS et ses cousins BaconJS et KefirJS permettent d'√©crire des traitements de flux d'information assez simplement √† partir d'√©v√©nements, de promesses et de plein d'autres choses.

    Et CubicWeb dans tout √ßa ? Et bien tout √ßa m'a donn√© envie de continuer activement le travail entam√© sur le javascript utilis√© dans CubicWeb. J'aimerais notamment qu'on puisse √©crire de l'ES 6, qu'en mode debug, les fichiers soient transpil√©s √† coups de babel (-- watch) et qu'on transpile √©galement √† la construction des paquets. On pourrait par la m√™me occasion d√©finir la liste des fonctionnalit√©s "futures" qu'on s'autorise √† utiliser dans le cŇďur de CubicWeb et pour lesquelles CubicWeb fournirait des polyfills si besoin (promesses, fetch, fileAPI, etc.).

    Pour conclure, f√©licitations aux organisateurs pour avoir su trouver une autre salle √† la derni√®re minute et pour la qualit√© de la journ√©e dans son ensemble. Sans doute √† l'an prochain et pour certains d'entre eux √† bient√īt √† WebGL Paris

  • Experiments on building a Jenkins CI service with Salt

    2015/06/17 by Denis Laxalde

    In this blog post, I'll talk about my recent experiments on building a continuous integration service with Jenkins that is, as much as possible, managed through Salt. We've been relying on a Jenkins platform for quite some time at Logilab (Tolosa team). The service was mostly managed by me with sporadic help from other team-mates but I've never been entirely satisfied about the way it was managed because it involved a lot of boilerplate configuration through Jenkins user interface and this does not scale very well nor does it make long term maintenance easy.

    So recently, I've taken a stance and decided to go through a Salt-based configuration and management of our Jenkins CI platform. There are actually two aspects here. The first concerns the setup of Jenkins itself (this includes installation, security configuration, plugins management amongst other things). The second concerns the management of client projects (or jobs in Jenkins jargon). For this second aspect, one of the design goals was to enable easy configuration of jobs by users not necessarily familiar with Jenkins setup and to make collaborative maintenance easy. To tackle these two aspects I've essentially been using (or developing) two distinct Salt formulas which I'll detail hereafter.

    Jenkins jobs salt

    Core setup: the jenkins formula

    The core setup of Jenkins is based on an existing Salt formula, the jenkins-formula which I extended a bit to support map.jinja and which was further improved to support installation of plugins by Yann and Laura (see 3b524d4).

    With that, deploying a Jenkins server is as simple as adding the following to your states and pillars top.sls files:

        - jenkins
        - jenkins.plugins

    Base pillar configuration is used to declare anything that differs from the default Jenkins settings in a jenkins section, e.g.:

        - home: /opt/jenkins

    Plugins configuration is declared in plugins subsection as follows:

            url: ''
            hash: 'md5=9574c07bf6bfd02a57b451145c870f0e'
            url: ''
            hash: 'md5=1b46e2732be31b078001bcc548149fe5'

    (Note that plugins dependency is not handled by Jenkins when installing from the command line, neither by this formula. So in the preceding example, just having an entry for the Mercurial plugin would have not been enough because this plugin depends on scm-api.)

    Other aspects (such as security setup) are not handled yet (neither by the original formula, nor by our extension), but I tend to believe that this is acceptable to manage this "by hand" for now.

    Jobs management : the jenkins_jobs formula

    For this task, I leveraged the excellent jenkins-job-builder tool which makes it possible to configure jobs using a declarative YAML syntax. The tool takes care of installing the job and also handles any housekeeping tasks such as checking configuration validity or deleting old configurations. With this tool, my goal was to let end-users of the Jenkins service add their own project by providing a minima a YAML job description file. So for instance, a simple Job description for a CubicWeb job could be:

    - scm:
        name: cubicweb
          - hg:
             clean: true
    - job:
        name: cubicweb
        display-name: CubicWeb
          - cubicweb
          - shell: "find . -name 'tmpdb*' -delete"
          - shell: "tox --hashseed noset"
          - email:

    It consists of two parts:

    • the scm section declares, well, SCM information, here the location of the review Mercurial repository, and,

    • a job section which consists of some metadata (project name), a reference of the SCM section declared above, some builders (here simple shell builders) and a publisher part to send results by email.

    Pretty simple. (Note that most test running configuration is here declared within the source repository, via tox (another story), so that the CI bot holds minimum knowledge and fetches information from the sources repository directly.)

    To automate the deployment of this kind of configurations, I made a jenkins_jobs-formula which takes care of:

    1. installing jenkins-job-builder,
    2. deploying YAML configurations,
    3. running jenkins-jobs update to push jobs into the Jenkins instance.

    In addition to installing the YAML file and triggering a jenkins-jobs update run upon changes of job files, the formula allows for job to list distribution packages that it would require for building.

    Wrapping things up, a pillar declaration of a Jenkins job looks like:

            file: <path to local cubicweb.yaml>
              - mercurial
              - python-dev
              - libgecode-dev

    where the file section indicates the source of the YAML file to install and pkgs lists build dependencies that are not managed by the job itself (typically non Python package in our case).

    So, as an end user, all is needed to provide is the YAML file and a pillar snippet similar to the above.


    This initial setup appears to be enough to greatly reduce the burden of managing a Jenkins server and to allow individual users to contribute jobs for their project based on simple contribution to a Salt configuration.

    Later on, there is a few things I'd like to extend on jenkins_jobs-formula side. Most notably the handling of distant sources for YAML configuration file (as well as maybe the packages list file). I'd also like to experiment on configuring slaves for the Jenkins server, possibly relying on Docker (taking advantage of another of my experiment...).

  • WebGL Paris 2015

    2015/10/13 by Florent Cayré

    Hier, Logilab assistait à la journée de conférence WebGL Paris dans le centre de conférences de Microsoft France.

    Cette journée était riche de présentations variées par le public visé : scientifiques, artistes, développeurs, équipes mixtes graphistes/ développeurs. J'ai apprécié le format assez long de ces présentations, qui permet d'approfondir plus qu'à l'habitude. Les présentateurs ont profité de ce temps soit pour illustrer leur démarche artistique, soit pour démontrer l'utilisation en direct des technologies proposées, ce qui rend les présentations à la fois plus vivantes et plus motivantes pour les techniciens que nous sommes car plus rapides à mettre en oeuvre.

    Logilab s'intéresse depuis plusieurs années à WebGL (et autres API HTML5 avancées, comme WebAudio), ayant réalisé plusieurs démonstrateurs utilisant cette technologie, notamment une interface de Web pour Code_TYMPAN basée sur CubicWeb, ou encore un outil de visualisation de maillages pour Simulagora. Nous souhaitions lors de cette conférence aller plus loin en recherchant :

    • des mani√®res originales de pr√©senter des donn√©es, par exemple celles tir√©es de l'application derri√®re, d√©velopp√©e par Logilab avec CubicWeb¬†;
    • √† d√©porter des calculs du serveur vers le navigateur en utilisant le GPU via le langage GLSL, ce qui pourrait conduire √† des solutions innovantes pour nos applications scientifiques.

    Au travers de ce prisme, les présentations qui nous ont le plus intéressés lors de cette journée WebGL Paris sont les suivantes :

    • R√©seaux de neurones¬†: int√©ressante entr√©e en mati√®re par Xavier Bourry sur la th√©matique du calcul dans le navigateur, m√™me si on aurait aim√© y voir un peu plus de code¬†; son site est cependant une source d'information tr√®s int√©ressante sur le sujet, par exemple la le√ßon sur la r√©solution des √©quations de Saint-Venant r√©gissant les √©coulements de fluide √† surface libre¬†;
    • WebVR¬†: dans cette pr√©sentation, Jean-marc Le Roux a surtout pr√©sent√© les outils de d√©veloppement de la plateforme Minko, en particulier l'extension cr√©√©e pour Blender permettant aux graphistes 3D d'aller plus loin dans le processus de cr√©ation en int√©grant eux-m√™mes des scripts d√©di√©s √† diff√©rents effets 3D (animation de forme, environnement lumineux, etc.) dans l'application Web, en temps r√©el¬†; il a finalement assez peu √©t√© question de r√©alit√© virtuelle, bien que l'int√©r√™t de cette API, identique dans Firefox et Chrome, mais encore consid√©r√©e comme exp√©rimentale, ait √©t√© soulign√©¬†;
    • Live coding avec BabylonJS¬†: au cours de cette pr√©sentation, David Rousset a notamment montr√© le tout nouveau BabylonJS playground, qui offre une fa√ßon tr√®s didactique de se mettre √† BabylonJS et de partager du code¬†;
    • Le raymarching¬†: R√©mi Papilli√© nous a fait une d√©mo live √† la fois efficace et instructive de cette technique facile √† mettre en place¬†; cela m'a permis de voir comment √©crire et tester visuellement des shaders, et me permettra de me lancer plus facilement dans le d√©veloppement d'applications scientifiques avec GLSL¬†; ce champ a l'air finalement assez peu explor√©, comme en t√©moigne le faible nombre d'outils permettant de tester automatiquement du code GLSL¬†: GLSL Unit semble √™tre le seul outil disponible.

    En conclusion, on a beaucoup apprécié cette journée qui nous a fournit de bonnes pistes techniques et motivés pour continuer à pousser nos clients dans à utiliser WebGL. Merci aux organisateurs et aux présentateurs !

  • Nous allons √† PyConFR 2015 √† Pau

    2015/10/13 by Arthur Lutz

    Nous allons avec une partie de l'équipe de l'agence Toulousaine de Logilab, participer à la conférence annuelle France sur le langage python : PyConFr. Nous avions appris plein de choses l'année dernière, et partagé via une série d'articles de blogs (1, 2, 3).

    Quatre présentations à noter dans votre planning si vous avez la chance de pouvoir venir (la conférence est gratuite et accueillante). Les descriptions détaillées sont au bout des liens :

    Au plaisir de vous y croiser.

  • Syst√®me d'Archivage √Člectronique Mutualis√©

    2015/11/20 by Marla Da Silva

    √Ä l'occasion de l'Open Source Summit Paris 2015 Sylvain Th√©nault a co-pr√©sent√© le projet SAEM : Syst√®me d'Archivage √Člectronique Mutualis√© en compagnie de Pascal Romain et Pierre-Etienne Cassagnau du Conseil D√©partemental de la Gironde dans le cadre des retours d'exp√©rience et solutions des entreprises.

    De nos jours, les institutions publiques locales doivent conjuguer efficacit√© et √©conomie. Cherchant √† r√©soudre cette √©quation complexe, les services d'Archives du Conseil D√©partemental de Gironde, de la M√©tropole de Bordeaux et de la Ville de Bordeaux ont choisi de s'allier pour d√©velopper et d√©ployer un Syst√®me d'Archivage √Člectronique Mutualis√© (SAEM) construit √† partir de logiciels libres.

    Cette présentation allie le point de vue du client (Conseil Départemental de Gironde) et notre regard technique (Logilab), en particulier sur l'utilisation du logiciel libre CubicWeb et des technologies du Web Sémantique. Vous pouvez la visualiser en HTML et aussi sur slideshare.

    Une prise vid√©o a √©t√© r√©alis√©e et nous partagerons bient√īt la vid√©o avec vous.