MozFR

Mozilla s’exprime sur la Loi Renseignement

Ce communiqué est repris du blog de presse de Mozilla et est une traduction de Mozilla speaks out on French intelligence bill


Depuis l’affaire Snowden, de plus en plus de gouvernements se sont interrogés sur les limites convenables de la surveillance ; certains États cherchant à restreindre leur propre accès à l’information et d’autres à restreindre celui d’autres gouvernements. De manière générale, nous sommes heureux de soutenir ce genre d’efforts. Cependant, les récents évènements autour de la loi sur le renseignement débattue en ce moment en France nous préoccupent fortement. Le Gouvernement soumet ce projet au Parlement en urgence, avec presque aucune consultation des parties prenantes. De plus, les modalités exactes de ce projet de loi semblent changer fréquemment.

Les mesures de l’actuel projet de loi ayant été rendues publiques – y compris celles autorisant la collecte massive de métadonnées, l’analyse automatique par algorithme des communications des utilisateurs, ou encore les mesures visant à affaiblir le chiffrement – constituent une menace pour l’infrastructure d’Internet, la vie privée des utilisateurs, ainsi que pour la sécurité des données. Compte tenu de notre engagement pour l’ouverture et la transparence, nous ne nous inquiétons pas seulement du contenu de ces mesures, mais également de la manière dont cette législation est élaborée. Les discussions menées secrètement, à huis clos, aboutissent rarement à une législation forte.

Tandis que ces dispositions évoluent rapidement avec le processus politique, Mozilla rejoint de nombreuses institutions, entreprises et organisations de la société civile française pour exprimer sa profonde inquiétude quant aux mesures proposées par le Gouvernement français. En particulier, Mozilla s’opposerait à toute loi qui :

  • Permettrait la surveillance généralisée des communications, des activités sur le Web et des métadonnées des utilisateurs. Nous pensons que ceci représente une violation disproportionnée de la vie privée et fragilise la confiance nécessaire au fonctionnement d’un Internet ouvert.

  • Saperait l’efficacité des outils de chiffrement, voire la capacité à les utiliser. Le monde entier dépend du chiffrement pour garantir la sécurité et la confidentialité des communications et du commerce.

  • Négligerait le respect de la vie privée, une procédure équitable et transparente et les garde-fous d’une supervision judiciaire, ou permettrait la rétention injustifiée de données.

Nous sommes particulièrement préoccupés par l’installation de « boîtes noires » au sein des infrastructures des fournisseurs de services de communications afin de procéder à une surveillance par algorithme. Cette disposition oblige les entreprises à permettre une surveillance gouvernementale de l’activité en ligne de tous leurs utilisateurs, à la recherche d’un ensemble obscur de motifs comportementaux « suspects ».

Mozilla exhorte le Gouvernement français à ouvrir un véritable débat autour de cette loi. En particulier, il est nécessaire de prendre en compte son impact technologique sur l’infrastructure d’Internet et la sécurité des utilisateurs. À l’heure où il apparaît de plus en plus clairement que confidentialité et sécurité se renforcent mutuellement, le Gouvernement français semble vouloir mettre en opposition ces deux valeurs, au risque de les affaiblir toutes les deux.

Comment passer de LIMIT / OFFSET aux Continuation Tokens ?

Si vous êtes là, c'est que quelqu'un a du vous le dire : Paginer sur des grosses tables avec LIMIT et OFFSET ne monte pas en charge : plus on avance dans les pages, plus c'est lent.

C'est dommage parce que c'était facile à appréhender! La limite donne le nombre d'éléments affichés et le décalage est calculé en fonction de la page en cours !

Il y a même une initiative "STOP OFFSET" pour que les développeurs y pensent.

Sur ce site, la solution évoquée consiste à mettre en place une keyset pagination, ou seek method. Autrement dit une pagination à base de filtrage.

L'idée générale consiste à remplacer les ?page=3&size=10 de vos URLs par un ensemble de critères de filtrage sur la table qui réduiront les résultats obtenus à ceux attendus sur la page en cours.

C'est le serveur qui va construire les requêtes de filtrages nécessaires à la pagination à partir d'information sur le dernier élément affiché. Ces informations sont appellées continuation token car elles permettent au serveur de savoir d'où il doit reprendre pour continuer à afficher les résultats.

Pourquoi c'est mal d'utiliser OFFSET et LIMIT ?

Le site ci-dessus l'explique mieux que moi, mais ce qu'il faut retenir c'est que la base de données doit faire la requête entière pour ensuite aller se déplacer jusqu'à la bonne ligne.

Si pendant que vous changez de page quelqu'un modifie la collection vous pouvez aussi louper des entrées ou avoir des doublons dans les résultats. Cela rend la liste des résultats incohérente entre deux affichages.

Comment faire pour s'en passer ?

Pour bien comprendre, prenons le cas le plus simple.

Si vous triez par id (la clé primaire), il vous suffit de garder trace du dernier id de la page précédente.

Prenons comme exemple la table de salariés suivante. Pour les besoins de l'exercice la date de recrutement est unique. Les données sont inexactes mais plausibles.

CREATE TABLE `salaries` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nom` text NOT NULL,
  `societe` text NOT NULL,
  `date_embauche` date NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `date_embauche` (`date_embauche`)
) CHARSET=utf8 ;
+----+----------+----------+---------------------+
| ID | Nom      | Société  | Date de recrutement |
+----+----------+----------+---------------------+
| 1  | Rodolphe | Novapost | 2014-09-03          |
+----+----------+----------+---------------------+
| 2  | Tarek    | Mozilla  | 2009-03-01          |
+----+----------+----------+---------------------+
| 3  | Benoit   | Novapost | 2012-02-25          |
+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+
| 5  | Bruno    | Novapost | 2013-06-14          |
+----+----------+----------+---------------------+
| 6  | Rémy     | Mozilla  | 2014-03-11          |
+----+----------+----------+---------------------+
| 7  | Mathieu  | Mozilla  | 2014-12-06          |
+----+----------+----------+---------------------+
| 8  | Natal    | Novapost | 2013-08-05          |
+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+

Pour l'exemple, nous allons également paginer nos résultats par deux.

Voici les requêtes que nous ferions en utilisant OFFSET et LIMIT

SELECT * FROM `salaries`
ORDER BY `id`
LIMIT 2

+----+----------+----------+---------------------+
| 1  | Rodolphe | Novapost | 2014-09-03          |
+----+----------+----------+---------------------+
| 2  | Tarek    | Mozilla  | 2009-03-01          |
+----+----------+----------+---------------------+

SELECT * FROM `salaries`
ORDER BY `id`
LIMIT 2
OFFSET 2

+----+----------+----------+---------------------+
| 3  | Benoit   | Novapost | 2012-02-25          |
+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+

Comment peut-on obtenir le même résultat sans utiliser OFFSET ?

SELECT * FROM `salaries`
ORDER BY `id`
LIMIT 2

+----+----------+----------+---------------------+
| 1  | Rodolphe | Novapost | 2014-09-03          |
+----+----------+----------+---------------------+
| 2  | Tarek    | Mozilla  | 2009-03-01          |
+----+----------+----------+---------------------+

SELECT * FROM `salaries`
WHERE `id` > 2
ORDER BY `id`
LIMIT 2

+----+----------+----------+---------------------+
| 3  | Benoit   | Novapost | 2012-02-25          |
+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+

Quand on fait le tri sur une valeur unique pour toute la collection, on se rend compte que l'on peut sauvegarder la valeur du dernier élément de la liste et l'utiliser pour faire une condition where.

Faisons maintenant le tri sur la date d'embauche :

SELECT * FROM `salaries`
ORDER BY `date_embauche`
LIMIT 2

+----+----------+----------+---------------------+
| 2  | Tarek    | Mozilla  | 2009-03-01          |
+----+----------+----------+---------------------+
| 3  | Benoit   | Novapost | 2012-02-25          |
+----+----------+----------+---------------------+

SELECT * FROM `salaries`
WHERE `date_embauche` > '2012-02-25'
ORDER BY `date_embauche`
LIMIT 2

+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+
| 5  | Bruno    | Novapost | 2013-06-14          |
+----+----------+----------+---------------------+

SELECT * FROM `salaries`
WHERE `date_embauche` > '2013-06-14'
ORDER BY `date_embauche`
LIMIT 2

+----+----------+----------+---------------------+
| 8  | Natal    | Novapost | 2013-08-05          |
+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+

Et pour la page précédente ?

Soit on se rappelle de la règle de filtrage précédente, soit on peut ruser en inversant l'ordre de tri puis en selectionnant les résultats supérieurs au premier élément de la page courante et en affichant les résultats dans l'ordre inverse :

SELECT * FROM `salaries`
WHERE `date_embauche` < '2013-08-05'
ORDER BY `date_embauche` DESC
LIMIT 2

+----+----------+----------+---------------------+
| 5  | Bruno    | Novapost | 2013-06-14          |
+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+

Qu'il faut afficher à l'utilisateur comme cela :

+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+
| 5  | Bruno    | Novapost | 2013-06-14          |
+----+----------+----------+---------------------+

Et pour les tris sur des clés non uniques ?

Dès lors qu'une clé de tri n'est plus unique, contrairement à date_embauche et id dans notre exemple, il faut trouver une requête qui permet d'identifier de manière unique la ligne à partir de laquelle continuer.

Prenons la requête suivante :

SELECT * FROM `salaries`
ORDER BY `societe`, `nom`

+----+----------+----------+---------------------+
| ID | Nom      | Société  | Date de recrutement |
+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+
| 7  | Mathieu  | Mozilla  | 2014-12-06          |
+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+
| 6  | Rémy     | Mozilla  | 2014-03-11          |
+----+----------+----------+---------------------+
| 2  | Tarek    | Mozilla  | 2009-03-01          |
+----+----------+----------+---------------------+
| 3  | Benoit   | Novapost | 2012-02-25          |
+----+----------+----------+---------------------+
| 5  | Bruno    | Novapost | 2013-06-14          |
+----+----------+----------+---------------------+
| 8  | Natal    | Novapost | 2013-08-05          |
+----+----------+----------+---------------------+
| 1  | Rodolphe | Novapost | 2014-09-03          |
+----+----------+----------+---------------------+

Si on souhaite obtenir la deuxième page en utilisant id on se rend compte qu'il y a un soucis.

SELECT * FROM `salaries`
WHERE `id` > 7
ORDER BY `societe`, `nom`

+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+
| 8  | Natal    | Novapost | 2013-08-05          |
+----+----------+----------+---------------------+

Or la seconde page attendue est :

+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+
| 6  | Rémy     | Mozilla  | 2014-03-11          |
+----+----------+----------+---------------------+

Tri avec une seule clé non unique

Commençons avec un tri sur une seule colonne non unique societe:

SELECT * FROM `salaries`
ORDER BY `societe`

+----+----------+----------+---------------------+
| ID | Nom      | Société  | Date de recrutement |
+----+----------+----------+---------------------+
| 2  | Tarek    | Mozilla  | 2009-03-01          |
+----+----------+----------+---------------------+
| 4  | Alexis   | Mozilla  | 2012-09-24          |
+----+----------+----------+---------------------+
| 6  | Rémy     | Mozilla  | 2014-03-11          |
+----+----------+----------+---------------------+
| 7  | Mathieu  | Mozilla  | 2014-12-06          |
+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+
| 1  | Rodolphe | Novapost | 2014-09-03          |
+----+----------+----------+---------------------+
| 3  | Benoit   | Novapost | 2012-02-25          |
+----+----------+----------+---------------------+
| 5  | Bruno    | Novapost | 2013-06-14          |
+----+----------+----------+---------------------+
| 8  | Natal    | Novapost | 2013-08-05          |
+----+----------+----------+---------------------+

On se rends compte qu'il s'agit en fait de cette requête :

SELECT * FROM `salaries`
ORDER BY `societe`, `id`

Notre requête pour la page deux est donc :

  • Les salariés qui ont un nom de société supérieurs à Mozilla ou
  • Les salariés de Mozilla qui ont un id supérieur à 4
SELECT * FROM `salaries`
WHERE `societe` > 'Mozilla'
OR (`societe` = 'Mozilla' AND `id` > 4)
ORDER BY `societe`, `id`
LIMIT 2

+----+----------+----------+---------------------+
| 6  | Rémy     | Mozilla  | 2014-03-11          |
+----+----------+----------+---------------------+
| 7  | Mathieu  | Mozilla  | 2014-12-06          |
+----+----------+----------+---------------------+

On peut vérifier que le cas limite fonctionne aussi:

SELECT * FROM `salaries`
WHERE `societe` > 'Mozilla'
OR (`societe` = 'Mozilla' AND `id` > 7)
ORDER BY `societe`, `id`
LIMIT 2

+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+
| 1  | Rodolphe | Novapost | 2014-09-03          |
+----+----------+----------+---------------------+

Tri sur de multiples clé non uniques

Maintenant revenons à notre tri par societe et par nom

Pour atteindre la page deux, on a donc trois ensembles à concaténer:

  • Les salariés de Mozilla qui s'appellent à Mathieu et dont l'id est supérieur à 7
  • Les salariés de Mozilla dont le nom est supérieur à Mathieu
  • Les salariés dont le nom de société est supérieur à Mozilla
SELECT * FROM `salaries`
WHERE `societe` = 'Mozilla' AND `nom` = 'Mathieu' AND `id` > 7
OR (`societe` = 'Mozilla' AND `nom` > 'Mathieu')
OR `societe` > 'Mozilla'
ORDER BY `societe`, `nom`
LIMIT 2

+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+
| 6  | Rémy     | Mozilla  | 2014-03-11          |
+----+----------+----------+---------------------+

On peut tester notre cas limite en ajoutant

+----+----------+----------+---------------------+
| 10 | Mathieu  | Mozilla  | 2015-03-22          |
+----+----------+----------+---------------------+

Et on a bien :

SELECT * FROM `salaries`
WHERE `societe` = 'Mozilla' AND `nom` = 'Mathieu' AND `id` > 7
OR (`societe` = 'Mozilla' AND `nom` > 'Mathieu')
OR `societe` > 'Mozilla'
ORDER BY `societe`, `nom`
LIMIT 2

+----+----------+----------+---------------------+
| 10 | Mathieu  | Mozilla  | 2015-03-22          |
+----+----------+----------+---------------------+
| 9  | Nicolas  | Mozilla  | 2014-02-27          |
+----+----------+----------+---------------------+

Généralisation

La manière générique que j'ai trouvée pour utiliser un Continuation Token ou jeton de continuation tout en laissant l'utilisateur choisir sa requête de tri est de générer le jeton à partir du dernier élément de la page et des champs de tri.

En complétant toujours les champs de tri par la clé primaire à la fin.

Ensuite je génère une fonction recursive qui prend la liste des champs de tri et la dernière entrée de la page précédente et me retourne une liste de conditions de tri.

def get_continuation_token_conditions(record, sorting, results=None):
    """Return the list of conditions for a given record and sorting attributes.

    >>> get_continuation_token_conditions(
    ...     {'id': 7, 'nom': 'Mathieu', 'societe': 'Mozilla'},
    ...     ['societe', 'nom', 'id']
    ... )
    [(('societe', '=', 'Mozilla'), ('nom', '=', 'Mathieu'), ('id', '>', 7)),
     (('societe', '=', 'Mozilla'), ('nom', '>', 'Mathieu')),
     (('societe', '>', 'Mozilla'))]

    >>> get_continuation_token_conditions(
    ...     {'id': 7, 'nom': 'Mathieu', 'societe': 'Mozilla'},
    ...     ['societe', '-nom', 'id']
    ... )
    [(('societe', '=', 'Mozilla'), ('nom', '=', 'Mathieu'), ('id', '>', 7)),
     (('societe', '=', 'Mozilla'), ('nom', '<', 'Mathieu')),
     (('societe', '>', 'Mozilla'))]

    """

    result = []
    for field in sorting[:-1]:
        field_name = field.lstrip('-')
        result.append((field_name, '=', record[field_name]))

    field = sorting[-1]
    field_name = field.lstrip('-')
    direction = '<' if (field[0] == '-') else '>'
    result.append((field_name, direction, record[field_name]))

    if results is not None:
        results.append(result)
    else:
        results = [result]

    if len(sorting) == 1:
        return results
    else:
        return get_continuation_token_conditions(record, sorting[:-1], results)

Conclusion

Vous voyez que c'est possible de faire de la pagination à l'aide d'un continuation token tout en gardant les fonctionnalités de tri.

L'inconvénient c'est qu'il est impossible de pouvoir sauter à la dernière page ou à une page donnée, heureusement les utilisateurs sont maintenant habitués à filtrer les résultats afin d'avoir la réponse sur la première ou deuxième page et dans le cas où ils souhaitent tous les résultats, ils regardent les pages dans l'ordre.

Qui dit conditions de tri dit aussi index et c'est là que bien cadrer les fonctionnalités de tri autorisées devient intéressant. Est-ce bien nécessaire de laisser l'utilisateur choisir les champs de tri, ou peut-on se contenter de ne lui laisser comme choix que le sens du tri sur des champs prédéfinis ?

Si votre condition de pagination est fixe, vous allez pouvoir créer les index nécessaires et optimiser au maximum vos requêtes de pagination.

Le 30 avril 1993, le Web décolle

Firefox OS n’est pas né de nulle part. Il est le fruit d’une riche histoire. Découvrons-en un événement marquant.

The World Wide Web project – CERN.pngCe 30 avril, je voulais fêter avec vous le 22e anniversaire du 1er site web (pas Internet mais web). Mais, le compte @1jour m’a rappelé[1] une chose relative à fêter bien plus importante : le 30 avril 1993 le CERN a aussi placé le Web dans le domaine public.

Nous vous avons déjà raconté la naissance du Web le 13 mars 1989 quand la proposition de système de gestion de l’information de Tim Berners-Lee a été acceptée par son chef au CERN (en France). Après quatre ans de développement…

Le 30 avril 1993, le CERN publiait une déclaration autorisant l’utilisation gratuite de la technologie du World Wide Web (« W3 », ou plus simplement « le web »). Le fait d’avoir rendu accessible gratuitement le logiciel nécessaire au fonctionnement d’un serveur web, ainsi que le navigateur et la bibliothèque de codes associés, a permis à la Toile de se tisser.[2]

Pourtant, ça n’allait pas de soi :

Déjà, en 1993, les dirigeants du CERN souhaitaient que le web reste la propriété du centre de recherche et devrait être consacré à la recherche en physique. Ce que Tim Berners-Lee et son équipe ont refusé.

Le CERN a donc accepté de signé un document légal qui a rendu le web public. Plus important encore, ce papier précise que personne ne peut réclamer la propriété du web, assurant ainsi un Internet gratuit et ouvert à tous. « Ce document est sans doute le document le plus important de toute l’Histoire du web. Sans lui, le web serait morcelé en différentes parties détenues par des entreprises comme Microsoft, Apple ou Vodafone », affirme Dan Noyes [web manager du CERN]. Le 30 avril 1993, le code source du WorldWideWeb est disponible gratuitement.

(…)

À l’origine, le premier site web permettait de décentraliser les informations et les rendre accessibles gratuitement à tous. C’est cette culture de l’accès universel et de l’interne gratuit qui est symbolisée par ce site internet.

« Garder le web gratuit et accessible à tous est pratiquement un droit élémentaire », déclare le professeur Nigel Shadbolt, de l’Université de Southampton, à la BBC.[3]

Laissons le mot de la fin au directeur du CERN :

« L’invention, dans un laboratoire de physique, du web a révolutionné tous les secteurs de la société, a déclaré Rolf Heuer, directeur général du CERN. Du monde de la recherche au secteur privé, en passant par l’enseignement, le web a transformé notre façon de communiquer, de travailler, d’innover et de vivre. Le web est un exemple éclatant de la manière dont la société récolte les fruits de la recherche fondamentale. »[2]

Pas besoin de vous décrire la relation de cet anniversaire avec Mozilla, Firefox et Firefox OS !

Voici le document qui versa officiellement le Web dans le domaine public :



Un souvenir ? Une idée ? Racontez-nous votre histoire de Mozilla et du logiciel libre.


@Mozinet

Lien vers le précédent coup d’œil dans le rétro : Naissance de Firefox pour Android – 29 mars 2011

Voir aussi : Il y a 26 ans naissait le Web – 13 mars 1989

Eco-système et stockage générique

tl;dr Nous devons construire un service de suivi de paiements, et nous hésitons à continuer à nous entêter avec notre propre solution de stockage/synchronisation.

Comme nous l'écrivions dans l'article précédent, nous souhaitons construire une solution de stockage générique. On refait Daybed chez Mozilla !

Notre objectif est simple: permettre aux développeurs d'application, internes à Mozilla ou du monde entier, de faire persister et synchroniser facilement des données associées à un utilisateur.

Les aspects de l'architecture qui nous semblent incontournables:

  • La solution doit reposer sur un protocole, et non sur une implémentation ;
  • L'auto-hébergement de l'ensemble doit être simplissime ;
  • L'authentification doit être pluggable, voire décentralisée (OAuth2, FxA, Persona) ;
  • Les enregistrements doivent pouvoir être validés par le serveur ;
  • Les données doivent pouvoir être stockées dans n'importe quel backend ;
  • Un système de permissions doit permettre de protéger des collections, ou de partager des enregistrements de manière fine ;
  • La résolution de conflits doit pouvoir avoir lieu sur le serveur ;
  • Le client doit être pensé «offline-first» ;
  • Le client doit pouvoir réconcilier les données simplement ;
  • Le client doit pouvoir être utilisé aussi bien dans le navigateur que côté serveur ;
  • Tous les composants se doivent d´être simples et substituables facilement.

La première question qui nous a été posée fût «Pourquoi vous n'utilisez pas PouchDB ou Remote Storage ?»

Remote Storage

Remote Storage est un standard ouvert pour du stockage par utilisateur. La specification se base sur des standards déjà existants et éprouvés: Webfinger, OAuth 2, CORS et REST.

L'API est simple, des projets prestigieux l'utilisent. Il y a plusieurs implémentations du serveur, et il existe un squelette Node pour construire un serveur sur mesure.

Remote Storage widget

Le client remoteStorage.js permet d'intégrer la solution dans les applications Web. Il se charge du «store local», du cache, de la synchronization, et fournit un widget qui permet aux utilisateurs des applications de choisir le serveur qui recevra les données (via Webfinger).

ludbud, la version épurée de remoteStorage.js, se limite à l'abstraction du stockage distant. Cela permettrait à terme, d'avoir une seule bibliothèque pour stocker dans un serveur remoteStorage, ownCloud ou chez les méchants comme Google Drive ou Dropbox.

Au premier abord, la spécification correspond à ce que nous voulons accomplir:

  • La philosophie du protocole est saine;
  • L'éco-système est bien fichu;
  • La vision politique colle: redonner le contrôle des données aux utilisateurs (voir unhosted);
  • Les choix techniques compatibles avec ce qu'on a commencé (CORS, REST, OAuth 2);

En revanche, vis à vis de la manipulation des données, il y a plusieurs différences avec ce que nous souhaitons faire:

En résumé, il semblerait que ce que nous souhaitons faire avec le stockage d'enregistrements validés est complémentaire avec Remote Storage.

Si des besoins de persistence orientés «fichiers» se présentent, a priori nous aurions tort de réinventer les solutions apportées par cette spécification. Il y a donc de grandes chances que nous l´intégrions à terme, et que Remote Storage devienne une facette de notre solution.

PouchDB

PouchDB est une bibliothèque JavaScript qui permet de manipuler des enregistrements en local et de les synchroniser vers une base distante.

var db = new PouchDB('dbname');

db.put({
 _id: 'dave@gmail.com',
 name: 'David',
 age: 68
});

db.replicate.to('http://example.com/mydb');

Le projet a le vent en poupe, bénéficie de nombreux contributeurs, l'éco-système est très riche et l'adoption par des projets comme Hoodie ne fait que confirmer la pertinence de l'outil pour les développeurs frontend.

PouchDB gère un « store » local, dont la persistence est abstraite et repose sur l'API LevelDown pour persister les données dans n'importe quel backend.

Même si PouchDB adresse principalement les besoins des applications «offline-first», il peut être utilisé aussi bien dans le navigateur que côté serveur, via Node.

Synchronisation

La synchronisation (ou réplication) des données locales s'effectue sur un CouchDB distant.

Le projet PouchDB Server implémente l'API de CouchDB en NodeJS. Comme PouchDB est utilisé, on obtient un service qui se comporte comme un CouchDB mais qui stocke ses données n'importe où, dans un Redis ou un PostgreSQL par exemple.

La synchronisation est complète. Autrement dit, tous les enregistrements qui sont sur le serveur se retrouvent synchronisés dans le client. Il est possible de filtrer les collections synchronisées, mais cela n'a pas pour objectif de sécuriser l'accès aux données.

L'approche recommandée pour cloisonner les données par utilisateur consiste à créer une base de données par utilisateur.

Ce n'est pas forcément un problème, CouchDB supporte des centaines de milliers de bases sans sourciller. Mais selon les cas d'utilisation, le cloisement n'est pas toujours facile à déterminer (par rôle, par application, par collection, ...).

Le cas d'utilisation « Payments »

Put Payments Here  -- Before the Internet - CC-NC-SA Katy Silberger https://www.flickr.com/photos/katysilbs/11163812186

Dans les prochaines semaines, nous devrons mettre sur pied un prototype pour tracer l'historique des paiements et abonnements d'un utilisateur.

Le besoin est simple:

  • l'application « Payment » enregistre les paiements et abonnements d'un utilisateur pour une application donnée;
  • l'application « Donnée » interroge le service pour vérifier qu'un utilisateur a payé ou est abonné;
  • l'utilisateur interroge le service pour obtenir la liste de tous ses abonnements.

Seule l'application « Payment » a le droit de créer/modifier/supprimer des enregistrements, les deux autres ne peuvent que consulter en lecture seule.

Une application donnée ne peut pas accéder aux paiements des autres applications, et un utilisateur ne peut pas accéder aux paiements des autres utilisateurs.

Avec RemoteStorage

Remote Love - CC-BY-NC Julie https://www.flickr.com/photos/mamajulie2008/2609549461

Clairement, l'idée de RemoteStorage est de dissocier l'application executée, et les données créées par l'utilisateur avec celle-ci.

Dans notre cas, c'est l'application « Payment » qui manipule des données concernant un utilisateur. Mais celles-ci ne lui appartiennent pas directement: certes un utilisateur doit pouvoir les supprimer, surtout pas en créer ou les modifier!

La notion de permissions limitée à privé/publique ne suffit pas dans ce cas précis.

Avec PouchDB

Il va falloir créer une base de données par utilisateur, afin d'isoler les enregistrements de façon sécurisée. Seule l'application « Payment » aura tous les droits sur les databases.

Mais cela ne suffit pas.

Il ne faut pas qu'une application puisse voir les paiements des autres applications, donc il va aussi falloir recloisonner, et créer une base de données par application.

Quand un utilisateur voudra accéder à l'ensemble de ses paiements, il faudra agréger les databases de toutes les applications. Quand l'équipe marketing voudra faire des statistiques sur l'ensemble des applications, il faudra agrégér des centaines de milliers de databases.

Ce qui est fort dommage, puisqu'il est probable que les paiements ou abonnements d'un utilisateur pour une application se comptent sur les doigts d'une main. Des centaines de milliers de bases contenant moins de 5 enregistrements ?

De plus, dans le cas de l'application « Payment », le serveur est implémenté en Python. Utiliser un wrapper JavaScript comme le fait python-pouchdb cela ne nous fait pas trop rêver.

Un nouvel éco-système ?

Wagon wheel - CC-BY-NC-SA arbyreed https://www.flickr.com/photos/19779889@N00/16161808220

Évidemment, quand on voit la richesse des projets PouchDB et Remote Storage et la dynamique de ces communautés, il est légitime d'hésiter avant de développer une solution alternative.

Quand nous avons créé le serveur Reading List, nous l'avons construit avec Cliquet, ce fût l'occasion de mettre au point un protocole très simple, fortement inspiré de Firefox Sync, pour faire de la synchronisation d'enregistrements.

Et si les clients Reading List ont pu être implémentés en quelques semaines, que ce soit en JavaScript, Java (Android) et ASM (Add-on Firefox), c'est que le principe «offline first» du service est trivial.

Les compromis

Évidemment, nous n'avons pas la prétention de concurrencer CouchDB. Nous faisons plusieurs concessions:

  • De base, les collections d'enregistrements sont cloisonnées par utilisateur;
  • Pas d'historique des révisions;
  • Pas de diff sur les enregistrements entre révisions;
  • De base, pas de résolution de conflit automatique;
  • Pas de synchronisation par flux (streams);

Jusqu'à preuve du contraire, ces compromis excluent la possibilité d'implémenter un adapter PouchDB pour la synchronisation avec le protocole HTTP de Cliquet.

Dommage puisque capitaliser sur l'expérience client de PouchDB au niveau synchro client semble être une très bonne idée.

En revanche, nous avons plusieurs fonctionnalités intéressantes:

  • Pas de map-reduce;
  • Synchronisation partielle et/ou ordonnée et/ou paginée ;
  • Le client choisit, via des headers, d'écraser la donnée ou de respecter la version du serveur ;
  • Un seul serveur à déployer pour N applications ;
  • Auto-hébergement simplissime ;
  • Le client peut choisir de ne pas utiliser de « store local » du tout ;
  • Dans le client JS, la gestion du « store local » sera externalisée (on pense à LocalForage ou Dexie.js) ;

Et, on répond au reste des specifications mentionnées au début de l'article !

Les arguments philosophiques

Il est illusoire de penser qu'on peut tout faire avec un seul outil.

Nous avons d'autres cas d'utilisations dans les cartons qui semblent correspondre au scope de PouchDB (pas de notion de permissions ou de partage, environnement JavaScript, ...). Nous saurons en tirer profit quand cela s'avèrera pertinent !

L'éco-système que nous voulons construire tentera de couvrir les cas d'utilisation qui sont mal adressés par PouchDB. Il se voudra:

  • Basé sur notre protocole très simple ;
  • Minimaliste et multi-usages (comme la fameuse 2CV) ;
  • Naïf (pas de rocket science) ;
  • Sans magie (explicite et facile à réimplémenter from scratch) ;

La philosophie et les fonctionnalités du toolkit python Cliquet seront bien entendu à l'honneur :)

Quant à Remote Storage, dès que le besoin se présentera, nous serons très fier de rejoindre l'initiative, mais pour l'instant cela nous paraît risqué de démarrer en tordant la solution.

Les arguments pratiques

Avant d'accepter de déployer une solution à base de CouchDB, les ops de Mozilla vont nous demander de leur prouver par A+B que ce n'est pas faisable avec les stacks qui sont déjà rodées en interne (i.e. MySQL, Redis, PostgreSQL).

De plus, on doit s'engager sur une pérennité d'au moins 5 ans pour les données. Avec Cliquet, en utilisant le backend PostgreSQL, les données sont persistées à plat dans un schéma PostgreSQL tout bête. Ce qui ne sera pas le cas d'un adapteur LevelDown qui va manipuler des notions de révisions éclatées dans un schéma clé-valeur.

Si nous basons le service sur Cliquet, comme c'est le cas avec Kinto, tout le travail d'automatisation de la mise en production (monitoring, builds RPM, Puppet...) que nous avons fait pour Reading List est complètement réutilisable.

De même, si on repart avec une stack complètement différente, nous allons devoir recommencer tout le travail de rodage, de profiling et d'optimisation effectué au premier trimestre.

Les prochaines étapes

Et il est encore temps de changer de stratégie :) Nous aimerions avoir un maximum de retours ! C'est toujours une décision difficile à prendre... </appel à troll>

  • Tordre un éco-système existant vs. constuire sur mesure ;
  • Maîtriser l'ensemble vs. s'intégrer ;
  • Contribuer vs. refaire ;
  • Guider vs. suivre.

Nous avons vraiment l'intention de rejoindre l'initiative no-backend, et ce premier pas n'exclue pas que nous convergions à terme ! Peut-être que nous allons finir par rendre notre service compatible avec Remote Storage, et peut-être que PouchDB deviendra plus agnostique quand au protocole de synchronisation...

XKCD — Standards https://xkcd.com/927/

Utiliser ce nouvel écosystème pour le projet « Payments » va nous permettre de mettre au point un système de permissions (probablement basé sur les scopes OAuth) qui correspond au besoin exprimé. Et nous avons bien l'intention de puiser dans notre expérience avec Daybed sur le sujet.

Nous extrairons aussi le code des clients implémentés pour Reading List afin de faire un client JavaScript minimaliste.

En partant dans notre coin, nous prenons plusieurs risques:

  • réinventer une roue dont nous n'avons pas connaissance ;
  • échouer à faire de l'éco-système Cliquet un projet communautaire ;
  • échouer à positionner Cliquet dans la niche des cas non couverts par PouchDB :)

Comme le dit Giovanni Ornaghi:

Rolling out your set of webservices, push notifications, or background services might give you more control, but at the same time it will force you to engineer, write, test, and maintain a whole new ecosystem.

C'est justement l'éco-système dont est responsable l'équipe Mozilla Cloud Services!

[1]Il existe le projet Sharesome qui permet de partager publiquement des ressources de son remote Storage.

Naissance de Firefox pour Android – 29 mars 2011 – Coup d'œil dans le rétro

Firefox OS n’est pas né de nulle part. Il est le fruit d’une riche histoire. Découvrons-en un événement marquant.

Firefox is mobileEn mars 2011, Mozilla lançait une nouvelle version de Firefox longtemps attendue : Firefox 4. Cette dernière version majeure de l’ancien paradigme de développement dans lequel il fallait attendre les nouveautés pendant un an ou plus est sortie pour Linux, Mac OS X, Windows, mais aussi pour Android et Maemo, deux systèmes d’exploitation mobiles. La première version stable de Firefox pour Android remonte donc au 29 mars 2011.

Le développement pour Maemo a depuis été abandonné.

Firefox 4 mobile comptait lors de sa sortie plus de dix langues et prenait en charge la synchronisation qui permettait de réduire la saisie de texte souvent fastidieuse sur mobile.

Voyez donc cet extrait du communiqué de presse de Mozilla Europe à l’époque :

Firefox pour mobile permet aux utilisateurs d’emporter avec eux leur expérience de navigation avec Firefox et de réduire l’entrée de texte (parfois un peu fastidieuse sur un clavier de smartphone) grâce aux fonctionnalités telles que la navigation par onglets, les marque-pages, les extensions et Firefox Sync. Grâce à une nouvelle interface qui cache les menus de contrôles du navigateur quand il ne sont pas activement utilisés, Firefox permet de se concentrer sur le contenu du site web qu’il est en train de visiter. Firefox Sync donne à l’utilisateur un accès permanent à son historique de navigation, ses marque-pages, ses onglets ouverts, ses données de formulaires et ses mots de passe entre ordinateurs et smartphones. Firefox offre aussi des centaines de manières différentes de personnaliser les fonctionnalités et l’interface de navigation avec les extensions Firefox

Firefox est jusqu’à 3 fois plus rapide que le navigateur par défaut sous Android. Les améliorations importantes apportées au moteur JavaScript permettent de rendre tout plus rapide : du chargement d’une page à l’affichage d’image, jusqu’à l’utilisation globale de Firefox.

Firefox pour mobile est basé sur la même plateforme technologique ouverte que son aîné sur ordinateur. Grâce aux technologies web modernes telles que le HTML5, les développeurs peuvent construire des applications et des sites web riches et interactifs.

Cette première grosse incursion de Mozilla dans le monde du mobile a permis à Mozilla d’emmagasiner de l’expérience et de constater les limitations du développement d’un navigateur pour un OS qu’on ne maîtrisait pas.

Depuis, Firefox pour Android a été téléchargé plus de 100 millions de fois sur la boutique d’applications d’Android.

Si vous n’avez pas le vôtre sur votre smartphone ou votre tablette Android, précipitez-vous ! Il a pas mal progressé encore depuis le 29 mars 2011.

Firefox pour Android : 100 M de téléchargements


Un souvenir ? Une idée ? Racontez-nous votre histoire de Mozilla et du logiciel libre.


@Mozinet

Le précédent coup d’œil dans le rétro : Libération du code source de Netscape et naissance de Mozilla – 31 mars 1998

Crédit illustration : n° 1 Mozilla via 01net

n° 2 Mozilla

Testez Lightning 4.0 bêta avec Thunderbird 38 bêta

agendaConnaissez-vous Lightning ? C’est l’agenda issu du Mozilla Calendar Project qui devrait être à terme intégré à Thunderbird. Tout comme maintenant, vous ne serez pas obligé de l’utiliser. Par contre, si vous l’utilisez ou désirez une solution d’agenda, vous pouvez participer au test de Lightning 4.0 bêta 3 actuellement puis sans doute 4.

Calé sur le rythme de Thunderbird qui sortira le 12 mai en version majeure 38, Lightning sortira en version 4.0 majeure. Afin d’éviter toute déconvenue, il est vital de tester les versions bêta en condition réelle. Faites tout ce que vous faites quotidiennement : créer des événements, accepter une invitation, accomplir une tâche, etc.

Télécharger les bêta…

  1. Thunderbird 38.0 bêta
  2. Lightning bêta : en bas de page dépliez la section « Canal de développement » et téléchargez la bêta.
  3. Installer Lightning dans Thunderbird

Précautions

Bien qu’il soit très peu probable que de graves problèmes se posent, vous êtes chaudement encouragé à faire une sauvegarde avant de passer à la bêta. Philipp vous réconforte en vous affirmant qu’il se sert des versions bêta pour son profil de travail et qu’il ne se souvient pas d’une seule fois où il aurait perdu des événements ou dû recommencer.

Rapporter les problèmes découverts

Maintenant, vous êtes prêt à rapporter des bogues en anglais dans les commentaires du billet de Philipp Kewisch ou en remplissant un rapport de bogue dans Bugzilla.

Nouveautés

Les changements ne seront pas très visibles depuis qu’ils ne concernent que le backend, ce qui se trouve sous le capot. Philipp mentionne « une formidable nouvelle fonctionnalité » pour enregistrer des copies des invitations. C’est utile dans le cas où vous n’envisagez pas de répondre à l’invitation, mais souhaitez tout de même la voir dans votre agenda. Des améliorations générales de la compatibilité des invitations, des performances et de la stabilité sont aussi dans cette version 4.0 encore en bêta.

Sources et références

Mozilla Calendar Project Blog, The Third Beta on the way to Lightning 4.0, 28 avr. 2015, Philipp Kewisch Bugzilla@Mozilla : liste complète des changements

© 2010-2014 Mozinet - Ce billet a été publié sur BlogZiNet.

Pweek : Le puzzle en smileys

Le concept d’associer un ou plusieurs objets de même couleurs est arrivé avec le jeu Puyo Puyo, apparu sur les consôles comme Famicom Disk System, Mega Drive, NES, Super Nintendo, Game Gear… dans les années 90. Depuis, des jeux du même genre sont apparus : Tetris, Columns, Quadrapop, Blobs, Bubble… et beaucoup d’autres, tout en gardant le même principe de regroupement.

Logo PweekPweek mini est un jeu de réfexion, inspiré du jeu original Pweek, mais spécialement conçu pour les smartphones. Dont celui-ci a été inspiré du premier jeu du même genre : Puyo Puyo (un jeu des années 1991/92 sur consoles).

Il fonctionne aussi hors connexion.

Le but du jeu est de regrouper 4 « pweeks » de même couleur. Pour cela, vous disposez à chaque fois de 2 pweeks qui tombent du haut et qui descendent vers le bas avec des couleurs aléatoires.

Ces 2 pièces peuvent tourner en tapant n’importe où sur l’écran de ¼ de tour verticalement ou horizontalement. Par contre pour les déplacer, vous maintenez appuyer votre doigt de gauche à droite et le descendre plus rapidement en glissant votre doigt de haut en bas.

Pour faire disparaitre les pweeks, vous devez assembler au moins 4 pweeks de même couleurs.

Les défis

Dès le lancement du jeu, vous vous trouvez devant 2 choix qui seront vos défis :

  • Le mode solo
  • Le mode Chrono
Pweek : Solo + Chrono

Le mode solo propose 10 niveaux à passer. Chacun d’eux a un niveau de complexité supérieur au précédent. Au dernier niveau, vous ne verrez pas d’écran de FIN, car il continuera tant que les pweek n’ont pas atteint le haut de l’écran, c’est à dire que vous aurez perdu. La conséquence, c’est de garder son sang froid pour arriver à l’écran final et même plus.

Le mode chrono est différent car il vous oblige à aller le plus vite possible dans un temps limité de 120 secondes. Il se joue de la même façon que le mode solo, mais le stress a augmenté d’un niveau.

La jouabilité des niveaux

Le défis solo

Quel que soit le mode que vous choisissez, les pweeks arrivent par le haut par deux.

Ainsi…

Pweek : les pweeks arrivent par le haut par deux

Vous commencez par 3 couleurs (rouge, vert, jaune).

Pweek

À partir du niveau 2, la couleur bleue s’invite dans la combinaison.

Pweek

À partir du niveau 2, la couleur bleue s’invite dans la combinaison.

Pweek

Du niveau 6 à 10, vous trouverez de nouveau une nouvelle augmentation de la vitesse et l’apparition plus rapide des pweeks.

Pweek Pweek

Le niveau 10 est le niveau maximum de difficultés et sera la difficulté ultime.

le défis chrono

Le mode chrono est un mode chronométré. Vous devez obtenir le maximum de points dans un minimum de temps, c’est à dire 120 secondes

Les temps de chaque niveau est beaucoup court que dans le mode solo.

Pweek Pweek

Mais si vous souhaitez obtenir un maximum de points, il faut mieux regrouper un maximum de pweeks en une seule fois et ne pas se limiter à 4.

Game Over

Pweek : Game Over ! Pweek : Game Over !

Quel que soit le défi que vous relevez, vous aurez tôt ou tard un écran « Game Over ! » qui signale que vous avez perdu. L’écran de gauche est l‘écran du mode solo et celui de droite, le mode chrono.

Sniff

Le jeu est très bien comme vous pouvez le voir, mais c’est dommage que la bande sonore soit absente ce qui ne gâche pas du tout la qualité du jeu, surtout si vous vous trouvez dans des lieux ou transports publics.

Bien entendu, nous pouvons espérer d’autres niveaux, mais vous pouvez déjà prévoir de passer de nombreuses heures pour essayer d’aller le plus loin possible.


@hellosct1

Retrouvez l’appli de la semaine dernière : CloudActivity, un client Dropbox pour Firefox OS

Crédit illustration : Logo de Pweek Maxime Chéramy.

Locasprint N°3 @Mozilla Paris

Et hop, déjà la troisième édition et tant mieux si nous parvenons à en faire un rendez-vous régulier tous les six mois ! C’est un plaisir de retrouver en chair et en os des contributeurs éloignés géographiquement qui ne sont parfois que d’obscurs pseudos sur IRC ou sur la liste Mozfr.
Un grand merci donc à Clara et Sasha dont l’efficacité et la disponibilité nous ont permis de nous rencontrer le week-end dernier (oui, du vendredi au dimanche !) pour une troisième session de localisation mozillienne. Les chantiers habituels comme SUMO et MDN étaient au programme, mais aussi un atelier d’initiation à GitHub, une présentation de l’indispensable Transvision et de ses fonctionnalités avancées, les traductions des pages et snippets bientôt en production pour mozilla.org et sans doute bien d’autres choses…

groupe2.jpg

SUMO francophone, tous les feux sont au vert

SUMO, c’est SUpport MOzilla, l’aide aux utilisateurs pour tous les produits, une ressource de 580 articles régulièrement augmentée et mise à jour, disponible ici https://support.mozilla.org/fr/. Ces articles peuvent compléter les réponses obtenues par les bénévoles qui vous dépannent avec compétence sur les forums de mozfr à cette adresse https://forums.mozfr.org/
Les contributeurs à la traduction de Sumo ont l’habitude de travailler un peu dans l’ombre au bénéfice des utilisateurs, mais cette fois, nous ne cacherons pas notre satisfaction, voici pourquoi.

Lorsque nous avons planifié ce locasprint il y a deux mois maintenant, le conseil des Reps de Mozilla, qui nous attribue un budget de défraiement pour le transport et la nourriture et que nous remercions ici, nous a comme d’habitude demandé une estimation de nos objectifs.

Dans un premier temps, nous avons déclaré que ce serait bien de passer la barre des 500 articles traduits. Puis nous avons révisé cet objectif à la mi-avril en estimant que nous pourrions atteindre 530 articles traduits (85%) et publiés après relecture. Eh bien nous nous trompions encore !
Nous sommes fiers en effet d’annoncer que dimanche vers midi nous avions déjà traduit… tous les articles de SUMO et donc atteint les 100% pour tous les « produits » (comprendre les pages d’aide pour Firefox, Thunderbird, Firefox pour Android, Firefox OS, Webmaker et Open Badges…).

centPourcentSumo.png

Ce résultat sympathique est bien sûr l’aboutissement d’un effort continu de l’équipe des contributeurs actifs depuis plus d’un an comme on le voit sur ce graphique :

progression.png Je dois avouer qu’atteindre les 100% ne me paraissait pas indispensable, compte tenu du faible intérêt en nombre de “vues” des tout derniers articles qui manquaient (anciens, ou portant sur des projets mozilliens de faible intensité…). Ce qui a fait la différence, c’est la résolution inoxydable et l’enthousiasme communicatif d’Imen Rahal, qui est avec moi « responsable de langue » pour Sumo et qui était venue d’Alger pour l’occasion.

imen.jpg

Notez également que même les chaînes de l’interface ont été achevées grâce à l’excellent Benoit (dont les chocolats rapportés de Bruxelles où il vit ont été appréciés).

Il est temps de féliciter tous nos contributeurs, en particulier Yves, fidèle à nos rendez-vous, qui a non seulement traduit mais aussi soigneusement révisé la qualité toujours perfectible des articles les plus consultés. Son appui sera précieux car il vient d’accepter de rejoindre notre petite équipe de « vérificateurs » ! Banban.jpg

Je suis aussi particulièrement heureux de remercier Thomas (alias Toumitoun), un nouveau contributeur bénévole, qui a traduit pendant le locasprint 18 pages précédemment non traduites ! tomitoun.jpg Encore un qui par ailleurs a déjà les doigts dans le code :) et c’est prometteur.

— Et maintenant, que reste-t-il à faire pour Sumo ? — beaucoup encore :

  • Ajouter des copies d’écran francisées, il en manque toujours par-ci par-là !
  • Vérifier et améliorer la qualité des articles au plan rédactionnel, s’il le faut en choisissant des phrases plus explicites que la version originale.
  • traduire les nouveaux articles qui ne vont pas tarder à arriver en rangs serrés pour traiter de Firefox sous iOS, du partage d’écran, des fonctionnalités de Hello etc.

et surtout…

  • Garder un œil sur les mises à jour des articles anciens qui sont en quasi constant remaniement. Chaque semaine, une dizaine de pages en moyenne sont ainsi réécrites partiellement, quelquefois pour des détails infimes, quelquefois pour des paragraphes entiers.

Merci donc à tous les traducteurs bénévoles occasionnels ou réguliers, et gardez le contact avec Sumo :)

…et les participants fébriles ont aussi…

* Contribué à la traduction de MDN
dont l’équipe est venue en force avec Jean-Yves (teoli), Julien (Sphinx), Jérémie (<3) et Maxime.
Rappelons que Mozilla Developer Network est LA ressource massive pour les développeurs web débutants ou avancés. Un chouette diaporama vous met sur la voie de la contribution, qui est ouverte à tous.
On peut mentionner à titre d’exemples la progression récente du glossaire et le vaste chantier des articles sur le HTML, ou encore les articles consacrés aux devtools (outils de développement) : l’objectif des 60% traduits 80% à jour a été largement atteint avec 65% de traduit et 100% à jour. C’est le français qui est le plus avancé pour ce module, parmi les langues disponibles. Cocorico ! devtools_locasprint_end.png

* Appris à fourcher
C’est Pascal, toujours très attentif à la communauté bien qu’il soit depuis longtemps employé Mozilla ;-) qui a proposé cet atelier en estimant que les volontaires qui veulent contribuer au code seraient probablement de plus en plus appelés à le faire avec Git ou Github, vu que beaucoup de projets désormais, qu’ils soient modestes ou de grande ampleur, se développent de façon ouverte et contributive avec cet outil populaire. Voici l’atelier en pleine concentration, mais je vous certifie qu’il y a eu également de vastes et sonores éclats de rire entre commits et checkouts. atelierGithub.jpg

* Découvert les finesses du Transvision
…que Pascal — encore lui — a exposées dans une petite conférence-démo. Rappelons en deux mots que le Transvision est un précieux moteur de recherche qui permet de retrouver les traductions mozilliennes déjà existantes dans toutes les langues parlées par Firefox, avec des fonctionnalités avancées assez étonnantes. Non seulement chacun peut l’utiliser, mais bien sûr son développement est ouvert aux suggestions, patches, et autres contributions.
C’est l’occasion de signaler que Francesco (alias Flod) de Mozilla Italia était un peu notre “special guest” : il travaille aux côtés de Pascal pour les équipes de localisation de Mozilla et il contribue également au Transvision. Le voici aux côtés d’Hélène, une jeune recrue qui code et traduit avec une égale concentration. helene_et_Flod.jpg

*Mangé, bu, hurlé de rire, chanté et geeké jusqu’aux petites heures de la nuit
…parce qu’une rencontre mozillienne c’est aussi passer du temps ensemble, échanger des humeurs et des informations, donner des nouvelles des uns et des autres, se raconter l’histoire de la communauté et planifier des activités mozilliennes (hello Flore et Sasha !) et puis découvrir une charmante néo-mozillienne de 4 mois et demi… mais bon vous n’aurez qu’à venir la prochaine fois, dans quelques mois peut-être !

hljeFpQI_400x400.jpeg— à bientôt alors ?




— encore quelques photos ? cliquez sur les vignettes pour les agrandir :

dattaz.jpg groupe1.jpg groupe3.jpg Julien.jpg groupe4.jpg groupe4.jpg

Aurélie a participé au futur de Firefox OS

Cette semaine nous accueillons une Starfox qui a participé au futur de Firefox OS au sein de Mozilla en tant que membre de la communauté. Elle a participé au groupe communautaire que nous présentait il y a deux mois Julien, le facilitateur du brainstorming pour Firefox OS 3.0 chez Mozilla Paris. Voici ce qu’il nous en disait :

En parallèle, le groupe des membres de la communauté se composait de 8 personnes avec Julien en tant que facilitateur. Ils se sont réunis en soirée pour 3 sessions de 3 à 4 heures chacune. Julien voulant des personnes motivées, un appel aux volontaires a été lancé aux participants lors du meetup Firefox OS en décembre : « voilà ce qu’on va faire, ceux qui sont intéressés, envoyez moi un mail ». Bien que les discussions entre employés et celles avec les membres de la communauté n’étaient pas vraiment différentes aux dires de Julien, il estime que « les gens de la communauté ont peut-être été plus focalisés vers l’utilisateur ».

Aurélie : proposition de nouveauté pour Firefox OS 3.0Nous avons interviewé deux membres de ce groupe communautaire et nous commençons par Aurélie (le dessin ci-contre qu’elle nous a confié est extrait du storyboard qu’elle a fait pour aider à la mise en forme d’une des idées qui a émergé lors du brainstorming).

Q. Peux-tu te présenter en quelques mots et nous dire comment tu en es arrivée à contribuer à Firefox OS et au projet Mozilla ?

Je m’appelle Aurélie, j’ai 31 ans et je suis conceptrice d’expérience utilisateur (UX designer) et c’est via le meetup Firefox OS France User Group que j’ai été amenée à participer à Firefox OS.

Q. Julien nous a dit qu’il avait demandé des volontaires pour le brainstorming pour Firefox OS 3.0 lors d’un meetup Firefox OS chez Mozilla Paris. As-tu hésité longtemps à te proposer ? Et qu’attendais-tu de cet exercice ?

En fait, l’idée m’a plu, je n’ai pas vraiment hésité. J’ai déjà participé à plusieurs brainstorming dans le cadre de mon travail et je savais que cette technique pouvait donner de très bonnes choses. Ça m’a donné envie de participer. Et puis je suis intéressée par le mobile, le logiciel libre et ce brainstorming, c’était aussi l’occasion pour moi de mieux connaître Firefox OS et d’essayer d’y contribuer un peu. Je suis venue sans trop d’attentes particulières. J’étais curieuse d’en apprendre plus, de rencontrer des personnes de la communauté, d’échanger sur les usages mobiles, d’essayer aussi de comprendre les spécificités techniques de Firefox OS et les perspectives du projet.

Q. Tu nous dis avoir participé à plusieurs brainstormings avant celui de Firefox OS 3.0, quelles différences y as-tu vu et y a-t-il des choses dans cet exercice chez Mozilla réservé à des membres de la communauté qui t’ont étonnée ?

Jusque là, j’avais surtout participé à des brainstormings avec des gens que je connaissais : des collègues de travail, des personnes ayant la même activité professionnelle que moi. En général, les brainstormings étaient organisés sur une seule séance et sur un laps de temps assez court (une heure à une demi-journée). Pour ce brainstorming, même si la majorité des participants avaient plutôt un profil technique, nous venions tous de secteurs différents et nous ne nous connaissions pas tous. Au début, j’étais un peu étonnée du nombre de séances prévues et de leur espacement. Je me demandais ce que ça allait donner par rapport à la dynamique du groupe. Finalement, le fait d’en avoir fait plusieurs discontinues nous a permis de réfléchir entre les séances et de revenir avec d’autres éléments à partager.

Q. Tes attentes et ta curiosité ont-elles été comblées lors de ce brainstorming chez Mozilla Paris ?

Ça a été une très bonne expérience. Dès la première rencontre, Julien n’a pas hésité à confier des Flame[1] pour tester Firefox OS pendant quelques jours. J’ai donc pu tester davantage et m’en faire une idée plus précise, mais aussi poser des questions sur les choix qui avaient été faits au niveau de l’interface (barre de recherche affichée en permanence, etc.). Ça a été aussi l’occasion de faire la connaissance de personnes très sympas et de réfléchir ensemble sur beaucoup de concepts intéressants. Certains autour de la personnalisation de l’expérience utilisateur en fonction du contexte (travail, loisir), mais aussi de sa morphologie (« gros doigts »), continuent d’ailleurs de me trotter dans la tête car j’y vois un vrai bénéfice pour l’utilisateur.

Q. Peux-tu nous en dire plus sur l’idée élaborée par votre groupe communautaire et sur l’influence que cette nature communautaire a eu sur le choix de l’idée et sur la formulation retenue ? De même, dans quelle mesure la nature de l’exercice de brainstorming ouvert a-t-il influé sur le choix de cette idée et sur sa formulation ?

À l’origine, c’est parti d’un constat, d’une expérience qu’on avait tous faite : lorsque quelqu’un nous envoie par exemple un lien hypertexte par SMS, on n’a en général pas d’information, pas d’aperçu sur le contenu de la page associée avant de l’ouvrir dans son navigateur. Et c’est gênant, car passer d’une application à une autre est une manipulation assez contraignante. Elle a pour effet de nous faire basculer dans un autre contexte et d’interrompre la dynamique de conversation dans laquelle on était, pour un contenu qui au final, peut ne pas en valoir la peine. L’idée était donc de créer des « microwidgets » pour avoir directement dans ses messages un aperçu de l’information partagée, sans quitter son contexte de conversation et ainsi gagner en efficacité.

De ce point de vue, l’exercice de brainstorming a favorisé une prise de conscience par un retour et un partage d’expérience collectifs. Le fait qu’on ait été plusieurs à évoquer ou confirmer un même point d’achoppement dans une expérience nous a permis d’avancer plus facilement ensemble sur la recherche d’une solution.

Q. Que penses-tu qu’il faudrait changer à l’exercice de brainstorming pour le rendre plus productif pour Firefox OS 4.0 ?

En l’état, j’ai trouvé que le brainstorming avait été déjà bien organisé et animé. Je trouve qu’on a été plutôt prolifiques. Pour rendre l’exercice encore plus productif, peut-être qu’il faudrait simplement renouveler l’opération plus souvent, avec des groupes de personnes différents et sur des thématiques ciblées.

Au niveau des profils des participants, j’étais la seule femme du groupe et il y avait une majorité de profils techniques. Peut-être que plus de mixité pourrait aussi apporter d’autres choses.

Ceci dit, là où je pense que le brainstorming a été intéressant, ce n’est peut-être pas seulement sur l’aspect quantitatif des idées. Le but d’un brainstorming c’est effectivement de les faire foisonner, mais si aucune idée ne peut être raccrochée à la réalité, l’exercice trouve aussi ses limites. Je trouve justement qu’on a su rebondir sur quelques concepts de manière constructive, à propos de vrais besoins qu’on avait. Le fait de les formaliser sous forme de fiches avec un questionnement par rapport à l’intérêt de l’idée en pratique, a beaucoup aidé à passer du quantitatif au qualitatif.

Q. Le mot de la fin ?

Je voulais remercier Julien pour l’initiative et l’organisation et aussi tous les participants du brainstorming pour les échanges. On ne retrouve pas partout cette démarche d’ouverture et ce genre d’appel à la participation. N’hésitez pas à vous impliquer si l’occasion se présente !


Nous tenons vraiment à remercier Aurélie pour son implication approfondie, non seulement dans cette interview, mais aussi dans le processus menant à un meilleur Firefox OS.

La semaine prochaine, nous vous proposerons le point de vue de Philippe ayant aussi participé avec Aurélie au groupe communautaire du brainstorming pour Firefox OS 3.0 chez Mozilla Paris.


@Mozinet

Notre précédent Starfox : Ce qui a étonné Pyves en rejoignant le groupe comm pour Firefox OS et Mozilla

Crédit illustrations : Aurélie Messa. Tous droits réservés.

Note

[1] Flame est un téléphone sous Firefox OS conçu pour les développeurs.

Thunderbird : Aidez à résoudre un plantage massif avec les adresses françaises

Théo sur la liste Mozilla communautaire francophone a demandé l’aide des utilisateurs du client de messagerie Thunderbird qui gèrent avec des adresses email chez @orange.fr, @free.fr, @wanadoo.fr :

Thunderbird : Aider à résoudre un plantage massif avec les adresses @orange.fr, @free.fr, @wanadoo.fr

Je vous traduis ci-dessous un message de Wayne Mery, l’un des bénévoles contribuant à Thunderbird.

Bonjour, je suis en train de m’occuper d’une des causes du principal plantage (« OOM | small ») au démarrage de Thunderbird (ceux intervenant dans les 60 secondes après le lancement).

80 % des utilisateurs ayant signalé ce problème utilisent des adresses électroniques basées en France, telles que orange.fr, wanadoo.fr, free.fr, etc. Oui, 80 % des personnes.

Avez-vous la moindre idée de ce qui pourrait affecter à ce point les utilisateurs français ? Le dictionnaire français peut-être ? (On a eu de gros problèmes avec le dictionnaire il y quelques temps, si je me souviens bien).

Si vous avez une adresse du genre et que vous avez vous aussi ce plantage au démarrage, vous pouvez contacter Wayne directement à l’adresse suivante : vseerror@lehigh.edu. Si vous n’êtes pas à l’aise avec l’anglais, envoyez-moi directement votre message en français et je transmettrai.

Toutes les versions de Thunderbird semblent affectées, d’où l’importance de corriger ce problème.

Wayne a également fourni un échantillon des rapports de plantage des utilisateurs (en fin de message).

Il pourrait être également intéressant de creuser dans le forum Thunderbird de Geckozone, il y a peut-être des informations à faire remonter, le problème a sûrement du être abordé vu le nombre de personnes concernées.

Merci d’avance à vous !

À plus,

Théo

© 2010-2014 Mozinet - Ce billet a été publié sur BlogZiNet.