Mix-IT 2015 – Le langage Ceylon

logo-mixit

Le langage Ceylon étant présenté dans l’une des nombreuses et intéressantes conférences du Mix-it. Au passage, je ne peux que vous conseiller d’assister au Mix-it pour vous tenir au courant des nouveautés dans le monde du Java et de l’agilité, mais pas uniquement.

Revenons donc au langage présenté :

Origine du langage

ceylon-logo
C’est un langage créé par Gavin King et publié par Red Hat sous licence Apache v2 depuis 2011. Il est actuellement en version 1.1.

Lire la suite

Une introduction à Python

Le langage Python a été conçu à partir de 1989 par Guido van Rossum, et est actuellement maintenu par la Python Software Foundation, sous la coupe de son benevolant dictator for life.Python

La principale philosophie derrière le langage est d’être simple à utiliser, aussi bien par sa lecture que son écriture. D’ailleurs, son nom vient de l’émission “Monty Python’s Flying Circus”, comme pour illustrer l’état d’esprit de ses utilisateurs.
Historiquement successeur du langage ABC, il s’en sert à la fois comme modèle et anti-modèle, reprenant certains traits comme la structure par indentation, mais évitant d’autres tels que son caractère monolithique.

Historique

La première version est publiée en janvier 1994, et inclut notamment la gestion d’exceptions et quelques outils repris de Lisp. D’autres éléments de ce langage y seront ajoutés par la suite.
La deuxième version est publiée en octobre 2000, et introduit plusieurs éléments repris de langages fonctionnels, tels que la liste en compréhension, et se rapproche du Haskell du point de vue de la structure, à la différence de la préférence pour les mots clés plutôt que la ponctuation. C’est également dans cette version qu’apparait le garbage collector. Dans la version 2.2, les types et les classes sont regroupés dans une hiérarchie unique; le langage devenant véritablement orienté objet.
La troisième version est publiée en décembre 2008, avec pour objectif de retirer les défauts du langage, ainsi que de retirer les implémentations redondantes de certaines fonctionnalités. Malheureusement, certaines modifications ne permettant pas de conserver une compatibilité descendante, les versions 2 et 3 doivent coexister pour une certaine durée.

Lire la suite

Quand Agile rencontre Craftsmanship

Faisant suite à un premier article sur le lieu, l’ambiance de la conférence, puis un second sur une approche psychologique de l’Agile, le clap de fin de la série de retours de l’Agile Tour Paris 2014 se fera autour de l’artisanat logiciel.

logo

 

L’artisanat logiciel, aussi connu sous le nom du Craftsmanship

Il est temps d’aborder le second grand axe qui a retenu mon attention lors de cet Agile Tour Paris, une conférence dont le sujet est le « beau code » : Travailler avec l’existant ou comment s’en débarrasser, présentée par un développeur quelque peu expérimenté (15 ans !), Sam Cranford.

Lire la suite

Il faut en finir avec l’agilité « romantique »

Marie et Hervé viennent d’acheter une maison de caractère dans un petit village de Normandie. Ils sont très fiers de leur acquisition, bien que l’aventure soit loin d’être finie : il y a encore de gros travaux à faire. Parmi les changements qui préoccupent le couple, il y a une grosse dizaine de fenêtres à changer : vieilles de plus de quarante ans, en vitrage simple, elles accusent sérieusement leur âge. En fait, en grattant un peu, Hervé s’est aperçu qu’elles s’effilochaient à l’ongle. Le doute n’est pas permis : il faut tout changer. Heureusement, au sein même du village travaille Marc…

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;

A bug’s life

J’existe. Mon existence n’est pas nouvelle, c’est ma conscience qui l’est. Je suis conscient d’être. Mais qui suis-je ? Je suis d’abord un scénario utilisateur non prévu, non voulu. Un parasite. Une tache qu’on veut effacer. Puis je suis aussi une entrée au sein d’un ensemble nommé Jira. Enfin, je suis également quelques signes sur un post-it. Oui, je suis un bug. Mais je ne suis pas seul.

« It’s not a bug, it’s a feature.
— Très drôle Laurent. Alors, tu prépares ta carte de planning poker ? On t’attend là. »

On parle de moi. On m’ausculte, on me triture, on me pèse, on me soupèse et finalement on tranche sur mon sort. On me catégorise, on me prévoit des critères d’acceptance. J’existe. Mais je ne suis pas libre, j’appartiens à un produit. Un certain Product Owner peut me faire basculer dans le néant en un instant. Trêve de rêverie, la réunion de backlog refinement prend fin.

Je suis priorisé puis sélectionné au sein d’un sprint. Dès lors on m’épingle sur un tableau Kanban tel un Prométhée de papier. J’ai une belle vue. J’observe. Et je ne suis toujours pas seul.

L’open space devant moi est d’une rare beauté. Un soin particulier est donné à l’environnement de l’équipe de développement, d’ailleurs j’aperçois même un patio intérieur. Ils ont tout. Je n’ai rien. Et j’entends des voix, les voix de mes compagnons d’infortune, ces post-its multicolores représentant ici une évolution, là un proof of concept, plus loin une étude de faisabilité.

Mais déjà il est trop tard, car on m’arrache à ma torpeur. Je comprends que c’est le grand jour, le dernier jour d’un condamné.

Deux développeurs se penchent sur mon corps, cet amas d’instructions ordonnées, cet effet de bord héritage d’un chantier d’une gloire passée. Ils appellent ça de la dette technique. Le refactoring de code peut commencer.

Et là tout va très vite. Protégés des interruptions par le responsable des perturbations, les deux artisans, architectes à leurs heures perdues, entrent dans la zone, cet espace-temps spécial où la concentration s’allie à la productivité. Le pair programming les épuise mais le test driven development utilisé leur permet d’obtenir rapidement le résultat escompté. De mon point de vue d’esprit conscient, c’est comme si j’observais mon corps se faire triturer par deux chirurgiens talentueux. Et pourtant je ne disparais pas pour autant. Je comprends que je fais l’objet d’un feature flipping. Tel un fantôme je continuerai donc de hanter le programme.

Mais déjà tout est terminé. L’intégration continue prend le relai, les voyants sont au vert. Les développeurs s’en vont discuter open source à un brown bag lunch. Le dernier visage que je verrai est celui du lead developer lors d’une revue de code, avant que mon nouveau corps ne soit envoyé au processus de livraison continue. La mise en production approche, le temps m’est compté. Sur un mur je peux lire cet aphorisme : « There are only two problems in software development and it’s communication ».

Ce soir, les développeurs – ces créateurs et destructeurs de bugs – se coucheront le sourire aux lèvres, contents d’avoir pu améliorer le quotidien de leurs clients. Mais qui sait combien de nouveaux bugs naîtront de cette mise en production ?


Pair programming, perturbations, brown bag lunch, feature flipping : explications.

Tests unitaires, d’intégration, fonctionnel, métier : comment les définir ?

Le champ sémantique de ces termes a évolué au fil du temps, conduisant à un certain flou et parfois des incompréhensions. Nous allons dans cet article apporter différents éclairages sur la terminologie du test, en espérant que cela pourra contribuer à une meilleure compréhension entre experts !

Situons le contexte

Le niveau processus

Un logiciel utilisé dans une entreprise a pour vocation de servir ses utilisateurs dans l’exécution des processus métier ou support. Au niveau le plus élevé, le fonctionnement d’une entreprise peut en général être décrit par des processus. Certains de ces processus ont pour objectif premier d’apporter de la valeur aux clients de l’entreprise (processus de commande et livraison, processus de service après vente, etc.), d’autres y contribuent moins directement mais restent pour autant nécessaires (processus d’approvisionnement, processus de paie des collaborateurs, etc.).

Ces processus sont caractérisés par des échelles de temps pouvant aller de quelques minutes à quelques années, l’ordre de grandeur typique étant de quelques jours. Ils font intervenir dans la majorité des cas plusieurs acteurs (de l’entreprise ou externes).

Le niveau cas d’utilisation

A certaines étapes de ces processus, un acteur sera susceptible d’utiliser un logiciel. Dans l’exemple du processus de commande et livraison, nous avons par exemple des étapes informatisées :

  • La prise de commande
  • La préparation de la commande
  • Le contrôle de la commande
  • L’expédition
  • La facturation

La plupart du temps, chacune de ces étapes correspondra à la notion de cas d’utilisation du logiciel. Le niveau de granularité est plus fin que pour le processus, et l’échelle de temps limitée à quelques minutes. Lorsqu’un cas d’utilisation a été déroulé à une étape du processus, l’étape suivante pourra être déclenchée immédiatement,  ou de manière asynchrone. Dans notre exemple, après la prise de commande, celle-ci est ajoutée dans la liste d’attente de l’entrepôt ou de l’atelier, et sera traitée dans un délai fonction de la charge de travail de ce service à l’instant présent. Lire la suite

Mix-It 2014

Viseo Technologies (Objet Direct) présent au Mix-It 2014

Vous cherchez l’inspiration, les bonnes pratiques, et les nouveaux outils : vous les trouverez au Mix-IT !
Mais surtout venez rencontrer et échanger avec d’autres passionnés.

A l’occasion de cette édition du Mix It, Viseo Technologies (Objet Direct) sera sponsor officiel de l’événement.

Nous vous invitons à passer nous voir sur notre stand pendant les pauses, nous vous y réservons plusieurs surprises :
Nous vous proposons de faire le Tour du Monde grâce à nos vaisseaux Star Wars !!!

Nous gérons aussi vos attestations DIF à cette occasion !!!

Vous nous retrouverez donc les 29 et 30 avril prochains sur notre stand au Mix-IT à CPE LYON, Rue Victor Guignard à VILLEURBANNE.

Objet Direct et son Université au Devoxx France 2014

Ces derniers jours s’est déroulée la troisième édition du Devoxx France. Elle a eu lieu comme l’année dernière, au Mariott du mercredi 16 Avril au vendredi 18 Avril.

Beaucoup de monde encore cette année s’est déplacé pour nous parler de sujets aussi divers que variés (évolutions de Java depuis la version 8, maîtriser Git, utiliser la Leap Motion …). Et nous avons eu la chance de pouvoir présenter un sujet en tant qu’Université : « JavaScript as a first language : votre IC prête à la révolution ».

Nous étions trois ingénieurs d’Objet Direct Grenoble à venir présenter cette Université :

  • Julien Roche
  • Frédéric Dubois
  • Frédéric Bouquet

Notre but ? Montrer que JavaScript et Qualité peuvent faire bon ménage. Et montrer que ce qui existe dans le monde Java a un équivalent dans le monde JavaScript.

Pour cela, nous avons commencé par une courte présentation d’outils pour nous, développeurs, tel qu’un bon IDE comme WebStorm ou encore le ChromeDevTools qui permet de comprendre ce qui ne va pas dans nos sites (du debugger au profiling).

Nous avons ensuite enchainé sur la démonstration de notre usine logicielle autour d’une petite application que nous avons entièrement conçue en JavaScript.

 

Pour la partie serveur, nous avons utilisé NodeJs afin de définir un service REST et de faire le lien vers MongoDB. Pour la partie cliente, nous sommes partis sur une architecture basée sur Backbone.Marionette. De plus, nous avons structuré notre projet avec une architecture AMD (basé sur NodeJs pour le serveur, RequireJs pour le client), ce qui permet d’organiser plus efficacement notre projet.

L’idée est ensuite d’utiliser NodeJs et son outillage pour automatiser les traitements d’une usine logicielle Javascript à savoir : gestion des dépendances, compilation (des fichiers LESS par exemple), analyse statique du code (JS, HTML, CSS, etc.), exécution des tests et analyse de la couverture de code, packaging. Comme nous le faisons déjà avec Maven sur nos projets Java.

Nous avons donc utilisé Bower pour la gestion des dépendances et GruntJs pour définir le cycle de vie à notre application.

  

Un accent a été mis sur la partie testing. Nous avons des tests unitaires pour la partie serveur et la partie cliente avec Jasmine et Karma. Nous avons également créé un projet qui réunit les deux projets et qui permet à la fois de lancer l’application en mode production, mais aussi de lancer des tests fonctionnels de bout en bout, et cela via CasperJs.

                 

Enfin, nous avons montré l’intégration de nos projets au sein d’une intégration continue comme Jenkins où nous pouvions voir toutes nos métriques s’afficher.

Si vous le souhaitez, vous pouvez récupérer le code de notre application sur les liens suivants :

Trier les éléments d’un paquetage par alias dans Sparx Enterprise Architect avec un script Project Browser

J’ai récemment travaillé sur un nouveau projet Enterprise Architect dans lequel j’ai importé les exigences initiales à partir d’un fichier Excel avec eaDocX. Chacune des exigences comportait alors les informations suivantes sous Enterprise Architect : titre, référence (importée dans le champ Alias), description. Par défaut, Sparx Enterprise Architect tri le nom des exigences d’un paquetage sélectionné par ordre alphabétique.

Après avoir importé mes exigences, j’avais besoin de les trier par alias (exemple : REQ-TEST-001, REQ-TEST-002, REQ-TEST-003, etc). La capture d’écran suivante illustre sur la partie gauche les exigences affichées dans l’explorateur du projet (Project Browser), et sur la partie droite l’ordre d’affichage souhaité i.e. triées par alias.

Cet article présente l’installation du script SortByAlias pour trier par alias les éléments d’un paquetage sélectionné. 

Lire la suite