Demain soir, Jeanne Darche, l’archiviste responsable de la gestion documentaire à l’Agence de la santé et des services sociaux des Laurentides, interviendra lors d’un « 6 à 8″ sur la thématique « Logiciels de GED » proposé par le Groupe Archivistes étudiants et diplômés du Québec (ARÉDIQ). Trois technologies y seront présentées. Nous en profitons pour publier aujourd’hui une vidéo, jusqu’ici inédite, tournée lors de la préparation d’une conférence sur le sujet en mai dernier.

Il s’agit d’une répétition de l’atelier présenté au 43e Congrès de l’Association des archivistes du Québec. Jeanne Darche, archiviste et responsable de la gestion documentaire à l’Agence de la santé et des services sociaux des Laurentides, et Yannick Richard, meneur de pratique GED chez Savoir-faire Linux, y présentèrent le module RM 2.1 d’Alfresco en suivant un scénario archivistique complet. On y découvre ainsi de façon très concrète comment cette solution peut répondre aux besoins des archivistes québécois.

Alfresco est la plateforme logicielle libre de gestion de documents la plus utilisée au monde. Avec la dernière version de son module de Records Management, elle offre aux usagers la souplesse de son mode collaboratif tout en respectant maintenant les normes québécoises archivistiques.

Liens complémentaires:

TalendL’éditeur Talend, chef de file de l’intégration de données dans le monde du logiciel libre, sera de nouveau présent, cette année, au Salon du BI et de l’analytique qui a lieu mercredi prochain à Montréal. En compagnie de Jim Battista, je serai heureux de vous accueillir à notre kiosque conjoint afin de vous éclairer sur les outils et solutions d’analytique qu’ensemble, nous proposons.

À l’ère des données massives, en effet, le partenariat entre un éditeur comme Talend et un intégrateur comme Savoir-faire Linux est complémentaire. Dans cette entrevue vidéo réalisée à notre bureau de Montréal il y a quelques semaines, Pete Chamberlin et Jim Battista décrivent les avantages d’un tel partenariat dans le contexte du « Big Data » :

La vidéo est sous-titrée en français ➚  cc  ➚ English subtitles available

Plomberie et câblage: une plate-forme unifiée

Comme le font souvent remarquer les professionnels, les données massives ne sont pas vraiment une nouveauté. Ce qui les rend très « tendance », aujourd’hui, c’est que l’apparition de l’infonuagique et de la mobilité en ont fait exploser la masse et la portée, tant ce ce qui concerne les produits que les utilisateurs. En tirer un avantage concurrentiel n’est pas une mince affaire, mais grâce notamment aux technologies ouvertes comme Talend, il est devenu beaucoup moins coûteux de se lancer dans l’aventure.

Talend est reconnu comme visionnaire de quatre Magic Quadrant de Gartner : Data Integration (DI), Data Quality (DQ), Enterprise Service Bus (ESB) et Master Data Management (MDM). Talend développe en fait des outils permettant de collecter et de standardiser tous les type de données afin de les intégrer dans de puissants outils d’analyse. Le succès de sa plate-forme unifiée provient de ces capacités, complémentaires à la qualité de données, de standardisation et de traitement cognitif de l’information, incluant le MDM et le temps réel, qui permettent d’ajuster les outils d’analyse en fonction du contexte et de la stratégie de chaque entreprise.

« Nous décrivons parfois notre plate-forme technologique comme la plomberie et le câblage électrique fournissant des données à l’environnement Big Data de Hadoop et permettant d’en extraire, de les intégrer en-dehors de la plate-forme de données massives afin que des partenaires, comme Savoir-faire Linux, disposent des moyens d’accès aux données dont ils ont besoin pour créer des outils d’analyse appropriés. Ensemble, nous offrons une grande valeur à nos clients. » – Pete Chamberlin (Talend)

L’intégration au service de votre stratégie

Pour être plus précis, voici un peu l’étendue de notre rôle de partenaire :

  • Aide aux choix technologiques et à l’acquisition des compétences nécessaires à l’utilisation de la plate-forme ;
  • Accompagnement dans la gestion de projets d’intégration des données DI-MDM-ESB ;
  • Infrastructure Hadoop et Openstack ;
  • Integration Java des interfaces Web ;
  • Intégration dans un portail d’analyse (exemple: Liferay) ;
  • Mise en œuvre des outils de référence (ex: JasperReport) et d’analytique (ex: SpagoBI, Pentaho) ;
  • Gestion des données inter-applicative comme la gestion de projet, la facturation et la paie ;

Jim et moi serons heureux d’en discuter avec vous et de vous présenter la plate-forme ainsi que quelques exemples d’exploitation concrets lors du salon, si vous y participez. Sinon, n’hésitez pas à m’écrire directement ou me téléphoner au poste 308 pour me faire part de vos besoins.

Ressources complémentaires

 

Câbles RJ45 dessinant le mot 'open'Dans mon précédent billet, j’ai discuté de la notion de gouvernance informatique et de ses implications stratégiques. Le choix des technologies, entre autres, repose sur plusieurs éléments : l’application est-elle compatible avec l’existant? Quelles sont les évolutions qui sont envisagées dans le futur – infonuagique, intégration continue, agilité? La solution sera-t-elle compatible avec ces évolutions et à quels coûts?

Une fois que ces critères ont été déterminés, la sélection de l’application sur une base de fonctionnalités commence. De plus en plus, ce choix comprend des logiciels libres, dont de nombreux sont de nature communautaire, c’est-à-dire sans éditeur adossé. Nous voilà donc face à un dilemme : comment peut-on profiter des avantages du logiciel libre en minimisant le risque? En d’autres mots : quelle est la meilleure stratégie en matière de gouvernance d’un logiciel libre?

Lisez la suite de ce billet dans le blogue de Direction informatique Lien.

Salae Logic AnalyzerRécemment, j’ai été amené à devoir prendre des mesures de temps très précises pour répondre à une problématique de contrainte temps-réel. Sur un SoC particulier avec un système Linux dessus, la question était de savoir quelle était la fluctuation de la latence entre le déclenchement d’un événement matériel et la réponse d’une tâche logicielle associée à cet événement.

La gigue ou fluctuation du signal

Qu’est ce que la gigue ou jitter en anglais ? Prenons, par exemple, un événement avec une fréquence parfaite — disons l’heure à laquelle sonne mon réveil — et un autre événement moins parfait qui lui est associé, comme le moment où j’ouvre les yeux. Chaque jour, l’heure de mon réveil reste la même. En revanche, le moment où j’ouvre les yeux pour éteindre mon réveil varie… au désespoir de mon patron. :/

Cette fluctuation est la gigue. Dans ce cas, il s’agit d’une gigue temporelle, comme dans ma problématique.

Mesurer la gigue avec un oscilloscope

Typiquement, mesurer la latence entre deux événements matériels se fait très bien avec un oscilloscope à deux canaux. Il suffit de savoir où sonder, sur notre circuit, ces événements. Après quelques réglages, on peut visualiser la latence et, notamment, avoir une persistance sur chaque prise de mesure qui va nous donner une enveloppe de cette fluctuation.

Ma première démarche à donc été d’associer à ma tâche logicielle un autre événement matériel pour m’aider à prendre ces mesures. Mon événement matériel initial était une interruption et je savais où la sonder sur le SoC. À celui-ci, je réponds par un autre événement matériel qui consiste à faire commuter une GPIO que je sais également où sonder sur le SoC.

Ainsi à chaque fois que l’interruption se déclenche, la GPIO change d’état.

Ce qui nous donnera par exemple sur un oscilloscope quelque chose comme ça :

jitter_simulated

Avec en jaune l’interruption qui est réguliére, et en vert la fluctuation des temps de réponse de la GPIO.

Il ne me restait plus qu’à prendre mes mesures avec un oscilloscope. Mais là c’est le drame… je ne disposais pas d’oscilloscope suffisamment récent pour avoir une enveloppe consistante de mes signaux; faute de mémoire, je pouvais conserver tout au plus les 32 dernières mesures et je ne pouvais donc pas voir ma fluctuation sur de longues périodes.

Le seul autre équipement à ma disposition pour prendre des mesures était un analyseur logique Saleae Logic. Bien que très pratique, ce dernier ne me permettait pas de visualiser ma fluctuation du signal.

Comment visualiser la gigue avec l’analyseur logique de Saleae ?

Avec cet analyseur, ce que je peux obtenir comme résultat ressemble à cela:

logic_output

En zoomant on voit bien la latence entre le déclenchement de l’interruption (en haut) et la commutation de ma GPIO (en bas):

logic_output_zoom

Ce qui m’intéresse, c’est mesurer étant le temps entre le drapeau 1 et le drapeau 2 pour chaque interruption et le visualiser de façon facilement compréhensible, comme ceci:

logic_output_zoom_flag

Mais je ne peux pas faire ça à la main pour chaque interruption et recommencer à chaque prise de mesure.

C’est en discutant de mon problème, qu’un collègue et ami (Emeric Vigier, pour ne pas le nommer), me pointa à juste titre sur la fonction d’exportation de ce logiciel. Et, effectivement, l’ensemble des informations qui me sont nécessaires sont à ma disposition, le dernier problème étant juste qu’elles ne sont pas organisées comme je le désire.

Visualisation des données : du CSV au Graphique

Donc, comme précisé précédemment, l’analyseur logique de Saleae me permet d’exporter mes données au format CSV sous la forme:

Time[s], Interrupt Trigger, Gpio 0
0, 0, 1
0.00258295833333333, 1, 1
0.00258408333333333, 0, 1
0.002633, 0, 0
0.00758641666666667, 1, 0
0.00758758333333333, 0, 0
0.007629625, 0, 1
0.0125899166666667, 1, 1
...

La première valeur me donnant le temps en seconde, la deuxième l’état de mon interruption (0 = bas, 1 = haut), et la troisième l’état de ma GPIO. Donc, l’algorithme me permettant de récupérer ma latence sera:

Pour chaque ligne,

  1. Si mon interruption passe de 0 à 1, Alors je note son temps dans A
  2. Si j’ai A et que ma GPIO change d’état, Alors je note son temps dans B
  3. Si j’ai A et B, Alors je soustrais A à B et je garde le résultat dans le tableau C

Le tableau C contiendra ainsi l’ensemble des temps de latence. En quelques lignes de Python, cela donne le code suivant :

STEP_INTERRUPT  = 0
STEP_GPIO       = 1

with open(file_csv, 'r') as csvfile:
    cvsreader = csv.reader(csvfile, delimiter=',')

    # the first entry give us the initial state
    init_state      = next(cvsreader)
    interrupt_state = init_state[interrupt]
    gpio_state      = init_state[gpio]
    step            = STEP_INTERRUPT

    for row in cvsreader:

        # The first step is to find an interrupt edge
        if step == STEP_INTERRUPT:
            if (interrupt_state == 0 and int(row[interrupt]) == 1):
                interrupt_value = float(row[0])
                step = STEP_GPIO

        # The second step is to find a gpio commutation
        elif step == STEP_GPIO:
            if (gpio_state != int(row[gpio])):
                gpio_value = float(row[0])
               
                # here we know we have an interrupt edge value
                # and the gpio commutation time
                # we can take the delay mesure between the two
                delay = gpio_value - interrupt_value

                # store the delay value in millisecond.
                dic.append((delay * 1000, 0.5))

                # we can now reinit the step
                step = STEP_INTERRUPT

        interrupt_state = int(row[interrupt])
        gpio_state      = int(row[gpio])

À ce stade, je dispose de l’ensemble de mes latences, maintenant j’aimerais bien pouvoir les mettre en forme avec quelque chose de plus parlant — et ce n’est pas comme si l’on manquait de librairies pour réaliser des graphiques dans Python. Donc, prenons en une au hasard, et dessinons!

J’ai choisi la librairie pygal, qui permet de dessiner des points dans un espace à 2 dimensions. Il m’a suffit de rajouter ces quatre lignes de Python à mon script:

xy_chart = pygal.XY(stroke=False, fill=False, show_y_labels=False, legend_at_bottom=True, show_dots=True, dots_size=0.8, print_values=False)
xy_chart.title = 'Jiffies'
xy_chart.add('values in milli-second', sorted(dic))
xy_chart.render_to_png('jitter.png')

Et voilà le résultat tant désiré car nettement plus parlant:

jitter-with-pygal

On peut ainsi voir quelque chose qui se rapproche de notre première capture d’écran (l’exemple d’un oscilloscope) tout en économisant quelques milliers de dollars… cette fois, au grand bonheur de mon patron. ;-)

Le script complet est disponible ici :

Pour aller plus loin :

Le script actuel ne tient pas compte de la répartition des mesures, si la gigue tombe plusieurs fois au même instant on ne verra qu’un seul point.
Il pourrait être intéressant de modifier la visualisation pour savoir combien de fois la gigue est tombé sur un instant T.

De plus Saleae fournit un SDK qui permet de récupérer toutes les données de l’analyseur logique sur une socket. On pourra envisager d’effectuer la même analyse, non plus en parsant un fichier CSV préalablement exporté, mais en temps-réel.

À suivre…

Le 17 septembre 2014 à l’Espace Dalhousie de Québec

Logo S2LQLa deuxième édition du Salon du Logiciel Libre et des technologies ouvertes du Québec (www.s2lq.com) a lieu dans quelques jours. Ce sera une occasion unique d’échanger entre gestionnaires et professionnels des technologies numériques s’intéressant, de près ou de loin, à ce « carburant de l’économie du XXIème siècle » qu’est aujourd’hui le logiciel libre.

Pour votre information, Savoir-faire Linux sera présent à titre de commanditaire Platine, mais aussi d’exposant sur trois kiosques que nous co-animerons avec nos partenaires :

BlueMind
Red Hat
Alfresco

Nous contribuerons directement au programme à deux reprises:

Par ailleurs, nous serons très heureux d’écouter deux de nos clients présenter, dans la salle Savoir-faire Linux, leurs approches des logiciels libres et des technologies ouvertes au cours de ces retours d’expérience :

Pour plus de détails, visionnez la courte vidéo (2’07 ») ci-dessous, enregistrée la semaine dernière par notre vice-président exécutif, Christophe Villemer, puis consultez le programme. Si vous n’avez pas encore pris votre billet et que vous pouvez nous rejoindre mercredi prochain pour participer à cet important événement, inscrivez-vous sans tarder.

Six vidéos de l’APELL

Au cours du dernier mois, nous avons collaboré avec l’Association des professionnels en logiciels libres (APELL) afin de produire et diffuser cette série de six vidéos qui éclairent les enjeux du salon sous différents angles :

Liens et informations complémentaires