Dans une base de données, il peut être très utile de disposer d'un historique des modifications successives des enregistrements. Cela permet par exemple de gérer des versions de vos données avec la possibilité de revenir à une version précédente ou bien de pouvoir visualiser les différences entre deux versions. Cela peut également être utile dans le cas où, pour des raisons de sécurité par exemple, vous souhaitez être capable de savoir quel utilisateur a effectué quelles modifications sur les données.

• Mécanisme utilisé

Nous allons donc voir comment mettre en place ce système avec MySQL 5.x et supérieur. La technique utilisée est celle des "triggers". Sous ce terme un peu barbare se cache simplement la possibilité de déclencher une ou plusieurs requêtes SQL lorsqu'un enregistrement est ajouté, modifié ou bien supprimé dans une table SQL donnée. Grâce à ce mécanisme, vous pourriez par exemple compter le nombre de fois où une table est modifiée. Nous allons utiliser ce système de triggers pour mettre en place notre historique des enregistrements.

• La table "maître"

Pour illustrer concrètement notre exemple, nous allons considérer une base de données avec la table suivante :

[sourcecode language='sql']
CREATE TABLE utilisateur (
id BIGINT NOT NULL AUTO_INCREMENT,
version BIGINT NOT NULL DEFAULT 0,
nom VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (id),
KEY (version)
);
[/sourcecode]

Comme vous le voyez, la structure de cette table est extrèmement simple. Cela n'a pas d'importance, la méthode que nous allons voir maintenant peut s'appliquer à n'importe quelle table quelle que soit sa complexité. Remarquez la présence d'un champ "version" qui contiendra le numéro de version de l'enregistrement.

• La table d'historique

Pour sauvegarder l'historique des enregistrements, nous allons à chaque modification ou suppression d'un enregistrement dans la table "utilisateur" recopier les anciennes données dans une autre table que nous appellerons "histo_utilisateur". Cette table DOIT impérativement inclure tous les champs de la table "utilisateur" puisque nous allons recopier l'intégralité de l'enregistrement vers cette table d'historique. Elle comportera également quelques champs supplémentaires que nous détaillerons par la suite. Voici donc la structure de notre table d'historique :

[sourcecode language='sql']
CREATE TABLE histo_utilisateur (
id BIGINT NOT NULL AUTO_INCREMENT,
action ENUM ( 'update' , 'delete' ) DEFAULT NULL,
date_action DATETIME DEFAULT NULL,
version BIGINT NOT NULL DEFAULT 0,
id_original BIGINT NOT NULL DEFAULT 0,
nom VARCHAR(255) DEFAULT NULL,
PRIMARY KEY (id),
KEY (id_original),
KEY (action),
KEY (date_action),
KEY (version)
);
[/sourcecode]

Nous retrouvons bien dans cette table le champ "nom" de la table d'origine. Le champ "id_original" va nous permettre de sauvegarder le champ "id" de la table d'origine. Ce qui nous permet de conserver un champ "id" pour l'identifiant unique de la table d'historique.

Le champ "action" permet de conserver le type d'événement qui a conduit à la recopie des données. Il permet également de savoir si l'enregistrement original existe toujours. En effet, si cet enregistrement a été supprimé, le champ action aura la valeur "delete". Le champ "date_action" permet de connaître la date et l'heure de la copie.

Le champ "version" sert à stocker le numéro de version d'enregistrement. Il s'agit ici tout simplement d'un nombre qui sera incrémenté à chaque recopie de données.

• Définition des triggers

Nous pouvons maintenant mettre en place les triggers nécessaires pour la gestion de l'historique. De quoi avons-nous besoin ? :

- A chaque modification d'un enregistrement de la table "utilisateur", il nous faut recopier les données dans la table "histo_utilisateur" et gérer les champs qui servent à l'historique. C'est à dire incrémenter le numéro de version, renseigner le champ "action" à la valeur "update" et le champ "date_action" à la date et heure courante.

- A chaque suppression d'un enregistrement de la table "utilisateur", il nous faut recopier les données (qui vont être supprimées dans la table d'origine) et là encore gérer les champs qui servent à l'historique. C'est à dire incrémenter le numéro de version, renseigner le champ "action" cette fois-ci avec la valeur "delete" et le champ "date_action" à la date et heure courante.

Cela se traduit en SQL avec les instructions suivantes :

[sourcecode language='sql']
delimiter //
CREATE TRIGGER trig_avant_update_utilisateur
BEFORE UPDATE ON utilisateur FOR EACH ROW
BEGIN
SET NEW.version = OLD.version + 1;
INSERT INTO histo_utilisateur
(action, date_action, version, nom, id_original)
VALUES
('update', NOW(), OLD.version, OLD.nom, OLD.id);
END;
//
CREATE TRIGGER trig_apres_delete_utilisateur
AFTER DELETE ON utilisateur FOR EACH ROW
BEGIN
INSERT INTO histo_utilisateur
(action, date_action, version, nom, id_original)
VALUES
('delete', NOW(), OLD.version, OLD.nom, OLD.id);
END;
//
delimiter ;
[/sourcecode]

L'instruction "delimiter" indique à MySQL de modifier le délimiteur de commande (par défaut le caractère ";") avec la séquence de caractères "//". Cela nous permet d'utiliser le caractère ";" dans la définition des triggers sans qu'il soit interprété par le client MySQL.

Le premier trigger appelé "trig_avant_update_utilisateur" indique qu'avant chaque mise à jour d'un enregistrement de la table "utilisateur" les actions suivantes seront effectuées :

- Incrément du numéro de version pour l'enregistrement de la table "utilisateur". Les pseudo noms d'enregistrements "NEW" et "OLD" indiquant respectivement l'ancien et le nouvel enregistrement de la table concernée par le trigger (donc ici l'enregistrement mis à jour de la table "utilisateur").

- Insertion d'un enregistrement dans la table "histo_utilisateur" avec recopie des données (via l'utilisation du pseudo nom d'enregistrement "OLD") et renseignement des champs dédiés à la gestion de l'historique.

Le deuxième trigger appelé "trig_apres_delete_utilisateur" indique qu'après chaque suppression d'un enregistrement de la table "utilisateur" les actions suivantes seront effectuées :

- Insertion d'un enregistrement dans la table "histo_utilisateur" avec recopie des données (via l'utilisation du pseudo nom d'enregistrement "OLD") et renseignement des champs dédiés à la gestion de l'historique.

• Passons aux tests !

Nous allons maintenant vérifier que tout fonctionne. Connectez-vous à votre serveur MySQL et créez une base de données de test :

[sourcecode language='sql']
mysql> CREATE DATABASE test_cache;
[/sourcecode]

Vous devez évidemment avoir les droits suffisants pour effectuer cette opération.

Créez ensuite les tables et les triggers en utilisant les instructions SQL que nous avons vu précedemment. Nous allons maintenant créer un premier enregistrement dans la table "utilisateur" :

[sourcecode language='sql']
mysql> INSERT INTO utilisateur (nom) VALUES ("Homer Simpson");
[/sourcecode]

Regardons ensuite le contenu de nos deux tables :

[sourcecode language='sql']
mysql> SELECT * FROM utilisateur;
+----+---------+----------------+
| id | version | nom            |
+----+---------+----------------+
|  1 |       0 | Homer Simpson |
+----+---------+----------------+
1 row in set (0.00 sec)

mysql> SELECT * FROM histo_utilisateur;
Empty set (0.00 sec)
[/sourcecode]

Nous avons bien notre enregistrement dans la table "utilisateur" et aucun enregistrement dans la table d'historique. Ce qui est normal puisque nous n'avons créé aucun trigger dans le cas d'une insertion d'un enregistrement dans la table "utilisateur".

Modifions maintenant notre enregistrement :

[sourcecode language='sql']
mysql> UPDATE utilisateur SET nom="Donuts" WHERE id=1;
Query OK, 1 row affected (0.06 sec)
Rows matched: 1  Changed: 1  Warnings: 0
[/sourcecode]

Regardons maintenant à nouveau le contenu de nos deux tables :

[sourcecode language='sql']
mysql> SELECT * FROM utilisateur;
+----+---------+--------+
| id | version | nom    |
+----+---------+--------+
|  1 |       1 | Donuts |
+----+---------+--------+
1 row in set (0.00 sec)

mysql> SELECT * FROM histo_utilisateur;
+----+--------+---------------------+---------+-------------+----------------+
| id | action | date_action         | version | id_original | nom            |
+----+--------+---------------------+---------+-------------+----------------+
|  1 | update | 2008-08-17 14:13:03 |       0 |           1 | Homer Simpson |
+----+--------+---------------------+---------+-------------+----------------+
1 row in set (0.00 sec)
[/sourcecode]

Notre trigger a bien fonctionné ! L'enregistrement d'origine a bien été modifié. Et la table d'historique contient bien une copie de l'enregistrement précédent. Par ailleurs, le numéro de version de l'enregistrement présent dans la table "utilisateur" a bien été incrémenté.

Supprimons maintenant notre enregistrement :

[sourcecode language='sql']
mysql> DELETE FROM utilisateur WHERE id=1;
Query OK, 1 row affected (0.02 sec)
[/sourcecode]

Puis regardons à nouveau le contenu de nos deux tables :

[sourcecode language='sql']
mysql> SELECT * FROM utilisateur;
Empty set (0.00 sec)

mysql> SELECT * FROM histo_utilisateur;
+----+--------+---------------------+---------+-------------+----------------+
| id | action | date_action         | version | id_original | nom            |
+----+--------+---------------------+---------+-------------+----------------+
|  1 | update | 2008-08-17 14:13:03 |       0 |           1 | Homer Simpson |
|  2 | delete | 2008-08-17 14:16:59 |       1 |           1 | Donuts         |
+----+--------+---------------------+---------+-------------+----------------+
2 rows in set (0.00 sec)
[/sourcecode]

Là encore, le trigger a bien été pris en compte. L'enregistrement d'origine a été supprimé. La table d'historique contient bien une copie de l'enregistrement supprimé.

• Conclusion

Nous avons vu un procédé très simple à mettre en place afin de conserver l'historique des modifications et suppressions dans une base de données. L'exemple s'appuie sur MySQL mais est évidemment transposable sur toutes les autres bases de données qui gèrent les triggers. Le choix de gérer l'historique dans une deuxième table dédiée et non pas dans la table d'origine permet de clairement séparer les données actives des données d'historique. Par ailleurs, cela permet également d'éliminer tout impact sur les performances des requêtes effectuées sur les données actives. Il reste ensuite à ajouter une gestion de la durée de conservation des données d'historique afin d'éviter une explosion de la taille des tables dédiées aux données d'historique.

• Références

Section "Triggers" de la documentation MySQL :

http://dev.mysql.com/doc/refman/5.0/fr/triggers.html

Le CEA (Commissariat à l’Énergie Atomique) et l'équipe SDS (Sécurité et Distribution des Systèmes, équipe du Laboratoire d’Informatique Fondamentale d’Orléans) proposent une bourse de doctorat dans le domaine de la Sécurité Appliquée ou des Fondements Théoriques de la Sécurité, sous la supervision administrative de Mathieu Blanc (CEA) et Christian Toinard (SDS).

La bourse dure trois ans (renouvelables) et couvre un salaire brut de  1990,25€ par mois (première et deuxième année)  à  2049,75€/mois (troisième année).Le poste est disponible à partir du premier octobre 2008.

Compétences et parcours

Idéalement, le candidat doit avoir un excellent Master 2 d'informatique et un intérêt en Sécurité des Systèmes ou en Méthodes Formelles. De plus, le candidat doit avoir des connaissances dans au moins un des domaines suivants :

• sécurité des systèmes
• systèmes d'exploitation
• systèmes distribués
• programmation système
• clusters
• analyse statique
• théorie des graphes
• théorie du parallélisme
• logique formelle
• sémantique dénotationnelle
• sémantique opérationnelle
• aspects théoriques de la sécurité et de la confiance.

Les candidats doivent avoir le droit de travailler en France et seront affectés sur le campus de l'ENSIB (École Nationale Supérieure d’Ingénieurs de Bourges). Leur tâche première concernera la théorie ou/et l'implantation de mécanismes efficaces de garantie de politiques de sécurité pour des systèmes distribués tels que les grilles et les clusters. L'objectif principal de ce doctorat est d'étendre les approches actuelles de garantie locale de politiques de sécurité pour en construire des techniques applicables à de vastes systèmes distribués, tels que ceux utilisés pour l'analyse de données ou l'analyse numérique.

Pour candidater

Pour candidater, nous vous invitons à envoyer un CV et une lettre de motivation, par courrier physique ou électronique, à Christian Toinard et Mathieu Blanc. Si possible, joignez un échantillon de vos travaux scientifiques. La candidature implique une vérification de sécurité par le Ministère de la Défense.

Le programmeur SAS pourra recueillir des informations d'un non spécialiste en créer un fichier Excel. Il importe ensuite les données sous SAS.

Dans un précédent sujet "Mes 1ers pas avec ODS TAGSET.EXCELXP", nous avons vu comment créer un fichier Excel, ou plutôt un fichier XML lisible sous Excel, à partir de la syntaxe d'ODS TAGSET.EXCELXP.

Maintenant, il s'agit de voir les limites de l'importation d'un fichier XML avec la procédure PROC IMPORT.

Exemple : Nous aurons un fichier LST_STUDY.XLS avec plusieurs feuillets, dont un nommé '2000', comme exemple. Ce feuillet a deux colonnes : le numéro de l'étude (STUDY) et la variable à compléter manuellement (FLAG_EXTERNAL). La première ligne contient le nom de la colonne. La variable STUDY peut contenir des nombres et du texte.

1. PROC IMPORT a besoin de données Excel

Même si le fichier créé par ODS TAGSET.EXCELXP a une extension .xls, ce fichier est en fait un fichier en langage XML. Comment observer cette information ? Voici deux propositions :

1. Ouvrez un fichier de ce type sous Excel et regarder le type lors que la fenêtre OUVRIR apparaît.
2. Ouvrez le fichier dans un éditeur de texte

Afin d'utiliser la procédure PROC IMPORT, il faudra donc convertir le fichier en "enregistrant sous" et là choisir le standard Excel.

2. Les options de l'instruction PROC IMPORT

Préciser le nom du fichier d'entrée et celui de sortie : Dans l'instruction PROC IMPORT, le nom du fichier Excel est donné avec l'option DATAFILE=; celui du data set SAS est introduit par l'option OUT=. Pour rendre ce data set permanent, le nom de la bibliothèque précédera le nom du data set comme d'habitude.

Indiquer à SAS le type de fichier à lire : Selon l'environnement et la version Excel utilisée, l'option DBMS= variera. DBMS=XLS est l'option que j'utilise sous Unix et Windows pour Excel2003. Reportez-vous à la documentation en ligne (PROC IMPORT Statement) pour connaître toutes les valeurs possibles de cette option.

Remplacer un fichier SAS existant : Si le data set SAS existe déjà, il ne sera pas remplacé, à moins d'ajouter l'option REPLACE.

%let resultats = C:/sasref;

proc import datafile = "&resultats./lst_study.xls"
            out      = lst_study
            dbms     = xls
            replace;
run;

3. Les Instructions sur les données sources

Après avoir vu les options de l'instruction PROC IMPORT, je vous propose trois instructions supplémentaires de la procédure (SAS Online Doc. : Data Source Statements)

Des noms de variables personnalisés avec GETNAMES=YES : SAS se sert de la première ligne du fichier Excel pour définir le nom des variables SAS à moins que l'instruction GETNAMES=NO soit ajoutée.

SAS considère les premières lignes du fichier pour identifier le type des variables sauf si MIXED=YES : Si on a une combinaison de caractères et chiffres, on peut se retrouver avec des valeurs manquantes. Par exemple, si vous avez une variable année contenant les valeurs 2008, 2007, <2007, il faudra importer les variables sous forme de caractère. L'instruction MIXED=YES fera le travail pour vous. 

Importer une feuille de calcul en particulier gràce à SHEET=: Par défaut, SAS importera la première feuille de calcul disponible dans le fichier Excel. Pour choisir un autre feuillet, son nom est donné entre guillemets dans l'instruction  SHEET=.

%let resultats = C:/sasref;

proc import datafile = "&resultats./lst_study.xls"
            out      = lst_study
            dbms     = xls
            replace;
   *getnames = yes;
   mixed    = yes;
   sheet    = '2000';
run;

Vous trouverez plus d'informations sur la procédure PROC IMPORT dans l'aide en ligne : SAS Online Doc, The IMPORT Procedure.

4. Une spécificité de l'ODS TAGSET.EXCELXP à gérer

Lors de la création du fichier avec ODS TAGSET.EXCELXP, une ligne est parfois ajoutée après la dernière ligne de saisie. Cette ligne est incluse dans le data set SAS à l'importation. La raison pour laquelle cette ligne est saisie m'est inconnue.

Par contre, je vous propose un data step pour vous en débarrasser une fois le data set SAS créé. 

• L'option END= de l'instruction SET sert à repérer la dernière ligne d'observations.
• La fonction MISSING permet de ne supprimer la ligne que si notre variable STUDY est vide.

data lst_study;
   set lst_study end=eof;
   if eof and missing(study) then delete;
run;

A Mozilla Workshop will be held in Paris on September 20th 2008. The main topic of this workshop is add-ons development, for a technical audience of developers and beginners. I will be talking about security of add-ons. More informations here.

Un Atelier Mozilla se tiendra à Paris le 20 Septembre 2008. On y parlera des divers aspects du développement d'extensions, à l'attention d'un public plutôt technique, composé de développeurs et de débutants. J'y parlerai de sécurité des extensions. Plus d'informations ici.

Je modifirai ce texte au fur et à mesure que j'airai un peu de temps.

À bientôt

Sous SAS, deux possibilités sont envisageables pour répéter une action sur plusieurs variables. Dans le cas d'un data step, la syntaxe de l'ARRAY est tout à fait appropriée. Dans d'autres cas, le langage macro peut s'avérer plus pertinent. Voici donc une présentation de l'approche via le langage macro.

1. L'exemple

Pour illustrer le propos, le programme aura pour but de définir un PROC REPORT contenant toutes les variables du data set SASHELP.CLASS. Si on connaît le nom des variables, la syntaxe se résume de la manière suivante.

proc report data=sashelp.class;
   columns name age sex weight height;
   define name   / display;
   define age    / display;
   define sex    / display;
   define weight / display;
   define height / display;
run;

Mais si on ne connaît pas le nom des variables par avance, il faut automatiser la tâche.

2. Remplacer le nom des variables par des macro variables

Dans l'exemple suivant, le nom de chaque variable est sauvegardé dans une macro variable. Ces macro variables ont une structure particulière :

un préfixe commun + un nombre

%let class1 = name;
%let class2 = age;
%let class3 = sex;
%let class4 = weight;
%let class5 = height;

proc report data=sashelp.class;
   columns name age sex weight height;
   define &class1. / display;
   define &class2. / display;
   define &class3. / display;
   define &class4. / display;
   define &class5. / display;
run;

3. Répéter l'instruction DEFINE grâce à une boucle

Grâce à cette structure particulière, une boucle peut être envisagée. L'instruction DEFINE est alors répétée autant de fois qu'il y a de variables. La boucle est définie par une macro variable "I" qui prend des valeurs allant de 1 à 5. La partie nombre de la macro variable est donc remplacée par la valeur de la macro variable "I".

NOTE : Pour résoudre la macro variable lors de la première boucle, SAS effectue deux lectures. A la première lecture, les deux ampersands && se transforment en un seul ; &i. se transforme en 1. On a donc &CLASS1. A la deuxième lecture, SAS résout la macro variable &CLASS1. comme précédemment.

%macro test;
   proc report data=sashelp.class;
   columns name age sex weight height;
   %do i=1 %to 5
      define &&class&i. / display;
   %end;
   run;
%mend test;
%test;

4. Créer les macro variables de manière automatique

Pour créer les macro variables automatiquement, il faut agir en deux étapes.

1. Enregistrer chacune des noms de variables du data set choisi dans PROC REPORT (SASHELP.CLASS) dans un nouveau data set (LST_VAR) et plus particulière dans une variable (NAME) .
2. Associer un numéro à chaque nom de variable (compteur) et convertir l'information en macro variable (CALL SYMPUT).

proc sql;
   create table lst_var as
      select name
      from dictionary.columns
      where upcase(libname)='SASHELP' and
            upcase(memname)='CLASS';
quit;

data _null_;
   set lst_var;
   cnt+1;
   call symput (cats('CLASS',put(cnt,best.)),name);
run;

5. Compter le nombre de variables de manière automatique

Si le nombre de variable dans le data set n'est pas connu à l'avance, il faut le retrouver. Cette information est ensuite sauvegardée dans une macro variable, disons MAX_VAR, et remplacera notre nombre 5. L'article "3 méthodes pour construire des macro variables sans macro" vous donnera plus de précisions concernant la création d'une macro variable.

Obtenir rapidement le nombre de variables dans un data set : Un moyen pour trouver le nombre de variables est de faire appel au dictionnaire de SAS intitulé TABLES.

proc sql noprint;
   select nvar into : max_var
   from dictionary.tables
   where upcase(libname)='SASHELP' and
         upcase(memname)='CLASS';
quit;

Plus de flexibilité sur la liste des variables concernées : Un autre moyen pour compter le nombre de variables est d'agir en deux étapes.

• Enregistrer dans un variable d'un nouveau data set chacune des noms de variables de SASHELP.CLASS.
• Compter le nombre d'observations dans ce data set. Vous pouvez vous reporter à l'article "Combien d'observations dans mon data set" pour plus de précisions sur les différentes alternatives.

Dans notre exemple, il s'agit de créer le data set LST_VAR pour la première étape. Le code de la section 4 est tout à fait suffisant pour cela. Ensuite, CALL SYMPUTX peut servir à sauvegarder l'information dans une macro variable.

data _null_ ;
   call symputx('max_var',_N_-1);
   set lst_var;
run;

Pourquoi vous ai-je proposé cette alternative ?  Ici, toutes les variables sont sélectionnées. Mais si seulement quelques une sont choisies, seule la seconde alternative marche. Voici quelques sous-sélections possibles.

• Sélectionner toutes les variables numériques,
• Sélectionner toutes les variables finissant pas _X,
• etc.

En résumé : En résumé, le code se décompose en 2 étapes : créer les macros variables et utiliser ces macros variables pour définir une boucle.

*1. Créer les macros variables CLASS1 à CLASS5, MAX_VAR.;

*1.1 Créer le data set LST_VAR servant de fichier de référence.;

proc sql;
   create table lst_var as
      select name
      from dictionary.columns
      where upcase(libname)='SASHELP' and
            upcase(memname)='CLASS';
quit;

*1.2 Créer les macro variables CLASS1-CLASS5 en se basant sur le data set LST_VAR créé précédemment.;

data _null_;
   set lst_var;
   cnt+1;
   call symput (cats('CLASS',put(cnt,best.)),name);
run;

*1.3 Créer la macro variable VAR_MAX en se basant sur le data set LST_VAR créé précédemment.;

data _null_ ;
   call symputx('max_var',_N_-1);
   set lst_var;
run;

*2. Reporting : appeler les différentes macro variables pour créer la boucle autour de l'instruction DEFINE.;

%macro test;
proc report data=sashelp.class;
   columns name age sex weight height;
   %do i=1 %to &max_var.;
      define &&class&i. / display;
   %end;
run;
%mend test;
%test;

Dans le fond, mon problème c'est un peu ça (non en fait c'est exactement ça) :

J'ai 2 tables access, la première contient les champs a,b,c,g et la deuxième, les champs d,e,f,g

J'ai créé une autre table avec les champs
a,b,c,d,e,f

Est-ce qu'il existe une façon d'importer les données des 2 tables premières tables dans la troisième et replacer les données dans les colonnes appropriées (la a avec la a, la b avec la b, etc...)
Bon là on est rendu à éliminer ceux qui se disent :

- MeeeuuuanngnNngt!! rapport men!! c'est comme ben trop facile! trouve le tout seul!

- C'est impossible de faire ça! botte-toi le derrière et fait le manuellement! (c'est quand même un excellent argument ça!)

Pis on garde ceux qui disent :

- Ben voyons! tu me niaises-tu la! c'est super facile, fait ça comme ça.... (ça, c'est un peu ce que je voudrais entendre)

Merci d'avance, je commence à être un peu tanné, ça fait 3 jours que je suis là-dessus (et en même temps, je viens de justifier, pourquoi j'écris pas souvent sur le blog)

Hirald

Le code n'est pas bien sorcier, mais d'autres plus complets seront prochainement mis en ligne (peut-être). Le début de la gloire, quoi

L'octet (byte en anglais) est une unité de mesure informatique utilisée en SAS pour définir la longueur des variables. Il permet de stocker 1 caractère parmi une liste de 256. Une des listes de caractères les plus répandue est la table des ASCII (American Standard Code for Information Interchange). SAS dispose de deux fonctions RANK et BYTE pour passer d'un nombre à un de ces caractères et inversement. Ces notions sont à découvrir ou redécouvrir sous la forme de 9 points.

1. Des notions mathématiques mises à la sauce informatique

Deux valeurs possibles avec les booléens : Les booléens (boolean) sont des valeurs égales à 0 ou à 1. C'est une notation mathématique. On parle souvent de la logique des booléens. L'interprétation de ces valeurs est :

• 0 pour faux (false)
• 1 pour vrai (true)

En SAS, les syntaxes FIRST/LAST et END= du data step se servent de la logique des booléens.

Le bit est l'unité informatique de base : L'unité de mesure élémentaire en informatique, le bit (bit en anglais également) est basé sur le même principe. Le bit prend soit la valeur 0, soit la valeur 1.

L'octet est un groupement de 8 bits : Un octet (byte en anglais) est égal à la combinaison de 8 unités élémentaires, de 8 bits.

2. Le but du jeu

En informatique, le but du jeu est de n'utiliser que des valeurs 0/1 pour faire référence à des nombres entiers. Pour avoir un éventail de nombre entier assez large, il faut donc plusieurs bits.

Ensuite, pour chaque nombre entier une valeur peut être assignée. Par exemples, les nombres allant de 0 à 255 servent dans une table de référence pour les caractères, la table des ASCII.

3. Combien de valeurs différentes sont extraites avec x bits ? 

Tout d'abord, les bits sont mis les uns à la suite des autres.

• Avec 1 bit : le bit prend soit la valeur 0 soit la valeur 1.
• Avec 2 bits : les valeurs de 2 bits s'arrangent de 4 manières différentes à savoir 00, 01, 10 ou 11.
• Avec 3 bits : les valeurs de 3 bits peuvent se présenter de 8 manières possibles 000, 001, 010, 011, 100, 101, 110, 111.

Généralisation : Pour savoir combien d'arrangements de 0 et 1 sont possibles, le nombre 2 (nombre de valeurs possibles dans un bit) est multiplié autant de fois qu'il y a de bits, soit 2^x. En termes mathématiques, on parle du nombre d'arrangements avec répétition. Il s'agit bien du calcul avec répétition car les valeurs 0 et/ou 1 peuvent apparaître plusieurs fois.

Ecrire un exposant sous SAS : Pour mettre une valeur en exposant sous SAS, on fait suivre la base de 2 étoiles et de l'exposant. Voici un exemple pour une variable nommée EXPOSANT.

• En langage mathématique : exposant=2⁸
• Sous SAS : exposant=2**8;

4. Quelle position pour mon bit ?

On commence par regarder celui qui est le plus à droite et on lui assigne la position 0. Celui qui suit aura une position 1, etc.

• Avec 1 bit : le bit est en position 0.
• Avec 2 bits : le premier bit est en position 1, le second en position 0.
• Avec 3 bits : le premier bit est en position 2, le second en position 1 et le dernier en position 0.
• Etc.

5. Création d'une liste de valeurs

Maintenant que la position (x) de chaque bit est connue, on va additionner des valeurs 2^x à chaque fois que le bit est égal à 1. Voici donc quelques exemples avec 1, 2 et 3 bits. D'un côté, on a l'arrangement des bites, de l'autre la valeur que l'on peut en extraire.

Avec 1 bit, les valeurs finales sont entre 0 et 1.

• "0" : 0
• "1" : 2⁰ = 1

Avec 2 bits, les valeurs finales sont entre 0 et 3.

• "00" : 0 + 0 = 0
• "01" : 0 + 2⁰ = 0 + 1 = 1
• "10" : 2¹ + 0 = 2 + 0 = 2
• "11" : 2¹ + 2⁰ = 2 + 1 = 3

Avec 3 bits, les valeurs finales sont entre 0 et 7.

• "000" : 0 + 0 + 0 = 0
• "001" : 0 + 0 + 2⁰ = 0 + 0  + 1 = 1
• "010" : 0 + 2¹+ 0 = 0 + 2 + 0 = 2
• "011" : 0 + 2¹+ 2⁰ = 0 + 1+ 2 = 3
• "100" : 2² + 0 + 0 = 4 + 0 + 0 = 4
• "101" : 2² + 0 + 2⁰ = 4 + 0 + 1 =5
• "110" : 2² + 2¹ + 0 = 4 + 2 + 0 = 6
• "111" : 2² + 2¹+ 2⁰ = 4 + 2 + 1 = 7

Avec 8 bits (1 octet) les valeurs vont de 0 à 255. Comme indiqué précédemment ces nombres servent pour la table des ASCII.

6. La table des ASCII et les fonctions RANK/BYTE

La table des ASCII regroupe les caractères en trois groupes :

• 0-31 : les codes de contrôle (control code) comme "passage à la ligne"
• 32-127 : les caractères imprimables (printable characters)
• 128-255 : les caractères spéciaux (special characters) comme é, à, û...

Note pour les claviers étrangers : La liste des caractères spéciaux est pratique à l'étranger lorsqu'un clavier d'ordinateur ne dispose pas des accents. Ainsi pour obtenir la lettre "é", maintenez la touche "Alt" enfoncé et tapez le nombre 0233. Voici ceux que j'utilise le plus souvent :

• 0224 à
• 0226 â
• 0231 ç
• 0233 é
• 0234 ê
• 0235 è
• 0238 î
• 0244 ô
• 0249 ù
• 0251 û

Exemples d'applications : Dans le cadre des fonctions SAS, je vais me concentrer sur les valeurs 32 à 255 car ce sont les valeurs que j'ai rencontré dans des data sets SAS. J'ai aussi eu besoin de vérifier qu'une macro pouvait toujours fonctionner quand elle rencontrait ces caractères dans un data set. Pour se faire, j'ai eu besoin de créer un data set les contenant.

7. Convertir un nombre en caractère (la fonction BYTE)

Dans cet exemple, la fonction BYTE génère toutes les valeurs ASCII imprimables et les sauvegarde dans une variable ASCII. Pour ce faire, une boucle est construite avec les instructions DO et END. C'est l'occasion d'introduire rapidement sous forme d'exemple la notion de boucle.

data one (drop=i);
   do i=32 to 127;
   *do i=128 to 255;
      ascii=byte(i);
      output;
   end;
run;

La boucle est définie par variable i allant de 32 à 128 (et non 127) mais l'action est conduite seulement pour les valeurs 32 à 127. Les valeurs intermédiaires sont distantes d'une valeur 1 car l'incrémentation par défaut est 1. Pour changer cette valeur par défaut et disons prendre une valeur sur deux, on ajoute BY 2 dans l'instruction DO.

A chaque fin de boucle i est incrémenté par 1. Quand i=127, la valeur est calculée une dernière fois. Puis i est incrémenté  par 1. Avec i=128, la condition n'est plus remplie. Le contenu de la boucle est ignoré. SAS s'intéresse à l'étape suivante dans le data step. Ici l'étape suivante est la suppression de la variable i définissant la boucle.

A chaque nouvelle valeur de la variable i, la variable ASCII est recalculée. Puis le record est ajouté dans le data set ONE grâce à l'instruction OUTPUT.

8. Convertir un caractère ASCII en nombre (la fonction RANK)

Dans cet exemple, la fonction RANK retourne la valeur numérique de la table ASCII pour la lettre "é". Cette valeur est sauvegardée dans la variable VAL_NUM.

data two;
   val_num=rank('é');
run; 

9. Les multiples des octets dans le commerce

Dans le monde des disques durs..., et taille de fichiers...., vous entendez couramment parler de :

• Kilooctet ou Ko (Kilo Byte KB en anglais),
• Megaoctet ou Mo (Mega Byte MB),
• Gigaoctet ou Go (Giga Byte GB),
• Teraoctet ou To (Tera Byte TB).

A l'avenir, on entendre peut-être même parle de :

• Petaoctet ou Po (Peta Byte PB),
• Exaoctet ou Eo (Exa Byte EB),
• Zebioctet ou Zo (Zebi Byte ZB),
• Yobioctet ou Yo (Yobi Byte YB).

La Commission Electrotechnique International (International Electrotechnique Commission IEC) a développé un standard se basant sur des multiples de 10 de l'octet. Cependant, l'ancien standard peut encore être rencontré.

• Nouveau standard : un Kilooctet est 1 000 octets (10³⁾. Un Megaoctet est 1 000 000 (10⁶).
• Ancien standard : un Kilooctet représente 1 024 octets (2¹⁰). Pour le Megaoctet, on passe à 1 048 576 (2²⁰).

En résumé, en achetant un disque dur de 500 Go, le produit est plus intéressant s'il réfère à l'ancien standard car il aura une plus grande capacité. Par contre, si on a un fichier de 5 Mo à envoyer, il représente moins de volume si on parle avec le nouveau standard.

1.Qu'est-ce-que la programmation?

2.La compilation, la programmation modulaire et le linker.

3.Le C et ses dérivés.

1. QU'EST-CE QUE LA PROGRAMMATION?

La programmation, c'est l'art ou et/ou la science (ca dépend du point de vue) de réaliser un programme complet pour indiquer a notre ordinateur comment obtenir un logiciel. Malheureusement vous et le PC ne parlez pas la même langue. Vous parlez une langue humaine (ici français je suipose :) ). Votre PC, lui parle binaire. En gros, vous, vous utilisez un 'set' de 26caracteres plus les nombres, l'espace et les caracteres spéciaux, lui il utilise juste... 2 nombre: 0 et 1. Mais rassurez vous: vous ne programmerez pas en utilisant que des 0 et des 1. Vous allez faire vos programmes en écrivant un "code" bien précis qui est en fait ce que vous voulez que votre ordinateur fasse, mais comme vous l'aurez compris il ne comprend rien comme ca. Il faut traduire votre programme. Et c'est pour ca que nous avons besoin d'un compilateur.

2. LE COMPILATEUR.

Un compilateur, en gros, c'est un traducteur: il vas traduire vos programmes en un fichier binaire exécutable. En gros, votre compilateur comprend en fait deux élément: le complilateur et le linker. Le compiltateur, lui se charge de transformez les fichiers .c et .h (ce sont les fichiers qui contiennent votre code, vous verrez ca plus tard) en fichiers.o . Et le linker se charge de lier les .h et .c entre eux pour faire un seul logiciel binaire. Voila, c'est pas plus compliqué que ca, bien que le fonctionement du compilateur, lui, l'est beaucoup plus. Parce que la je viens juste de vous expliquer ce qu'il fait, pas comment il marche :D. Peut etre qu'un jour, si vous etes (tres) motiver, vous réaliserez votre propre compilateur/linker, qui sait... Apres tout, un programmeur confirmé doit avoir la capacité d'en faire, mais tous n'ont peut etre pas la motivation de faire ca en tant qu'hobby :-)

3. Le C et ses dérivés.

Le language que nous nous allons travailler est un language tres connus, tres utilisé, si pas le plus utilisé. Il s'agit du C. Linux a été écrit en C, pour vous donner un exemple concret. Le C est un language pratique, clair, puissant, souple, et aux possibilités larges. Mais il a donné naissance a 2 dérivés: le C++ et le C# (c sharp). Le C++, c'est une modification du C "orienté Objet", qui est en résumé une facon plus claire et avec plus de possibilités d'organiser les fonctions. Quant au c#, il ne rappelle pas autant le C que C++. En fait, je dénonce tout de suite le fait... que c'est une Windowserie. Il s'agit meme d'une propriété Microsoft!!! C'est triste hein... Qui d'autre que Windows pouvait faire une chose pareille?

Bon voila vous connaissez a présent les concept de la programmation. J'attend vos question, suggestions, et autres.

Tofux.

Communiqués de presse, informatique, services.

RainCode, société d'ingénierie logicielle basée à Bruxelles

RainCode

Computer Research, Inc. (offre des solutions complètes de gestion de titres pour les banques et autres institutions financières.

Sur ce marché, la fiabilité et la robustesse sont essentielles, et les applications COBOL de CRI tournent sur les plateformes iSeries d' IBM (mieux connues sous la dénomination AS/400).

Face à l'accélération des demandes des clients et la pression de la concurrence, CRI était à la recherche de solutions techniques permettant d'améliorer la flexibilité de ses applications, et ainsi mieux répondre aux besoins, tout en maintenant une exigence qualitative élevée.

Une étude de marché des outils applicables à COBOL amena CRI assez rapidement chez RainCode, qui propose des outils d'analyse et de remédiassions pour les langages de programmation les plus populaires.

Ces outils permettent l'identification des points faibles dans les applications existantes, et fournissent le plus souvent les moyens de les corriger automatiquement ou semi-automatiquement.

Après une phase d'évaluation, CRI a fait l'acquisition d'une licence du RainCode Checker pour COBOL, qui supporte les extensions spécifiques à la gamme iSeries COBOL d' IBM.

Cet outil vérifie automatiquement une batterie de règles de codage sur un ensemble de programmes, afin d'en garantir la qualité et l'homogénéité.

De plus, la restructuration COBOL permet d'améliorer automatiquement la qualité, la maintenabilité et la performance de programmes existants par l'utilisation des constructions offertes par les dialectes COBOL les plus modernes.

Au vu des premiers résultats, CRI est rapidement devenu un partisan enthousiaste des technologies RainCode.

« Ce que j’apprécie chez RainCode, c’est leur flexibilité et leur volonté de s’adapter aux besoins de leurs clients.

En plus ils proposent une technologie phénoménale, et ils ont réussi sans effort particulier là ou tous leurs concurrents ont échoué lamentablement» dit Dennis Noto, directeur informatique chez Computer Research, Inc.

Après cette première phase, CRI envisage maintenant l'utilisation des technologies RainCode pour des projets techniques qui ont du être postposés à plusieurs reprises par manque de temps et de budget.

Les capacités d'automatisation offertes par RainCode permettent de réduire les coûts de tels projets (migration de base de données, normalisation, etc.) par des facteurs importants.

"CRI est pour nous le cas idéal: c'est un client dont les besoins sont clairement identifiés, et où le retour sur l’investissement des différents produits et services que nous pouvons
proposer se mesure aisément.

La décision d'achat y est toujours motivée par l'avantage concurrentiel obtenu, à l'exclusion de tout autre facteur émotionnel.

Malgré la faiblesse du dollar, la puissance de notre technologie nous permet de proposer des solutions pointues pour des prix très agressifs." (Darius Blasband, RainCode).

RainCode est une société basée à Bruxelles et fondée en septembre 1998.

Spécialisée dans les techniques de compilation et de manière plus générale, le traitement des langages de programmation.

Ses produits sont déclinés pour la majorité des langages utilisés en production aujourd'hui, (COBOL, PL/1, Informix 4GL, C, C++, ADA entre autres).

RainCode a également appliqué avec succès ses technologies aux migrations techniques (base de données, langage, moniteur transactionnel, etc.) et des solutions pointues pour des prix très agressifs."

(Darius Blasband, RainCode).

Contact Presse :

1 Rue de l’Autonomie,

B-1070

Bruxelles

Belgique

Téléphone : (0)2 522 06 63

Fax : (0)2 522 09 30

Communiqué de presse pour : RainCode

RainCode, société d'ingénierie logicielle basée à Bruxelles

RainCode

Computer Research, Inc. (offre des solutions complètes de gestion de titres pour les banques et autres institutions financières.

Sur ce marché, la fiabilité et la robustesse sont essentielles, et les applications COBOL de CRI tournent sur les plateformes iSeries d' IBM (mieux connues sous la dénomination AS/400).

Face à l'accélération des demandes des clients et la pression de la concurrence, CRI était à la recherche de solutions techniques permettant d'améliorer la flexibilité de ses applications, et ainsi mieux répondre aux besoins, tout en maintenant une exigence qualitative élevée.

Une étude de marché des outils applicables à COBOL amena CRI assez rapidement chez RainCode, qui propose des outils d'analyse et de remédiassions pour les langages de programmation les plus populaires.

Ces outils permettent l'identification des points faibles dans les applications existantes, et fournissent le plus souvent les moyens de les corriger automatiquement ou semi-automatiquement.

Après une phase d'évaluation, CRI a fait l'acquisition d'une licence du RainCode Checker pour COBOL, qui supporte les extensions spécifiques à la gamme iSeries COBOL d' IBM.

Cet outil vérifie automatiquement une batterie de règles de codage sur un ensemble de programmes, afin d'en garantir la qualité et l'homogénéité.

De plus, la restructuration COBOL permet d'améliorer automatiquement la qualité, la maintenabilité et la performance de programmes existants par l'utilisation des constructions offertes par les dialectes COBOL les plus modernes.

Au vu des premiers résultats, CRI est rapidement devenu un partisan enthousiaste des technologies RainCode.

« Ce que j’apprécie chez RainCode, c’est leur flexibilité et leur volonté de s’adapter aux besoins de leurs clients.

En plus ils proposent une technologie phénoménale, et ils ont réussi sans effort particulier là ou tous leurs concurrents ont échoué lamentablement» dit Dennis Noto, directeur informatique chez Computer Research, Inc.

Après cette première phase, CRI envisage maintenant l'utilisation des technologies RainCode pour des projets techniques qui ont du être postposés à plusieurs reprises par manque de temps et de budget.

Les capacités d'automatisation offertes par RainCode permettent de réduire les coûts de tels projets (migration de base de données, normalisation, etc.) par des facteurs importants.

"CRI est pour nous le cas idéal: c'est un client dont les besoins sont clairement identifiés, et où le retour sur l’investissement des différents produits et services que nous pouvons
proposer se mesure aisément.

La décision d'achat y est toujours motivée par l'avantage concurrentiel obtenu, à l'exclusion de tout autre facteur émotionnel.

Malgré la faiblesse du dollar, la puissance de notre technologie nous permet de proposer des solutions pointues pour des prix très agressifs." (Darius Blasband, RainCode).

RainCode est une société basée à Bruxelles et fondée en septembre 1998.

Spécialisée dans les techniques de compilation et de manière plus générale, le traitement des langages de programmation.

Ses produits sont déclinés pour la majorité des langages utilisés en production aujourd'hui, (COBOL, PL/1, Informix 4GL, C, C++, ADA entre autres).

RainCode a également appliqué avec succès ses technologies aux migrations techniques (base de données, langage, moniteur transactionnel, etc.) et des solutions pointues pour des prix très agressifs."

(Darius Blasband, RainCode).

Contact Presse :

1 Rue de l’Autonomie,

B-1070

Bruxelles

Belgique

Téléphone : (0)2 522 06 63

Fax : (0)2 522 09 30

Communiqué de presse pour : RainCode

Communiqués de presse, informatique, services.

RainCode, société d'ingénierie logicielle basée à Bruxelles

RainCode

Computer Research, Inc. (offre des solutions complètes de gestion de titres pour les banques et autres institutions financières.

Sur ce marché, la fiabilité et la robustesse sont essentielles, et les applications COBOL de CRI tournent sur les plateformes iSeries d' IBM (mieux connues sous la dénomination AS/400).

Face à l'accélération des demandes des clients et la pression de la concurrence, CRI était à la recherche de solutions techniques permettant d'améliorer la flexibilité de ses applications, et ainsi mieux répondre aux besoins, tout en maintenant une exigence qualitative élevée.

Une étude de marché des outils applicables à COBOL amena CRI assez rapidement chez RainCode, qui propose des outils d'analyse et de remédiassions pour les langages de programmation les plus populaires.

Ces outils permettent l'identification des points faibles dans les applications existantes, et fournissent le plus souvent les moyens de les corriger automatiquement ou semi-automatiquement.

Après une phase d'évaluation, CRI a fait l'acquisition d'une licence du RainCode Checker pour COBOL, qui supporte les extensions spécifiques à la gamme iSeries COBOL d' IBM.

Cet outil vérifie automatiquement une batterie de règles de codage sur un ensemble de programmes, afin d'en garantir la qualité et l'homogénéité.

De plus, la restructuration COBOL permet d'améliorer automatiquement la qualité, la maintenabilité et la performance de programmes existants par l'utilisation des constructions offertes par les dialectes COBOL les plus modernes.

Au vu des premiers résultats, CRI est rapidement devenu un partisan enthousiaste des technologies RainCode.

« Ce que j’apprécie chez RainCode, c’est leur flexibilité et leur volonté de s’adapter aux besoins de leurs clients.

En plus ils proposent une technologie phénoménale, et ils ont réussi sans effort particulier là ou tous leurs concurrents ont échoué lamentablement» dit Dennis Noto, directeur informatique chez Computer Research, Inc.

Après cette première phase, CRI envisage maintenant l'utilisation des technologies RainCode pour des projets techniques qui ont du être postposés à plusieurs reprises par manque de temps et de budget.

Les capacités d'automatisation offertes par RainCode permettent de réduire les coûts de tels projets (migration de base de données, normalisation, etc.) par des facteurs importants.

"CRI est pour nous le cas idéal: c'est un client dont les besoins sont clairement identifiés, et où le retour sur l’investissement des différents produits et services que nous pouvons
proposer se mesure aisément.

La décision d'achat y est toujours motivée par l'avantage concurrentiel obtenu, à l'exclusion de tout autre facteur émotionnel.

Malgré la faiblesse du dollar, la puissance de notre technologie nous permet de proposer des solutions pointues pour des prix très agressifs." (Darius Blasband, RainCode).

RainCode est une société basée à Bruxelles et fondée en septembre 1998.

Spécialisée dans les techniques de compilation et de manière plus générale, le traitement des langages de programmation.

Ses produits sont déclinés pour la majorité des langages utilisés en production aujourd'hui, (COBOL, PL/1, Informix 4GL, C, C++, ADA entre autres).

RainCode a également appliqué avec succès ses technologies aux migrations techniques (base de données, langage, moniteur transactionnel, etc.) et des solutions pointues pour des prix très agressifs."

(Darius Blasband, RainCode).

Contact Presse :

1 Rue de l’Autonomie,

B-1070

Bruxelles

Belgique

Téléphone : (0)2 522 06 63

Fax : (0)2 522 09 30

Communiqué de presse pour : RainCode

Communiqués de presse, informatique.

RainCode, société d'ingénierie logicielle basée à Bruxelles

RainCode

Computer Research, Inc. (offre des solutions complètes de gestion de titres pour les banques et autres institutions financières.

Sur ce marché, la fiabilité et la robustesse sont essentielles, et les applications COBOL de CRI tournent sur les plateformes iSeries d' IBM (mieux connues sous la dénomination AS/400).

Face à l'accélération des demandes des clients et la pression de la concurrence, CRI était à la recherche de solutions techniques permettant d'améliorer la flexibilité de ses applications, et ainsi mieux répondre aux besoins, tout en maintenant une exigence qualitative élevée.

Une étude de marché des outils applicables à COBOL amena CRI assez rapidement chez RainCode, qui propose des outils d'analyse et de remédiassions pour les langages de programmation les plus populaires.

Ces outils permettent l'identification des points faibles dans les applications existantes, et fournissent le plus souvent les moyens de les corriger automatiquement ou semi-automatiquement.

Après une phase d'évaluation, CRI a fait l'acquisition d'une licence du RainCode Checker pour COBOL, qui supporte les extensions spécifiques à la gamme iSeries COBOL d' IBM.

Cet outil vérifie automatiquement une batterie de règles de codage sur un ensemble de programmes, afin d'en garantir la qualité et l'homogénéité.

De plus, la restructuration COBOL permet d'améliorer automatiquement la qualité, la maintenabilité et la performance de programmes existants par l'utilisation des constructions offertes par les dialectes COBOL les plus modernes.

Au vu des premiers résultats, CRI est rapidement devenu un partisan enthousiaste des technologies RainCode.

« Ce que j’apprécie chez RainCode, c’est leur flexibilité et leur volonté de s’adapter aux besoins de leurs clients.

En plus ils proposent une technologie phénoménale, et ils ont réussi sans effort particulier là ou tous leurs concurrents ont échoué lamentablement» dit Dennis Noto, directeur informatique chez Computer Research, Inc.

Après cette première phase, CRI envisage maintenant l'utilisation des technologies RainCode pour des projets techniques qui ont du être postposés à plusieurs reprises par manque de temps et de budget.

Les capacités d'automatisation offertes par RainCode permettent de réduire les coûts de tels projets (migration de base de données, normalisation, etc.) par des facteurs importants.

"CRI est pour nous le cas idéal: c'est un client dont les besoins sont clairement identifiés, et où le retour sur l’investissement des différents produits et services que nous pouvons
proposer se mesure aisément.

La décision d'achat y est toujours motivée par l'avantage concurrentiel obtenu, à l'exclusion de tout autre facteur émotionnel.

Malgré la faiblesse du dollar, la puissance de notre technologie nous permet de proposer des solutions pointues pour des prix très agressifs." (Darius Blasband, RainCode).

RainCode est une société basée à Bruxelles et fondée en septembre 1998.

Spécialisée dans les techniques de compilation et de manière plus générale, le traitement des langages de programmation.

Ses produits sont déclinés pour la majorité des langages utilisés en production aujourd'hui, (COBOL, PL/1, Informix 4GL, C, C++, ADA entre autres).

RainCode a également appliqué avec succès ses technologies aux migrations techniques (base de données, langage, moniteur transactionnel, etc.) et des solutions pointues pour des prix très agressifs."

(Darius Blasband, RainCode).

Contact Presse :

1 Rue de l’Autonomie,

B-1070

Bruxelles

Belgique

Téléphone : (0)2 522 06 63

Fax : (0)2 522 09 30

Communiqué de presse pour : RainCode

Connaissez vous les RichTextBox ? probablement non si vous n'êtes pas programmeur, c'est les boites qui vous permettent d'écrire du texte formaté ( avec des couleurs, gras, italique etc...) que vous retrouvez dans WordPad ou autre...

Créé par Microsoft (lisez MyCrossoft :p ) pour simplifier la vie aux programmeurs... simplifier ? j'en doute... j'ai du galéré pour trouver la documentation et encore elle est loin d'être complète, pourtant ce n'est pas si compliquer a utiliser...

Enfin, pour remonter le moral voici la définition de Microsoft by Désencyclopedie ;)

D'abord quelques citations :

« AAAAAAAHHHHHHHHH!!!!!!!! »
~ Un utilisateur de Windows à propos du plaisir qu'il ressent à travailler dans cet environnement.

« Que... Et meeeeerdeeeeuh ! »
~ Un autre utilisateur de Windows à propos du plaisir qu'il ressent à travailler dans cet environnement.

JEFF FILLION ! Depuis que la rumeur s'est ébruitée, tout le monde en parle dont Steve Proulx, Patrick Lagacé qui évite de donner son opinion là-dessus (le privilège constitutionnel d'être en vacances) et Renart L'éveillé également. Bon, comment dire, je ne suis vraiment pas un fan de Jeff Fillion. Contrairement à bien des observateurs, néanmoins, j'ai écouté de ces émissions de temps à autre sur le Web, vérifier si c'était la chimère monstrueuse que les médias décrivaient. Pas tant que ça. En tout cas, pour les 5 ou 6 fois que je l'ai écouté, il y avait pas de propos dignes de se retrouver en Cour. Sauf que ça ne m'a impressionné non plus. Ça ne m'a pas fait comprendre pourquoi des milliers de personnes sont descendus dans les rues de Québec pour le défendre ?  On parle ici d'un polémiste frustré de droite qui vomit sur tout de la gauche sans discernement, en glorifiant les Américains à outrance et en prenant pour acquis que le PIB d'un pays est la seule indication économique valable ou presque... Bref, non, il ne me touche pas. Et son discours de droite - QU'IL N'ASSUME MÊME PAS (en entrevue, il a déjà dit qu'il refusait de se positionner sur la ligne gauche-droite... tiens, comme un certain Dumont...) - me donne de l'urticaire.

D'ailleurs, en lisant la nouvelle sur Showbizz.net, je me suis alors rendu compte que ça serait une émission de droite solide avec Nathalie Elgrably et Jacques Brassard (ex-ministre péquiste ultra à droite) comme chroniqueurs. Pour Michel Hébert du Journal de Québec, par contre, je ne sais pas. Je ne le connais pas, mais il semble que c'est un bon blogueur à ce que j'ai entendu. Alors, entre ça et "L'avocat du diable", la droite aura plus que son droit de parole à TQS. J'aime ce que dit Steve Proulx sur quoi TQS essaierait donc de faire de la contre-programmation. Donc, c'est quoi : si le show de Fillion est l'antithèse des Deux filles le matin. théoriquement pour contrer Star Académie, ils vont mettre un show journalistique ultra intelligent ? Ah non, c'est vrai ! Ils ont crissé (excusez) les journalistes dehors... Vraiment, chez TQS, on voit la vie en brun !

En réalité, ce qu'on perdait de vue c'est que cela serait vraiment pratique de pouvoir comparer les montant des factures à l'ancienne avec nos nouvelles factures avec un seul clic de souris. Si on avait ça, on le ferait tous les jours. C'est parce que, justement, examiner les listings était pénible qu'on le faisait pas tous les jours.

Je me plais à dire que, dans notre métier, la programmation en tant que telle n'est ni une étape du processus, ni une activité. Elle est là à toutes les étapes : préparation, conception, test, amélioration. Si on devait la définir par une abstraction dans le processus ça serait celle ci : "Contexte". C'est une erreur conceptuelle très courante dans les processus préfabriqués que de considérer la programmation comme une étape.

Nous sommes actuellement en phase de test intensif avant déploiement. C'est une étape plus ou moins critique selon le projet, et pour ce projet-ci, elle est très critique. Nous sommes en train de migrer l'un des plus importants grossistes en pharmaceutiques vers un nouveau système d'information intégré.

La difficulté dans ce genre de projets est toujours la même et peut se résumer à cette phrase du client : "n'oubliez pas que <nom de l'ancienne application> marche très bien depuis <nombre d'années supérieur à 10>". Quelle que soit la définition du client pour "marche très bien" et quelque soit sa perception de son bon fonctionnement, le contrat est là : il faut qu'on remplace une application qui marche par une application qui ne marche pas encore.

Concevoir des tests n'est pas toujours chose aisée : une fois qu'on sait ce qu'il faut tester et combien, le "comment?" demande souvent des masses de créativité ou de ressources. L'avantage d'avoir une ancienne application comme étalon, c'est que justement, toute une classe de tests devient évidente : beaucoup de fonctionnalités doivent fonctionner EXACTEMENT comme l'ancienne application.

Hassen était aux prises avec des listings contenant des centaines de factures issues de l'ancienne application. Le but était d'identifier les différences entre les nouvelles factures et les anciennes. et jusque là la seule manière de faire que nous avions trouvée c'est de comparer manuellement les montants (des centaines, je rappelle). J'ai regardé Hassen faire ça pendant quelques jours, puis j'ai eu l'inspiration. J'avais pas encore une idée, juste une piste : si ce vieux logiciel DOS pouvait imprimer sur une feuille, on pouvait le faire imprimer dans un fichier.

J'avais l'idée, mais je ne savais pas encore comment j'allais faire, ni combien de temps ça allait prendre et surtout je n'avais pas le temps. A ce moment là Bechir était venu à la rescousse de Hassen, ils faisaient ça en XP, alors je leurs ai proposé l'idée. Nous avons réévalué les taches de la semaine ensemble et avons estimé que cela ne valait pas la peine. Dans ces moments là, on a souvent la hantise du YAGNI : après tout, on ne va pas examiner les listings des factures tous les jours. Une fois que c'est fait, c'est terminé.

En réalité, ce qu'on perdait de vue c'est que cela serait vraiment pratique de pouvoir comparer les montant des factures à l'ancienne avec nos nouvelles factures avec un seul clic de souris. Si on avait ça, on le ferait tous les jours. C'est parce que, justement, examiner les listings était pénible qu'on le fait pas tous les jours.

J'avais laissé la porte ouverte, disant : "si vous sentez que ça va vous aider, je le fais". Ils ont fini par me demander de le faire. ça m'a pris quelques jours pour essayer différentes solutions qui n'ont pas marché et pour trouver la solution qui marche : j'ai installé dosemu sur un vieux poste linux, je l'ai configuré pour envoyer tout ce qui était destiné à l'imprimante dans un fichier texte accessible sur le réseau et j'ai installé la vieille application dessus. J'ai même pris la peine d'écrire un peu de code pour transformer les listings malpropres en fichiers CSV parfaitement acceptables pour notre base de données.

Nous ne fûmes pas déçus. Avec le recul, maintenant on est sur qu'on y serait jamais arrivé sans avoir fait cela. La morale de cette histoire c'est : donnez du pouvoir à l'équipe, ce n'est jamais une perte de temps. Faites comme Abraham Lincoln , si vous avez 8 heures pour couper un arbre, passez 6 heures à aiguiser votre hache. ça vaut la peine.

Voici un premier entrefilet, dans la chronique "Vos impôts sont bien investis". Le MTQ investit 2,5 millions$ sur l'A-55, et ce pour imperméabiliser les fossés d'une autoroute ouverte il y a moins de deux ans! Je présume que le fait d'avoir des fossés imperméables ne figuraient pas sur les plans originaux de l'autoroute! Et d'abord, c'est quoi, des fossés imperméables? Ça n'est pas supposé recueillir de l'eau, des fossés?

Allons maintenant à vos questions.

C'est Sam, un des bons lecteurs de ce blogue, qui m'a écrit ce commentaire, il y a quelques temps.

"Bonjour Richard,je veux savoir lorsque tu es allé prendre des photos sur la 55 pour nous prouver que c’est une autoroute de tout genre,as-tu remarqué qu’il y a encore des panneaux numérotés «155» à des endroits? En tout cas, je sais qu’avant l’ouverture complète de l’autoroute 55 entre St-Célestin et la 20,la 155 existait encore. Mais là, il n’est plus là. Donc, la route numérotée «155» devrait être supprimée sur tous les panneaux de supersignalisation et ainsi des panneaux de ce numéro devraient être enlevés après des échangeurs.Mais entre St-Grégoire et l’autoroute 20, après des intersections et échangeurs, le MTQ a enlevé les panneaux numérotés «155»."

Évidemment, n'écoutant que mon sens du devoir (et mon budget aussi; vous savez, avec l'essence à 1,50$ le litre, et aucune forme de commandite,...), j'ai voulu en avoir le coeur net. J'en ai profité pour tenter de savoir aussi ce qu'il en était de la route 161, depuis l'ouverture de l'A-55 (en super-2, mais quand même), de Saint-Wenceslas jusqu'à l'A-20. Je me suis rendu compte que, selon l'endroit où l'on se trouve, c'est un peu n'importe quoi!

Voici ce que l'on voit quand on sort de l'A-20 ouest, à la hauteur de la route 161, tout juste au sud du village de Sainte-Eulalie. On constate donc que la route 161 commence désormais au niveau de l'A-20, et monte vers le sud. Quoique lorsque l'on roule sur la 161 nord, aucune indication ne nous signale la fin de la route 161.

Tout juste avant le pont Laviolette, sur l'A-55, à la hauteur de la bretelle vers la route 132, on voit que Sam avait raison, au sujet de la supersignalisation. Si les petits panneaux de la route 155 ont été retirés, sur la rive sud du fleuve, on devra un jour revoir les grands panneaux, afin de savoir qui dit vrai. Cela m'étonne que cela n'ait pas été effectué lors des rénovations du pont Laviolette, qui comprenaient les caméras de surveillance, les feux de voies,...

...ainsi que ces magnifiques barrières, contrôlées à distance, qui se referment si l'on décide de fermer le pont à la circulation.

Sur la petite signalisation, comme le disait Sam, aucune trace de la route 155, comme on le voit ici, à l'intersection de la bretelle d'entrée de l'A-55 sud, à la hauteur de la route 132, à Bécancour (Saint-Grégoire).

Sur la rive nord du fleuve, par contre, c'est une toute autre histoire, comme le démontre ce petit panneau (pas si petit, mais bon, il ne s'agit pas de supersignalisation) situé sur la rue Notre-Dame ouest, qui est aussi la route 138, à Trois-Rivières. Comme il date quand même de plusieurs années, on serait porté à croire qu'il n'est qu'un panneau oublié, comme cela arrive à l'occasion.

Sur la supersignalisation, toutefois, il n'y a aucune mention de la route 155. À remarquer, la piste cyclable qui passe sous le panneau! Ils sont fous, ces trifluviens!

Celui-là, par contre, il n'a pas été oublié! Nous sommes sur l'A-55 nord, entre l'entrée en provenance de la rue Notre-Dame ouest et la sortie vers l'A-40 est. À partir de ce point, les petits panneaux de la route 155 sont toujours bien présents,...

...comme le démontrent ces panneaux, vus à l'intersection du boulevard Saint-Michel, toujours à Trois-Rivières. Il est donc permis de croire, en attendant une confirmation officielle du MTQ, que la route 155, qui commence à Chambord, au Lac-Saint-Jean, se termine désormais au pont Laviolette.

Passons à un autre commentaire. Mais avant d'aller plus loin,...

...allons-y d'un deuxième entrefilet, dans la chronique "Vos impôts sont bien investis". Je ne sais pas qui a commandé le lettrage, sur la façade de l'école Chavigny, à Trois-Rivières, mais force est de constater que le contraste est, comment dire, convaincant. Vous parvenez à lire quelque chose, vous? On ne voit rien de ce qui est écrit! C'est tellement évident...

...qu'on a dû ajouter une autre affiche, au-dessus de la porte d'entrée des élèves, avec le nom de l'école. De quoi donner le goût d'appuyer l'abolition des commissions scolaires. Dites-vous bien que ce sont ces décideurs qui gèrent votre argent si durement gagné!

De retour à notre programmation.

Un autre lecteur, Marc F. P., m'a fait parvenir un commentaire au sujet du tronçon oublié de l'A-30, à Bécancour. Le voici:

"La photo ou c’est que vous parliez des voies centrales qui devrai etre construite, et bien il était déja construite et ne les déblaye plus depui un certain temps…

et voila le lien pour la photo en question (version estivale)
http://cf.geocities.com/srquebec/photos/a30entete1.JPG

Marc F. P.

P.S.: cette autoroute aurait du etre construite depuis un certait temps de valleyfield à Gentilly"

Mon cher Marc, vous avez tout à fait raison; ces voies centrales sont déjà dans le paysage, et ce depuis de nombreuses années. D'ailleurs, on peut le constater sur les photos suivantes.

Voici la fin de l'A-30, en direction ouest. La bretelle, complètement à droite, mène à la route 132, à Bécancour (Saint-Grégoire). La chaussée en direction est porte plusieurs marquages,...

...et quand on y regarde de plus près, on constate que les peintres du MTQ se pratiquent même à peindre des flèches au gabarit! Encore un exemple d'argent bien investi!

Quand on regarde la même chaussée, mais en direction est, cette fois, elle prend presque des allures de piste d'atterrissage, tellement on y a mis de peinture.

Allez savoir pourquoi, on ne met pas de peinture sur la chaussée en direction ouest. Par contre, on constate que les joints du béton sont tous en train d'éclater, ce qui prouve que la technique de construction utilisée à l'époque n'est pas la meilleure pour la construction de routes en béton, d'autant plus que les dommages ne sont pas causés par la circulation lourde. D'ailleurs, il n'y a pas de circulation du tout, sur cette chaussée.

À surveiller bientôt: En Estrie, les travaux sur l'A-10, ainsi qu'une belle réalisation, complétée dans les années 1980. Également, on jettera un coup d'oeil sur l'A-55 sud, entre Drummondville et Sherbrooke, et je vous emmènerai sur un barrage d'Hydro-Québec. Alors c'est à suivre...

Pkg-config est un logiciel qui accède à des fichiers relatifs aux bibliothèques utilisées contenant tous les fichiers à renseigner au compilateur. Par exemple, si vous utilisez la bibliothèque SDL dans votre projet, il suffit de demander à pkg-config de vous donner les renseignements concernant cette bibliothèque. Pour ce faire, rien de plus simple, voici le format courant de la commande (il existe beaucoup d'autres options et je vous invite à lire le manuel):

pkg-config [––cflags] [––libs] <bibliotheque>

L'option ––cflags demande d'obtenir les options de compilation avec les dossiers contenant les fichiers d'entête et l'option ––libs concerne les fichiers de bibliothèque.

Ainsi, pour l'exemple avec la SDL, cela donne:

pkg-config ––cflags ––libs sdl

Et pkg-config nous répond par

-D_GNU_SOURCE=1 -D_REENTRANT -I/usr/include/SDL -Wl,-rpath,/usr/lib -lSDL -lpthread

Qui sont les options qu'il faudrat renseigné à gcc pour la compilation.
Auriez-vous pensez à indiquer tout cela?

Pour savoir quelles sont les bibliothèques supportées, allez dans le dossier /usr/lib/pkgconfig. Ce dossier contient tout un ensemble de fichiers avec une extension .pc. Le nom des fichiers correspond au nom de la bibliothèque. Attention, une bibliothèque peut posséder différents fichiers .pc, par exemple pour Qt:

Qt3Support.pc            QtDBus.pc      QtOpenGL.pc     QtSvg.pc     QtXml.pc
QtAssistantClient.pc     QtGui.pc        QtScript.pc       QtTest.pc
QtCore.pc                  QtNetwork.pc  QtSql.pc           QtUiTools.pc

Vous pouvez dès lors simplifier vos appels au compilateur:

gcc `pkg-config ––cflags ––libs sdl` test.c -o test

Ou dans votre Makefile, la variable CFLAGS par exemple contiendrait `pkg-config ––cflags <bibliotheques> `

En plus de la simplicité, cette méthode vous permet de mettre des options de compilation conseillées par les développeurs de la bibliothèque. Elle regroupe ainsi toutes les qualités requisent pour être utilisée par tous les développeurs en herbe que vous êtes :D

Dans "The greatest invention in Computer Science", il prend un peu de recul par rapport aux langages de programmation à la mode et considère que la "routine" (fonction ou procédure) est la plus grande invention de l'informatique (software).

Dans une avalanche de commentaires, puis aussi sur Digg, de nombreux programmeurs ont nommé leurs chouchou : pointeurs, compilateurs, langages divers etc.

Pour ma part, j'ai choisi la pile (stack). Indispensable aux routines, c'est aussi une structure de données assez puissante pour permettre de réaliser des calculatrices (HP) et même des langages de programmation (Forth).

Et pour vous, quelle est l'invention la plus marquante de l'informatique ?

ELEMENTS DE LANGAGE C

Une disquette contenant les programmes (développés sous Borland C++) de ce polycopié est disponible, en évitant la saisie.

Le corrigé des exercices et le listing de ces programmes se trouvent à la fin de chaque chapitre.

INTRODUCTION

Le langage C est un langage évolué et structuré, assez proche du langage machine destiné à des applications de contrôle de processus (gestion d'entrées/sorties, applications temps réel ...). Les compilateurs C possèdent les taux d'expansion les plus faibles de tous les langages évolués (rapport entre la quantité de codes machine générée par le compilateur et la quantité de codes machine générée par l'assembleur et ce pour une même application);

Le langage C possède assez peu d'instructions, il fait par contre appel à des bibliothèques, fournies en plus ou moins grand nombre avec le compilateur.

exemples: math.h : bibliothèque de fonctions mathématiques

stdio.h : bibliothèque d'entrées/sorties standard

On ne saurait développer un programme en C sans se munir de la documentation concernant ces bibliothèques.

Les compilateurs C sont remplacés petit à petit par des compilateurs C++.

Un programme écrit en C est en principe compris par un compilateur C++.

Le cours qui suit est un cours ce langage C écrit dans un contexte C++.

ETAPES PERMETTANT L'EDITION, LA MISE AU POINT,

L'EXECUTION D'UN PROGRAMME

1- Edition du programme source, à l'aide d'un éditeur (traitement de textes). Le nom du fichier contient l'extension .CPP, exemple: EXI_1.CPP (menu « edit »).

2- Compilation du programme source, c'est à dire création des codes machine destinés au microprocesseur utilisé. Le compilateur indique les erreurs de syntaxe mais ignore les fonctions-bibliothèque appelées par le programme.

Le compilateur génère un fichier binaire, non listable, appelé fichier objet: EXI_1.OBJ (commande « compile »).

3- Editions de liens: Le code machine des fonctions-bibliothèque est chargé, création d'un fichier binaire, non listable, appelé fichier executable: EXI_1.EXE (commande « build all »).

4- Exécution du programme (commande « flèche jaune »).

Les compilateurs permettent en général de construire des programmes composés de plusieurs fichiers sources, d'ajouter à un programme des unités déjà compilées ...

Exercice I-1: Editer (EXI_1.CPP), compiler et exécuter le programme suivant:

#include <stdio.h> /* bibliotheque d'entrees-sorties standard */

#include <conio.h>

void main()

{

puts("BONJOUR"); /* utilisation d'une fonction-bibliotheque */

puts("Pour continuer frapper une touche...");

getch(); /* Attente d'une saisie clavier */

}

Le langage C distingue les minuscules, des majuscules. Les mots réservés du langage C doivent être écrits en minuscules.

On a introduit dans ce programme la notion d’interface homme/machine (IHM).

- L’utilisateur visualise une information sur l’écran,

- L’utilisateur, par une action sur le clavier, fournit une information au programme.

Modifier le programme comme ci-dessous, puis le tester :

#include <stdio.h> /* bibliotheque d'entrees-sorties standard */

#include <conio.h>

void main()

{

int a, b, somme ; /* déclaration de 3 variables */

puts("BONJOUR"); /* utilisation d'une fonction-bibliotheque */

a = 10 ; /* affectation* /

b = 50 ; /* affectation */

somme = (a + b)*2 ; /* affectation et opérateurs */

printf(« Voici le resultat : %d\n », somme) ;

puts("Pour continuer frapper une touche...");

getch(); /* Attente d'une saisie clavier */

}
Dans ce programme, on introduit 3 nouveaux concepts :

- La notion de déclaration de variables : les variables sont les données que manipulera le programme lors de son exécution. Ces variables sont rangées dans la mémoire vive de l’ordinateur. Elle doivent être déclarées au début du programme.

- La notion d’affectation, symbolisée par le signe =.

- La notion d’opération.

LES DIFFERENTS TYPES DE VARIABLES

1- Les entiers

Le langage C distingue plusieurs types d'entiers:

___________________________________________________________

TYPE DESCRIPTION TAILLE MEMOIRE

___________________________________________________________

int entier standard signé 4 octets: - 231 ≤ n ≤231-1

unsigned int entier positif 4 octets: 0 ≤ n ≤ 232

short entier court signé 2 octets: - 215 ≤ n ≤ 215-1

unsigned short entier court non signé 2 octets: 0 ≤≤n ≤ 216

char caractère signé 1 octet : - 27 ≤≤n ≤ 27-1

unsigned char caractère non signé 1 octet : 0 ≤n ≤ 28

_____________________________________________________________

Numération: