Premiers pas avec Spring Batch 3 et ses annotations

A quoi sert Spring Batch ?

Spring Batch 3 est un framework qui offre de nombreuses fonctionnalités permettant de traiter de gros volumes de données avec de bonnes performances.

On peut par exemple citer :

- Reprise d’un batch après un arrêt inattendu

- Gestion des transactions

Lire la suite…

Categories: Java EE Tags: , , , ,

L’Agile Tour, pfff, moi les conf… (Mais ça, c’était avant !)

Vous avez déjà dû l’entendre ? Cette phrase qui consiste à penser qu’une conférence n’est qu’une suite ennuyante de discours. De celle faisant l’apologie de telle technologie, de telle méthode de travail, sans objectivité aucune. Celle dont l’ennui vous rappelle le cours d’histoire/anglais/maths (rayer les mentions inutiles) de votre époque étudiante et qui se transformait inexorablement en sieste au fond de la classe.

Alors qu’au final, quand on tente l’expérience… voilà ce qu’on peut trouver dans une conférence Agile Tour Paris 2014 !

logo

Lire la suite…

On aime, on partage #48

Bienvenue dans la série « On aime, on partage » de Viseo Technologies ! Chaque semaine retrouvez les meilleurs articles du web issus de notre veille technologique.

Web

Calendriers de l’avant du développeur Web

Deux initiatives de calendriers de l’avant, un article par jour sur le Web pendant 24 jours :

Google introduit « No CAPTCHA reCAPTCHA »

Utiliser le Machine Learning pour revoir l’utilisation des Captchas, c’est ce que Google propose. Plus d’informations sur le site dédié.

Learning JavaScript Design Patterns

Addy Osmani a publié la version 1.6 de l’alternative gratuite en ligne de son livre publié aux éditions O’Reilly.

Lire la suite…

Débriefing de la Wearable Tech Paris – part 2

Cet article est la suite de l’article intitulé « Débriefing de la « Wearable Tech Paris ». – part 1″ que je vous invite à lire en premier lieu en suivant ce lien

Dans la première partie de ce débriefing, je proposais un retour sur les thèmes suivants :

  • Apprendre de l’industrie de la mode pour créer des objets connectés
  • Wearable, IoT et les business models à succès.
  • Le futur de la voiture connectée

Ces premiers échanges traitaient du positionnement des objets connectés en s’appuyant sur la vision proposée par le monde de la mode. Était également abordé le sujet traitant de l’accointance avec l’IoT au sens data du terme avec enfin un focus sur les applications possibles adaptées au milieu automobile.

Au travers de ce second et dernier billet sur le sujet, je propose de vous présenter trois autres thèmes débattus lors de la conférence à savoir :

  • La santé;
  • La maison intelligente;
  • comment réussir une campagne de financement via une plateforme de crowdfunding

Lire la suite…

Utilisation avancée des procédures stockées en PL SQL

Utilisation avancée des procédures stockées en PL SQL

Passage de paramètres et récupération de tableaux.

Introduction

L’utilisation des procédures stockées est considérée par la plupart des développeurs comme une bonne pratique; celles-ci présentent effectivement plusieurs intérêts :

  • Elles sont bien séparées du code serveur et peuvent être optimisées en parallèle par des spécialistes en SQL
  • Elles offrent un contexte d’exécution plus sécurisé
  • Il est possible de transmettre des informations plus complexe qu’en passant par une requête en dur dans le code
  • On sait exactement ce que l’on doit donner en entrée et ce que l’on aura en retour
  • Côté serveur, le code les appelant n’est pas nécessairement plus concis mais est plus lisible

Bien sûr, il est possible de rencontrer des projets où elles ne sont pas utilisées. Bien souvent, il s’agit de projets où il y a une maitrise limitée de l’interface entre celles-ci et le langage serveur (le C# en l’occurrence). C’est d’ailleurs à juste titre ; l’approche n’est pas nécessairement des plus intuitives et, aussi bien au niveau de leur écriture que de leur appel, il y a certaines subtilités qui sont à connaitre.

Cet article est une première approche assez détaillée des principaux écueils que l’on peut rencontrer. Il se focalise sur l’écriture et l’utilisation des procédures stockées dans un contexte purement PL/SQL mais en vue de les utiliser depuis un serveurs développé en C#. Les explications concernant ces appels feront l’objet d’un second article (à paraitre bientôt).

Concepts généraux

Déclarations des types hors package :

Il y a deux façons différentes de déclarer de nouveau type dans une base Oracle :

  • Soit hors d’un package, dans la liste des types directement accessibles à l’ensemble de la base.
  • Soit à l’intérieur d’un package, auquel cas, il faudra désigner le nom du package dans lequel il est déclaré pour pouvoir l’utiliser en dehors.

Attention : Les types objets composés doivent être déclarés hors du package, sinon le code C# ne sait pas y accéder. (Comme nous le verrons, le mapping est géré différemment dans ce cas.)

Pour les mêmes raisons, les listes d’objets composés doivent absolument être déclarées hors du package.

Remarque : Déclarer des tables d’objets personnalisés peut être utile pour requêter plus facilement sur celles-ci. Il est inutile de déclarer des objets n’ayant qu’une propriété pour de les intégrer directement dans une requête car il est possible d’accéder à l’unique colonne avec column_value, comme nous le verrons. Sauf  si l’on pense que l’on ne sera amené à ajouter de nouvelles propriétés par la suite.

Code PL/SQL


-- Objet composé
create or replace TYPE MON_OBJET AS OBJECT
(
  PROP_NUM NUMBER,
  PROP_STR VARCHAR2(10)
);

-- Liste d’objets composés
create or replace TYPE MON_OBJET_TABLE AS TABLE OF MON_OBJET;


-- Liste d’objets système
TYPE GLOBAL_NUMBER_TABLE AS TABLE OF NUMBER;

Le package peut déclarer localement certaines informations comme certains types, les déclarations de procédures stockées ou autres fonctions.

Cependant, les listes/tables ne sont pas systématiquement à déclarer ici si on veut que la procédure stockée puisse être appelée par le code C# :

  • Dans le cas des listes d’objets système, on peut déclarer le type table localement dans le package, mais cela implique une manipulation assez fastidieuse dans la procédure (Et attention à l’appel depuis PL SQL : cf. : Tests d’une procédure stockée)
  • Dans le cas de listes d’objets composés personnalisés, on doit déclarer le type hors du package.

Les listes déclarées dans le package doivent être indexées.

Code PL/SQL :


create or replace PACKAGE PKG_STORPROC IS

  -- Les curseurs doivent être déclarés localement
  TYPE refCursor IS REF CURSOR;

  -- Liste d’objets système
  -- Attention : le  INDEX BY BINARY_INTEGER est très important!
  TYPE NUMBER_TABLE AS TABLE OF NUMBER INDEX BY BINARY_INTEGER;

  -- Déclaration d’une procédure avec paramètres
  PROCEDURE SP_TEST(
    ParamStr IN VARCHAR2,
    ParamNum IN NUMBER,
    ListeNum IN NUMBER_TABLE,-- Local au package
    ListeNumGlobale IN GLOBAL_NUMBER_TABLE,-- Externe au package
    ParamCustom IN MON_OBJET,-- Externe au package
    ListeCustom IN MON_OBJET_TABLE, -- Externe au package
    Result OUT refCursor
  );

END PKG_STORPROC;

Définition du package :

Pour utiliser des types personnalisés au sein du corps d’un package, il suffit de les manipuler comme les autres.

Code PL/SQL


create or replace PACKAGE BODY PKG_STORPROC IS

  PROCEDURE SP_TEST(
    ParamStr IN VARCHAR2,
    ParamNum IN NUMBER,
    ListeNum IN NUMBER_TABLE,
    ListeNumGlobale IN GLOBAL_NUMBER_TABLE,
    ParamCustom IN MON_OBJET,
    ListeCustom IN MON_OBJET_TABLE,
    DetailResult OUT refCursor
  )
  IS

  BEGIN

    sys.dbms_output.put_line(‘ParamStr: ' || ParamStr || ' - ParamCustom. PROP_NUM: ' || ParamCustom.PROP_NUM);

    IF TripIds.First IS NOT NULL THEN

      sys.dbms_output.put_line(‘ListeCustom. First. PROP_NUM: ' || ListeCustom.First.PROP_NUM);

    END IF;

  END;

END PKG_STORPROC;

Retourner des résultats

En utilisant un Ref Cursor

Pour récupérer un tableau de résultats lors d’un appel à procédure stockée, il est possible d’utiliser un REF CURSOR. Cela a l’avantage de pouvoir s’adapter à différents contextes d’exécution.

Celui-ci doit être absolument déclaré dans l’entête du package.

Le retour est indiqué par le mot clé OUT dans les paramètres.

Code PL SQL


--------------------------------------------------------------------
-- Dans l’entete du package

create or replace PACKAGE PKG_STORPROC IS

  TYPE refCursor IS REF CURSOR;

  PROCEDURE SP_TEST_SIMPLE (ParamNum IN NUMBER, resultat OUT refCursor);

END PKG_STORPROC;


--------------------------------------------------------------------
-- Dans le corps du package

create or replace PACKAGE BODYPKG_STORPROC IS

  PROCEDURE SP_TEST_SIMPLE (
    ParamNum IN NUMBER,
    Resultat OUT refCursor
  )
  IS

  BEGIN
  
  -- On ouvre le curseur pour insérer les résultats dedans
  OPEN Resultat FOR
    SELECT
      t.StrVal as Name,
      t.NumVal as Age,
      t.LongStrVal as Adresse
    FROM FOURRE_TOUT t
    WHERE t.Cat = ParamNum;

  END;

END PKG_STORPROC;

En utilisant un tableau

Pour récupérer un tableau de résultats lors d’un appel à procédure stockée, il est également possible d’utiliser un tableau d’objets personnalisés. Mais cela a l’inconvénient d’être assez spécifique à un cas d’utilisation et le fait que ce type soit déclaré hors du package pollue un peu l’environnement.

Le retour est indiqué par le mot clé OUT dans les paramètres.

Code PL SQL

--------------------------------------------------------------------
-- Dans l’entete du package

create or replace PACKAGE PKG_STORPROC IS

  PROCEDURE SP_TEST_SIMPLE_TABL (ParamNum IN NUMBER, resultat OUT MON_OBJET_TABLE);

END PKG_STORPROC;


--------------------------------------------------------------------
-- Dans le corps du package

create or replace PACKAGE BODYPKG_STORPROC IS

  PROCEDURE SP_TEST_SIMPLE_TABL (
    ParamNum IN NUMBER,
    Resultat OUT MON_OBJET_TABLE
  )
  IS

  BEGIN

    -- On ouvre le curseur pour insérer les résultats dedans
    SELECT
      t.NumVal,
      t.StrVa
    BULK COLLECT INTO Resultat
    FROM FOURRE_TOUT t
    WHERE t.Cat = ParamNum;

  END;

END PKG_STORPROC;

Passage de paramètres

Passage d’une liste de types simples en paramètre

L’intérêt de passer une liste à une procédure stockée serait de pouvoir faire une requête directement sur celle-ci, en l’utilisant comme une table.

Déclaration du type à l’intérieur du package

Cela est possible de manière indirecte en transformant la liste passée en paramètre en une table locale. Pour cela, il faut déclarer un autre type table contenant des objets pour lesquels on pourra accéder aux propriétés.

Cette façon de procéder est plus fastidieuse côté PLSQL mais demandera moins de développement côté C#.

Notes :

  • Attention à l’appel depuis PL SQL : cf. : Tests d’une procédure stockée
  • les performances semblent légèrement moins bonnes avec cette façon de procéder.

Code PLSQL


-- Hors package, pour que les types génériques puissent être utilisés dans d’autres packages :

-- Objet simple permettant de l’inclure dans une requête
create or replace TYPE MON_OBJET_NOMBRE AS OBJECT
(
  PROP_NUM NUMBER
);


-- Liste d’objets
create or replace TYPE TABLE_DE_NOMBRE AS TABLE OF MON_OBJET_NOMBRE;


--------------------------------------------------------------------
-- Dans l’entête du package
create or replace PACKAGE PKG_STORPROC IS

  TYPE refCursor IS REF CURSOR;

  -- Liste d’objets systèmes
  -- Attention : le  INDEX BY BINARY_INTEGER est très important!
  TYPE NUMBER_TABLE AS TABLE OF NUMBER INDEX BY BINARY_INTEGER;

  PROCEDURE SP_TEST_LISTE_SIMPLE ( ListeNum IN NUMBER_TABLE, resultat OUT refCursor );

END PKG_STORPROC;


--------------------------------------------------------------------
-- Dans le corps du package
create or replace PACKAGE BODYPKG_STORPROC IS

  PROCEDURE SP_TEST_LISTE_SIMPLE(
  ListeNum IN NUMBER_TABLE,-- Local au package, pour l’appel extérieur
  Resultat OUT refCursor
  )
  IS

    numTable TABLE_DE_NOMBRE:= TABLE_DE_NOMBRE ();-- Externe au package pour les manipulation internes

  BEGIN

    -- On commence par recréer une table dans un environnement qui permet de l’utiliser et avec une structure plus facile à manipuler.
    numTable.Extend(ListeNum.count);

    FOR i IN ListeNum.First .. ListeNum.Last
    LOOP
      numTable(i) := MON_OBJET_NOMBRE(ListeNum(i));
    END LOOP;

    -- On peut ensuite l’utiliser comme une table dès lors qu’on l’a castée.
    SELECT * FROM table(numTable) nt where nt.PROP_NUM = 1 ;

  END;

END PKG_STORPROC;

Déclaration en dehors du package

En déclarant le type table en dehors du package, cela permet de le convertir simplement en une table dans le code PLSQL. Cette table ne doit pas être indexée, contrairement à la précédente.

Cette façon de procéder est plus simple côté PLSQL mais demandera plus de développement côté C#.

Notes :

  • Attention à l’appel depuis PL SQL : cf. : Tests d’une procédure stockée
  • les performances semblent légèrement moins bonnes avec cette façon de procéder.

Code PLSQL


-- Hors package, pour que les types génériques puissent être utilisés dans d’autres packages :

-- Liste de nombre
-- On passe cette fois directement par une table de Number pour montrer comment accéder à la colonne sans nom.
create or replace TYPE GLOBAL_NUMBER_TABLE AS TABLE OF NUMBER;


--------------------------------------------------------------------
-- Dans l’entête du package
create or replace PACKAGE PKG_STORPROC IS

  TYPE refCursor IS REF CURSOR;

  PROCEDURE SP_TEST_LISTE_SIMPLE_HP ( numberTable IN GLOBAL_NUMBER_TABLE, resultat OUT refCursor );

END PKG_STORPROC;


--------------------------------------------------------------------
-- Dans le corps du package
create or replace PACKAGE BODYPKG_STORPROC IS

  PROCEDURE SP_TEST_LISTE_SIMPLE(
    numberTable IN GLOBAL_NUMBER_TABLE,-- Externe au package, manipulable directement
    Resultat OUT refCursor
  )
  IS

  BEGIN

    -- On peut directement l’utiliser comme une table dès lors qu’on l’a castée.
    SELECT * FROM table(numberTable) nt where nt.column_value = 1 ;

  END;

END PKG_STORPROC;

Paramètres d’objets de types utilisateur

Les paramètres de type Object se manipulent assez simplement, comme les paramètres système.

Ils peuvent être déclarés dans ou hors du package sans que cela ait une incidence négative sur leur accessibilité côté C#.

Code PLSQL


-- Hors package, pour que les types génériques puissent être utilisés dans d’autres packages :

-- Objet composé
create or replace TYPE MON_OBJET AS OBJECT
(
  PROP_NUM NUMBER,
  PROP_STR VARCHAR2(10)
);

-- Dans l’entete du package
create or replace PACKAGE PKG_STORPROC IS

  TYPE refCursor IS REF CURSOR;

  PROCEDURE SP_TEST_OBJET (paramObjet IN MON_OBJET, resultat OUT refCursor);

END PKG_STORPROC;


-- Dans le corps du package
create or replace PACKAGE BODYPKG_STORPROC IS

  PROCEDURE SP_TEST_OBJET (
    paramObjet IN MON_OBJET,
    resultat OUT refCursor
  )
  IS

  BEGIN

    -- On peut ensuite l’utiliser comme un paramètre classique...
    sys.dbms_output.put_line('ParamCustom.PROP_NUM: ' || ParamCustom.PROP_NUM);

  END;

END PKG_STORPROC;

Liste d’objets de types utilisateur

Tout comme pour les listes d’objets système, le but est d’utiliser cette entrée comme une table.

Là encore, il faut transformer la liste passée en paramètre en une table locale. Mais il est inutile, cette fois, de recourir à une nouvelle structure de table.

Elles peuvent être déclarées dans ou hors du package sans que cela ait une incidence négative sur leur accessibilité.

Code PLSQL


-- Hors package, pour que les types génériques puissent être utilisés dans d’autres packages :
-- Objet composé
CREATE OR REPLACE TYPE MON_OBJET AS OBJECT
(
  PROP_NUM NUMBER,
  PROP_STR VARCHAR2(10)
);

-- Liste d’objets composés
CREATE OR REPLACE TYPE MON_OBJET_TABLE AS TABLE OF MON_OBJET;

-- Dans l’entete du package
CREATE OR REPLACE PACKAGE PKG_STORPROC
IS

  TYPE refCursor IS REF CURSOR;

  PROCEDURE SP_TEST_LISTE_OBJET(
        paramListeObjets IN MON_OBJET_TABLE,
        resultat OUT refCursor
  );

END PKG_STORPROC;


-- Dans le corps du package
CREATE OR REPLACE PACKAGE BODY PKG_STORPROC
IS

  PROCEDURE SP_TEST_LISTE_ OBJET(
    paramListeObjets IN MON_OBJET_TABLE,
    resultat OUT refCursor )
  IS
    tableObjetsLocale MON_OBJET_TABLE:= MON_OBJET_TABLE ();
  BEGIN
    -- On commence par recréer la table dans un environnement qui permet de l’utiliser.
    tableObjetsLocale.Extend(paramListeObjets.count);

    FOR i IN paramListeObjets.First .. paramListeObjets.Last
    LOOP
      tableObjetsLocale (i) := MON_OBJET(paramListeObjets(i).PROP_NUM, paramListeObjets(i).PROP_STR);
    END LOOP;

    -- On peut ensuite l’utiliser comme une table dès lors qu’on l’a castée.
    SELECT nt.PROP_STR
      FROM TABLE(tableObjetsLocale) nt
      WHERE nt.PROP_NUM = 1 ;

  END;

END PKG_STORPROC;

Tests d’une procédure stockée côté PL SQL

La seule subtilité à indiquer réside dans la création de paramètres de type liste d’objets système quand ils sont déclarés dans le package. En effet, dans ce cas uniquement, il ne faut pas « créer » le tableau après l’avoir déclaré.

Le résultat peut être affiché, en utilisant le debugger

Code PL SQL


DECLARE
  ParamStr VARCHAR2;
  ParamNum NUMBER;
  ListeNum NUMBER_TABLE;
  ParamCustom MON_OBJET;
  ListeCustom MON_OBJET_TABLE;

  Result refCursor;

BEGIN

  ParamStr := 'valeur';
  ParamNum := 1;

  -- Rien à faire pour initialiser ListeNum
  ListeNum(1) := 1;
  ListeNum(2) := 2;

  ParamCustom := MON_OBJET(0, 'valeur objet');
  ListeCustom := MON_OBJET_TABLE();
  ListeCustom(1) := MON_OBJET(10, 'val obj');
  ListeCustom(2) := MON_OBJET(20, 'val obj2');

  PKG_STORPROC.SP_TEST(
    ParamStr => ParamStr,
    ParamNum => ParamNum,
    ListeNum => ListeNum,
    ParamCustom => ParamCustom,
    ListeCustom => ListeCustom,
    Result => Result
  );

END;

APIDays, L’API service, publique ou privée

 

apidays2014

 

Demain, et pour une durée de deux jours (2 et 3 décembre), aura lieu la troisième édition des APIdays aux salons du Tapis Rouge à Paris. APIDays est la première conférence dédiée aux APIs, les bonnes pratiques, ainsi que l’avenir du monde du logiciel.


Impatient d’assister à la conférence « Discovering API and services in a containerized world» animée par Jérôme Petazzoni, Senior Evangelist chez Docker, le célèbre outil Devops. L’idée sera de tirer un maximum de profit de cet outil d’abstraction (basée sur Linux LXC) qui permet de réduire les échanges difficiles entre les équipes de développements et les équipes de production (opérationnelles) : tout le monde parlera un seul langage, celui  du fichier docker. Si cela vous intéresse, sachez que des plateformes Cloud PaaS, telles que CloudBees, proposent d’ores et déjà l’hébergement de ce type de « container ».

Lire la suite…

Le continuous delivery, réelle opportunité ou mode passagère ?

Le 11 Septembre 2014 a eu lieu à Paris le CD (Continuous Delivery) Summit. Cet événement centré sur le processus de « Continuous Delivery » (ou livraison continue) a été l’occasion de revenir en détail sur les différents acteurs du CD ainsi que des difficultés de sa mise en place au sein de grands groupes. Au delà du buzzword, le Continuous Delivery est né d’un réel besoin des entreprises. Lire la suite…

Agile Innovation 2014

Pour ceux qui ne connaissent pas, la conférence « Agile Innovation » suit immédiatement Agile Grenoble, depuis sa fondation en 2008. La population se compose d’habitude de Coach agiles, de Scrum Master, de clients, en général un peu expérimentés.

Principe

Le principe en est simple : c’est un Open Space (en bon français Forum Ouvert) :

  • Les sujets ne sont pas connus à l’avance, ils sont proposés par les participants qui s’engagent à animer la session sur leur sujet.
  • L’agenda est libre, ceux qui proposent un sujet choisissent l’heure et le lieu.
  • Ca commence quand ça commence (à l’heure).
  • Ca finit quand ça finit (à l’heure).
  • Ce sont les bonnes personnes qui participent.
  • Si vous n’apportez plus de valeur à une session ou si elle ne vous apporte plus de valeur, utilisez la loi des deux pieds et changez de session.

Sujets

Nous n’étions « que » 70 (les années précédentes le maximum de 100 était atteint), mais les sujets proposés étaient de bonne tenue (avec parfois des sujets un peu décalés) :

Lire la suite…

On aime, on partage #47

Bienvenue dans la série « On aime, on partage » de Viseo Technologies ! Chaque semaine retrouvez les meilleurs articles du web issus de notre veille technologique.

Java

JSR 375 : Java EE Security API

Une JSR qui vise à reconsidérer l’API de sécurité pour qu’elle embrasse le paradigme du Cloud et des PaaS. Au programme notamment : une normalisation des mappings de rôles, et un enrichissement des conditions d’autorisations annotant les méthodes. Quand on voit ce qu’il est possible de faire avec Spring Security, il était temps d’y penser.

James Gosling et Bruno Souza rejoignent Jelastic

Le fournisseur de PaaS et IaaS Java et PHP (mais aussi Ruby, Nodes.js, Python, et bientôt .NET) voit arriver le père de Java et un membre très actif et reconnu de la communauté Java rejoindre ses effectifs. Jelastic poursuit donc son développement et illustre par là la volonté d’accroitre son offre sur le périmètre Java (53% des utilisateurs). L’ambition est même plus large puisque Jelastic a candidaté récemment pour rejoindre le JCP afin de faire évoluer la plateforme Java de façon favorable pour son usage dans le Cloud.

Top Java IDE keyboard

ZeroTurnaround rend disponible un document reprenant, par catégories d’actions, les raccourcis clavier des trois principaux environnement de développement du monde Java. Ce document de 37 pages comprend également une analyse du marché des IDEs pour le monde Java, ainsi que des plugins les plus uilisés.

Lire la suite…

Débriefing de la Wearable Tech Paris – Part 1

Le mardi 18 novembre s’est tenu la conférence « Wearable Tech » à Paris organisée par Gizworld. Pour ceux qui ne connaissent pas, cette conférence initiée il y a à peine 9 mois s’est déjà tenue dans les villes de Toronto, Los Angeles et Tel-Aviv, aujourd’hui à Paris et demain à Pékin.

Au menu de cette journée très chargée, pas moins de :

  • 9 thématiques d’échange ;
  • 2 keynotes ;
  • 46 intervenants différents répartis dans les différents panels ;
  • 1 showroom quelques startups venues présenter leurs projets ou produits.

Cette journée était avant tout l’occasion d’assister à des échanges non techniques sur le monde du wearable et dans une moindre mesure de l’IoT.
Au travers de cet article scindé en deux parties, je vous propose de passer en revue les principales thématiques abordées en vous présentant non pas une retranscription des échanges mais plutôt en appuyant les réflexions ou point qui m’ont semblé intéressants. Aussi, comme vous pourrez le lire, certains sujets amènent plus de questions qu’ils ne fournissent de solutions. Mais c’est bien là la propre de ce type de conférence : s’interroger pour mieux se positionner.

Lire la suite…